《数据结构与算法之美》——冒泡排序、插入排序、选择排序

排序,是每一本数据结构的书都绕不开的重要部分。

排序的算法也是琳琅满目、五花八门。

每一个算法的背后都是智慧的结晶,思想精华的沉淀。

个人觉得排序算法没有绝对的孰优孰劣,用对了场景,就是最有的排序算法。

当然,撇开这些业务场景,排序算法本身有一些自己的衡量指标,比如我们经常提到的复杂度分析。

我们如何分析一个算法?

排序算法的执行效率

1、最好、最坏和平均情况的时间复杂度

2、时间复杂度的系数、常数和低阶

一般来说,在数据规模n很大的时候,可以忽略这些,但是如果我们需要排序的数据规模在几百、几千,那么这些指标就变的更加重要。

3、比较的次数和移动的次数

排序的过程涉及数据的比较和交换(移动)

排序算法的内存消耗

除了时间复杂度,我们还有空间复杂度,用来衡量内存消耗。这里我们引入原地排序的概念。原地排序即特指空间复杂度为O(1)的排序算法。

排序算法的稳定性

什么是稳定性,这比较抽象。

举个例子,现在有一组集合1,3,5,3,7

按照从小打到的顺序进行排序,结果应该是1,3,3,5,7

稳定指的是原集合的第二个3仍然在第四个3前面。不稳定则情况相反。

冒泡排序

原理

相邻元素两两比较,如果满足大小关系就保持不动,如果不满足,则两两交换位置,以此类推,直到集合有序为止。

之所以叫冒泡排序,因为其过程就犹如水中的气泡,泡泡越大的就在上面,越小的就在下面。

举例

现在给定一个集合4,5,6,3,2,1

第一次冒泡过程如下所示

619240-20190113212334498-1884184339.png

可以看出在这趟冒泡中,最大的泡泡6已经到达最高的位置,要让集合中所有元素都有序,还要继续冒泡,如下图:

619240-20190113212343781-1016986241.png

代码


package com.jackie.algo.geek.time.chapter11_sort;

/**
 * @Author: Jackie
 * @date 2019/1/12
 */
