常见的三种排序(冒泡排序、插入排序、选择排序)

冒泡排序

什么是冒泡排序？

百度百科解释：

它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

按照我的理解其实很简单，比较两个相邻数据的大小，如果满足大小关系，则数据不变动，否者将他们的位置互换，所以，一次冒泡完毕之后，至少一个数据已经移动到它该待的位置，所以像对n个数据排序，那么只需要进行n（或者n-1）次冒泡即可得到最终的排序结果。

我们来举个例子，现在有一组数据：6，5，4，3，2，1，我们现在需要将这些数据从小到大排序，需要怎么做呢？我们现在就用冒泡排序实现一下，请看冒泡的动态图：

不知道看完这张动态图，你是否对冒泡排序有所认识了呢？这时候你可能会发现，数据被交换了很多次，这样会影响性能吗？我会在后面总结的时候说明。

下面我们来看代码实现：

 /**
     * 排序
     *
     * @param arr
     * @return
     */
    private static int[] sort(int[] arr) {
        int tmp = 0;
        int length = arr.length;
        for (int i = 0; i < length; i++) {
            for (int j = i + 1; j < length; j++) {
                if (arr[i] > arr[j]) {
                    tmp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = tmp;
                }
            }
        }
        return arr;
    }

    public static void main(String[] args) {
       // int[] arr = DataUtil.getRandomNum();
        int[] arr ={6,5,4,3,2,1};
        //开始时间
        long startTime = System.currentTimeMillis();
        arr = sort(arr);
        //结束时间
        long endTime = System.currentTimeMillis();
        DataUtil.print(arr, startTime, endTime);
    }

DataUtil.java

 public static void print(int[] arr, long startTime, long endTime) {
        int length = arr.length;
        for (int i = 0; i < length; i++) {
            System.out.print("  " + arr[i]);
            /*if (i % 5 == 0) {
                System.out.println(" ");
            }*/
        }
        System.out.println(" ");
        System.out.println("数组大小:" + arr.length);
        System.out.println("所花时间:" + (endTime - startTime) + " ms");
    }

tmp：存储需要交换的临时变量

执行结果如下：

你会发现，数组的顺序已经由小到大排列完成，由于数据比较少，所花时间可以忽略不记。

插入排序

百度百科概念：

插入排序（Insertion sort）是一种简单直观且稳定的排序算法。如果有一个已经有序的数据序列，要求在这个已经排好的数据序列中插入一个数，但要求插入后此数据序列仍然有序，这个时候就要用到一种新的排序方法——插入排序法,插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据。

插入排序的基本思想是：每步将一个待排序的记录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。

我的理解：如果往一个有序的数组中插入数据，那么只需要将这个数据与有序数组中最后一位开始比大小，如果大，直接再数据后面添加，如果小将数据往后移一位，集合和上一个数据对比，直到找出比插入数据小的数据，然后将需要插入的数据插入到此数据后面一位，如果找到第一位都没有找到，那么就将此数据插入到数组的第一位，这是针对有序数组，那无序数组我们可以通过插入排序计算吗？也是可以的，我们只需要将数组的第一位当成有序数组，后面的数据当成无序数组，然后操作就和前面说的有序数组是一样的，概念说了这么多，我们还是来看一下插入排序的动图，方便大家理解：

数组的原始数据还是：6，5，4，3，2，1，通过插入排序之后数组的顺序变成了1，2，3，4，5，6，需要选择插入的是从第二个元素开始，然后分别与前面有序的数组进行对比。

代码实现：

 /**
     * 排序
     *
     * @param arr
     * @return
     */
    public static int[] sort(int[] arr) {
        int n = arr.length;
        if (n <= 1) {
            return arr;
        }
        for (int i = 1; i < n; 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; // 插入数据
        }
        return arr;
    }

    public static void main(String[] args) {
        //int[] arr = DataUtil.getRandomNum();
        int[] arr ={6,5,4,3,2,1};
        long startTime = System.currentTimeMillis();
        arr = sort(arr);
        long endTime = System.currentTimeMillis();
        DataUtil.print(arr, startTime, endTime);
    }

其中DataUtil.print(arr, startTime, endTime);请参考冒泡排序。

结果：

选择排序

百度百科：

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。

数组中从第一个元素开始，与后面的所有元素进行对比，如果不满足大小关系，则互换位置，否者不东，继续下一位做判断，直到走到数组的最后一位位置，我们来看动图：

我们可以很直观的看出这里都是拿目前最小的数据与后面的数据做对比，然后再做位置的交换，第一个位置的时候找到了数组中最小的元素，将它与第一个元素互换位置，所以这时候第一个元素就已经是最小元素了，后面的以此类推。

代码实现：

 /**
     * 从小到大排序
     *
     * @param arr
     * @return
     */
    private static int[] sort(int[] arr) {
        int length = arr.length;
        for (int i = 0; i < length - 1; i++) {
            int index = i;
            for (int j = i + 1; j < length; j++) {
                if (arr[j] < arr[index]) {
                    index = j;
                }
            }
            if (index != i) {
                int tmp = 0;
                tmp = arr[index];
                arr[index] = arr[i];
                arr[i] = tmp;
            }
        }
        return arr;
    }


    public static void main(String[] args) {
        //int[] arr = DataUtil.getRandomNum();
        int[] arr ={6,5,4,3,2,1};
        //开始时间
        long startTime = System.currentTimeMillis();
        arr = sort(arr);
        long endTime = System.currentTimeMillis();
        DataUtil.print(arr, startTime, endTime);

    }

输出结果：

到这里这三种排序就已经说的差不多了，我们现在再来对比一下这三种排序算法。

总结对比

空间复杂度冒泡排序、插入排序、选择排序的空间复杂度都是：O(1)。因为数据交换的元素都是固定的，是一个常量，所以空间复杂度为O(1)。

时间复杂度冒泡排序：O(n^2)插入排序：O(n^2)选择排序：O(n^2)

性能对比我随机生成10w条数据的数组，然后分别用这三种排序方式进行排序，然后记录时间。生成随机数的代码如下：

 public static int[] getRandomNum() {
        int num = 100000;
        int[] arr = new int[num];
        int i = 0;
        for (; ; ) {
            if (i >= arr.length) {
                break;
            }
            Random r = new Random();
            arr[i] = r.nextInt(num) + 1;
            i++;
        }
        return arr;
    }

冒泡排序： 第一次：18395 ms 第二次：17758 ms 第三次：17792 ms插入排序： 第一次：1098 ms 第二次：1124 ms 第三次：1093 ms选择排序： 第一次：5776 ms 第二次：6432 ms 第三次：5367 ms

结合上诉测试结果来看，性能方面应该是：选择排序 > 插入排序 > 冒泡排序

为什么空间复杂度、时间复杂度都是一样的，为什么三者的性能回差距那么大呢？因为插入排序只需要一次操作就能完成，而冒泡需要三次，选择排序有时候一组有时候三次，不要小看这里的操作次数，数据量小的时候我们看不错什么变化，单数数据量一大，这些都是会占用内存空间的。

冒泡排序应该是我们学习排序时候的第一个算法把，也是最简单的一个，同时效率也是最低的一个，这就是为什么现在很多程序员喜欢用插入排序而不想用冒泡排序的原因之一。