基本排序算法总结

最新推荐文章于 2021-05-12 22:35:54 发布

xkd-ys

最新推荐文章于 2021-05-12 22:35:54 发布

阅读量252

点赞数

文章标签：排序算法数据结构快速排序算法

本文链接：https://blog.csdn.net/weixin_42579576/article/details/106676572

版权

1. 简单排序

1.1 冒泡排序

需求：

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

排序原理：

比较相邻的元素。如果前一个元素比后一个元素大，就交换这两个元素的位置。
对每一对相邻元素做同样的工作，从开始第一对元素到结尾的最后一对元素。最终最后位置的元素就是最大

值。

动态演示：

代码实现：

public static void sort(Comparable[] a){
       for (int i =0;i<a.length;i++){
           for (int j=0;j<a.length-1-i;j++){
               if (greater(a[j],a[j+1])){ //比较大小
                   exch(a,j,j+1);   //交换
               }
           }
       }
    }

冒泡排序的时间复杂度分析：

冒泡排序使用了双层for循环，其中内层循环的循环体是真正完成排序的代码，所以，我们分析冒泡排序的时间复杂度，主要分析一下内层循环体的执行次数即可。

在最坏情况下，也就是假如要排序的元素为{6,5,4,3,2,1}逆序，那么：

元素比较的次数为：

(N-1)+(N-2)+(N-3)+…+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;

元素交换的次数为：

(N-1)+(N-2)+(N-3)+…+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;

总执行次数为：

(N^2/2-N/2)+(N2/2-N/2)=N^2-N;

按照大O推导法则，保留函数中的最高阶项那么最终冒泡排序的时间复杂度为O(N^2)

2.2 选择排序

排序原理：

1.每一次遍历的过程中，都假定第一个索引处的元素是最小值，和其他索引处的值依次进行比较，如果当前索引处的值大于其他某个索引处的值，则假定其他某个索引出的值为最小值，最后可以找到最小值所在的索引

2.交换第一个索引处和最小值所在的索引处的值

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-f1jERwUn-1591799273819)(C:\Users\YS520ZZZ\AppData\Roaming\Typora\typora-user-images\1591710962156.png)]$

 public static void sort(Comparable[] a){
        for (int i=0;i<a.length-1;i++){
            int index = i;
            for (int j=i+1;j<a.length;j++){
                if (greater(a[index],a[j])){
                    index=j;
                }
            }
            exch(a,i,index);
        }

    }

时间复杂度：

N^{2/2-N/2+（N-1）=N}2/2+N/2-1;

根据大O推导法则，保留最高阶项，去除常数因子，时间复杂度为O(N^2);

2.3 插入排序

动画演示：

排序原理：

1.把所有的元素分为两组，已经排序的和未排序的；

2.找到未排序的组中的第一个元素，向已经排序的组中进行插入；

3.倒叙遍历已经排序的元素，依次和待插入的元素进行比较，直到找到一个元素小于等于待插入元素，那么就把待

插入元素放到这个位置，其他的元素向后移动一位；
在这里插入图片描述

public static void sort(Comparable[] a){
        for (int i=1;i<a.length;i++){
            for (int j=i;j>0;j--){
            //比较j和他前一个位置的值，如果比前一个小，交换
                if (greater(a[j-1],a[j])){
                    exch(a,j-1,j);
                }else {
                    break;
                }
            }
        }
    }

时间复杂度分析：

插入排序使用了双层for循环，其中内层循环的循环体是真正完成排序的代码，所以，我们分析插入排序的时间复

杂度，主要分析一下内层循环体的执行次数即可。

最坏情况，也就是待排序的数组元素为{12,10,6,5,4,3,2,1}，那么：

比较的次数为：

(N-1)+(N-2)+(N-3)+…+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;

交换的次数为：

(N-1)+(N-2)+(N-3)+…+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;

总执行次数为：

(N^2/2-N/2)+(N2/2-N/2)=N^2-N;

按照大O推导法则，保留函数中的最高阶项那么最终插入排序的时间复杂度为O(N^2)

2. 高级排序

1.1 希尔排序

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

排序原理：

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

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XrVqGZT8-1591799223293)(C:\Users\YS520ZZZ\AppData\Roaming\Typora\typora-user-images\1591757131467.png)]$

 public static void sort(Comparable[] a){
        int N=a.length;
        int h=1;
        while (h<N/2){
            h=2*h+1;
        }
        while (h>=1){
            for (int i=h;i<N;i++){
                for (int j=i;j>=h;j-=h){
                    if (greater(a[j-h],a[j])){
                        exch(a,j,j-h);
                    }else {
                        break;
                    }

                }
            }
            h=h/2;
        }
    }

2.2 归并排序

动画演示：

排序原理：

