冒泡排序和选择排序

冒泡排序和选择排序

这篇博客开始，我将逐步更新排序算法的学习。

顺序是难度上由易到难，最终循序渐进的理解排序算法的精髓，所有的排序算法都介绍完之后，会对实际使用中排序算法的最佳实践做一个总结，此后再深入jdk源码，看看Java在jdk各种不同的类中提供给我们的排序方法，都用到了怎样的实现。

后面这段话将作为排序算法系列博客每一篇的开头：

为避免文中过多赘述，写在最前面：

1. 接下来所有的排序算法讲解中，无论是思路梳理，还是代码实现，都是最终实现从小到大排序，从大到小可以学会后自行类推。
2. 都是使用int数组进行排序，数据总量为n

---

本章将冒泡排序和选择排序放在一起，首先是由易到难么，这两种排序算法个人认为从思想到实现方式都是最好理解的，就从它们先开始了，其次还因为两种排序思想非常相似所以放在一起来说。

两种排序的核心理念

对于冒泡排序和选择排序来说，它们的核心理念是相同的，都是通过找最值的方式实现对一组数据的排序，区别只在于寻找最值的方式不同。

那么找到最值和最终完成排序要怎么联系起来呢？

思路：

1. 如果我们可以通过一种方式在在一组数据中找到最小值
2. 我们将最小值放在数组的最前面，最小的数字就应该排在第一位，可以发现第一位数排好序了。
3. 之后就可以将后面n-1个数据当做一个新的数组再进行找最小值的操作，第二次再找到最小的数字放在第二个位置，直到第n-1次找到最小的数字放在第n-1个位置后，整个数组就排序完毕了

是不是很容易理解，接下来我们看一下Java代码要如何对上述思路进行实现:

首先分析我们每一次都需要找到最小值放在一个相应的位置，第1次需要找到最小值放在第1个位置，第i次找到第i小的数放在第i个位置，当i=n-1时执行最后一次将第n-1小的数，放在第n-1个位置上排序就完成了，所以一共执行n-1次

也就是外层需要一个n-1次的循环，每次在里边找到最值放在相应位置

        //外层控制找最值的总次数，所以i=1表示从第一趟开始，当等于length就不执行了也就是一共执行length-1趟
        for (int i = 1; i < arr.length; i++) {
            //内层，找到最值放在相应位置，这个在具体的排序算法中进行讨论
        }

之前的博客中介绍过递归，这里也可以用一个递归的思想来解释，假设我们有一个方法max(int i)，可以找到数组中从下标i开始到下标n-1这些数中最小的，并把它放在下标i的位置，那么每次执行完max(i)后，接着执行max(i+1)，直到排到i=n-1，就排序完成了

public void sort(int i){
    max(i);
    if(i<){
        sort(i+1);
    }
}

接下来就看一下，两种排序分别是怎么实现找到最值放在相应位置完成排序的

冒泡排序

冒泡排序找最值的方式是比较+交换，从数组中第一个位置开始向倒数第二个遍历，每次遍历到一个位置，就将这个位置的数字和后一个数字比较大小，如果两个数字是逆序的就交换两个数字的位置（对于从大到小排序来说就是每次都让两个数字大的在后小的在前），遍历结束后就将最大的数字放在了最后面

一句话就是，从前到后两两比较，顺序不管，逆序就交换

用数组[20, 32, 16,7, 26]模拟一下冒泡排序找到最大值放在最后面

1. 先比较第一个和第二个，也就是20和32，是从小到大的，不做改变

2. 再比较第二个和第三个，也就是32和13，是从大到小，逆序的，交换两个数的位置

   交换后：[20, 16, 32,7, 26]

3. 再比较第三个和第四个，也就是32和7，是从大到小，逆序的，交换两个数的位置

   交换后：[20, 16, 7,32, 26]

4. 再比较第四个和第五个，也就是32和26

   交换后：[20, 16, 7,26, 32]

可以发现，这样操作确实像冒泡泡一样将最大值32浮了起来放在了最后面

（如果想把最小值浮到最前面，可以从后向前逆序遍历）

