十大排序算法学习笔记

引言：[更新ing]

十大排序算法分为两类：
A 内部排序
选择排序【1.简单选择排序、8.堆排序】
插入排序【2.直接插入排序、3.希尔排序】
交换排序【4.冒泡排序、5快速排序】
6.归并排序
7.基数排序

B 外部排序
9.桶排序
10.计数排序

1.简单选择排序

   public static void selectSort(int[] num){
        for (int i = 0; i < num.length; i++){
            int min = i;
            for (int j = i+1 ; j <num.length; j++){
                if (num[j] < num[min]) min = j;
            }
            int temp = num[i];
            num[i] = num[min];
            num[min] = temp;
        }
    }

2.直接插入排序

 public static void insertionSort(int[] num){
     for (int i = 1; i < num.length; i++){
            int current  = num[i];
            int j = i;
          while(j > 0 && current < num[j-1]) {
                num[j] = num[j - 1];
                j--;
            }
      if(j != i)  num[j] = current;
      }
    }

3.Shell排序

  public static void shellSort(int[] num){
       int h = 1;
       while (h < num.length/3) h  = h * 3 + 1;
       while (h >=1) {
           for (int i = h; i < num.length; i++) {
               for (int j = i; j >= h && num[j] < num[j - h]; j -= h) {
                   int temp = num[j];
                   num[j] = num[j - h];
                   num[j - h] = temp;
               }
           }
           h = h /3;
       }
    }
    //可将内循环中较大元素都向右移动，而不是交换两个元素。
    public static void shellSort(int[] num){
       int h = 1;
       while (h < num.length/3) h  = h * 3 + 1;
       while (h >=1) {
           for (int i = h; i < num.length; i++) {
               int j = i;
               int current = num[i];
                while (j >= h && current < num[j - h]) {
                    num[j] = num[j-h];
                    j -= h;
                }
                num[j] = current;
               }
           h = h /3;
       }
    }

4.冒泡排序

5.Quick Sort

应用最广泛的排序算法，原地排序，将长度为N的数组排序所需的时间和 N * lgN 成正比。

//l0 = 0 ,hi = a.length -1
    private static void sort(Comparable[] a, int lo, int hi) {
        if (lo >= hi) return;
        int j = partition(a,lo,hi);
        sort(a,lo,j-1);
        sort(a,j+1,hi);

    }

    private static int partition(Comparable[] a, int lo, int hi) {
        Comparable pivot = a[lo];
        int left = lo;
        int right = hi;
        while (left < right) {
            while (left < right && a[right].compareTo(pivot) >= 0)
                right--;
            a[left] = a[right];
            while (left < right && a[left].compareTo(pivot) <= 0)
                left++;
            a[right] = a[left];
        }
        a[left] = pivot;
        return left;
    }

3种快排算法的改进方式。
a .排序小数组时，切换至插入排序。

    private static void sort(Comparable[] a, int lo, int hi) {
        //if (lo >= hi) return;
        if(lo + M >= hi){
           Insertion.sort(a,lo,hi)
           return;   
        }
        int j = partition(a,lo,hi);
        sort(a,lo,j-1);
        sort(a,j+1,hi);
    }

b. 三取样切分
使用子数组的一小部分元素的中位数来切分数组，但代价是计算中位数。人们发现取样大小为 3 并用大小居中的元素来切分效果最好。
c. 熵最优的排序
当数据中存在大量的重复元素时，一个简单的想法是将数组分为三部分，分别对应小于、等于和大于切分元素的数组元素。

    private static void sort(Comparable[] a, int lo, int hi) {
        if (hi <= lo) return;
        int lt = lo, i = lo + 1, gt = hi;
        Comparable v  = a[lo];
        while (i <= gt){
            if(a[i].compareTo(v) < 0)
                exch(a,lt++,i++);
            else if (a[i].compareTo(v) > 0)
                exch(a,i,gt--);
            else i++;
        }// a[lo...lt-1] < V = a[lt..gt] <a [gt..hi]成立
        sort(a,lo,lt-1);
        sort(a,gt+1,hi);
    }

    private static void exch(Comparable[] a, int lo, int hi) {
        Comparable temp = a[lo];
        a[lo] = a[hi];
        a[hi] = temp;
    }

6.归并排序 【分治思想】

6.1 自顶向下的归并排序 【化整为零】

   public static void sort(Comparable[] a){
        // 避免每次归并时，即使小数组，都创建一个新的数组。
        //如果这样做，创建新数组将成为归并排序运行时间的主要部分
        //好的解决方案是将aux[] 变为sort方法的局部变量，作为参数传递给merge()
        Comparable[] aux = new Comparable[a.length];
        sort(a, 0,a.length-1,aux);
    }

    private static  void sort(Comparable[] a , int lo, int hi,Comparable[] aux){
        if(lo >= hi) return;
        int mid = (lo + hi)/2;
        sort(a,lo,mid,aux);    // 将左半边排序
        sort(a,mid+1,hi,aux);   //将右半边排序
        merge(a,lo,mid,hi,aux);   //归并结果
    }
    public static void merge(Comparable[] a,int lo, int mid,int hi,Comparable[] aux){
        int i = lo;
        int j = mid + 1;
        
        for(int k = lo; k <= hi; k++)
            aux[k] = a[k];
         //可用三个while和循环代替
        for (int k =lo; k <= hi; k++){
            if (i > mid) a[k] = aux[j++];
            else if (j > hi) a[k] = aux[i++];
            else if (aux[i].compareTo(aux[j]) < 0) a[k] = aux[i++];
            else  a[k] = aux[j++];
        }

    }

3种归并排序的优化方式：

a: 对于小规模数组使用插入排序。 可将运行时间缩短10-15%。
b: 测试数组是否已经有序，如果a[mid] <= a[mid+1],我们认为数组已经有序并跳过merge()方法。
c: 可以节省将数组元素复制到用于归并的辅助数组所用的时间。

6.2 自底向上的归并排序
【非递归方法】比较适合链表组织的数据。

public static void sort(Comparable[] a){
      Comparable[] aux = new Comparable[a.length];
      int N  = a.length;
      for (int sz = 1; sz < N ; sz = sz + sz)// sz为子数组的大小
         for (int lo = 0; lo < N-sz; lo += sz+sz)
            merge(a,lo,lo+sz-1,Math.min(lo+sz+sz-1,N-1),aux);
        }