尽可能的一组数据拆分成两个元素相等的子组，并对每一个子组继续拆分，直到拆分后的每个子组的元素个数是1为止。
将相邻的两个子组进行合并成一个有序的大组；
不断的重复步骤2，直到最终只有一个组为止。

在这里插入图片描述

private static Comparable[] assist;//归并所需要的辅助数组
    //对数组内的元素进行排序
    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)/2;
        //对lo到mid进行排序分组
        sort(a,lo,mid);
        //对mid到hi进行排序分组
        sort(a,mid+1,hi);
        //进行归并排序
        merge(a,lo,mid,hi);

    }
    /**
     * 从索引lo到索引mid为一个子组，
     * 从索引mid+1到索引hi为另一个子组，
     * 把数组a中的这两个子组的数据合并成一个有序的大组（从索引lo到索引hi）
     *
     */
    private static void merge(Comparable[] a, int lo, int mid, int hi){
        int i=lo;
        int p1=lo;//指向左子组的第一个元素
        int p2=mid+1;//指向右子组的第一元素
        //比较两边的大小
        while (p1<=mid & p2<=hi){
            if (greater(a[p2],a[p1])){
                assist[i]=a[p1];
                p1++;
                i++;
            }else {
                assist[i]=a[p2];
                p2++;
                i++;
            }
        }
        //左子组没走完
        while(p1<=mid){
            assist[i++]=a[p1++];
        }
        //右自组没走完
        while(p2<=hi){
            assist[i++]=a[p2++];
        }
        //将assist数组lo*hi的元素拷贝到数组a中
        for (int index=lo;index<=hi;index++){
            a[index]=assist[index];
        }

    }
    private static boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }
    private static void exch(Comparable[] a,int i,int j){
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }

2.3 快速排序

快速排序是对冒泡排序的一种改进。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一

部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序

过程可以递归进行，以此达到整个数据变成有序序列。

动画演示

排序原理：

首先设定一个分界值，通过该分界值将数组分成左右两部分；
将大于或等于分界值的数据放到到数组右边，小于分界值的数据放到数组的左边。此时左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值；
然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左侧和右侧两个部分的数据排完序后，整个数组的排序也就完成了。

在这里插入图片描述

 //对数组内的元素进行排序
    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;
        }
        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){
            //从左往右扫描找到一个比基准数大的数
            while (!greater(a[++left],key)){
                if (left==hi){
                    break;
                }
            }
            //从右往左找找到一个比基准数小的数
            while(!greater(key,a[--right])){
                if (right==lo){
                    break;
                }
            }
            if (left>=right){
                break;
            }else {
                exch(a,left,right);
            }
        }
        exch(a,lo,right);
        return right;
    }
    private static boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }
    private static void exch(Comparable[] a,int i,int j){
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }

快速排序和归并排序的区别：

快速排序是另外一种分治的排序算法，它将一个数组分成两个子数组，将两部分独立的排序。快速排序和归并排序

是互补的：归并排序将数组分成两个子数组分别排序，并将有序的子数组归并从而将整个数组排序，而快速排序的

方式则是当两个数组都有序时，整个数组自然就有序了。在归并排序中，一个数组被等分为两半，归并调用发生在

处理整个数组之前，在快速排序中，切分数组的位置取决于数组的内容，递归调用发生在处理整个数组之后。

2.4 排序的稳定性

稳定性的定义：

数组arr中有若干元素，其中A元素和B元素相等，并且A元素在B元素前面，如果使用某种排序算法排序后，能够保

证A元素依然在B元素的前面，可以说这个该算法是稳定的。

稳定性的意义：

如果一组数据只需要一次排序，则稳定性一般是没有意义的，如果一组数据需要多次排序，稳定性是有意义的。例

如要排序的内容是一组商品对象，第一次排序按照价格由低到高排序，第二次排序按照销量由高到低排序，如果第

二次排序使用稳定性算法，就可以使得相同销量的对象依旧保持着价格高低的顺序展现，只有销量不同的对象才需

要重新排序。这样既可以保持第一次排序的原有意义，而且可以减少系统开销。

3. 六种排序算法时间复杂度与稳定性比较

[外链图片转存中...(img-N8HnFhrY-1591799223300)]

xkd-ys

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
基本排序算法总结

1. 简单排序1.1 冒泡排序需求：排序前：{4,5,6,3,2,1}排序原理：比较相邻的元素。如果前一个元素比后一个元素大，就交换这两个元素的位置。对每一对相邻元素做同样的工作，从开始第一对元素到结尾的最后一对元素。最终最后位置的元素就是最大值。动态演示：代码实现：public static void sort(Comparable[] a){ for (int i =0;i<a.length;i++){ for (int j
复制链接

扫一扫