下面用代码完整实现冒泡排序

    public static void bubbleSort(int[] arr){
        //外层控制总趟数，i=1表示从第一趟开始，当等于length就不执行了，也就是一共执行length-1趟
        for (int i = 1; i < arr.length; i++) {
            //内层，进行从第1个数到第length-i个数，依次与后一个数字比较，逆序就交换
            // 这里j=0,因为第一个数下标为0
            for (int j = 0; j < arr.length-i; j++) {
                //如果当前数比后一个大，说明逆序，将两数交换位置
                if (arr[j]>arr[j+1]){
                    //利用临时变量t实现两数交换
                    int t = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = t;
                }
            }
        }
    }

冒泡排序优化

这里其实存在一个问题，按照上面这个代码，即便数组在执行到一半甚至最开始就已经是有序的了，冒泡排序还是会整个循环都执行一遍，内层循环一定会执行n(n-1)/2次

那么怎么优化呢？

当我们判断数组已经是有序的了，排序结束，直接跳出循环即可

那么如何判断数组已经有序了呢？

如果某一趟排序内层冒泡的的时候，一次交换都没有发生，就说明数组是有序的

优化代码如下

    public static void bubbleSort(int[] arr){
        //变量times记录某一趟发生交换的次数，初始化为0
        int times = 0;
        //外层控制总趟数，i=1表示从第一趟开始，当等于length就不执行了，也就是一共执行length-1趟
        for (int i = 1; i < arr.length; i++) {
            //内层，进行从第1个数到第length-i个数，依次与后一个数字比较，逆序就交换
            // 这里j=0,因为第一个数下标为0
            for (int j = 0; j < arr.length-i; j++) {
                //如果当前数比后一个大，说明逆序，将两数交换位置
                if (arr[j]>arr[j+1]){
                    //进入if说明发生交换，让times++
                    times++;
                    //利用临时变量t实现两数交换
                    int t = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = t;
                }
            }
            //内层冒泡结束后，判断times是否大于0
            if(times>0){
                //如果大于0，说明数组还不一定有序，需要继续循环去排序下一趟
                times = 0;
            }else{
                //到这里说明这里次冒泡没有发生交换，数组已经有序
                break;
            }
        }
    }

选择排序

选择排序事实上完全可以理解为对冒泡排序的优化，因为冒泡排序找最值并放在相应位置的方式效率太低了，中间会进行很多次原本没必要进行的两个数据交换的操作

选择排序寻找最值同样也需要遍历数组，我们用一组临时变量来存放最小的数字和它的下标索引，首先将数组中第一个数和下标存入临时变量，后续遍历到每一个数据都和临时遍历中的数对比，如果比它小就替换跟新临时变量到当前数字，比较完最后一个数字之后，临时变量中就是最小的数字了，只需要执行一次交换将这个最小值放到第一个位置即可

实现代码如下：

    public static void selectSort(int[] arr){
        //记录某一趟的最小值位置索引
        int minIndex;
        //比较变量——最终保存某一趟的最小值
        int min;
        for (int i = 0; i < arr.length-1; i++) {
            //每一趟排序开始前，把这一趟要扫描的第一个数放到比较变量上，假定他就是最小的
            minIndex = i;
            min = arr[i];
            //寻找第i+1小的数存入临时变量
            for (int j = i+1; j < arr.length; j++) {
                if (arr[j]<min) {
                    min = arr[j];
                    minIndex = j;
                }
            }
            //一趟排序扫描完毕后，是第几趟就把这一趟找到的最小值和第几个交换，如果当前i索引位置本身就是最小值了，就没有必要执行交换操作
            if (minIndex!=i){
                arr[minIndex] = arr[i];
                arr[i] = min;
            }
        }
    }

比较一下两种排序的效率

我们随机创建8w个数的数组，让两种排序方法进行排序，看看用时情况

        //用80000个数据来测试排序算法
        int[] arr = new int[80000];
        for (int i = 0; i < 80000; i++) {
            arr[i] = (int) (Math.random() * 8000000);
        }

同一台电脑，相同环境下，分别执行五次，记录执行时间（单位ms）

冒泡排序执行时间——8150、8198、8218、8185、8264

选择排序执行时间——1621、1642、1560、1613、1613

可以发现，冒泡排序需要8.2秒左右，选择排序1.6秒左右，效率相差五倍多

下一篇将介绍插入排序和希尔排序，还会更快，可以见得算法的重要性