图解选择排序与插入排序

上一篇详述了冒泡排序及其优化，有兴趣的能够看看：

如何优化冒泡排序？

1、选择排序（SelectionSort）

• 算法思想：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，而后，再从剩余未排序元素中继续寻找最小（大）元素，而后放到已排序序列的末尾。以此类推，直到全部元素均排序完毕。
• 排序过程：（默认升序）

1. 从原序列中找到最小值，与数组第一个元素交换；
2. 除第一个元素外，从剩下未排序的序列中找到最小值，与数组第二个元素交换；
3. 共N-1趟，每趟都找到未排序的最小值，放到已排序的序列后面。

如图所示，每一趟找到未排序的最小值，并放到有序序列的后面（即当前趟对应于数组中的第几个元素）。

• java实现选择排序：

 private static <T extends Comparable<? super T>> void selectionSort(T[] nums) {
        if (null == nums || nums.length == 0) {
            throw new RuntimeException("数组为null或长度为0");
        }
        int length = nums.length;
        int minValueIndex = 0;
        T temp = null;
        for (int i = 0; i < length - 1; i++) {
            minValueIndex = i;
            for (int j = i + 1; j < length; j++) {
                if (nums[j].compareTo(nums[minValueIndex]) < 0) {
                    minValueIndex = j;
                }
            }
            if (minValueIndex != i) {
                temp = nums[i];
                nums[i] = nums[minValueIndex];
                nums[minValueIndex] = temp;
            }
        }
    }
复制代码

• 时间、空间复杂度及稳定性分析：

1. 最好时间复杂度：最好状况是输入序列已经升序排列，须要比较n*(n-1)/2次，但不须要交换元素，即交换次数为：0；因此最好时间复杂度为O(n^2)。
2. 最坏时间复杂度：最坏状况是输入序列是逆序的，则每一趟都须要交换。即须要比较n*(n-1)/2次，元素交换次数为：n-1次。因此最坏时间复杂度仍是O(n^2)。
3. 平均时间复杂度：O(n^2)。
4. 空间复杂度：只用到一个临时变量，因此空间复杂度为O(1)；
5. 稳定性：不稳定排序。如序列3，5，3，1。第一次交换结果为1，5，3，3，咱们发现原序列的第一个3排在了第二个3的后面。

2、插入排序（InsertSort）

• 算法思想：经过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序于是在从后向前扫描过程当中，须要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

• 排序过程：（默认升序）

  InsertionSort 和打扑克牌时，从牌桌上逐一拿起扑克牌，在手上排序的进程相同。

  举例：

  Input: {4, 3, 8, 5, 2, 6, 1, 7}。

1. 首先拿起第一张牌, 手上有 {4}。

2. 拿起第二张牌 3, 把 3insert 到手上的牌 {4}, 获得 {3 ，4}。

3. 拿起第三张牌 8, 把 8 insert 到手上的牌 {3，4 }, 获得 {3 ，4，8}。

4. 以此类推。

   插入排序由N-1趟排序组成。对于p=1到N-1趟排序后，插入排序保证从位置0到位置p上的元素为已排序状态。即插入排序利用了从位置0到p-1位置上已经有序的条件，将位置p上的元素向前查找适当的位置插入此元素。

   

   如图所示：在第p趟，咱们将位置p上的元素向左移动，直到它在前p+1个元素（包括当前位置的元素）中的正确位置被找到。

• java实现插入排序

  private static <T extends Comparable<? super T>> void insertSort(T[] nums) {
        if (null == nums || nums.length == 0) {
            throw new RuntimeException("数组为null或长度为0");
        }
        int length = nums.length;
        T temp = null;
        int i = 0;
        for (int p = 1; p < length; p++) {
            temp = nums[p];
            for (i = p; i > 0 && (temp.compareTo(nums[i - 1]) < 0); i--) {
                nums[i] = nums[i - 1];
            }
            nums[i] = temp;
        }
    }
  复制代码

• 时间、空间复杂度及稳定性分析：

1. 最好时间复杂度：最好状况就是，序列已是升序排列了，在这种状况下，须要进行的比较操做需n-1次便可。即最好时间复杂度为O(n)。
2. 最坏时间复杂度：最坏状况就是，序列是降序排列，那么总共须要n(n-1)/2次比较；移动次数（赋值操做）是比较次数减去n-1次（由于每一次循环的比较都比赋值多一次，共n-1次循环），即n(n-1)/2 - (n-1)；因此最坏时间复杂度为O(n^2)。
3. 平均时间复杂度：O(n^2)。
4. 空间复杂度：只用到一个临时变量，因此空间复杂度为O(1)；
5. 稳定性：稳定。

3、总结

​ 选择排序的主要优势与数据移动有关。若是某个元素位于正确的最终位置上，则它不会被移动。选择排序每次交换一对元素，它们当中至少有一个将被移到其最终位置上，所以对n个元素的表进行排序总共进行n-1次交换。在全部的彻底依靠交换去移动元素的排序方法中，选择排序属于很是好的一种。选择排序最好、最坏时间复杂度都为O(n^2)，空间复杂度为O(1)，属于不稳定排序。

​ 插入排序不适合对于数据量比较大的排序应用。可是，若是须要排序的数据量很小，例如，量级小于千；或者若已知输入元素大体上按照顺序排列，那么插入排序仍是一个不错的选择。插入排序最好时间复杂度为O(n)、最坏时间复杂度为O(n^2)，空间复杂度为O(1)，属于稳定排序。