【数据结构和算法】之排序算法-冒泡，插入，选择排序

算法过程动态图：https://visualgo.net/

一、排序算法对比

二、如何衡量排序算法

1、排序算法的执行效率

• 最好情况、最坏情况、平均情况时间复杂度。（依赖-数据的有序性）
• 时间复杂度的系数、常数 、低阶。（在同一级别数据量时，衡量，就需要把系统，常数，低阶数据考虑在内）
• 比较次数和交换（或移动）次数（排序过程中，数据交换的次数）

2、排序算法的内存消耗

• 算法的内存消耗可以通过空间复杂度来衡量，排序算法也不例外
• 原地排序（Sorted in place）。原地排序算法，就是特指空间复杂度是 O(1) 的排序算法

3、排序算法的稳定性

• 如果待排序的序列中存在值相等的元素，经过排序之后，相等元素之间原有的先后顺序不变，叫稳定的排序算法。否则叫不稳定的排序算法。
• 稳定排序算法，减少对象交换的次数。

 

排序算法稳定性的案例

我们现在要给电商交易系统中的“订单”排序。订单有两个属性，一个是下单时间，另一个是订单金额。如果我们现在有 10 万条订单数据，我们希望按照金额从小到大对订单数据排序。对于金额相同的订单，我们希望按照下单时间从早到晚有序。

做法：

（1）先对订单时间进行排序，形成新的数组。

（2）使用稳定排序算法，对新数组使用稳定排序算法，按金额进行排序。

 

稳定排序算法可以保持金额相同的两个对象，在排序之后的前后顺序不变。第一次排序之后，所有的订单按照下单时间从早到晚有序了。在第二次排序中，我们用的是稳定的排序算法，所以经过第二次排序之后，相同金额的订单仍然保持下单时间从早到晚有序。

 

 

三、冒泡排序算法

1、第一次冒泡操作的过程

每次冒泡操作都会对相邻的两个元素进行比较，看是否满足大小关系要求。如果不满足就让它俩互换。一次冒泡会让至少一个元素移动到它应该在的位置，重复 n 次，就完成了 n 个数据的排序工作。

2、整个冒泡操作的过程

 

3、算法实现

 /**
     * 冒泡:从小到大排序
     * @param array
     * @return
     */
    public static int[] bubbleSort(int[] array) {
        if (array == null || array.length <= 1) {
            return array;
        }

        int tmp = 0;
        //冒泡排序，数组长度为n,只需要冒n-1次泡，即可完成排序
        //外层循环是为了控制冒泡次数的。(因为1次冒泡，能从数组中找到一个有序数)
        for (int i = 0; i < array.length-1; i++) {
            //如果在一次冒泡中未发生数字交换，则说明数组此时已经是有序了，无需再进行接下来的冒泡排序了。
            boolean already = true;
            //里层循环是每次从剩余未有序数组里找到1个最大的。
            //比如 不有序数组为[9,8,7,6,5]
            //第一次排序结果[8,7,6,5,9]，其中不有序是[8,7,6,5] , 有序是[9]
            //第二次排序结果[7,6,5,8,9], 其中不有序是[7,6,5]   , 有序是[8,9]
            //第三次排序结果[6,5,7,8,9], 其中不有序是[6,5]   ,   有序是[7,8,9]
            //第四次排序结果[5,6,7,8,9], 其中不有序是[5]   ,   有序是[6,7,8,9]
            for (int j = 0; j <= array.length-1-i;j++) {
                if(array[j]>array[j+1]){
                    tmp =array[j];
                    array[j]=array[j+1];
                    array[j+1]=tmp;
                    //有发生交换,说明此时数组还是无序状态
                    already=false;
                }
            }
            if(already){
                break;
            }
        }
        return array;
    }

4、算法分析

• 空间复杂度：原地排序，则为O(1)
• 是否为稳定排序算法：相邻两个元素大小相等，不进行交换，故是稳定排序算法。
• 时间复杂度：0(n^2)

平均情况下的时间复杂是多少呢?前面讲过，平均时间复杂度就是加权平均期望时间复杂度，分析的时候要结合概率论的知识.

有序度:是数组中具有有序关系的元素对的个数。有序元素对用数学表达式表示就是这样：

有序元素对：a[i] <= a[j], 如果i < j。

同理，对于一个倒序排列的数组，比如 6，5，4，3，2，1，有序度是 0；对于一个完全有序的数组，比如 1，2，3，4，5，6，有序度就是 n*(n-1)/2，也就是 15。我们把这种完全有序的数组的有序度叫作满有序度。

逆序度：

逆序元素对：a[i] > a[j], 如果i < j。

逆序度 = 满有序度 - 有序度

冒泡排序包含两个操作原子，比较和交换。每交换一次，有序度就加 1。不管算法怎么改进，交换次数总是确定的，即为逆序度，也就是n*(n-1)/2–初始有序度。

此例中就是 15–3=12，要进行 12 次交换操作。

对于包含 n 个数据的数组进行冒泡排序，平均交换次数是多少呢？

• 最坏情况下，初始状态的有序度是 0，所以要进行 n*(n-1)/2 次交换。
• 最好情况下，初始状态的有序度是 n*(n-1)/2，就不需要进行交换。
• 我们可以取个中间值 n*(n-1)/4，来表示初始有序度既不是很高也不是很低的平均情况。换句话说，平均情况下，需要 n*(n-1)/4 次交换操作，比较操作肯定要比交换操作多，而复杂度的上限是 O(n2)，所以平均情况下的时间复杂度就是 O(n2)。
• 这个平均时间复杂度推导过程其实并不严格，但是很多时候很实用，毕竟概率论的定量分析太复杂，不太好用。等我们讲到快排的时候，我还会再次用这种“不严格”的方法来分析平均时间复杂度。

 

