高级排序java实现（希尔归并快速）

Posted 2022-12-10 枸杞仙人

高级排序

• 希尔排序
• • 排序原理
  • API设计
  • 代码实现
  • 时间复杂度分析
• 归并排序
• • 排序原理
  • 归并原理
  • API设计
  • 代码实现
  • 时间复杂度分析
• 快速排序
• • 排序原理
  • API设计
  • 切分原理
  • 代码实现
  • 快速排序和归并排序的区别
  • 时间复杂度分析

基础排序，包括冒泡排序，选择排序还有插入排序的时间复杂度都是O(N^2)，而平方阶随着输入规模的增大，时间成本将急剧上升，所以这些基本排序方法不能处理更大规模的问题，我们需要一些高级的排序算法，争取降低算法的时间复杂度最高阶次幂。

希尔排序

希尔排序是插入排序的一种，又称“缩小增量排序”，是插入排序算法的一种更高效的改进版本。对于插入排序，如果已排序的分组元素为2,5,7,9,10，未排序的分组元素为1,8，那么下一个待插入元素为1，我们需要拿着1从后往前，依次和10,9,7,5,2进行交换位置，才能完成真正的插入，每次交换只能和相邻的元素交换位置。那如果我们要提高效率，直观的想法就是一次交换，能把1放到更前面的位置，比如一次交换就能把1插到2和5之间，这样一次交换1就向前走了5个位置，可以减少交换的次数，这样的需求如何实现呢？接下来我们来看看希尔排序的原理。

排序原理

1. 选定一个增长量h，按照增长量h作为数据分组的依据，对数据进行分组；
2. 对分好组的每一组数据完成插入排序；
3. 减小增长量，最小减为1，重复第二步操作。

其中h初始值的确定和后续的递减按照以下规则：

int h = 1;
while(h<length/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)：交换a数组中，索引i和索引j处的值

代码实现

Shell类：

public class Shell 
    public static void sort(Comparable[] a)
        //1.根据数组a的长度确定增长量h的初始值
        int h = 1;
        while(h<a.length/2)
            h = h * 2 + 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]))
                        exchange(a,j,j-h);
                    else
                        break;
                    
                
            
            //减小h的值
            h = h/2;
        
    

    private static boolean greater(Comparable a, Comparable b)
        return a.compareTo(b) > 0;
    

    private static void exchange(Comparable[] a, int i, int j)
        Comparable temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    

Test类：

public class ShellTest 
    public static void main(String[] args) 
        Comparable[] a = 4,5,6,1,2,3;
        Shell.sort(a);
        System.out.println(Arrays.toString(a));
    

时间复杂度分析

在希尔排序中，增长量h并没有固定的规则，有很多论文研究了各种不同的递增序列，但都无法证明某个序列是最好的，对于希尔排序的时间复杂度分析没有必要，但是我们可以使用事后分析法对希尔排序和插入排序做性能比较。通过测试发现，在处理大批量数据时，希尔排序的性能确实高于插入排序。

归并排序

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

排序原理

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)：对数组a中从索引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)：交换a数组中，索引i和索引j处的值
成员变量	1.private static Comparable[] assist：完成归并操作需要的辅助数组

代码实现

Merge类：

public class Merge 
    //归并需要的辅助数组
    private static Comparable[] assist;

    //对a进行排序
    public static void sort(Comparable[] a)
        assist = new Comparable[a.length];
        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;
        
        int mid = lo + (hi-lo)/2;
        //对lo到mid进行排序
        sort(a,lo,mid);
        //对mid+1 到hi进行排序
        sort(a,mid+1,hi);
        //合并排序完成的两个数组
        merge(a,lo,mid,hi);
    

    //把a中的lo到mid为一组，mid+1到hi为一组，把这两组进行合并
    private static void merge(Comparable[] a,int lo, int mid, int hi)
        //先把数组归并到辅助数组assist对应的索引处
        int i = lo; //辅助数组上的指针，指向assist数组中需要填充数据的那个索引
        int p1 = lo;//左边数组上的指针，指向当前左数组所在的索引
        int p2 = mid+1;//右边数组上的指针，指向当前右数组所在的索引

        //比较左数组和右数组中的指针所指的元素大小，把小的那个填充到assist中，然后把指向那个数的指针往后移动一位，assist指针也往后一位
        while(p1<=mid && p2<=hi)
            if (less(a[p1],a[p2]))
                assist[i++] = a[p1++];
            else
                assist[i++] = a[p2++];
            
        

        //如果循环退出的条件是p1》mid 那么左边数组已经全部归并完毕，需要把右边数组剩下的内容填充进assist。
        while(p1<=mid)
            assist[i++] = a[p1++];
        
        while(p2<=hi)
            assist[i++] = a[p2++];
        

        //到这一步排序已经完成了，只需要把已经排好序的assist数组重新拷贝回a数组即可
        for (int j = lo; j <= hi; j++) 
            a[j] = assist[j];
        
    

    //比较两个数的大小
    private static boolean less(Comparable a, Comparable b)
        return a.compareTo(b) < 0;
    

    //交换
    private static void exchange(Comparable[] a, int i,int j)
        Comparable temp=a[i];
        a[i] = a[j];
        a[j] = temp;
    

