常用排序算法总结

---

	平均时间	是否原地排序	是否基于比较	稳定性
冒泡排序	$O(n^2)$	是	是	稳定
插入排序	$O(n^2)$	是	是	稳定
选择排序	$O(n^2)$	是	是	不稳定
快速排序	$O(nlogn)$	是	是	不稳定
归并排序	$O(nlogn)$	否	是	稳定
桶排序	$O(n)$	否	否	稳定
计数排序	$O(n)$	否	否	稳定
基数排序	$O(n)$	否	否	稳定

原地排序算法：特指空间复杂度是$O(1)$的排序算法

稳定性：如果待排序的序列中存在值相等的元素，经过排序之后，相等元素之间原有的先后顺序不变

冒泡排序(Bubble Sort)

• 基本思想：冒泡排序只会操作相邻的两个数据。每次冒泡操作都会对相邻的两个元素进行比较，看是否满足大小关系要求。如果不满足就让它俩互换。一次冒泡会让至少一个元素移动到它应该在的位置，重复$n$次，就完成了$n$个数据的排序工作

• 优化：当某次冒泡操作已经没有数据交换时，说明已经达到完全有序，不用再继续执行后续的冒泡操作

public void bubbleSort(int[] array) {
   
    int n = array.length;
    if (n <= 1) {
   
        return ;
    }
    for (int i = 0; i < n-1; i++) {
      // 遍历次数
        boolean isChange = false;
        for (int j = 0; j < n-1-i; j++) {
     // 比较相邻元素
            // 比较相邻两个元素的大小，前一个大于后一个就交换
            if (array[j] > array[j+1]) {
   
                int tmp = array[j];
                array[j] = array[j+1];
                array[j+1] = tmp;
                isChange = true;
            }
        }
        if (!isChange) {
   
            // 如果某次未发生数据交换，说明数据已排序
            break;
        }
    }
}

• 冒泡排序是原地排序算法：冒泡的过程只涉及相邻数据的交换操作，只需要常量级的临时空间，所以它的空间复杂度为O(1)，是一个原地排序算法

• 冒泡排序是稳定的排序算法：在冒泡排序中，只有交换才可以改变两个元素的前后顺序。为了保证冒泡排序算法的稳定性，当有相邻的两个元素大小相等的时候，我们不做交换，相同大小的据在排序前后不会改变顺序，所以冒泡排序是稳定的排序算法

• 冒泡排序的时间复杂度：

  • 最好情况：要排序的数据已经是有序的了，只需要进行一次冒泡操作，所以最好情况时间复杂度是$O(1)$
  • 最坏情况：要排序的数据刚好是倒序排列的，需要进行$n$次冒泡操作，所以最坏情况时间复杂度为$O(n^2)$
  • 平均时间复杂度：$O(n^2)$

插入排序(Insertion Sort)

• 基本思想：将数组中的数据分为两个区间， 已排序区间和未排序区间。初始已排序区间只有一个元素，就是数组的第一个元素，取未排序区间中的元素，在已排序区间中找到合适的插入位置将其插入，并保证已排序区间数据一直有序。重复这个过程，直到未排序区间中元素为空，算法结束
  • 插入排序也包含两种操作，一种是元素的比较，一种是元素的移动。当需要将一个数据$a$插入到已排序区间时，需要拿$a$与已排序区间的元素依次比较大小，找到合适的插入位置。找到插入点之后，还需要将插入点之后的元素顺序往后移动一位，这样才能腾出位置给元素插入

public void insertSort(int[] arr) {
   
    int n = arr.length;
    if (n <= 1) {
   
        return ;
    }
    for (int i = 1; i < n; i++) {
   
        int insertVal = arr[i];       // 待插入的数
        int insertIndex = i - 1;
        // 给insertVal找到插入的位置
        // 1. insertIndex >= 0 保证在给insertVal找插入位置，不越界
        // 2. insertVal < arr[insertIndex]待插入的数还没有找到插入的位置，需要将arr[insertIndex]后移
        while(insertIndex >= 0 && insertVal < arr[insertIndex]) {
   
            arr[insertIndex + 1] = arr[insertIndex]; // 大数后移
            insertIndex--;
        }

        // 退出while循环时，说明找到插入位置：insertIndex+1
        if (insertIndex + 1 != i) {
   
            arr[insertIndex + 1] = insertVal;
        }
    }
}

• 插入排序是原地排序算法：插入排序算法的运行并不需要额外的存储空间，所以空间复杂度是$O(1)$
• 插入排序是稳定的排序算法：在插入排序中，对于值相同的元素，我们可以选择将后面出现的元素，插入到前面出现元素的后面，这样就可以保持原有的前后顺序不变，所以插入排序是稳定的排序算法
• 插入排序的时间复杂度
  • 最好情况：如果要排序的数据已经是有序的，并不需要搬移任何数据。如果从尾到头在有序数据组里面查找插入位置，每次只需要比较一个数据就能确定插入的位置。所以这种情况下，最好是时间复杂度为$O(n)$
  • 最坏情况：如果数组是倒序的，每次插入都相当于在数组的第一个位置插入新的数据，需要移动大量的数据，所以最坏情况时间复杂度为$O(n^2)$
  • 平均时间复杂度：在数组中插入一个数据的平均时间复杂度是$O(n)$。所以，对于插入排序来说，每次插入操作都相当于在数组中插入一个数据，循环执行$n$次插入操作，所以平均时间复杂度为$O(n^2)$

选择排序(Selection Sort)

• 基本思想：选择排序算法的实现思路有点类似插入排序，也分已排序区间和未排序区间。但是选择排序每次会从未排序区间中找到最小的元素，将其放到已排序区间的末尾

public void selectSort(int[] arr) {
   
    int n = arr.length;