排序(四)-归并排序

稳定性:stable sort

空间:Out-place sort

最优复杂度:O(nlgn)

最差复杂度:O(nlgn)

伪代码:

Merge_sort(A)
{
    recursive_mergesort(A,1,length[A])
}

recursive_mergesort(A,p,q)
{
    if p<q
        m = (p+q)/2
        recursive_mergesort(A,p,m)
        recursive_mergesort(A,m+1,q)
        merge(A,p,m,q)
}

merge(A,p,m,q)
{
    a = m-p+1
    b = q-m
    create array L[a+1] & R[b+1]
    for i=1 to a
        L[i] = A[p+i-1]
    for i=1 to b
        R[i] = A[m+i]
    L[a+1] = INFINITY
    R[b+q] = INFINITY
    i = j = 1
    for k=p to q
        if L[i] < R[j]
            A[k] = L[i]
            i++
        else if L[i] > R[j]
            A[k] = R[j]
            j++
}

Java代码:

import java.util.Arrays;

public class Main {
	public static void main(String[] args){
		Main m = new Main();
		int[] A = {1,2,3,5,4,7,9,1,2,5,3,2,1};
		m.mergeSort(A);
		System.out.print(Arrays.toString(A));
		//输出:[1, 1, 1, 2, 2, 2, 3, 3, 4, 5, 5, 7, 9]
	}
	
	public void mergeSort(int[] A){
		recursiveMergeSort(A,0,A.length-1);
	}
	
	public void recursiveMergeSort(int[] A,int p,int q){
		if(p<q){
			int m = (p+q) / 2;
			recursiveMergeSort(A,p,m);
			recursiveMergeSort(A,m+1,q);
			merge(A,p,m,q);
		}
	}
	
	public void merge(int[] A,int p,int m,int q){
		int a = m-p+1;
		int b = q-m;
		int[] L = new int[a+1];
		int[] R = new int[b+1];
		int i,j;
		for(i = 0; i < a;++i)
			L[i] = A[p+i];
		for(i = 0; i < b;++i)
			R[i] = A[m+i+1];
		L[a] = 0x7fffffff;
		R[b] = 0x7fffffff;
		i = j = 0;
		for(int k = p; k <= q;++k){
			if(L[i] < R[j]){
				A[k] = L[i];
				++i;
			}else{
				A[k] = R[j];
				++j;
			}
		}
	}
	
}