排序算法手写——面试必过基本功 on Dorkytiger 的小屋

快速排序（QuickSort）

Mon, 01 Jan 0001 00:00:00 +0000

一、核心思想：分治 + 分区

快速排序的流程：选一个 pivot（基准值），把小于 pivot 的放左边，大于的放右边。然后递归对左右两部分排序。

原始数组：[3, 7, 8, 5, 2, 1, 9, 5, 4]
选 pivot = 4（最后一个元素）

分区后：
小于 4 的部分 | pivot=4 | 大于等于 4 的部分
[3, 2, 1]    |   4    | [7, 8, 5, 9, 5]

递归排序左边 [3, 2, 1] 和右边 [7, 8, 5, 9, 5]

二、Lomuto 分区（最简单，面试首选）

整体操作流程（Lomuto 分区）：

选基准：取最右侧元素 nums[right] 作为 pivot。
双指针扫描：i 指向"小于区域的边界"，j 从左到右扫描。
交换：如果 nums[j] < pivot，将它与 nums[i] 交换，i++（扩大小于区域）。
归位 pivot：扫描结束后，将 pivot（nums[right]）交换到 nums[i] 位置。
返回 pivot 索引：此时 i 就是 pivot 的正确位置。

整体操作流程（quickSort 递归）：

归并排序（MergeSort）

Mon, 01 Jan 0001 00:00:00 +0000

一、核心流程：分治 + 合并

[3, 7, 8, 5, 2, 1, 9, 4]
         ↓ 分割
[3, 7, 8, 5]    [2, 1, 9, 4]
   ↓ 分割           ↓ 分割
[3, 7] [8, 5]   [2, 1] [9, 4]
   ↓ 分割           ↓ 分割
[3][7] [8][5]   [2][1] [9][4]
   ↓ 合并           ↓ 合并
[3, 7] [5, 8]   [1, 2] [4, 9]
   ↓ 合并           ↓ 合并
[3, 5, 7, 8]    [1, 2, 4, 9]
         ↓ 合并
[1, 2, 3, 4, 5, 7, 8, 9]

二、自顶向下（递归）实现

merge 整体操作流程：

堆排序（HeapSort）

Mon, 01 Jan 0001 00:00:00 +0000

一、核心思路：利用二叉堆

堆排序分两步：

建堆：把数组变成最大堆（父节点 ≥ 子节点）。
排序：反复把堆顶（最大值）交换到数组末尾，然后调整剩余部分为堆。

heapify 整体操作流程：

初始化：假设当前节点 i 是最大值，记录其左右子节点位置。
找最大：比较 nums[i] 与其左右子节点，将最大值的索引赋值给 largest。
交换与下沉：如果 largest != i，交换 nums[i] 和 nums[largest]，然后递归对 largest 位置进行 heapify（下沉调整）。

heapSort 整体操作流程：

建堆：从最后一个非叶子节点（n/2 - 1）开始，从下往上调用 heapify，构建最大堆。
排序：循环 n-1 次：将堆顶（最大值）与末尾元素交换 → 堆大小减 1 → 对堆顶执行 heapify 恢复堆性质。
结果：所有元素交换完毕后，数组按升序排列。

void heapify(vector<int>& nums, int n, int i) {
    int largest = i;                               // ① 假设当前节点最大
    int left = 2 * i + 1;                          // ② 左子节点
    int right = 2 * i + 2;                         // ③ 右子节点

    if (left < n && nums[left] > nums[largest])    // ④ 左子更大 → 更新
        largest = left;
    if (right < n && nums[right] > nums[largest])  // ⑤ 右子更大 → 更新
        largest = right;

    if (largest != i) {                            // ⑥ 最大值不是当前节点
        swap(nums[i], nums[largest]);              // ⑦ 交换，让最大值上浮
        heapify(nums, n, largest);                 // ⑧ 递归下沉被换下去的节点
    }
}

void heapSort(vector<int>& nums) {
    int n = nums.size();

    for (int i = n / 2 - 1; i >= 0; i--) {         // ① 从最后一个非叶子节点开始建堆
        heapify(nums, n, i);
    }

    for (int i = n - 1; i > 0; i--) {              // ② 逐个取出堆顶
        swap(nums[0], nums[i]);                    // ③ 堆顶（最大值）放到末尾
        heapify(nums, i, 0);                       // ④ 对剩余 i 个元素调整堆
    }
}

建堆的过程（nums = [3, 7, 8, 5, 2, 1, 9]）：

排序算法选择策略

Mon, 01 Jan 0001 00:00:00 +0000

一、`std::sort` 内部实现

std::sort 不是单纯的快排，而是内省排序：

// 伪代码
void sort(iterator first, iterator last) {
    if (last - first < 16) {
        insertion_sort(first, last);  // 小数组用插入排序
        return;
    }

    int depth_limit = 2 * log2(last - first);

    intro_sort_loop(first, last, depth_limit);
    // 如果 depth_limit 达到 0，说明快排退化，切换到堆排序
}

void intro_sort_loop(iterator first, iterator last, int depth) {
    while (last - first > 16) {
        if (depth == 0) {
            make_heap(first, last);      // 切换到堆排序
            sort_heap(first, last);
            return;
        }
        depth--;
        iterator cut = partition(first, last);  // 快排分区
        intro_sort_loop(cut + 1, last, depth);  // 递归大的一边
        last = cut;  // 尾递归处理小的一边
    }
}

组合策略：快排（通用最快）+ 堆排（退化保护）+ 插入排序（小数组最优）。

排序算法手写——面试必过基本功 on Dorkytiger 的小屋

快速排序（QuickSort）

一、核心思想：分治 + 分区

二、Lomuto 分区（最简单，面试首选）

归并排序（MergeSort）

一、核心流程：分治 + 合并

二、自顶向下（递归）实现

堆排序（HeapSort）

一、核心思路：利用二叉堆

排序算法选择策略

一、std::sort 内部实现

一、`std::sort` 内部实现