「这是我参与11月更文挑战的第5天，活动详情查看：2021最后一次更文挑战」。

因比赛原因使用Java语言进行编写，后续考虑更新js/ts版本...

基本介绍

• 内部排序
  • 将需要处理的所有数据都加载到内部存储器中进行排序。
  • 分类
    • 插入排序
      • 直接插入排序（稳定，不占用额外空间，O(n2)）
      • 希尔排序（不稳定，不占用额外空间，O(nlogn)）
    • 选择排序
      • 简单选择排序（不稳定，不占用额外空间，O(n2)）
      • 堆排序（不稳定，不占用额外空间，O(nlogn)）
    • 交换排序
      • 冒泡排序（稳定，不占用额外空间，O(n2)）
      • 快速排序（不稳定，不占用额外空间，O(nlogn)）
    • 归并排序（稳定，占用额外空间，O(nlogn)）
    • 基数排序（桶排序）:（稳定，占用额外空间，O(n*桶的个数)）
• 外部排序

时间复杂度

• 方法
  • 事后统计法
  • 事前估算法
• 时间频度 T(n) ：一个算法中语句的执行次数
  • 算法话费的时间与算法中语句执行次数成正比
• 时间复杂度 O(n
  • T(n)不同，O(n)可能相同
  • 常见的时间复杂度
    • 1、log2n、n、nlog2n、n2、n3、nk、2n、n！
• 平均时间复杂度
• 最坏时间复杂度

空间复杂度

该算法所消耗的存储空间

相关概念

• 稳定：排序后不改变原来的相对位置，比如a=b，a原本在b之前，排序后仍在b之前
• 不稳定
• 内排序：所有排序操作在内存中进行
• 外排序：数据量过大，把数据放在磁盘中，需要磁盘和内存的数据传输才能进行

冒泡排序

从前到后依次比较相邻元素的值，发现逆序这交换，使值比较大的逐渐从前移向后。

• 规则

  • 一共进行数组的大小-1次的循环
  • 每一趟排序的次数在逐渐的减少
  • 如果我们发现在某趟排序中，没有发生一次交换，可以提前结束排序（优化）

public static void bubbleSort(int[] arr) {
    int temp = 0; //临时变量
    boolean flag = false; //标识变量，表示是否进行过排序
    for (int i = 0; i < arr.length - 1; i++) {
        for (int j = 0; j < arr.length - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                flag = true;
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        //优化点
        if (!flag) {
            //在一趟排序中。一次交换也没有发生，说明已经有序
            break;
        } else {
            //重置flag，进行下次判断
            flag = false;
        }
    }
}
复制代码

选择排序

按指定规则选出某个元素，再依规定交换位置后达到排序的目的。

• 规则

  • 一共有n-1轮排序
  • 假定当前的数是最小数，从后面的每个数一次比较
  • 如果找到更小数，重新确定最小数，获得下标
  • 遍历完本轮数组后，进行交换
  • 之后缩减范围，继续重复过程

public static void selectSort(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        int minIndex = i;
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[j] < arr[minIndex]) {
                //如果发现不是最小值，记录最小值下标
                minIndex = j;
            }
        }
        //发现min下标发生改变
        if (minIndex != i) {
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }
}
复制代码

插入排序

对欲排序的元素以插入的方式找寻该元素的适当位置，以达到排序的目的

public static void insertSort(int[] arr) {
    for (int i = 1; i < arr.length; i++) {
        int insertVal = arr[i]; //存储要插入的值
        int index = i - 1; //待插入的数的前一个数的下标，该数之前的数组已经有序
        while (index >= 0 && arr[index] > insertVal) {
            //将该位置的数后移
            arr[index + 1] = arr[index];
            //继续向前查找
            index--;
        }
        //判断是否需要插入
        if (index + 1 != i) {
            //当退出循环时，说明插入位置已经找到
            arr[index + 1] = insertVal;
        }
    }
}
复制代码

存在问题：当需要插入的数是比较小的数时，后移的次数明显增多，对效率有影响

希尔排序

缩小增量排序

//交换法(效率低)
public static void shellSort(int[] arr) {
    int temp = 0;
    //获取gap:步长，组数
    for (int gap = arr.length / 2; gap > 0; gap /= 2) {
        //gap初始位置为第一个组的第二个元素，gap每加1，切换一个组，逐个与前面同组的进行比较
        for (int i = gap; i < arr.length; i++) {
            //向前比较，比较范围不断扩大，直到整个组
            for (int j = i - gap; j >= 0; j -= gap) {
                //如果当前元素大于加上步长后的那个元素，说明交换
                if (arr[j] > arr[j + gap]) {
                    temp = arr[j];
                    arr[j] = arr[j + gap];
                    arr[j + gap] = temp;
                }
            }
        }
    }
}
​
//插入法
public static void shellSort2(int[] arr) {
    //获取步长
    for (int gap = arr.length / 2; gap > 0; gap /= 2) {
        //从第gap个元素，逐个对齐所在的组进行直接插入排序
        for (int i = gap; i < arr.length; i++) {
            //当前要插入元素的下标和值
            int index = i;
            int value = arr[index];
            if (arr[index] < arr[index - gap]) {
                while (index - gap >= 0 && arr[index] < arr[index - gap]) {
                    arr[index] = arr[index - gap];
                    index -= gap;
                }
                //找到位置，跳出循环,赋值
                arr[index] = value;
            }
        }
    }
}
复制代码