三、插入排序算法

我们将数组中的数据分为两个区间，已排序区间和未排序区间。初始已排序区间只有一个元素，就是数组的第一个元素。插入算法的核心思想是取未排序区间中的元素，在已排序区间中找到合适的插入位置将其插入，并保证已排序区间数据一直有序。重复这个过程，直到未排序区间中元素为空，算法结束。

1、插入排序分析

空间复杂度：O(1)

是否稳定排序算法：插入排序中，对于值相同的元素，我们可以选择将后面出现的元素，插入到前面出现元素的后面，这样就可以保持原有的前后顺序不变，所以插入排序是稳定的排序算法。

时间复杂度：

• 最好时间复杂度O(n)
• 最坏时间复杂度O(n^2)
• 平均时间复杂度为 O(n^2)。

2、插入排序的案例

/**
     * 插入排序：从小到大
     *
     * @param array
     * @return
     */
    public static int[] insertSort(int[] array) {
        if (array == null || array.length <= 1) {
            //临界条件
            return array;
        }
        int length = array.length;

        //比如原始数组是[8,3,6,4,2,10,4]
        //第一次外层循环, 其中有序数组是[8]              待插入元素是3,      排序结果[3,8,6,4,2,10,4]
        //第二次外层循环, 其中有序数组是[3,8]            待插入元素是6,      排序结果[3,6,8,4,2,10,4]
        //第三次外层循环, 其中有序数组是[3,6,8]          待插入元素是4,      排序结果[3,4,6,8,2,10,4]
        //第四次外层循环, 其中有序数组是[3,4,6,8]        待插入元素是2,      排序结果[2,3,4,6,8,10,4]
        //第五次外层循环, 其中有序数组是[2,3,4,6,8]      待插入元素是10,     排序结果[2,3,4,6,8,10,4]
        //第六次外层循环, 其中有序数组是[2,3,4,6,8,10]   待插入元素是4,      排序结果[2,3,4,4,6,8,10]

        //默认第一个元素就是有序数组，从第二个元素开始进行插入排序
        for (int i = 1; i < length; i++) {

            int compare = array[i];//给比较元素赋值
            int j = i - 1;
            //开始从有序数字的尾巴向前找合适的位置
            for (; j >= 0; --j) {
                if (array[j] > compare) {
                    array[j + 1] = array[j];
                } else {
                    //已经找到合适位置,需要进行循环中断
                    break;
                }
            }
            array[j + 1] = compare;
        }

        return array;

    }

public static int[] insertSortArray(int[] target){
        if(target==null||target.length<=1){
            return target;
        }
        int length=target.length;
        //外层循环从第一个元素开始向后排序
        //例如 [8,4,7,9,10]从4开始向后遍历
        //第一轮遍历结果：[4,8       7,9,10]
        //第二轮遍历结果：[4,7,8     9,10]
        //第三轮遍历结果：[4,7,8,9   ,10]
        //第四轮遍历结果：[4,7,8,9,10   ]
        for(int i=1;i<length;i++){
            int tmp=0;
            //内存循环,从自身开始，向有序数组进行遍历比较
            for(int j=i;j>=1;j--){
                if(target[j]<target[j-1]){
                    tmp=target[j];
                    target[j]=target[j-1];
                    target[j-1] =tmp;
                    continue;
                }
                break;
            }
        }
        return target;
    }

四、选择排序算法

选择排序算法的实现思路有点类似插入排序，也分已排序区间和未排序区间。但是选择排序每次会从未排序区间中找到最小的元素，将其放到已排序区间的末尾。

1、选择排序分析

空间复杂度:O(1)

是否稳定排序算法：不稳定排序算法;比如 5，8，5，2，9 这样一组数据，使用选择排序算法来排序的话，第一次找到最小元素 2，与第一个 5 交换位置，那第一个 5 和中间的 5 顺序就变了，所以就不稳定了。正是因此，相对于冒泡排序和插入排序，选择排序就稍微逊色了。

时间复杂度：

• 选择排序的最好情况时间复杂度、最坏情况和平均情况时间复杂度都为 O(n2)

 

2、选择排序案例

public void selectionSort(int[] a,int n){
        if(n<=1){return ;}
        for(int i=0;i<n;i++){

            //声明最小变量为未排序空间的第一个值
            int min=a[i];
            //声明未排序空间最小值的下标
            int minIndex=i;

            for(int j=i;j<n;j++){
                //从未排序的部分找到最小值
                if(min>a[j]){
                    min=a[j];
                    minIndex=j;
                }
            }

            //将最小值放入已排序空间的最后1个位置
            int temp=a[i];
            a[i]=min;
            a[minIndex]=temp;
        }
    }

3、总结

 

如果对于链表进行排序的话，执行冒泡，插入，选择排序的如何进行

觉得应该有个前提，是否允许修改链表的节点value值，还是只能改变节点的位置。

一般而言，考虑只能改变节点位置

• 冒泡排序相比于数组实现，比较次数一致，但交换时操作更复杂；
• 插入排序，比较次数一致，不需要再有后移操作，找到位置后可以直接插入，但排序完毕后可能需要倒置链表；
• 选择排序比较次数一致，交换操作同样比较麻烦。
• 综上，时间复杂度和空间复杂度并无明显变化，若追求极致性能，冒泡排序的时间复杂度系数会变大，插入排序系数会减小，选择排序无明显变化。