常见高级排序

高级排序

希尔排序

希尔排序是插入排序的一种，又称缩小增量排序，是插入排序算法的一种更高效的改进版本

需求：

排序前：{9,1,2,5,7,4,8,6,3,5}

排序后：{1,2,3,4,5,5,6,7,8,9}

排序原理：

1.选定一个增长量h，按照增长量h作为数组分组的依据，对数据进行分组 2.对分好组的每一组数据完成插入排序

3.减少增长量，最小减为1，重复第二步操作

 

增长量h的确定：我们这里采用以下规则：

int h=1;
while(h<数组的长度/2){
    h=2*h+1;
}
//循环结束后我们就可以确定h的最大值
//h减小的规则为
h=h/2;

希尔排序的API设计：

类名	Shell
构造方法	shell()：创建Shell对象
成员方法	1. public static void sort(Comparable[] a)：对数组内的元素进行排序 2. private static boolean greater(Comparable v,Comparable w)：判断v是否大于w 3. private static void exch(Comparable[] a,int i,int j)：交换数组中，索引和索引处的值

希尔排序代码实现

public class Shell {
    //构造方法
    public Shell() {}
​
    //排序规则
    public static void sort(Comparable[] a){
        //1.根据数组a的长度，确定增长量h的值
        int h=1;
        while (h<a.length/2){
            h=2*h+1;
        }
        //2.希尔排序
        while (h>=1){
            //排序
            //2.1找到待插入的元素
            for (int i=h;i<a.length;i++){
                //2.2把待插入的元素放到有序数列中
                for (int j=i;j>=h;j-=h){
                    if (greater(a[j-h],a[j])){
                        //交换元素
                        exch(a,j-h,j);
                    }else{
                        break;
                    }
                }
            }
​
            //减小h的值
            h=h/2;
        }
    }
​
    //比较v元素是否大于w元素
    private static boolean greater(Comparable v, Comparable w) {
        return v.compareTo(w)>0;
    }
​
    //数组元素i索引与j索引位置上的值交换位置
    private static void exch(Comparable[] a,int i,int j){
        Comparable temp;
        temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }
}

归并排序

归并排序是建立在归并操作上的一种有效的排序算法，该算法是采用分治法的一个非常典型的应用，将已有序的子序列合并，得到完全有序的序列；即先时每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并

排序原理：

1.尽可能的把一组数据拆分为两个元素相等的子组，并对每一个子组继续拆分，直到拆分后的每个子组的元素个数是1为止

2.将相邻的两个子组进行合并成一个有序的大组

3.不断重复步骤2，直到最终只有一个组为止

 

归并排序API设计

类名	Merge
构造方法	Merge()：创建Merge对象
成员方法	1. public static void sort(Comparable[] a)：对数组内的元素进行排序 2. private static void sort(Comparable[] a,int lo,int hi)：对数组中索引 lo到索引hi之间的元素进行排序 3. private static void merge(Comparable[] a,int lo,int mid,int hi)：从索引 lo到索引mid为一个子组，从索引mid+1到索引hi为另一个子组，把数组a中的这两个子组的数据合并成一个有序的组（从索引 lo到索引hi） 4. private static boolean less(Comparable v,Comparable w)：判断v是否小于w 5. private static void exch(Comparable[] a,int i,int j)：交换数组中，索引i和索引j处的值
成员变量	1. private static Comparable[] assist：完成归并操作需要的辅助数组

归并排序代码实现

public class Merge {
    //归并操作需要的辅助数组
    private static Comparable[] assist;
​
    public Merge() {
    }
​
    //对数组内的元素进行排序
    public static void sort(Comparable[] a){
        //1.初始化辅助数组
        assist=new Comparable[a.length];
        //2.定义一个lo变量和hi变量，用来记录数据中最小索引和最大索引
        int lo=0;
        int hi=a.length-1;
        //3.调用sort重载方法完成数据a中，从索引lo到索引hi的元素的排序
        sort(a,lo,hi);
    }
​
    //对数组中索引 lo到索引hi之间的元素进行排序
    private static void sort(Comparable[] a,int lo,int hi){
        //安全性校验
        if (hi<=lo){
            return;
        }
​
        //对lo到hi之间的数分为两个组
        int mid=lo+(hi-lo)/2;
        //分别对每一组数据进行排序
        sort(a,lo,mid);
        sort(a,mid+1,hi);
        //把两个组数据进行归并
        merge(a,lo,mid,hi);
    }
​
    //比较v元素是否小于w元素
    private static boolean less(Comparable v,Comparable w){
        return v.compareTo(w)<0;
    }
​
    //交换元素位置
    private static void exch(Comparable[] a,int i,int j){
        Comparable temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }
​
    //合并两个子组数据
    private static void merge(Comparable[] a,int lo,int mid,int hi){
        //定义三个指针
        int i=lo;
        int p1=lo;
        int p2=mid+1;
        //遍历：移动p1指针和p2指针，比较对应索引处的值，将较小的放到辅助数组的对应索引处
        while(p1<=mid && p2<=hi){
            if (less(a[p1],a[p2])){
                assist[i++]=a[p1++];
            }else {
                assist[i++]=a[p2++];
            }
        }
​
        //遍历：如果p2的指针没有走完，那么顺序移动p2指针，把对应元素放到辅助数组对应索引处
        while (p1<=mid){
            assist[i++]=a[p1++];
        }
​
        while (p2<=hi){
            assist[i++]=a[p2++];
        }
        //把辅助数组中的元素拷贝到原数组中
        for (int index=lo;index<=hi;index++){
            a[index]=assist[index];
        }
    }
}

