图解十大排序二------选择排序与插入排序

图解十大排序

2.1 前文回顾

在上篇文章中，给大家介绍了一下冒泡排序，大家还记得冒泡排序的时间复杂度吗？ 让我们来回顾一下

冒泡排序是一种稳定排序，值相等的元素并不会打乱原本的顺序。由于该排序算法的每一轮都要遍历 所有元素，总共遍历（元素数量-1）轮，所以平均时间复杂度是O（n 2）。

• 最佳情况：T(n) = O(n)
• 最差情况：T(n) = O(n2)
• 平均情况：T(n) = O(n2)

那么除了冒泡排序之外，还有俩种排序算法的时间复杂度也是O(n 2)，其中一种是选择排序，一种是插入排序。

2.2 选择排序

选择排序(Selection-sort) 是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕

让我们来看一个例子：假如一群小朋友正在排队做核酸， 需要按照身高从低到高的顺序进行排队，你会如何给小朋友进行排队呢？

1号小朋友比2号高，所以把1号和2号换一个位置！

1号小朋友你比3号高，所以把1号和3号换一个位置！

1号小朋友你比4号高，所以把1号和4号换一个位置！

1号小朋友你比5号高，所以把1号和5号换一个位置！

如此一来，同学们一共交换了4次，还只是完成了冒泡排序的第一 轮操作。_{你见过谁排队这样排？这不就是沙雕}，如果继续下去，人一多的话该怎么办呢？
其实有一种更简单的、也是最贴合实际生活的方法，就是每一次找到个子最矮的学生，直接 交换到队伍的前面。让我们看一看具体的指挥流程

5号小朋友是最矮的，所以把5号和1号换一个位置！

4号小朋友是其余同学最矮的，所以把4号和2号换一个位置！

2号小朋友是其余同学最矮的，所以把3号和2号换一个位置！

已经排好序啦，不用换了！

如此一来，只需要很少的交换次数就可以完成队伍的排序，大家可以更快的做核酸啦，老师和同学也可以花更多的时间来看我写的文章了 _偷笑。

像这样，每一轮选出最小元素直接交换到左侧的思路，就是选择排序。这种排序的最大优势，就是省去了多余的元素交换。

选择排序的代码实现

public static void selectionSort(int [] arr) {
    for (int i = 0; i < arr.length - 1; i++) { 比较arr.length - 1次
        int minIndex = i; //记录最小值的数组下标
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        if (minIndex != i) {  //交换arr[i]和arr[minIndex]
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }
}

public static void main(String[] args) {
    int [] arr = new int[] {3, 5, 2, 6, 4, 8};
    selectionSort(arr);
    System.out.println(Arrays.toString(arr));// Arrays.toString打印数组的内容
}

算法分析：
外循环正好运行 n − 1 次迭代。 但内部循环运行变得越来越短
当 i = 0，内层循环 n − 1 次「比较」操作。
当 i = 1，内层循环 n − 2 次「比较」操作。
当 i = 2，内层循环 n − 3 次「比较」操作。
……
当 i = n − 3，内层循环 2 次「比较」操作。
当 i = n − 2，内层循环 1 次「比较」操作。
因此，总「比较」次数如下：(n - 1) + … + 2 + 1 = n(n - 1) / 2

• 最佳情况：T(n) = O(n)
• 最差情况：T(n) = O(n2)
• 平均情况：T(n) = O(n2)

既然选择排序有着交换次数更少的优点，那为什么它不可以取代冒泡排序呢，就是因为它的不稳定性。也就是说，当数组中包含多个值相等的元素时，选择排序有可能打乱它们原有的顺 序。

2.3 插入排序

插入排序的算法描述是一种简单直观的排序算法。它的工作原理：通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间

通俗点来讲就是说 维护一个有序区，把元素一个个插入有序区的适当位置，直到所有元素都有序为止。让我们来用样例演示

给定无序数组：[3, 5, 2, 6, 4, 8]

把数组中第一个元素3看作有序区，这时元素3就是有序区中唯一的一个元素

第一轮 ：让元素5和有序区的元素从后向前依次比较，此时有序区中只有3这一个元素。5>3, 所以把5放入有序区中3的后面，此时有序区中有2个元素

第二轮 ： 让元素2和有序区的元素依次比较。2<5 把元素2和元素5进行交换， 2<3把2和3进行交换，
此时有序区中有3个元素

第三轮 ：6>5, 所以把元素6放在有序区中5的后面，此时有序区中有4个元素

第四轮 ： 4<6把元素4和元素6进行交换，4<5把元素3和元素5进行交换，此时有序区中有5个元素

第五轮 ： 8>6，把元素8加入有序区，此时有序区中有6个元素，最终排序好的结果如下

大家有没有注意到，在演示的插入排序过程中，当我们把每一个新元素插到有序区的时候，都要进行元素之间的两两交换。
那么我们如何优化可以减少无谓的交换呢？
我们将需要插入的元素暂存起来，再把有序区中大于待插入值的元素从前向后逐一复制，让我们回到第四轮操作

步骤1，另取空间暂存 元素4

步骤2， 和前一个元素比较，由于4<6，把6复制给它下一个位置

步骤3， 和前一个元素比较， 由于4<5， 把5复制给它下一个位置

步骤4， 和前一个元素比较， 由于4>3， 把暂存的元素4赋值到元素3下一个位置

插入排序的代码实现

public static void insertSort(int [] arr) {
    for (int i = 1; i < arr.length; i++) { //插入 arr.length - 1次
        int current = arr[i];  //存放待插入的元素
        int j = i - 1;
        while (j >= 0 && arr[j] > current) {
            arr[j + 1] = arr[j];
            j-- ;
        }
        arr[j + 1] = current;  
    }

}

public static void main(String[] args) {
    int [] arr = new int[] {3, 5, 2, 6, 4, 8};
    insertSort(arr);
    System.out.println(Arrays.toString(arr));// Arrays.toString打印数组的内容
}

• 算法分析
• 最佳情况：T(n) = O(n)
• 最坏情况：T(n) = O(n2)
• 平均情况：T(n) = O(n2)

下篇预告 ：图解十大排序篇三    希尔排序