排序算法：快速排序（C实现）

最新推荐文章于 2024-07-12 17:45:42 发布
最新推荐文章于 2024-07-12 17:45:42 发布
阅读量263 收藏
点赞数
分类专栏： 算法 文章标签： 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43690795/article/details/107188880
版权

目录：
        三数取中
        Hoare法(左右指针法)
        挖坑法
        前后指针法
        用栈实现非递归快排
        特性总结

基本思想

快速排序是指在待排序列中选取一个基准（key值），然后把不比该基准大的放在基准的前面，把不比该基准小的放在基准的后面，这样待排序列就被基准划分成了两个序列，对这两个序列再递归进行这样的操作，直到基准两边没有或者只有一个数字，最终就完成了排序。快排主要用到的算法思想是分治思想。常用的快排方法有：Hoare法（左右指针法）、挖坑法、前后指针法。

对下面的数据进行排序：
在这里插入图片描述

三数取中：

首先我们需要选定一个 key值，通常情况下是直接用 arr[begin] 或者 arr[end] 作为 key值的。但是在一些特殊情况下还不是很好，因为选取的 key值可能偏大或者偏小。因此可以用三数取中法选择 key值，判断 begin、end、middle的大小，从上图中可以看到 begin的值适中，适合作为 key值。则交换 begin 和 end 所在位置的元素，然后选取 arr[end]作为key值。
在这里插入图片描述
选定好 key值以后，就可以开始进行快速排序的步骤了。后面介绍的Hoare法（左右指针法）、挖坑法、前后指针法三种方法都是要先用到三数取中。

过程分析

Hoare法(左右指针法)

我们来对三数取中后的数据进行排序：
在这里插入图片描述

  1. 从 begin开始依次向后找，直到找到比 key大的元素停止；从 end开始依次向前找，直到找到比 key小的元素停止
    在这里插入图片描述
    在这里插入图片描述
  2. 交换 begin 和 end 所在位置的元素
    在这里插入图片描述
  3. begin继续依次向后找，直到找到比 key大的元素停止；end继续依次向前找，直到找到比 key小的元素停止
    在这里插入图片描述
  4. 继续交换 begin 和 end 所在位置的元素
    在这里插入图片描述
  5. begin继续依次向后找，直到找到比 key大的元素停止；end继续依次向前找，直到找到比 key小的元素停止
    在这里插入图片描述
  6. 继续交换 begin 和 end 所在位置的元素
    在这里插入图片描述
  7. begin继续依次向后找，此时 begin和 end相遇，结束 begin和 end的遍历交换。只有当 begin < end时才可以继续遍历。

在这里插入图片描述

  1. 把begin所在位置的元素和 key值交换
    在这里插入图片描述
    从上图可以发现 key左边的元素都是小于等于6的，key右边的元素都是大于6的，这样我们就完成了第一次预排序。然后再分别对左区间和右区间的元素重新用三数取中法选定 key值，重复上述步骤，就完成了快速排序。
    在这里插入图片描述
    代码实现：
void Swap(int* x, int* y)
{
    int tmp = *x;
    *x = *y;
    *y = tmp;
}

int GetMiddleKey(int* arr, int begin, int end)
{
    int middle = (begin + end) / 2;
    if (arr[begin] > arr[middle])
    {
        if (arr[middle] > arr[end])
        {
            return middle;
        }
        else if(arr[begin] > arr[end]) //arr[middle] < arr[end]
        {
            return end;
        }
        else
        {
            return begin;
        }
    }
    else //arr[begin] < arr[middle]
    {
        if (arr[end] > arr[middle])
        {
            return middle;
        }
        else if (arr[begin] > arr[end]) //arr[end] < arr[middle]
        {
            return end;
        }
        else
        {
            return begin;
        }
    }
}

//Hoare法（左右指针法）
int Hoare(int* arr, int begin, int end)
{
    //三数取中
    int middle_key = GetMiddleKey(arr, begin, end);
    Swap(&arr[middle_key], &arr[end]);

    //依据key进行排序确定子区间
    int key = arr[end];
    int keyi = end;
    while (begin < end)
    {
        while (begin < end && arr[begin] <= key)
        {
            ++begin;
        }

        while (begin < end && arr[end] >= key)
        {
            --end;
        }
        Swap(&arr[begin], &arr[end]);
    }
    Swap(&arr[begin], &arr[keyi]);
    return begin;
}

