归并排序（稳定）

归并排序
时间复杂度：O(nlogn)
空间复杂度：O(n)
思想：将数组一分为二，然后对左边排序，再对右边排序
然后左边又一分为二，然后重复上面过程，右边也一分为二，重复上面过程
java

public static void sort(int[] arr, int left, int right){
    if(left >= right) return;
    int mid = (left + right) / 2;   //划分边界
    mergeSort(arr, left, mid);      //排序左区间
    mergeSort(arr, mid + 1, right);  //排序右区间
    //排序
    int i = left, j = mid + 1;
    Stack<Integer> stack = new Stack<Integer>();//定义一个栈
    while(i <= mid && j <= right){  //排序并入栈
        if(arr[i] <= arr[j]){
            stack.push(arr[i++]);
        }else{
            stack.push(arr[j++]);
        }
    }
    while(i <= mid){  //左数组没完
        stack.push(arr[i++]);
    }
    while(j <= right){ //右数组没完
        stack.push(arr[j++]);
    }
    /*for(int k = right;!stack.empty(); k--){
        arr[k] = stack.pop();
    }*/
    for(int k = left,m = 0; m < stack.size(); m++, k++){
        arr[k] = stack.get(m);
    }
}

go

func mergeSort(array []int, start, end int) {
	if start >= end {
		return
	}
	mid := start + (end - start) >> 1
	mergeSort(array, start, mid)
	mergeSort(array, mid + 1, end)
	merge(array, start, mid, end)
}

func merge(array []int, start, mid, end int) {
	var tmpArray []int
	h1, h2 := start, mid + 1
	for h1 <= mid && h2 <= end {
		if array[h1] < array[h2] {
			tmpArray = append(tmpArray, array[h1])
			h1++
		} else {
			tmpArray = append(tmpArray, array[h2])
			h2++
		}
	}
	if h1 <= mid {
		tmpArray = append(tmpArray, array[h1 : mid+1]...)
	}
	if h2 <= end {
		tmpArray = append(tmpArray, array[h2 : ] ...)
	}
	for i := 0; i < len(tmpArray); i++ {
		array[start + i] = tmpArray[i]
	}
	return
}