Merging sort time complexity analysis:

Induction:

T(n)<2 T(n/2)+cn 

T(n)<4 T(n/4)+2 cn  

T(n)<8 T(n/8)+3 cn

n numbers, layered in order as follows:

If n is 16,

Divided into left and right, traversal times when merging: n (8 + 8)

When divided into 4 parts (4, 4, 4, 4), when merging, first 4 + 4, 4 + 4 once, then 8 + 8 once, then 2 * n times

When divided into 8 parts (2, 2, 2, 2, 2, 2, 2, 2), when merging (2+2, 2+2, 2+2, 2+2) then (4+4, 4+ 4) Then 8+8 is 3*n times

When n=2^k

T(n)<2^K*T(n/(2^k))+k c n =n T(1)+c n log2n=Θ(nlogn)

Can also be understood as:

16+ 8+8 +4+4+4+4 +2+2+2+2+2+2+2+2 (no need to subdivide after two numbers per layer, recursively meet a number directly return I met the two numbers and compared them directly. It is already the bottom layer.)

The actual operation is not traversed layer by layer, but is similar to traversing the binary tree (the order of traversing in order)

The extra space complexity is O(n) with the help of an auxiliary array

Merge sort code:

Recursive part:

    public static void mergeSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		mergeSort(arr, 0, arr.length - 1);
	}
	public static void mergeSort(int[] arr, int l, int r) {
		if (l == r) {
			return;
		}
		int mid = l + ((r - l) >> 1);
		mergeSort(arr, l, mid);
		mergeSort(arr, mid + 1, r);
		merge(arr, l, mid, r);
	}

Merge code:

The two arrays are combined into one array: the range of the arr array is l, r. Divided into left array is l, mid, right array is mid+1, r,

Create a new array to traverse the merge, the space complexity is O(n), the time complexity of the constant term is O(n), and the traversal is copied back to the original array arr, which is equivalent to using two O(n) (so From this point of view, slightly lost to fast row)

public static void merge(int[] arr, int l, int m, int r) {
		int[] help = new int[r - l + 1];
		int i = 0;
		int p1 = l;
		int p2 = m + 1;
		while (p1 <= m && p2 <= r) {
			help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
		}
		while (p1 <= m) {
			help[i++] = arr[p1++];
		}
		while (p2 <= r) {
			help[i++] = arr[p2++];
		}
/ / Copy back to the original array
		for (i = 0; i < help.length; i++) {
			arr[l + i] = help[i];
		}
	}

Main function:

public static void main(String[] args) {
		int []a= {1,6,3,5,9,3,4,8,4,0};
		mergeSort(a,0,a.length-1);
		for(int i=0;i<a.length;i++)
		System.out.println(a[i]);
		
	}

Merging and sorting can achieve stability. In addition, the extra space complexity of the merge sort can be reduced to O(1) but it is difficult

(fast row and heap sorting can not achieve stability)