Test类：

public class MergeTest 
    public static void main(String[] args) 
        Comparable[] a = 4,5,6,1,2,3;
        Merge.sort(a);
        System.out.println(Arrays.toString(a));
    

时间复杂度分析

用树状图来描述归并，如果一个数组有8个元素，那么它将每次除以2找最小的子数组，共拆log8次，值为3，所以树共有3层,那么自顶向下第k层有$2^k$个子数组，每个数组的长度为$2^{3-k}$，归并最多需要$2^{3-k}$次比较。因此每层的比较次数为 $2^k\times 2^{3-k}=2^3$,那么3层总共为 $3\times 2^3$。
假设元素的个数为n，那么使用归并排序拆分的次数为$lo{g}_2(n)$,所以共$lo{g}_2(n)$层，那么使用$lo{g}_2(n)$替换上面$3\times 2^3$中 的3这个层数，最终得出的归并排序的时间复杂度为：$lo{g}_2(n)\times 2^{lo{g}_2(n)}=lo{g}_2(n)\times n$,根据大O推导法则，忽略底
数，最终归并排序的时间复杂度为$O(n\times logn)$;

• 归并排序的缺点：
  需要申请额外的数组空间，导致空间复杂度提升，是典型的以空间换时间的操作。
• 归并排序与希尔排序性能测试：
  之前我们通过测试可以知道希尔排序的性能是由于插入排序的，那现在学习了归并排序后，归并排序的效率与希尔排序的效率哪个高呢？通过测试，发现希尔排序和归并排序在处理大批量数据时差别不是很大。

快速排序

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

排序原理

1. 首先设定一个分界值，通过该分界值将数组分成左右两部分；
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[] a,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)：交换a数组中，索引i和索引j处的值

切分原理

把一个数组切分成两个子数组的基本思想：

1. 找一个基准值，用两个指针分别指向数组的头部和尾部；
2. 先从尾部向头部开始搜索一个比基准值小的元素，搜索到即停止，并记录指针的位置；
3. 再从头部向尾部开始搜索一个比基准值大的元素，搜索到即停止，并记录指针的位置；
4. 交换当前左边指针位置和右边指针位置的元素；
5. 重复2,3,4步骤，直到左边指针的值大于等于右边指针的值停止。
6. 交换此时左右指针指向的数和partition的位置。

代码实现

Quick类：

public class Quick 

    public static void sort(Comparable[] a) 
        int lo = 0;
        int hi = a.length-1;
        sort(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的元素进行分组，并返回分组界限对应的索引
    private static int partition(Comparable[] a, int lo, int hi) 
        //确定分界值
        Comparable key = a[lo];
        //定义两个指针，分别指向待切分元素的最小索引处和最大索引处的下一位
        int left = lo;
        int right = hi+1;

        //切分（因为不确定扫描次数所以使用while语句）
        while (true)
            //先从右往左扫描，移动right指针，找到一个比分界值小的数停止
            while(less(key,a[--right]))
                if (right == lo)
                    break;
                
            
            //再从左往右扫描，移动left指针，找到一个比分界值大的数停止
            while(less(a[++left],key))
                if (left == hi)
                    break;
                
            
            //判断left>=right？如果是证明扫描完毕，停止扫描,交换partition和right即可，如果不是，则交换元素
            if (left>=right)
                exchange(a,right,lo);
                break;
            else
                exchange(a,left,right);
            
        
        return right;
    

    //比较两个数的大小
    private static boolean less(Comparable a, Comparable b) 
        return a.compareTo(b) < 0;
    

    //交换
    private static void exchange(Comparable[] a, int i, int j) 
        Comparable temp = a[i];
        a[i] = a[j以上是关于高级排序java实现（希尔归并快速）的主要内容，如果未能解决你的问题，请参考以下文章
 
 Java实现快速排序
 常见排序算法的实现（归并排序快速排序堆排序选择排序插入排序希尔排序）
 排序算法二（归并排序快速排序希尔排序）
 Python实现希尔排序快速排序归并排序
 Python八大算法的实现，插入排序希尔排序冒泡排序快速排序直接选择排序堆排序归并排序基数排序。
 数据结构与算法从零开始系列：冒泡排序选择排序插入排序希尔排序堆排序快速排序归并排序基数排序