【科学刷题】完全吃透所有排序算法

1 十大经典排序算法

超详细十大经典排序算法总结（java代码）c或者cpp的也可以明白

• 图片名词解释：
  • n: 数据规模
  • k: “桶”的个数
  • In-place: 占用常数内存，不占用额外内存
  • Out-place: 占用额外内存

0.6 比较和非比较的区别

常见的快速排序、归并排序、堆排序、冒泡排序 等属于比较排序 。在排序的最终结果里，元素之间的次序依赖于它们之间的比较。每个数都必须和其他数进行比较，才能确定自己的位置 。

在冒泡排序之类的排序中，问题规模为n，又因为需要比较n次，所以平均时间复杂度为O(n²)。在归并排序、快速排序之类的排序中，问题规模通过分治法消减为logN次，所以时间复杂度平均O(nlogn)。

比较排序的优势是，适用于各种规模的数据，也不在乎数据的分布，都能进行排序。可以说，比较排序适用于一切需要排序的情况。

计数排序、基数排序、桶排序则属于非比较排序 。非比较排序是通过确定每个元素之前，应该有多少个元素来排序。针对数组arr，计算arr[i]之前有多少个元素，则唯一确定了arr[i]在排序后数组中的位置 。

非比较排序只要确定每个元素之前的已有的元素个数即可，所有一次遍历即可解决。算法时间复杂度O(n)。

非比较排序时间复杂度底，但由于非比较排序需要占用空间来确定唯一位置。所以对数据规模和数据分布有一定的要求。

1.1 插入类排序

1.1.1 直接插入排序

void insert_sort(vector<int> &nums) {
   
    //有序区的终点索引
    int k = 0, n = nums.size();
    for (int i = 1; i < n; ++i) {
   
        // 如果数组基本有序 , if 大概率为 False，时间复杂度接近 O(N)
        if (nums[i] < nums[k]) {
   
            //在有序区中找到第一个更大的元素
            int j = 0;
            while (j <= k and nums[j] < nums[i]) ++j;
            int tmp = nums[i];
            for (int p = i; p > j; --p) nums[p] = nums[p - 1];
            nums[j] = tmp;
        }
        ++k;//更新有序区
    }
}

1.1.2 二分插入排序

pass

1.1.3 shell排序

pass

1.2 选择类排序

1.2.1 简单选择排序

class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        length = len(nums)
        for i in range(length - 1):
            min_index = i
            for j in range(i + 1, length):
                if nums[min_index] > nums[j]:
                    min_index = j
            nums[min_index], nums[i] = nums[i], nums[min_index]
        return nums

1.2.2 堆排序

// 下沉, 用于数组后半部分满足堆定义时, 不断向下调整使得整体满足堆定义
void sink(vector<int> &nums, int k, int n) {
   
    while (true) {
   
        int i = k * 2 + 1, j = k * 2 + 2;
        if (i >= n) break;
        int min_ix = i;
        if (j < n && nums[j] < nums[i]) min_ix = j;
        if (nums[min_ix] > nums[k]) break;
        swap(nums[min_ix], nums[k]);
        k = min_ix;
    }
}

// 上浮
void swim(vector<int> &nums, int k) {
   
    for (int p = (k + 1) / 2; p >= 0 && nums[p] < nums[k]; k = p, p = (k + 1) / 2) {
   
        swap(nums[k], nums[p]);
    }
}

void heap_sort(vector<int> &nums) {
   
    int n = nums.size();
    // 建堆，从 n/2 -> 0 下沉（相当于对非叶子结点进行操作）
    for (int k = n / 2; k >= 0; --k) {
   
        sink(nums, k, n);
    }
    // 从后往前, 将第0个元素放置到后面的有序区(交换), 这样第0个元素就不再满足堆的定义了. 第0个元素下沉
    while (n > 0) {
   
        swap(nums[0], nums[--n]);
        sink(nums, 0, n);
    }
    // 应该建一个最大堆, 但这里为了兼容建成最小堆了. 没有关系, 反转一下就好了
    reverse(nums.begin(), nums.end());
}

1.3 交换类排序

1.3.1 冒泡排序

void bubble_sort(vector<int> &nums) {
   
    int n = nums.size();
    // 如果有n个元素，那么只需要交换n-1次。i 是用来统计交换次数的，或者：当前有序区元素个数
    for (int i = 0; i < n - 1; ++i) {
   
        bool is_sorted = true;
        // 因为要取 j+1 ，所以  j < n - i - 1
        for (int j = 0; j < n - i - 1; ++j) {
   
            // 将较大的元素交换到前面
            if (nums[j] > nums[j + 1]) {
   
                swap(nums[j], nums[j + 1]);
                is_sorted = false;
            }
        }
        if(is_sorted) break;
    }
}

1.3.2 快速排序

1.3.2.1 递归版本

int partition(vector<int> &nums, int l, int r) {
   
    int rid = rand() % (r - l + 1) + l;
    swap(nums[l], nums[rid]);
    int j = l;
    int pivot