“有匪君子，如切如磋，如琢如磨 ”

概述

冒泡排序、选择排序、插入排序三种排序算法的时间复杂度为，经常被用来作为排序算法的入门。虽然这三种排序算法相对于其他高级排序算法时间效率较低，但是仍然有学习的价值。

• 实际系统应用的算法都是经过综合优化后，初等排序算法可以用作高级排序算法的优化的子过程，例如插入排序常常被用作小规模算法的实现。
• 初等算法的实现过程的方法思想可以被借鉴。

初等排序算法共同思路是把待排序的序列分为已排序部分（如下绿色部分）和未排序（如下红色部分）部分，然后对未排序部分处理，将其逐个合并到已经排序部分，差异之处在于合并的方法。

排序.png

冒泡

思想

核心思想是从序列的一端开始寻找第i大，将其放置于最终排序的位置，寻找第i个元素的过程是不停的交换，如下图所示。

冒泡排序动态演示

实现

冒泡排序的算法具体实现，根据每次冒泡找到的是最小还是最大有两种实现方式。

• 寻找最小者

    static void bubble_min(T arr[], int size) {
        for (int i = 0; i < size; i++) {
            for (int j = size - 1; j > 0; j--) {
                if (arr[j] < arr[j - 1]) {
                    swap(arr[j], arr[j - 1]);
                }
            }
        }
    }

• 寻找最大者

static void bubble_max(T arr[], int size) {
        for (int i = size-1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if (arr[j] > arr[j + 1]) {
                    swap(arr[j], arr[j + 1]);
                }
            }
        }
    }

• 边界值
  边界值选取直接决定实现的算法是否正确，边界值的选取依赖于对于算法思想的理解和对于每个变量的定义。
  在寻找最小者实现中：外层循环变量i的含义是每次冒泡确定下来的最小元素在数组中的下标，想要对整个数组实现排序，小元素的下标小，该变量应该覆盖数组全部元素，所以i的范围应该是；变量j的含义是内层循环过程用来交换两个元素的下标较大者，按照这种定义j的范围应该是,下面的比较、交换的元素就是j，j-1，这里需要注意的是变量含义的定义和后续的实现应该匹配，只要内在的逻辑自洽即可。
  在寻找最大者实现中：外层循环变量i的含义是每次冒泡确定下来的最大元素在数组中的下标。想要对整个数组实现排序，小元素的下标小，该变量应该覆盖数组全部元素，所以i的范围应该是；变量j的含义是内层循环过程用来交换两个元素的下标较小者，按照这种定义j的范围应该是,下面的比较、交换的元素就是j，j+1，这里需要注意的是变量含义的定义和后续的实现应该匹配，只要内在的逻辑自洽即可。
• 实测用时
  冒泡排序的时间复杂度是,通过实测记录其用时曲线如下，类似一条抛物线。
  冒泡排序用时

优化

如果内层循环在一轮下来已经没有发生交换，说明“未排序”部分已经有序，则排序循环可以终止，实现如下。

    static void bubble_op(T arr[], int size) {
        for (int i= 0; i < size - 1; i++) {
            bool swap_flag = false;
            for (int j = size - 1; j > 0; j--) {
                if (arr[j] < arr[j - 1]) {
                    swap(arr[j], arr[j - 1]);
                    swap_flag = true;
                }
            }
            if (false == swap_flag) {
                break;
            }
        }
    }

选择

思想

冒泡排序的是通过把较小者不停向前交换达到将无序部分合并到有序部分，其实我们需要达到的目的是找到最小者，所以是否可以避免无用的交换，只需在找到最小者后将其交换到合适的位置即可。

选择排序动态演示

实现

使用一个变量记录内层循环每次找到的最小索引，内层循环结束后将交换到合适位置。

    static void select(T arr[], int size) {
        for (int i = 0; i < size; i++) {
            int min = i;
            for (int j = i + 1; j < size; j++) {
                if (arr[j] < arr[min]) {
                    min = j;
                }
            }
            swap(arr[i], arr[min]);
        }
    }

• 边界
  外层循环需要遍历到数组所有元素所以i范围是,内层循环在范围内搜索最小者。

插入

思想

image.png

插入排序类似在玩扑克牌的时候手中牌已经有序，从牌堆中抓取一张牌，然后将其插入到手中合适的位置。插入排序的优点是可以提前完成内层循环，即对于近乎有序序列可以效率很高。

实现

    static void insert(T arr[], int size){
        // i 待插入元素
        for (int i = 1; i < size; i++) {
            // j 待考察的插入位置
            for (int j = i - 1; j >= 0; j--) {
                if (arr[j + 1] < arr[j]) {
                    swap(arr[j + 1], arr[j]);
                }
                else {
                    break;
                }
            }
        }
    }

边界

外层循环变量指示待插入的元素，认为第一个元素只有其自身，已经有序，所以的范围是。内层循环变量用来表示下一个待插入的位置，其范围是,内层循环比较的时候应该将当前插入位置和下一个插入位置元素比较。

优化

之前的实现方式中的内层循环中，如果后一个元素小于前一个元素则需要不停的交换两者，以达到找寻合适位置的目的。由于前边有序部分的已经完成排序，现在只是需要将新考察的元素插入。可以将考察元素依次和有序元素比较，如果待考察元素小于有序元素则将有序元素后移，否则待考察元素已经找到合适位置，如下动图所演示。

插入排序动态演示

具体代码如下

    static void insert_op(T arr[], int size) {
        for (int i = 1; i < size; i++) {
            int j = i - 1;
            T   v = arr[i];
            for (; (j >= 0) && (arr[j] > v); j--) {
                arr[j + 1] = arr[j];
            }
            arr[j + 1] = v;
        }
    }

希尔

思想

插入排序的优势在处理序列元素个数较少并且近乎有序的序列，但是极端情况下对于逆序序列内层循环每次都需要全部执行完，这样插入插入排序的时间复杂度就退化成.Donald Shel 1959年提出希尔（shell）排序算法，其核心思想是对待排序序列使用固定间隔分成若干组，对每一个分组内的元素使用插入排序，然后变更固定间隔，最后一次以1为间隔执行插入排序。希尔排序是先在总体让序列有序，然后在一步步细化。希尔排序对使用的间隔序列对输入序列规模有依赖，通常选用序列。

实现

static void shell(T arr[], int size) {
        int d = 0;
        while ((3 * d + 1) < size)d++;
        for (; d >= 0; d--) {
            int h = 3 * d + 1;
            for (int i = h; i < size; i++) {
                int j = i - h;
                T v = arr[i];
                for (; (j >= 0) && (arr[j]>v); j -= h) {
                    arr[j + h] = arr[j];
                }
                arr[j + h] = v;
            }
        }
    }