高级排序算法

初级排序方法有直接插入排序、直接交换排序（冒泡）、直接选择排序。对应的高级排序方法分别是shell排序、快速排序、堆排序

另外高级排序算法还有归并排序。

下面演示对数组R[]进行非降排序：

直接插入排序：

    public static int[] InsertSort(int[] R){
        int n =R.length;
        for(int j =1;j<n;j++){
            int i= j-1;
            int K = R[j];
            while(i>=0&&K < R[i]){
                R[i+1]=R[i];
                i--;
            }
            R[i+1] = K;
        }
        return R;
    }

如果将数组的第一个元素置为一个最小值，那么算法中的 while(i>=0&&K<R[i]){……} 可以改写成 while(K<R[i]){……} ;这样就可以节省比较 i 的时间。

直接插入排序（冒泡排序）：

每一趟排序能够找出一个最大值，并把它交换到最终位置。因此每一趟的扫描次数可以减 1 ；

    public static int[] BoubleSort(int[] R){
        int n = R.length;
        for(int j =n-1;j>=1;j--){
            for(int i =1;i<=j;i++){
                if(R[i]<R[i-1]){
                    int t =R[i];
                    R[i] = R[i-1];
                    R[i-1] = t;
                }
            }
        }
        return R;
    }

冒泡排序还可以通过添加标记的方法减少不必要的比较次数，如下代码用 Bound 控制每趟扫描的边界，这样就可以加速算法。

    public static int[] BSort(int[] R){
        int n = R.length;
        int j = n;
        int Bound = n;
        while(Bound!=0){
            Bound = j;
            j = 0;
            for(int i =1;i<Bound;i++){
                if(R[i]<R[i-1]){
                    int t =R[i];
                    R[i] = R[i-1];
                    R[i-1] = t;
                    j = i;
                }
            }
        }
        return R;
    }    

直接选择排序：

直接选择排序每次从待排序列中选出一个最小值（用一个数m来记录最小值的下标，提高算法效率）放在它的最终位置，每次选最小元素的时间复杂度是 O(n) ,有 n 个元素，n*O(n) -> 算法的效率是 O(n*n).

    public static int[] SelectSort(int[] R){
        int n =R.length;
        for(int j =0;j<n;j++){
            int K = R[j];
            int m = j;
            int i = j+1;
            while(i<n){
                if(R[i]<K){
                    K = R[i];
                    m =i;
                }
                i++;
            }
            int t = R[j];
            R[j] = R[m];
            R[m] = t;
        }
        return R;
    }

高级排序算法：

shell 排序：

shell 排序是目前对小规模数据(少于 50 个元素)进行排序的最有效的算法(优于快速排序)，它的主要思想是通过逐减（由大到小）增量对数据进行分组，对每组数据单独使用直接插入排序算法进行组内排序；当增量减小到 1 时，所有的数据变成一组，经过最后一趟直接插入排序后得到有序数列。 shell 排序之所以效率很高，主要是因为当增量很大时，组内一次交换减少的乱序对数量相当可观，因而 shell 排序是很有效的排序算法。

复杂度： shell 排序的时间复杂度与其所选取的增量关系密切，目前已知最好的序列是{1,4,10,23,57,132,301,701,1750……},当渐减增量序列形如 2^p*3^q 时shell排序时间复杂度是 O(n*(log(n))^2) ;

下面我以 n/(2^i),i =1,2,3……为渐减序列进行 shell 排序：

public class ShellSort{
    static int[] a = {0,2,1,8,3,46,85,14,85,78,56,4,5,69,8755,1,12,54,15,5,};
    public static void main(String[] args){
        int n = a.length;
        show(a);
        shell(a);
        System.out.println("shell排序：");
        show(a);
    }
    public static void shell(int[] R){
        //int[] s = {1,4,10,23,57,132,301,701,1750};//目前已知的最好的增量序列
        int n = R.length;
        int h = n;
        while(h != 1){
            for(int i =0;i<h;i++){
                h = h/2;
                InsertSort(R,i,n-1,h);
            }
        }
    }
    public static void InsertSort(int[] R,int a,int b,int h){
        for(int j = a+h;j<=b;j+=h){
            int i =j-h;
            int K = R[j];
            while(i>=a&&K<R[i]){
                R[i+h]=R[i];
                i-=h;
            }
            R[i+h] = K;
        }
    }
    public static void show(int[] a ){
        for(int i =0;i<a.length;i++){
            System.out.print(a[i]+" ");
        }
        System.out.println();
    }    
}

快速排序：

快速排序是一种效率特别高的排序算法，主要思想是首先确定一个基准 R[m] (通常选用第一个元素，当待排序列基本有序时，总是选第一个数作为基准会使算法效率特别低，这时就需要使用三者取中法把R[m],R[n],R[(m+n)/2]中的中间元素交换到R[0]处作为基准);

（1）算法开始时首先初始化两个指针i,j，一个指向基准元素(加 1 操作后指向基准元素的下一个元素)，一个指向最末元素下一个(减 1 操作后指向最末元素)；

（2）然后第一个指针 ( i ) 往后移寻找大于基准的元素找到后停止移动，第二个指针(j)从后往前寻找小于基准的元素找到后停止移动；

（3）当 i,j 未发生交叉时，R[i]<--> R[j];

（4）当 i,j 有交叉时 基准<-->R[j],本趟排序结束,基准交换到它的最终位置(可以根据这一性质设计复杂度为 O(n) 的查找低 i 大元素的算法);

（5）分别对 j  前后的序列进行下一趟快速排序。