快速排序

冒泡排序的改进，基本思想：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分数据比另一部分数据都要小，然后再按子方法分别进行快速排序。过程可递归运行

// 快速排序
public static void quickSort(int[] arr, int left, int rigth) {
    int l = left;// 左下标
    int r = rigth;// 右下标
​
    // pivot 中轴 的值
    int pivot = arr[(rigth + left) / 2];
    int temp = 0;// temp 临时变量为交换时 引用
​
    // while目的：
    // 1、让其比 pivot 小的值 放左边
    // 2、让其比 pivot 大的值 放右边
    while (l < r) {// 前提： 左边始终小于右边的值
        // 在pivot 的左边一直找，找到大于等于 pivot值，才退出
        while (arr[l] < pivot) {
            l += 1;// 或l++，不过 后自增似乎效率低，因为最终还是 l=l+1 既 l+=1
        }
        // 在pivot 的右边一直找，找到小于等于pivot值，才退出
        while (arr[r] > pivot) {
            r -= 1;
        }
​
        // 若 l >= r 则说明 pivot 两边的值已经按照 规则 ：
        // 左边全部小于等于pivot,右边全部大于等于pivot 排列好了(最终结果)
        if (l >= r) {
            break;
        }
​
        // 交换
        temp = arr[l];
        arr[l] = arr[r];
        arr[r] = temp;
​
        // 若交换后发现：arr[l] = arr[pivot] 值相等， 则前移 r--
        if (arr[l] == pivot) {
            r -= 1;
        }
        // 若交换后发现：arr[r] = arr[pivot] 值相等， 则后移 l++
        if (arr[r] == pivot) {
            l += 1;
        }
    }
​
    // 若 l==r ,则必须 l++，r-- 否则陷入死循环，导致栈溢出
    if (l == r) {
        l += 1;
        r -= 1;
    }
​
    // 向左递归
    if (left < r)
        quickSort(arr, left, r);
    // 向右递归
    if (rigth > l)
        quickSort(arr, l, rigth);
}
复制代码

归并排序

采用分治思想

public class MergeSort {
    public static void main(String[] args) {
        int[] arr = {8, 4, 5, 7, 1, 3, 6, 2};
        int[] temp = new int[arr.length];
        mergeSort(arr, 0, arr.length - 1, temp);
        System.out.println(Arrays.toString(arr));
    }
​
    public static void mergeSort(int[] arr, int left, int right, int[] temp) {
        if (left < right) {
            int mid = (left + right) / 2; //中间索引
            mergeSort(arr, left, mid, temp);
            mergeSort(arr, mid + 1, right, temp);
            //分解完合并
            merge(arr, left, mid, right, temp);
        }
    }
​
    //合并方法
    public static void merge(int[] arr, int left, int mid, int right, int[] temp) {
        int i = left; // 初始化i，左边有序序列的初始索引
        int j = mid + 1; // 初始化j，右边有序序列的初始索引
        int t = 0; // 指定temp数组的当前索引
​
        //先把左右两边（有序）按照规则填充到temp数组
        //直到左右两边的有序序列，有一边处理完毕为止
        while (i <= mid && j <= right) {
            if (arr[i] <= arr[j]) {
                temp[t++] = arr[i++];
            } else {
                temp[t++] = arr[j++];
            }
        }
        //将有剩余数据的一边的数据，依次全部填充到temp
        while (i <= mid) {
            temp[t++] = arr[i++];
        }
​
        while (j <= right) {
            temp[t++] = arr[j++];
        }
        //将temp数组的元素拷贝到arr
        //注意，并不是每次都拷贝所有
        t = 0;
        int tempLeft = left;
        while (tempLeft <= right) {
            arr[tempLeft++] = temp[t++];
        }
    }
}
复制代码

基数排序

稳定性，效率最高的稳定性排序法

问题：耗费空间

有负数的数组，不使用基数排序来进行排序

//基数排序法
public static void radixSort(int[] arr) {
​
    //计算数组中最大数的位数
    int max = arr[0];
    for (int i = 1; i < arr.length; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    //得到最大数是几位数
    int maxLength = (max + "").length();
    int[][] bucket = new int[10][arr.length];
​
    //为了记录每个桶，存储每个桶的数量
    int[] bucketElementCounts = new int[10];
​
    for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {
        for (int j = 0; j < arr.length; j++) {
            //取出每个元素的对应位的值
            int digitOfElement = arr[j] / n % 10;
            //放进对应的桶，然后对应 数量++
            bucket[digitOfElement][bucketElementCounts[digitOfElement]++] = arr[j];
        }
​
        int index = 0;
        for (int k = 0; k < bucketElementCounts.length; k++) {
            if (bucketElementCounts[k] > 0) {
                //如果桶中有数据，才放入原数组
                for (int t = 0; t < bucketElementCounts[k]; t++) {
                    //取元素放入arr
                    arr[index++] = bucket[k][t];
                }
            }
            //第i+1轮处理完之后，需要清0
            bucketElementCounts[k] = 0;
        }
    }
}
复制代码