归并排序缺点

需要申请额外的数组空间，导致空间复杂度提升，是典型的以空间换时间的造作

快速排序

快速排序是对冒泡排序的一种改进。它的·基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据要小，然后再按此方法对着两部分数据分别进行快速排序，整个排序过程可以递归进行，以此到达整个数据变成有序序列

排序原理：

1.首先设定一个分界值，通过该分界值将数组分成左右两部分

2.将对于或等于分界值的数据放到数组右边，小于分界值的数据放到数组左边，此时左边部分中各元素都小于或等于分界值，右边部分中各元素都大于或等于分界值

3.然后，左边和右边的数据可以独立排序，对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放较大值，右侧的数组数据也可以做类似的处理

4.重复上述过程，可以看出，这是一个递归定义吗，通过递归将左侧部分排好序后，再递归排好右侧部分的顺序，当左侧和右侧两个部分的数据排号序后，整个数组的排序也就完成了

 

切分原理

把一个数组分成两个子数组的基本原理

1.找一个基准值，用两个指针分别指向数组的头部和尾部

2.先从尾部向头部开始搜索一个比基准值小的元素，搜索到即停止，并记录指针的位置

3.再从头部向尾部开始搜索一个比基准值大的元素，搜索到即停止，并记录指针的位置

4.交换当前左边指针和右边指针的位置的元素

5.重复2，3，4步骤，直到左边指针的值大于右边指针的值停止

快速排序API设计

类名	Quick
构造方法	Quick()：创建Quick对象
成员方法	1. public static void sort(Comparable[] a)：对数组内的元素进行排序 2. private static void sort(Comparable[] a,int lo,int hi)：对数组a中索引 lo到索引hi之间的元素进行排序 3. public static int partition(Comparable[],int lo,int hi)：对数组a中，从索引 lo到索引hi之间的元素进行分组，并返回分组界限对应的索引 4. private static boolean less(Comparable v,Comparable w)：判断v是否小于w 5. private static void exch(Comparable[] a,int i,int j)：交换数组中，索引i和索引j处的值

快速排序代码实现

public class Quick {
    //构造方法
    public Quick() {
    }
​
    //判断v是否小于w
    private static boolean less(Comparable v,Comparable w){
        return v.compareTo(w)<0;
    }
​
    //交换数组中，索引 i 和索引 j 处的值
    private static void exch(Comparable[] a,int i,int j){
        Comparable temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }
​
    //对数组内的元素进行排序
    public static void sort(Comparable[] a){
        int lo=0;
        int hi=a.length-1;
        sort(a,lo,hi);
    }
​
    ///对数组a中索引 lo到索引 hi之间的元素进行排序
    private static void sort(Comparable[] a,int lo,int hi){
        //安全性校验
        if (hi<=lo){
            return;
        }
​
        //需要对数组中lo索引到hi索引处的元素进行分组
        int partition = partition(a,lo, hi);//返回分界值位置变换后的索引
        //让左子组有序
        sort(a,lo,partition-1);
        //让右子组有序
        sort(a,partition+1,hi);
    }
​
    //对数组a中，从索引 lo到索引hi之间的元素进行分组，并返回分组界限对应的索引
    public  static int partition(Comparable[] a,int lo,int hi){
        //确定分界值
        Comparable key=a[lo];
        //定义两个指针，分别指向待切分元素的最小索引和最大索引的下一个位置
        int left=lo;
        int right=hi+1;
​
        //切分
        while (true){
            //先从右开始扫描，移动right指针，找到一个比分界值小的元素，停止
            while (less(key,a[--right])){
                if (right==lo){
                    break;
                }
            }
            //再从左往右扫描，移动left指针，找到比分界值大的元素，停止
            while (less(a[++left],key)){
                if (left==hi){
                    break;
                }
​
            }
            /*判断left是否大于等于right，
            如果是，则证明元素扫描完毕，结束循环
            如果不是，则交换元素
            */
            if (left>=right){
                break;
            }else {
                exch(a,left,right);
            }
        }
        //交换分解值
        exch(a,lo,right);
​
        return right;
    }
}