void InQuickSort(int* arr, int begin, int end)
{
    if (begin >= end)
    {
        return;
    }
    int key = Hoare(arr, begin, end);
    InQuickSort(arr, begin, key - 1); //左区间
    InQuickSort(arr, key + 1, end); //右区间
}

void QuickSort(int* arr, int n)
{
    int begin = 0;
    int end = n - 1;
    InQuickSort(arr, begin, end);
}

测试用例：

void Test()
{
    int arr[] = { 6, 1, 2, 7, 9, 3, 4, 5, 10, 8 };
    int length = sizeof(arr) / sizeof(arr[0]);
    QuickSort(arr, length);
    for (int i = 0; i < length; i++)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

在这里插入图片描述

挖坑法

同样我们还是来对三数取中后的数据进行排序：
在这里插入图片描述

  1. 选定key值为arr[end]，且让 end所在位置为坑
    在这里插入图片描述
  2. 从 begin开始依次向后找，直到找到比 key大的元素停止，将 begin所在的位置和坑交换
    在这里插入图片描述
  3. 从 end开始依次向前找，直到找到比 key小的元素停止，将 end所在的位置和坑交换
    在这里插入图片描述
  4. begin继续依次向后找，直到找到比 key大的元素停止，将 begin所在的位置和坑交换
    在这里插入图片描述
  5. end继续依次向前找，直到找到比 key小的元素停止，将 end所在的位置和坑交换
    在这里插入图片描述
  6. begin继续依次向后找，直到找到比 key大的元素停止，将 begin所在的位置和坑交换
    在这里插入图片描述
  7. end继续依次向前找，直到找到比 key小的元素停止，将 end所在的位置和坑交换
    在这里插入图片描述
  8. begin继续依次向后找，此时 begin和 end相遇，结束遍历交换。只有当 begin < end时才可以继续遍历。

在这里插入图片描述

  1. 结束遍历交换后，将 key值填入到坑中
    在这里插入图片描述
    从上图可以发现 key左边的元素都是小于等于6的，key右边的元素都是大于6的，这样我们就完成了第一次预排序。然后再分别对左区间和右区间的元素重新用三数取中法选定 key值和坑，重复上述步骤，就完成了快速排序。
    在这里插入图片描述
    代码实现：
void Swap(int* x, int* y)
{
    int tmp = *x;
    *x = *y;
    *y = tmp;
}

int GetMiddleKey(int* arr, int begin, int end)
{
    int middle = (begin + end) / 2;
    if (arr[begin] < arr[middle])
    {
        if (arr[end] > arr[middle])
        {
            return middle;
        }
        else if (arr[begin] > arr[end]) //arr[end] < arr[middle]
        {
            return begin;
        }
        else
        {
            return end;
        }
    }
    else //arr[begin] > arr[middle]
    {
        if (arr[middle] > arr[end])
        {
            return middle;
        }
        else if (arr[begin] > arr[end])
        {
            return end;
        }
        else
        {
            return begin;
        }
    }
}

int DigPitMethod(int* arr, int begin, int end)
{
    int key_middle = GetMiddleKey(arr, begin, end);
    Swap(&arr[key_middle], &arr[end]);

    int key = arr[end];
    while (begin < end)
    {
        while (begin < end && arr[begin] <= key)
        {
            ++begin;
        }
        arr[end] = arr[begin];

        while (begin < end && arr[end] >= key)
        {
            --end;
        }
        arr[begin] = arr[end];
    }
    arr[begin] = key;
    return begin;
}

void InQuickSort(int* arr, int begin, int end)
{
    if (begin >= end)
    {
        return;
    }

    int key = DigPitMethod(arr, begin, end);
    InQuickSort(arr, begin, key - 1);
    InQuickSort(arr, key + 1, end);
}

void QuickSort(int* arr, int n)
{
    int begin = 0;
    int end = n - 1;
    InQuickSort(arr, begin, end);
}

测试用例：

void Test()
{
    int arr[] = { 6, 1, 2, 7, 9, 3, 4, 5, 10, 8 };
    int length = sizeof(arr) / sizeof(arr[0]);
    QuickSort(arr, length);
    for (int i = 0; i < length; i++)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

在这里插入图片描述

前后指针法

同样我们还是来对三数取中后的数据进行排序：
在这里插入图片描述
整体思路：cur初始位置是begin，prev初始位置是 begin-1。cur先依次向后遍历找比 key小的元素，当 cur < key时，++prev，然后交换 prev 和 cur所在位置的元素。重复前面的步骤，直到 cur遇到 key时终止。
在这里插入图片描述

  1. cur开始找比 key小的元素，找到后 ++prev，然后交换 prev 和 cur所在位置的元素
    在这里插入图片描述
  2. cur继续找比 key小的元素，找到后 ++prev，然后交换 prev 和 cur所在位置的元素
    在这里插入图片描述
  3. cur继续找比 key小的元素，找到后 ++prev，然后交换 prev 和 cur所在位置的元素
    在这里插入图片描述
  4. cur继续找比 key小的元素，找到后 ++prev，然后交换 prev 和 cur所在位置的元素
    在这里插入图片描述
  5. cur继续找比 key小的元素，找到后 ++prev，然后交换 prev 和 cur所在位置的元素
    在这里插入图片描述
  6. cur继续找比 key小的元素，此时 cur和 key相遇，然后 ++prev，交换 prev和 key所在位置的元素
    在这里插入图片描述
    通过对上图观察可以发现左区间都是小于等于6的元素，右区间都是大于6的元素。然后再对左区间和右区间分别重复上述步骤排序。
    在这里插入图片描述

代码实现：

void Swap(int* x, int* y)
{
    int tmp = *x;
    *x = *y;
    *y = tmp;
}

int GetMiddleKey(int* arr, int begin, int end)
{
    int middle = (begin + end) / 2;
    if (arr[begin] < arr[middle])
    {
        if (arr[end] > arr[middle])
        {
            return middle;
        }
        else if (arr[begin] > arr[end]) //arr[end] < arr[middle]
        {
            return begin;
        }
        else
        {
            return end;
        }
    }
    else //arr[begin] > arr[middle]
    {
        if (arr[middle] > arr[end])
        {
            return middle;
        }
        else if (arr[begin] > arr[end])
        {
            return end;
        }
        else
        {
            return begin;
        }
    }
}

//前后指针法
int PrevCurMethod(int* arr, int begin, int end)
{
    //三数取中
    int key_middle = GetMiddleKey(arr, begin, end);
    Swap(&arr[key_middle], &arr[end]);

    int key = arr[end];
    int cur = begin;
    int prev = begin - 1;
    while (cur < end)
    {
        if (arr[cur] < key && ++prev != cur)
        {
            Swap(&arr[prev], &arr[cur]);
        }
        ++cur;
    }
    ++prev;
    Swap(&arr[prev], &arr[end]);
    return prev;
}

void InQuickSort(int* arr, int begin, int end)
{
    if (begin >= end)
    {
        return;
    }

    int key = PrevCurMethod(arr, begin, end);
    InQuickSort(arr, begin, key - 1);
    InQuickSort(arr, key + 1, end);
}

void QuickSort(int* arr, int n)
{
    int begin = 0;
    int end = n - 1;
    InQuickSort(arr, begin, end);
}

测试用例：

void Test()
{
    int arr[] = { 6, 1, 2, 7, 9, 3, 4, 5, 10, 8 };
    int length = sizeof(arr) / sizeof(arr[0]);
    QuickSort(arr, length);
    for (int i = 0; i < length; i++)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

在这里插入图片描述

用栈实现非递归快排（C++实现）

#include <iostream>
#include <stack>
using namespace std;

void Swap(int* x, int* y)
{
    int tmp = *x;
    *x = *y;
    *y = tmp;
}

int GetMiddleKey(int* arr, int begin, int end)
{
    int middle = (begin + end) / 2;
    if (arr[begin] < arr[middle])
    {
        if (arr[end] > arr[middle])
        {
            return middle;
        }
        else if (arr[begin] > arr[end]) //arr[end] < arr[middle]
        {
            return begin;
        }
        else
        {
            return end;
        }
    }
    else //arr[begin] > arr[middle]
    {
        if (arr[middle] > arr[end])
        {
            return middle;
        }
        else if (arr[begin] > arr[end])
        {
            return end;
        }
        else
        {
            return begin;
        }
    }
}

//前后指针法
int PrevCurMethod(int* arr, int begin, int end)
{
    //三数取中
    int key_middle = GetMiddleKey(arr, begin, end);
    Swap(&arr[key_middle], &arr[end]);

    int key = arr[end];
    int cur = begin;
    int prev = begin - 1;
    while (cur < end)
    {
        if (arr[cur] < key && ++prev != cur)
        {
            Swap(&arr[prev], &arr[cur]);
        }
        ++cur;
    }
    ++prev;
    Swap(&arr[prev], &arr[end]);
    return prev;
}

//用栈实现非递归快排
void QuickSortNonR(int* arr, int begin, int end)
{
    stack<int> st;
    st.push(begin);
    st.push(end);
    while (!st.empty())
    {
        int right = st.top();
        st.pop();
        int left = st.top();
        st.pop();
        int key = PrevCurMethod(arr, left, right);

        if (left < key - 1)
        {
            st.push(left);
            st.push(key - 1);
        }

        if (key + 1 < right)
        {
            st.push(key + 1);
            st.push(right);
        }
    }
}

void QuickSort(int* arr, int n)
{
    int begin = 0;
    int end = n - 1;
    QuickSortNonR(arr, begin, end);
}

测试用例：

void Test()
{
    int arr[] = { 6, 1, 2, 7, 9, 3, 4, 5, 10, 8 };
    int length = sizeof(arr) / sizeof(arr[0]);
    QuickSort(arr, length);
    for (int i = 0; i < length; i++)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

在这里插入图片描述

特性总结

  1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
  2. 时间复杂度：O(N*logN)
  3. 空间复杂度：O(logN)，真正消耗空间的是递归调用，因为每次递归就要保持一些数据
  4. 稳定性：不稳定
一杆梅子酒丶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现快速排序算法
C语言C++学习俱乐部：765860056
12-17 3万+
序 愿天上的每一个流星，都为你而闪耀天际。 嗨，这里是狐狸~~ 今天是
快速排序算法(C语言实现)
木木的博客
02-25 4118
快速排序分三大步骤： 1.分：选择一个分割值并将数据按此分为左右两部分 2.治：分别在两部分用递归方式调用上述的分步骤，继续划分 3.合：对分割的部分排序直至完成 #include <stdio.h> #include <stdlib.h> #include <string.h> int partion(char *s,int start,int end) { //随机选取分割值 int key = s[start]; int temp;
【排序算法】快速排序（C语言）
weixin_52811588的博客
08-20 4万+
快速排序算法是八大排序算法中实用性最高的算法之一，这里详细介绍了快速排序的递归实现和非递归实现，以及单趟排序的多种方法，还有选择key值的三个方法，并附有完整代码和优化后的代码详解，希望能帮助到大家
八大排序算法（C语言实现）
2021dragon的博客
05-16 8万+
文章目录插入排序插入排序希尔排序选择排序选择排序堆排序交换排序冒泡排序快速排序并归排序并归排序 插入排序 插入排序 希尔排序 选择排序 选择排序 堆排序 交换排序 冒泡排序 快速排序 并归排序 并归排序 ...
排序算法:快速排序——C/C++
Tiany的博客
02-13 7572
快速排序详细介绍——C++一.算法介绍二.算法思路三.代码实现 一.算法介绍 快速排序几乎是目前所有排序法中速度最快的方法，STL的sort()函数就是基于快速排序的优化。 时间复杂度 O 最好 O( nlog⁡2nn\log_2nnlog2​n) 最坏（出现几率极小） O(n2n^2n2) 平均 O(nlog⁡2nn\log_2nnlog2​n) 空间复杂度 O(log⁡2n\log_2nlog2​n) 二.算法思路 1.确定一个分界点，将序列分为左右两部
用C语言实现快速排序算法
热门推荐
我的博客
11-04 20万+
一、快速排序算法（Quicksort） 1. 定义 快速排序由C. A. R. Hoare在1962年提出。快速排序是对冒泡排序的一种改进，采用了一种分治的策略。 2. 基本思想 通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 3....
排序算法：快速排序、归并排序、计数排序详解
晓风残月淡的博客
07-15 850
（1）快速排序是应用最广的排序算法，它流行的原因是当数据量n很大时，它是原地排序，只占用lgN的辅助栈空间，属于是O（nlogn）时间复杂度的先进排序。（2）如果中枢值（pivot）选取不对，那么性能受到严重影响，时间复杂度劣化为O（n2）特点：快速排序是对冒泡排序的改进，时间复杂度O(nlgn)，最糟糕的情况下会降到O(n2)。平均时间在所有先进方法中属于最好的。
C语言实现快速排序算法（附带源代码）
二当家的
01-25 1560
快速排序（Quick Sort）是一种常用的排序算法，它采用分治策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。以下是用 C 语言实现快速排序的示例代码：
快速排序(快排) (C语言实现)
Brant_zero的博客
07-11 3万+
本篇博客学习内容是快速排序，快速排序有多种不同的版本和优化，我们这次的目的就是将这些版本都搞明白，废话不多说，我们开始。
C语言快速排序算法
qq_63918780的博客
02-02 7503
C语言快速排序算法
二叉树建立遍历冒泡排序快速排序算法：C语言编程实现10个数据结构课程设计实例.zip
07-01
二叉树建立遍历冒泡排序快速排序算法：C语言编程实现10个数据结构课程设计实例.zip 二叉树建立遍历冒泡排序快速排序算法：C语言编程实现10个数据结构课程设计实例.zip 二叉树建立遍历冒泡排序快速排序算法：C语言...
快速排序算法C语言实现与优化.pdf
06-24
本文将详细介绍快速排序算法的C语言实现，并探讨其优化策略。 一、快速排序算法的基本原理 快速排序算法的基本思想是通过一趟排序将待排记录分隔成独立的两部分，其中一部分的所有记录比另一部分的所有记录都要小...
C语言实现快速排序算法（含实现步骤）
12-21
在C语言中实现快速排序算法，我们需要理解算法的基本原理和步骤。快速排序的高效性主要来源于其分治的思想。首先，我们需要选取一个基准值（pivot），通常选择序列的最后一个元素。然后，通过一趟排序将序列分为两...
【25届秋招备战C++】算法篇-排序算法合集
最新发布
weixin_44791229的博客
07-12 72
排序算法是计算机科学中的基本算法之一，用于将一组数据按照特定的顺序（升序或降序）进行排列。排序算法广泛应用于数据管理和检索系统，提高数据访问效率，也是其他高级算法的基础，如搜索和合并算法。
从LeetCode215看排序算法
weixin_43562105的博客
07-12 517
2.第二轮比较后，第二大的数字 48 被冒泡到了倒数第二的位置，数组变为：3, 5, 15, 38, 36, 26, 27, 2, 44, 4, 19, 46, 47, 48, 50。1.第一轮比较后，最大的数字 50 被冒泡到了数组末尾，数组变为：3, 5, 38, 15, 44, 36, 26, 27, 2, 46, 4, 19, 47, 48, 50。举个例子，假设我们有一组数字：3, 38, 5, 44, 15, 47, 36, 26, 27, 2, 46, 4, 19, 50, 48。
【八大排序】java版(上)（冒泡、快排、堆排、选择排序）
qq_55846232的博客
07-12 373
八大排序之 冒泡排序、快速排序、堆排序、选择排序
《算法笔记》总结No.3——排序
前端，算法，MATLAB，统计学爱好者，目前主攻Web全栈+考研内容
07-07 365
侧重应用，408中要求的种类更加繁多，此处先不扩展难度~总结最常用的两种排序。
常用的内部排序算法
瞉韩
07-12 213
简单选择排序、直接插入排序和冒泡排序、折半插入排序、希尔排序算法、快速排序算法（递归和非递归）、堆排序。
快速排序等经典排序算法C++、Java、python等版本
09-29
本资源提供了快速排序以及其它经典排序算法如冒泡排序、插入排序、选择排序、希尔排序、计数排序、基数排序、桶排序、归并排序和堆排序的实现，涵盖C++、Java和Python三种编程语言。排序算法是计算机科学中的重要...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值