两段快排代码

1. 基于list的：

template<typename T>
list<T> sequential_quick_sort(list<T> input)
{
    if(input.empty())
    {
        return input;
    }
    list<T> result;
    result.splice(result.begin(), input, input.begin());
    T const& pivot = *result.begin();
    auto divide_point = partition(input.begin(), input.end(), [&](T const& t){return t < pivot;});
    list<T> lower_part;
    lower_part.splice(lower_part.end(), input, input.begin(), divide_point);
    auto new_lower(sequential_quick_sort(move(lower_part)));
    auto new_higher(sequential_quick_sort(move(input)));
    result.splice(result.end(), new_higher);
    result.splice(result.begin(), new_lower);
    return result;
}

注意其中splice函数的作用：转移元素。

2. 基于vector的：

template<typename T>
std::vector<T> sequential_quick_sort(std::vector<T> input) {
    if (input.empty()) {
        return input;
    }

    T pivot = input[0];
    std::vector<T> lower_part;
    std::vector<T> higher_part;

    // 从第二个元素开始分区
    for (size_t i = 1; i < input.size(); ++i) {
        if (input[i] < pivot)
            lower_part.push_back(std::move(input[i]));
        else
            higher_part.push_back(std::move(input[i]));
    }

    // 分别递归排序两部分
    auto new_lower = sequential_quick_sort(std::move(lower_part));
    auto new_higher = sequential_quick_sort(std::move(higher_part));

    // 组合结果：new_lower + pivot + new_higher
    std::vector<T> result;
    result.reserve(new_lower.size() + 1 + new_higher.size()); // 避免多次 realloc

    result.insert(result.end(), std::make_move_iterator(new_lower.begin()), std::make_move_iterator(new_lower.end()));
    result.push_back(std::move(pivot));
    result.insert(result.end(), std::make_move_iterator(new_higher.begin()), std::make_move_iterator(new_higher.end()));

    return result;
}

或者用 std::partition 来实现 vector 的 in-place quick sort：

template<typename T>
void quick_sort(std::vector<T>& vec, int left, int right) {
    if (left >= right) return;

    T pivot = vec[left];
    auto it = std::partition(vec.begin() + left + 1, vec.begin() + right + 1,
                             [&](const T& val) { return val < pivot; });

    int mid = it - vec.begin();

    std::swap(vec[left], vec[mid - 1]); // 把 pivot 放到中间
    quick_sort(vec, left, mid - 2);     // 左边递归
    quick_sort(vec, mid, right);        // 右边递归
}

// 包装函数
template<typename T>
void sequential_quick_sort(std::vector<T>& vec) {
    quick_sort(vec, 0, vec.size() - 1);
}

这是更“原地”的 vector 快速排序写法，性能和 STL 的 std::sort 更接近。 

3. 基于vector的非模板写法：

#include <iostream>
#include <vector>
#include <algorithm> // for std::partition

void quick_sort(std::vector<int>& vec, int left, int right) {
    if (left >= right) return;

    int pivot = vec[left];  // 选取第一个元素作为 pivot

    // 使用 partition，将 < pivot 的移到前面
    auto mid_iter = std::partition(vec.begin() + left + 1, vec.begin() + right + 1,
                                   [&](int val) { return val < pivot; });

    int mid = mid_iter - vec.begin();  // mid 是第一个 >= pivot 的位置

    std::swap(vec[left], vec[mid - 1]); // 把 pivot 移到正确位置

    // 递归左边部分
    quick_sort(vec, left, mid - 2);
    // 递归右边部分
    quick_sort(vec, mid, right);
}

void quick_sort(std::vector<int>& vec) {
    if (!vec.empty()) {
        quick_sort(vec, 0, vec.size() - 1);
    }
}

 使用方法：

int main() {
    std::vector<int> nums = {7, 2, 5, 1, 9, 3};

    quick_sort(nums);

    for (int n : nums) {
        std::cout << n << " ";
    }
    std::cout << std::endl;

    return 0;
}