快速排序VS归并排序：谁更胜一筹？

原创于 2025-08-09 14:23:47 发布 · 762 阅读

8 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #排序算法 #数据结构 #开发语言

算法专栏收录该内容

7 篇文章

订阅专栏

今天我们为大家介绍两个排序算法，快速排序和归并排序。

一、两者的时间复杂度和稳定性对比

1.快速排序（Quick Sort）

平均时间复杂度：O(n log n)
最坏时间复杂度：O(n²)
最好时间复杂度：O(n log n)

2.归并排序（Merge Sort）

平均时间复杂度：O(n log n)
最坏时间复杂度：O(n log n)
最好时间复杂度：O(n log n)

总结：两者平均时间复杂度相同，但快速排序在最坏情况下性能会退化，而归并排序的时间复杂度更稳定。

所以建议大家通常使用归并排序！！！

二、思路介绍

1.快速排序

快速排序是一种高效的分治排序算法，其核心思路是：通过一趟排序将数组分为两部分，其中一部分的所有元素都比另一部分小，然后递归地对这两部分进行排序。

具体步骤如下：

1.1选择基准（确定分界点）
从数组中挑选一个元素作为 "基准"（通常选第一个、最后一个或中间元素，也可随机选择）。eg：q[l]、q[(l+r)/2]、q[r]。

1.2分区（调整区间）
重新排列数组，所有比基准值小的元素放在基准前面，所有比基准值大的元素放在基准后面（相等的元素可放任意一侧）。分区结束后，基准元素处于数组的中间位置。

图示：

1.3递归排序
递归地对基准左侧的子数组和右侧的子数组重复上述步骤，直到子数组长度为 0 或 1（天然有序）。

1.4难点：调整区间

2.归并排序

归并排序（Merge Sort）是一种基于分治思想的稳定排序算法，其核心思路是：将数组不断分割为更小的子数组，直到每个子数组只包含一个元素（天然有序），然后逐步将这些有序子数组合并成更大的有序数组，最终得到完整的有序数组。

具体步骤如下

1.1选择基准（确定分界点）
从数组中挑选一个元素作为 "基准"（一般为中点）eg:mid = (l+r)/2。

图示：

1.2递归处理两个部分（left、right）
递归地对基准左侧的子数组和右侧的子数组重复上述步骤。

1.3合并（合二为一）
将两个已排序的子数组合并成一个更大的有序数组。合并时需创建临时空间，比较两个子数组的元素，按顺序放入临时空间，最后将临时空间的内容复制回原数组。

1.4难点：合并。

三、具体代码

1.快速排序代码

#include<iostream>
using namespace std;

// 定义数组最大长度常量
const int N = 100010;
// 存储待排序数据的数组
int q[N];


//快速排序函数
void quick_sort(int q[], int l, int r)
{
    // 递归终止条件：如果区间长度小于等于1，说明已经有序，直接返回
    if (l >= r) return;
    
    // 选择基准值x（这里选择区间左端点元素作为基准）
    int x = q[l];
    // 定义左右指针，初始值分别为区间外左右各一位
    // 这样可以统一后续的do-while循环逻辑
    int i = l - 1, j = r + 1;

    // 分区过程：将小于x的元素放左边，大于x的元素放右边
    while (i < j)
    {
        // 从左向右找到第一个大于等于x的元素
        do i++; while (q[i] < x);
        // 从右向左找到第一个小于等于x的元素
        do j--; while (q[j] > x);
        // 如果不满足前面两个分区条件且左右指针还未相遇，则交换这两个元素
        if (i < j) swap(q[i], q[j]);
    }
    
    // 递归排序左半部分：区间[l, j]
    quick_sort(q, l, j);
    // 递归排序右半部分：区间[j+1, r]
    quick_sort(q, j + 1, r);
}

int main()
{
    int n;
    // 读取待排序元素的数量
    cin >> n;
    // 读取n个待排序的元素
    for (int i = 0; i < n; i++)
    {
        cin >> q[i];
    }
    
    // 调用快速排序函数，排序整个数组（区间[0, n-1]）
    quick_sort(q, 0, n - 1);
    
    // 输出排序后的结果
    for (int i = 0; i < n; i++)
    {
        cout << q[i] << ' ';
    }
    return 0;
}

下面我们具体讲一下：

怎么去调整区间？？？

这里我们采用的是一个头指针跟一个尾指针，不断移动确保i的左边 <基准, j的右边 >基准。当不满足条件时就交换两个值。

图示：

这样操作以后，左边就是小于基准的部分，右边是大于基准值的部分！！！

最后分别对两个部分进行一个递归，就ok了！

注意点：不要忘记递归的结束条件！

2.归并排序代码

#include<iostream>
using namespace std;

// 定义数组最大容量
const int N = 100010;

// q[]: 存储待排序的原始数组
// tmp[]: 临时数组，用于合并过程中存储中间结果
int q[N];
int tmp[N];

//归并排序函数
void merge_sort(int q[], int l, int r)
{
    // 递归终止条件：如果区间长度小于等于1，说明已经有序，直接返回
    if (l >= r) return;
    
    // 计算区间中点，将数组分为左右两部分
    int mid = (l + r) / 2;

    // 递归排序左半部分 [l, mid] 和右半部分 [mid+1, r]
    merge_sort(q, l, mid);
    merge_sort(q, mid + 1, r);
    
    // 合并两个已排序的子数组
    int i = l;          // 左半部分的起始指针
    int j = mid + 1;    // 右半部分的起始指针
    int k = 0;          // 临时数组的起始指针
    
    // 比较左右两部分的元素，按从小到大的顺序放入临时数组
    while (i <= mid && j <= r)
    {
        if (q[i] < q[j])
            tmp[k++] = q[i++];  // 左半部分元素更小，放入临时数组
        else
            tmp[k++] = q[j++];  // 右半部分元素更小，放入临时数组
    }
    
    // 处理左半部分剩余的元素
    while (i <= mid)
        tmp[k++] = q[i++];
    
    // 处理右半部分剩余的元素
    while (j <= r)
        tmp[k++] = q[j++];
    
    // 将临时数组中合并好的结果复制回原数组的对应区间
    for (int i = l, j = 0; i <= r; i++, j++)
        q[i] = tmp[j];
}

int main()
{
    int n;
    // 读取待排序元素的数量
    cin >> n;
    
    // 读取n个待排序的元素
    for (int i = 0; i < n; i++)
    {
        cin >> q[i];
    }
    
    // 调用归并排序函数，排序整个数组（区间[0, n-1]）
    merge_sort(q, 0, n - 1);
    
    // 输出排序后的结果
    for (int i = 0; i < n; i++)
    {
        cout << q[i] << ' ';
    }
    
    return 0;
}

下面来具体讲讲：

关于如何进行合并的：

前面我们已经通过递归把两个部分排好了顺序，现在我们需要把两个部分合并为一个部分，即归并。

我们需要不断比较两个部分left和right的数，把满足条件的数据放入到临时数组tmp中！！！

图示：