常见排序(归并排序)

各种常用排序算法
类别	排序方法	时间复杂度			空间复杂度	稳定性	复杂性	特点
		最好	平均	最坏	辅助存储		简单
插入 排序	直接插入	O(N)	O(N2)	O(N2)	O(1)	稳定	简单
	希尔排序	O(N)	O(N1.3)	O(N2)	O(1)	不稳定	复杂
选择 排序	直接选择	O(N)	O(N2)	O(N2)	O(1)	不稳定
	堆排序	O(N*log2N)	O(N*log2N)	O(N*log2N)	O(1)	不稳定	复杂
交换 排序	冒泡排序	O(N)	O(N2)	O(N2)	O(1)	稳定	简单	1、冒泡排序是一种用时间换空间的排序方法，n小时好 2、最坏情况是把顺序的排列变成逆序，或者把逆序的数列变成顺序，最差时间复杂度O(N^2)只是表示其操作次数的数量级 3、最好的情况是数据本来就有序，复杂度为O(n)
	快速排序	O(N*log2N)	O(N*log2N)	O(N2)	O(log2n)~O(n)	不稳定	复杂	1、n大时好，快速排序比较占用内存，内存随n的增大而增大，但却是效率高不稳定的排序算法。 2、划分之后一边是一个，一边是n-1个， 这种极端情况的时间复杂度就是O(N^2) 3、最好的情况是每次都能均匀的划分序列，O(N*log2N)
归并排序		O(N*log2N)	O(N*log2N)	O(N*log2N)	O(n)	稳定	复杂	1、n大时好，归并比较占用内存，内存随n的增大而增大，但却是效率高且稳定的排序算法。
基数排序		O(d(r+n))	O(d(r+n))	O(d(r+n))	O(rd+n)	稳定	复杂
注：r代表关键字基数，d代表长度，n代表关键字个数

不稳定：

  选择排序（selection sort）— O(n2)

  快速排序（quicksort）— O(nlogn) 平均时间, O(n2) 最坏情况; 对于大的、乱序串列一般认为是最快的已知排序

  堆排序 （heapsort）— O(nlogn)

  希尔排序 （shell sort）— O(nlogn)

  基数排序（radix sort）— O(n·k); 需要 O(n) 额外存储空间 （K为特征个数）


  稳定：

  插入排序（insertion sort）— O(n2)

  冒泡排序（bubble sort） — O(n2)

  归并排序 （merge sort）— O(n log n); 需要 O(n) 额外存储空间

  二叉树排序（Binary tree sort） — O(nlogn); 需要 O(n) 额外存储空间

  计数排序  (counting sort) — O(n+k); 需要 O(n+k) 额外存储空间，k为序列中Max-Min+1

  桶排序 （bucket sort）— O(n); 需要 O(k) 额外存储空间

1、归并排序，将元素列表进行二分分解，直到不可再分(实际上最终分解到了单个元素上),然后将元素按照顺序一步步合并起来

   a、数组-递归

　　

public class Main {
    public static void main(String[] args) {
        int [] d = new int[10];
        for(int i =0; i < 10; i++){
            d[i] = new Random().nextInt(10);
        }        
        System.out.println(Arrays.toString(d));
        sort(d);
        System.out.println(Arrays.toString(d));
    }
    
    static void sort(int[] data){
        sort_m(data, 0, data.length-1);
    }

    static void sort_m(int[] data, int start, int end){
        if(start < end){
            int mid = (start + end)/2;
            sort_m(data, start, mid);
            sort_m(data, mid+1, end);
            merge(data, start, mid, end);
        }
    }

    static void merge(int []d, int start, int mid, int end){
        int [] res = new int[end - start + 1];
        int i=0, j =start, k =mid+1;
        while(j <= mid  && k <= end){
            if(d[j] < d[k]){
                res[i++] = d[j++];
            }else{
                res[i++] = d[k++];
            }
        }
        if(start == 3 && end == 4) {
            System.out.println();
        }
        while(j <= mid){
            try {
                res[i++] = d[j++];                
            }catch(Exception e) {
                e.printStackTrace();
            }
            
        }        
        while(k <= end){
            res[i++] = d[k++];
        }
        System.arraycopy(res, 0, d, start, res.length);    
    }