C++面试中的手写快速排序：从基础到最优的完整思考过程

一、快速排序面试的完整应对策略

阶段1：理解题目要求（1-2分钟）

思考过程：

• 确认输入输出：“请问输入是vector还是数组？需要处理空输入吗？”
• 明确接口：“需要我实现完整的排序接口还是只需要核心排序逻辑？”
• 边界确认：“需要处理重复元素吗？对稳定性有要求吗？”

示例对话：

候选人：“请问函数签名需要完全按照标准库的sort接口，还是可以自定义？输入范围是否包含两端？”
面试官：“请实现对一个vector的原地排序，包含两端索引”

阶段2：写出基础版本（5-7分钟）

基础实现代码：

// 基础分区函数
int partition(vector<int>& nums, int left, int right) {
    int pivot = nums[right];  // 选择最右元素作为基准
    int i = left;
    for (int j = left; j < right; ++j) {
        if (nums[j] < pivot) {
            swap(nums[i], nums[j]);
            ++i;
        }
    }
    swap(nums[i], nums[right]);
    return i;
}

// 基础递归实现
void quickSort(vector<int>& nums, int left, int right) {
    if (left >= right) return;  // 递归终止条件
    
    int pivot_pos = partition(nums, left, right);
    quickSort(nums, left, pivot_pos - 1);
    quickSort(nums, pivot_pos + 1, right);
}

可视化过程：

初始数组：[3, 1, 4, 1, 5, 9, 2, 6]
          ↑               ↑
         left           right

分区过程(pivot=6):
[3,1,4,1,5,2] 6 [9]  // 最终i=5, 交换6到正确位置

阶段3：分析复杂度（2分钟）

边写边说的示例：
"这个基础版本的时间复杂度：

• 最好/平均情况：O(nlogn)
• 最坏情况（已排序数组）：O(n²)
  空间复杂度：
• 递归栈空间：最好O(logn)，最坏O(n)"

阶段4：优化实现（5-8分钟）

优化1：三数取中法避免最坏情况

int medianOfThree(vector<int>& nums, int left, int right) {
    int mid = left + (right - left) / 2;
    if (nums[left] > nums[mid]) swap(nums[left], nums[mid]);
    if (nums[left] > nums[right]) swap(nums[left], nums[right]);
    if (nums[mid] > nums[right]) swap(nums[mid], nums[right]);
    return mid;
}

int partition(vector<int>& nums, int left, int right) {
    int pivot_idx = medianOfThree(nums, left, right);
    swap(nums[pivot_idx], nums[right]);  // 将基准放到最右
    // 剩余逻辑不变...
}

优化2：小数组切换插入排序

void insertionSort(vector<int>& nums, int left, int right) {
    for (int i = left + 1; i <= right; ++i) {
        int key = nums[i];
        int j = i - 1;
        while (j >= left && nums[j] > key) {
            nums[j + 1] = nums[j];
            --j;
        }
        nums[j + 1] = key;
    }
}

void quickSort(vector<int>& nums, int left, int right) {
    if (right - left <= 16) {  // 阈值通常取8-32
        insertionSort(nums, left, right);
        return;
    }
    // 剩余逻辑不变...
}

优化3：尾递归优化

void quickSort(vector<int>& nums, int left, int right) {
    while (left < right) {  // 改用循环
        int pivot_pos = partition(nums, left, right);
        if (pivot_pos - left < right - pivot_pos) {
            quickSort(nums, left, pivot_pos - 1);
            left = pivot_pos + 1;
        } else {
            quickSort(nums, pivot_pos + 1, right);
            right = pivot_pos - 1;
        }
    }
}

阶段5：处理边界情况（2分钟）

需要提及的要点：

1. 处理重复元素：可以考虑三向切分(3-way partition)
2. 大数处理：避免溢出 mid = left + (right - left)/2
3. 内存安全：验证输入范围有效性

三向切分实现：

void quickSort3Way(vector<int>& nums, int low, int high) {
    if (low >= high) return;
    
    int lt = low, gt = high;
    int pivot = nums[low];
    int i = low;
    
    while (i <= gt) {
        if (nums[i] < pivot) {
            swap(nums[lt++], nums[i++]);
        } else if (nums[i] > pivot) {
            swap(nums[i], nums[gt--]);
        } else {
            i++;
        }
    }
    
    quickSort3Way(nums, low, lt - 1);
    quickSort3Way(nums, gt + 1, high);
}

二、完整优化后的实现

#include <vector>
#include <algorithm>
using namespace std;

const int INSERTION_THRESHOLD = 16;

void insertionSort(vector<int>& nums, int left, int right) {
    for (int i = left + 1; i <= right; ++i) {
        int key = nums[i];
        int j = i - 1;
        while (j >= left && nums[j] > key) {
            nums[j + 1] = nums[j];
            --j;
        }
        nums[j + 1] = key;
    }
}

int medianOfThree(vector<int>& nums, int left, int right) {
    int mid = left + (right - left) / 2;
    if (nums[left] > nums[mid]) swap(nums[left], nums[mid]);
    if (nums[left] > nums[right]) swap(nums[left], nums[right]);
    if (nums[mid] > nums[right]) swap(nums[mid], nums[right]);
    return mid;
}

int partition(vector<int>& nums, int left, int right) {
    int pivot_idx = medianOfThree(nums, left, right);
    swap(nums[pivot_idx], nums[right]);
    
    int pivot = nums[right];
    int i = left;
    for (int j = left; j < right; ++j) {
        if (nums[j] < pivot) {
            swap(nums[i], nums[j]);
            ++i;
        }
    }
    swap(nums[i], nums[right]);
    return i;
}

void optimizedQuickSort(vector<int>& nums, int left, int right) {
    while (left < right) {
        if (right - left <= INSERTION_THRESHOLD) {
            insertionSort(nums, left, right);
            return;
        }
        
        int pivot_pos = partition(nums, left, right);
        
        // 优先处理小的部分，减少递归深度
        if (pivot_pos - left < right - pivot_pos) {
            optimizedQuickSort(nums, left, pivot_pos - 1);
            left = pivot_pos + 1;
        } else {
            optimizedQuickSort(nums, pivot_pos + 1, right);
            right = pivot_pos - 1;
        }
    }
}

void sort(vector<int>& nums) {
    if (nums.empty()) return;
    optimizedQuickSort(nums, 0, nums.size() - 1);
}

三、面试应答流程图

四、进阶讨论方向

当完成基本实现后，可以主动引导讨论：

1. “实际标准库的sort实现通常使用内省排序(introspective sort)，结合了快速排序、堆排序和插入排序，您想让我详细解释下吗？”
2. “对于包含大量重复元素的数组，我们可以考虑Dijkstra的三向切分快速排序，需要我实现一下吗？”
3. “如果要处理非随机访问迭代器（如链表），快速排序的实现会有哪些不同？”

五、面试评分关键点

根据多数科技公司的面试评分标准，手写快排序题的评估维度通常包括：

六、总结

手写快速排序的面试过程，实际上是考察候选人从"能工作"到"优秀"的思维演进能力。优秀的候选人应该：

1. 从基础实现出发，保证正确性
2. 逐步加入优化，展示深度思考
3. 主动分析复杂度，体现计算机科学基础
4. 讨论工程实践，展现实际经验
5. 引导技术对话，掌握面试节奏

记住：面试官关心的不是你能否背出算法，而是你解决问题的思路和持续优化的能力。通过这样结构化的应对策略，你就能在排序算法面试中脱颖而出。