public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = new int[]{100,82,74,62,54,147};
        bubbleSort(arr);
        bubbleSort2(arr);
    }
    /**
     * 外层i的循环代表比较的趟数,内层j的循环代表的元素位置
     *  a[0],a[1],a[2],a[3],a[4],a[5]
     *  第一趟走完,最大的元素冒泡到最后a[5]的位置,需要比较的位置即为:
     *  a[0],a[1],a[2],a[3],a[4]
     *  所以可以看到j的终止条件是动态变化的,与i的位置相关,趟数每增加一次,终止的位置就往前挪一个,因为每次都能固定一个元素
     *
     *  注意这里的边界条件,是<还是<=
     *  第一层是小于,因为是从0开始,对于上面的例子来说,是比较length-1=6-1=5趟,因为总共6个元素,只要5趟就能比较完成
     *  好比有两个元素,只要一趟就能比较完成
     *  第二层是同样的道理,假设在i=0时,length-i-1=6-0-1=5,
     *  但是这里<,所以只会到j=4,乍一看你会觉得之比较到了a[j]=a[4],最后a[5]是不是就丢了
     *  其实不是,仔细看下面的比较条件就会发现有a[j+1]即a[5]
     *  所以,综上内层和外层都是从0开始,且都是<而不是<=
     */
    public static void bubbleSort(int[] arr) {
        int length = arr.length;
        if (length <= 0) {
            return;
        }
        int temp;
        for (int i = 0; i < length - 1; i++) {
            boolean flag = false;
            for (int j = 0; j < length - i - 1; j++) {
                if (arr[j] > arr[j+1]) {
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;

                    flag = true;
                }
            }
            if (!flag) {
                System.out.println("total loop: " + (i+1) + " times, stop at index:" + i);
                break;
            }
        }
        for (int i = 0; i < length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
    /**
     * 和上面的不同之处在于,上面的是保证数组从后往前有序,这里的是保证从前往后的有序
     * 上面的做法如下所示,每次要遍历的元素如下
     * a[0],a[1],a[2],a[3],a[4],a[5]
     * a[0],a[1],a[2],a[3],a[4]     (这里不再遍历a[5]的位置,因为a[5]在第一轮遍历已是最大,不需要参与遍历,下面遍历同理)
     * a[0],a[1],a[2],a[3]
     * a[0],a[1],a[2]
     * a[0],a[1]
     * a[0]
     *
     * 下面的做法如下所示,每次要遍历的元素如下
     * a[0],a[1],a[2],a[3],a[4],a[5]
     *      a[1],a[2],a[3],a[4],a[5]   (这里不再遍历a[0]的位置,因为a[0]在第一轮遍历已是最小,不需要参与遍历,下面遍历同理)
     *           a[2],a[3],a[4],a[5]
     *                a[3],a[4],a[5]
     *                     a[4],a[5]
     *                          a[5]
     */
    public static void bubbleSort2(int[] arr) {
        int length = arr.length;
        if (length <= 0) {
            return;
        }
        int temp;
        for (int i = 0; i < length - 1; i++) {
            boolean flag = false;
            for (int j = length - 1; j > i; j--) {
                if (arr[j] < arr[j-1]) {
                    temp = arr[j];
                    arr[j] = arr[j-1];
                    arr[j-1] = temp;

                    flag = true;
                }
            }
            if (!flag) {
                System.out.println("total loop: " + (length - i - 1) + " times, stop at index:" + i);
                break;
            }
        }
        for (int i = 0; i < length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
}

写这类算法对于边界判定、起始条件和结束条件要非常谨慎,比如是用<还是用<=;是从0开始还是从1开始;是到length结束还是到length-1结束。

看似惺忪平常,有时候弄错一个符号就无法得到正确的排序结果。

冒泡排序的这些注意事项已经写在代码的注释中,参见如上代码。

同时,代码已经上传至Github

各项指标

1、是否是原地排序

是,因为冒泡排序只涉及两两元素交换,空间复杂度为O(1)

2、是否是稳定排序

是,对于元素相等的情况,不会交换顺序

3、时间复杂度

平均时间复杂度是O(n2), 这里是n的平方

插入排序

原理

对于给定集合,从左至右,依次保证当前元素的左边集合有序。然后依次顺延当前位置,直至遍历完所有集合元素,保证整个集合有序。

有点抽象,没有关系,看举例。

举例

借用文章https://www.cnblogs.com/bjh1117/p/8335628.html中的例子说明插入排序的过程。


待比较数据:7, 6, 9, 8, 5,1



  第一轮:指针指向第二个元素6,假设6左面的元素为有序的,将6抽离出来,形成7,_,9,8,5,1,从7开始,6和7比较,发现7>6。将7右移,形成_,7,9,8,5,1,6插入到7前面的空位,结果:6,7,9,8,5,1



  第二轮:指针指向第三个元素9,此时其左面的元素6,7为有序的,将9抽离出来,形成6,7,_,8,5,1,从7开始,依次与9比较,发现9左侧的元素都比9小,于是无需移动,把9放到空位中,结果仍为:6,7,9,8,5,1



  第三轮:指针指向第四个元素8,此时其左面的元素6,7,9为有序的,将8抽离出来,形成6,7,9,_,5,1,从9开始,依次与8比较,发现8<9,将9向后移,形成6,7,_,9,5,1,8插入到空位中,结果为:6,7,8,9,5,1



  第四轮:指针指向第五个元素5,此时其左面的元素6,7,8,9为有序的,将5抽离出来,形成6,7,8,9,_,1,从9开始依次与5比较,发现5比其左侧所有元素都小,5左侧元素全部向右移动,形成_,6,7,8,9,1,将5放入空位,结果5,6,7,8,9,1。



  第五轮:同上,1被移到最左面,最后结果:1,5,6,7,8,9。

代码


package com.jackie.algo.geek.time.chapter11_sort;

/**
 * @Author: Jackie
 * @date 2019/1/13
 */
public class InsertSort {
    public static void main(String[] args) {
        int[] arr = new int[]{100,82,74,62,54,147};
        insertSort(arr);
    }
    /**
     * 借用https://www.cnblogs.com/bjh1117/p/8335628.html文中的举例,我们可以看到一个完整的插入排序的过程
     * 通过这个过程,我们可以更好的理解插入排序的思想
     * 待比较数据:7, 6, 9, 8, 5,1
     *
     *   第一轮:指针指向第二个元素6,假设6左面的元素为有序的,将6抽离出来,形成7,_,9,8,5,1,从7开始,6和7比较,发现7>6。将7右移,形成_,7,9,8,5,1,6插入到7前面的空位,结果:6,7,9,8,5,1
     *
     *   第二轮:指针指向第三个元素9,此时其左面的元素6,7为有序的,将9抽离出来,形成6,7,_,8,5,1,从7开始,依次与9比较,发现9左侧的元素都比9小,于是无需移动,把9放到空位中,结果仍为:6,7,9,8,5,1
     *
     *   第三轮:指针指向第四个元素8,此时其左面的元素6,7,9为有序的,将8抽离出来,形成6,7,9,_,5,1,从9开始,依次与8比较,发现8<9,将9向后移,形成6,7,_,9,5,1,8插入到空位中,结果为:6,7,8,9,5,1
     *
     *   第四轮:指针指向第五个元素5,此时其左面的元素6,7,8,9为有序的,将5抽离出来,形成6,7,8,9,_,1,从9开始依次与5比较,发现5比其左侧所有元素都小,5左侧元素全部向右移动,形成_,6,7,8,9,1,将5放入空位,结果5,6,7,8,9,1。
     *
     *   第五轮:同上,1被移到最左面,最后结果:1,5,6,7,8,9。
     *
     * 所以插入排序是保证一个元素的左边所有元素都是有序的,然后逐渐右移,直到遍历完所有的元素来保证整个数据是有序的
     * 下面i从1开始,是表示以a[1]作为哨兵,第一次比较是a[0]和其比较,这里的j的其实位置都是小于i一个位移,即j=i-1
     * 然后依次从右向左挨个比较,如果发现哨兵值小于左侧有序集合,则一直位移,以此保证始终留有一个位置用于插入待排序的值
     * 一旦发现哨兵值如果大于等于(保证稳定性,即不会跑到等于某个值的左侧)左侧集合中的某个值,
     * 则跳出内层循环,仔细想想左侧集合是有序的就明白了
     * 至于最后为什么是a[j+1]=value,直觉上更应该是a[j]=value,但是记得,在跳出内层循环的时候进行了一次j--操作,
     * 所以需要把这个操作补偿进来,变成了j+1
     */
    public static void insertSort(int arr[]) {
        int length = arr.length;
        if (length <= 0) {
            return;
        }
        for (int i = 1; i < length; i++) {
            int value = arr[i];
            int j = i - 1;

            for (; j >= 0; j--) {
                if (arr[j] > value) {
                    arr[j+1] = arr[j];  // 位移
                } else {
                    break;
                }
            }
            arr[j+1] = value;
        }
        for (int i = 0; i < length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
}

同冒泡排序,有关边界判定、起始条件和结束条件也都写在注释中,不再赘述。

各项指标

1、是否是原地排序

是,同冒泡排序,空间复杂度为O(1)

2、是否是稳定排序

是,对于元素相等的情况,不会交换顺序

3、时间复杂度

平均时间复杂度是O(n2), 这里是n的平方

选择排序

原理

选择排序思想和插入排序思想比较接近。每次排序从未排序的集合中找到最小的元素放进有序集合,通过这样的遍历排序保证整个集合有序。

举例

619240-20190113212357814-1305507263.png

代码


package com.jackie.algo.geek.time.chapter11_sort;

/**
 * @Author: Jackie
 * @date 2019/1/13
 */
public class SelectionSort {
    public static void main(String[] args) {
        int[] arr = new int[]{100,82,74,62,54,147};
        selectionSort(arr);
    }
    public static void selectionSort(int[] arr) {
        int length = arr.length;
        if (length <= 1) return;

        for (int i = 0; i < length - 1; ++i) {
            // 查找最小值
            int minIndex = i;
            for (int j = i + 1; j < length; ++j) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            // 交换
            int tmp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = tmp;
        }
        for (int i = 0; i < length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

各项指标

1、是否是原地排序

是,同冒泡排序,空间复杂度为O(1)

2、是否是稳定排序

否,通过元素的交换可能改变原来的稳定结构,比如5,8,5,2,9,第一次排序后,5和2交换,则第一个5就跑到第二个5后面了,破坏了稳定结构。

3、时间复杂度

平均时间复杂度是O(n2), 这里是n的平方,且最好最坏都是O(n2)。

声明:

文中图片来自极客时间王争老师专题《数据结构与算法之美》

转载于:https://www.cnblogs.com/bigdataZJ/p/algo-bubble-insert-selection-sort.html

版权声明:本文为baixieyun4655原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/baixieyun4655/article/details/101318592