class QSort{//排序结果为非降
    static int[] a = {0,2,1,8,3,46,85,14,85,78,56,4,5,69,8755,1,12,54,15,5,};
    public static void main(String[] args){
        //快速排序
        int n = a.length;
        show(a);
        quickSort(a,0,n-1);        
        System.out.println("快速排序");
        show(a);
    }
    public static void quickSort(int[] R,int a,int b){//R[a]~R[b] 
        if(b-a<1){
            return;
        }
        if(b-a==1){
            if(R[a]>R[b]){
                int t = R[a];
                R[a] = R[b];
                R[b] = t;
            }
            return;
        }
        int n = b;
        int m = a;
        int mid = (m+n)/2;
        int t;
        if(R[n]<R[mid]){
            t = R[n];
            R[n] = R[mid];
            R[mid] = t;
        }
        if(R[n]<R[m]){
            t = R[n];
            R[n] = R[m];
            R[m] = t;
        }
        if(R[m]<R[mid]){
            t = R[m];
            R[m] = R[mid];
            R[mid] =t;
        }//三者取中,中值存在R[m]中
        int i =m;
        int j =n+1;
        while(i<j){
            i++;
            while(R[i]<R[m]){
                i++;
            }
            j--;
            while(R[j]>R[m]){
                j--;
            }
            if(i<j){
                t = R[i];
                R[i] = R[j];
                R[j] = t;
            }
        }
        t = R[j];
        R[j] = R[m];
        R[m] = t;
        quickSort(R,m,j-1);
        quickSort(R,j+1,n);
        return;
    }
    public static void show(int[] a ){
        for(int i =0;i<a.length;i++){
            System.out.print(a[i]+" ");
        }
        System.out.println();
    }
}

 

堆排序：

堆排序包含两个过程，第一个过程是初始建堆（由下向上）;第二个过程是堆排序（自上而下），把堆顶与逐末元素交换，再重建堆。

上面两个过程都需要使用算法 Restore(R,f,e) 来调整堆中的元素，每次调整时父节点与儿子结点比较，如果儿子结点比他大就把比较大的儿子结点与父节点互换位置，然后重复此操作直至堆底。

public class HeapSort{
    static int[] a = {0,2,1,8,3,46,85,14,85,78,56,4,5,69,8755,1,12,54,15,5,};
    public static void main(String[] args){
        HeapSort(a);
        System.out.println("堆排序：");
        show(a);
    }
    public static void HeapSort(int[] R){
        int n = a.length;
        for(int i =n-1;i>=0;i-- ){//重建堆：从下向上
            Restore(a,i,n-1);
        }
        for(int i =n-1;i>0;i--){//堆排序：从上向下
            Restore(a,0,i);
            int t = a[0];
            a[0] = a[i];
            a[i] = t;
        }        
    }
    public static void Restore(int[] R,int f,int e){
        int j =f;
        int m;
        while(2*j+1<e){
            if(2*j+2<e&&R[2*j+1]<R[2*j+2]){
                m = 2*j+2;
            }else{
                m = 2*j+1;
            }
            if(R[j]<R[m]){
                int t = R[j];
                R[j] = R[m];
                R[m] = t;
                j = m;
            }else{
                j = e;//跳出循环
            }
        }
    }
    public static void show(int[] a ){
        for(int i =0;i<a.length;i++){
            System.out.print(a[i]+" ");
        }
        System.out.println();
    }    
}

 归并排序：

归并排序与快速排序一样都利用了分治思想，归并排序把排序的问题转化为了合并两个数组的问题，简单易懂。算法的复杂度主要由归并的趟数和数据的规模决定。归并的趟数近视等于 log2(n) （把归并的过程看成一个树结构，树的高度近似是 log2(n) ）,每一趟关键词比较次数复杂度为 O(n) ;整个过程的时间复杂度是 n*log(n) 。

public class MSort{
    static int[] a = {0,2,1,8,3,46,85,14,85,78,56,4,5,69,8755,1,12,54,15,5,};
    public static void main(String[] args){
        show(a);
        a = MSort(a);
        System.out.println("MSort:");
        show(a);
    }
    public static int[] MSort(int[] R){
        int n =R.length;
        int[] X = new int[n];
        int length = 1;
        while(length<n){
            int i =0;
            while(i+2*length-1<n){
                Merge(R,i,i+length-1,i+2*length-1,X);
                i = i+2*length;
            }
            if(i+length-1<n-1){
                Merge(R,i,i+length-1,n-1,X);
            }
            length = 2*length;
            int[] t = X;
            X = R;
            R = t;
        }
        return R;
    }
    public static void Merge(int[] R,int a,int b,int c,int[] X){
        int i = a;
        int j = b+1;
        int k = a;
        while(k<=c){
            while(i<=b&&j<=c){
                if(R[j]<R[i]){
                    X[k] = R[j];
                    j++;
                }else{
                    X[k] = R[i];
                    i++;
                }
                k++;
            }
            while(i<=b){
                X[k] = R[i];
                i++;
                k++;
            }
            while(j<=c){
                X[k] = R[j];
                j++;
                k++;
            }
        }
    }
    public static void show(int[] a ){
        for(int i =0;i<a.length;i++){
            System.out.print(a[i]+" ");
        }
        System.out.println();
    }    
}

 

 总结：

时间复杂度 : 所有的简单排序算法再加上直接插入排序的改进算法（shell排序）都是平方阶简单排序算法：O(n^2)，shell排序：O(n*(logn)^2);

高级排序算法中的快速排序，合并排序，堆排序的时间复杂度都是线性对数阶 O(n*logn);

具体的时空复杂度差异：快速排序 < 归并排序 < 堆排序 . 快速排序当值无愧是性能冠军。 

稳定性：高级算法中除归并算法外都不稳定；初级排序算法中除直接选择排序外都是稳定的排序算法。