【快速排序】（C语言实现）

已于 2022-11-01 20:31:43 修改
阅读量1.1w 收藏 137
点赞数 47
文章标签： c语言
于 2022-04-08 18:11:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/langk_/article/details/124005500
版权

快速排序

一. 递归实现

1. 快排是什么？

快速排序算法通过多次比较和交换来实现排序，其排序流程如下：

(1)首先设定一个分界值，通过该分界值将数组分成左右两部分。

(2)将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。此时，左边部分中各元素都小于分界值，而右边部分中各元素都大于或等于分界值。

(3)然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。

(4)重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后，整个数组的排序也就完成了。

2.实现快排的三种方式

a.挖坑法

单趟的图形演示：(红色为坑)
在这里插入图片描述

挖坑法的单趟排序的基本步骤如下：
（1）选出一个数据（一般是最左边或最右边得）作为key,并且在改数据位置形成一个坑。
（2）定义两个变量begin和end,begin从左向右走，end从右向左走。（若坑在左边，则end先走；若坑在右边，则begin先走）
（3）在end走的过程中，如果遇到比key小的数，停下来，把该位置的数放到坑里，然后把该位置更新为新坑。
（4）然后begin开始走，如果走的过成中遇到比key大的数，停下来，把该位置的数放到坑中，然后把该位置更新为新坑。

反复执行（3）（4）直到begin和end相遇，相遇的位置一定是一个坑，然后把key放入坑中。

经过一次单趟排序，最终也使得key左边的数据全部都小于key，key右边的数据全部都大于key。

然后也是将key的左序列和右序列再次进行这种单趟排序，如此反复操作下去，直到左右序列只有一个数据，或是左右序列不存在时，便停止操作。
 
代码实现：

void QuickSort1(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}

	int begin = left, end = right;
	//三数取中
	//int midIndex = GetThreeMid(a,begin,end);
    //Swap(&a[begin],&a[midIndex]);
	int pivot = begin;
	int key = a[begin];
	
	while (begin < end)
	{
		//右边找小的，如果不是小于key,继续
		while (begin < end && a[end] >= key)
		{
			end--;
		}
		//找到比key小的，把它放在坑里，换新坑
		a[pivot] = a[end];
		pivot = end;
		//左边找大的，如果不是大于key,继续
		while (begin < end && a[begin] <= key)
		{
			begin++;
		}
		//找到比key大的，把它放在坑里，换新坑
		a[pivot] = a[begin];
		pivot = begin;
	}
	
	a[pivot] = key;//bengin 与 end 相遇，相遇的位置一定是一个坑
	QuickSort1(a, left, pivot - 1);
	QuickSort1(a, pivot + 1, right);
}

b.左右指针法

单趟的图形演示：
在这里插入图片描述
左右指针法的单趟排序的基本步骤如下：
（1）选出一个key，一般是最左边或是最右边的。
（2）定义一个begin和一个end，begin从左向右走，end从右向左走。（需要注意的是：若选择最左边的数据作为key，则需要end先走；若选择最右边的数据作为key，则需要begin先走）。
（3）在走的过程中，若end遇到小于key的数，则停下，begin开始走，直到begin遇到一个大于key的数时，将begin和end的内容交换，end再次开始走，如此进行下去，直到begin和end最终相遇，此时将相遇点的内容与key交换即可。（选取最左边的值作为key）

经过一次单趟排序，最终使得key左边的数据全部都小于key，key右边的数据全部都大于key。

然后我们在将key的左序列和右序列再次进行这种单趟排序，如此反复操作下去，直到左右序列只有一个数据，或是左右序列不存在时，便停止操作，因为这种序列可以认为是有序的。
 代码实现：

void QuickSort2(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}

	int begin = left, end = right;
	//三数取中
	//int midIndex = GetThreeMid(a,begin,end);
    //Swap(&a[begin],&a[midIndex]);
	int keyi = begin;
	while (begin < end)
	{

		while (begin < end && a[end] >= a[keyi])
		{
			end--;
		}
		while (begin < end && a[begin] <= a[keyi])
		{
			begin++;
		}
		Swap(&a[begin], &a[end]);
	}
	Swap(&a[keyi], &a[begin]);
	QuickSort2(a, left, begin - 1);
	QuickSort2(a, begin + 1, right);
}

c.前后指针法

单趟的图形演示：
在这里插入图片描述
前后指针法的单趟排序的基本步骤如下：
（1）选出一个key，一般是最左边或是最右边的。
（2）起始时，prev指针指向序列开头，cur指针指向prev+1。
（3）若cur指向的内容小于key，则prev先向后移动一位，然后交换prev和cur指针指向的内容，然后cur指针++；若cur指向的内容大于key，则cur指针直接++。如此进行下去，直到cur指针越界，此时将key和prev指针指向的内容交换即可。

经过一次单趟排序，最终也能使得key左边的数据全部都小于key，key右边的数据全部都大于key。

然后也还是将key的左序列和右序列再次进行这种单趟排序，如此反复操作下去，直到左右序列只有一个数据，或是左右序列不存在时，便停止操作。

代码实现：

void QuickSort3(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}

	int begin = left, end = right;
	//三数取中
	//int midIndex = GetThreeMid(a,begin,end);
    //Swap(&a[begin],&a[midIndex]);
	int keyi = begin;
	int prev = begin;
	int cur = prev + 1;
	
	while (cur <= end)
	{
		if (a[cur] < a[keyi] && ++prev != cur)
		{
			Swap(&a[cur], &a[prev]);
		}
		cur++;
	}
	Swap(&a[keyi], &a[prev]);
	QuickSort3(a, left, prev - 1);
	QuickSort3(a, prev + 1, right);
}

d.快速排序的两个优化

（1）三数取中
如果不加三数取中，我们不能保证每次取到的key的值一定是在整个数组的中间位置，假设我们碰巧，key在每一趟排序中，都可以选到中间大小的值，那么我们来算算它的时间复杂度。
在这里插入图片描述
如果我们运气不好，每次的key都为头，我们再来算算他的时间复杂度。
在这里插入图片描述
对比上面两个key位置不同的的时间复杂度，显而易见，当key在中间位置一点的时候，算法效率高。所以我们要想办法，尽量要使key取在中间位置，这个时候就要用到三数取中了，三数取中就是在数组的头尾中间选择中间大小的那个值作为key，然后把它与数组的首元素位置进行交换。

代码实现：

//三数取中
 int GetThreeMid(int* a, int left, int right)
 {
	 int mid = (left + right) / 2;
	 if (a[mid] > a[left])
	 {
		 if (a[right] > a[mid])
			 return mid;
		 else if (a[left] > a[right])
			 return left;
		 else
			 return right;
	 }
	 else
	 {
		 if (a[left] < a[right])
			 return left;
		 else if (a[right] < a[mid])
			 return mid;
		 else
			 return right;
	 }
 }

然后把它与数组的首元素位置进行交换

int midIndex = GetThreeMid(a,begin,end);
Swap(&a[begin],&a[midIndex]);

(2)小区间优化
 我们可以看到，就算是上面理想状态下的快速排序，也不能避免随着递归的深入，每一层的递归次数会以2倍的形式快速增长。
 为了减少递归树的最后几层递归，我们可以设置一个判断语句，当序列的长度小于某个数的时候就不再进行快速排序，转而使用其他种类的排序。小区间优化若是使用得当的话，会在一定程度上加快快速排序的效率，而且待排序列的长度越长，该效果越明显。

void QuickSortTop(int* a, int left, int right)
{
	if (left >= right)
	{
		return;//如果只有一个数，直接返回。
	}
	if (right - left + 1 > 10)//可自行调整
	{
		QuickSort1(a, left, right);
		//QuickSort2(a, left, right);
		//QuickSort3(a, left, right);

	}
	else//当序列长度小于等于10是，使用堆排序
	{
		HeapSort1(a, right - left + 1);
	}
}

点一点学 堆排序.

二.非递归实现

1.三种方法的单趟实现代码

a.挖坑法

//1.挖坑法
 int QuickSortPlay1(int* a, int left, int right)
 {
	 if (left >= right)
	 {
		 return;//当只有一个数，直接返回
	 }
	 int begin = left;
	 int end = right;
	 //三数取中
	 int midIndex = GetThreeMid(a, begin, end);
	 Swap(&a[begin], &a[midIndex]);
	 int pivot = begin;
	 int key = a[begin];
	 while (begin < end)
	 {
		 //右边找小的，如果不是小于key,继续
		 while (begin < end && a[end] >= key)
		 {
			 end--;
		 }
		 //找到比key小的，把它放在坑里，换新坑
		 a[pivot] = a[end];
		 pivot = end;
		 //左边找大的，如果不是大于key,继续
		 while (begin < end && a[begin] <= key)
		 {
			 begin++;
		 }
		 //找到比key大的，把它放在坑里，换新坑
		 a[pivot] = a[begin];
		 pivot = begin;
	 }
	 a[pivot] = key;//最后相遇一定是在坑相遇
	 return pivot;
 }

b.左右指针法

//2.左右指针 
 int QuickSortPlay2(int* a, int left, int right)
 {
 
	 if (left >= right)
	 {
		 return;//当只有一个数，直接返回
	 }
	 int begin = left;
	 int end = right;
	 //三数取中
	 int midIndex = GetThreeMid(a, begin, end);
	 Swap(&a[begin], &a[midIndex]);
	 int keyi = begin;
	 
	 while (begin < end)
	 {
		 while (begin < end && a[end] >= a[keyi])
		 {
			 end--;
		 }
		 
		 while (begin < end && a[begin] <= a[keyi])
		 {
			 begin++;
		 }
		 
		 Swap(&a[begin], &a[end]);
	 }
	 
	 int meet = begin;//begin与end的相遇点
	 Swap(&a[keyi], &a[meet]);//交换key和相遇点的值
	 return meet;
 }

c.前后指针法

//3.前后指针
 int  QuickSortPlay3(int* a, int left, int right)
 {
	 if (left >= right)
	 {
		 return;//当只有一个数，直接返回
	 }
	 int begin = left;
	 int end = right;
	 //三数取中
	 int midIndex = GetThreeMid(a, begin, end);
	 Swap(&a[begin], &a[midIndex]);
	 int keyi = begin;
	 int prev = begin;
	 int cur = prev + 1;
	 while (cur <= end)
	 {
		 if (a[cur] < a[keyi] && ++prev != cur)
		 {
			 Swap(&a[cur], &a[prev]);
		 }
		 cur++;
	 }
	 Swap(&a[keyi], &a[prev]);
	 return prev;
 }

d.非递归实现快排

快速排序的非递归算法基本思路：
 1、先将待排序列的最后元素的下标和第一个元素的下标入栈。
 2、当栈不为空时，读取栈中的信息（一次读取两个：前一个是begin，后一个是end），然后调用某一版本的单趟排序，排完后获得了key的下标pivot，然后判断key的右序列和左序列是否还需要排序，若还需要排序，就将相应序列的end和begin依次入栈；若不需排序了，就不需要将该序列的信息入栈。
 3、反复执行步骤2，直到栈为空为止。
 如果不理解栈点一点 栈.

void QuickSortNonR(int* a, int left, int right)
{
	ST st;//创建栈
	InitStack(&st);//初始化栈
	int begin = left;
	int end = right;
	StackPush(&st, end);//待排序列的end
	StackPush(&st, begin);//待排序列的begin 
	while (!StackEmpty(&st))
	{
		begin = StackTop(&st);//读取待排序列的begin
		StackPop(&st);//出栈
		end = StackTop(&st);//读取待排序列的end
		StackPop(&st);//出栈
		//int pivot = QuickSortPlay1(a, begin, end);//调用单趟排序函数
		//int pivot = QuickSortPlay2(a, begin, end);//调用单趟排序函数
		int pivot = QuickSortPlay3(a, begin, end);//调用单趟排序函数
		if (pivot + 1 < end)//该序列的右序列还需要排序
		{
			StackPush(&st, end);//右序列的end入栈
			StackPush(&st, pivot + 1);//右序列的begin入栈
		}
		if (begin < pivot - 1)//该序列的左序列还需要排序
		{
			StackPush(&st, pivot - 1);//左序列的end入栈
			StackPush(&st, begin);//左序列的begin入栈
		}
	}
	StackDestory(&st);//销毁栈
}
桑榆非晚ᴷ
关注
快速排序的C语言代码实现
farsightliuht的专栏
09-13 714
 作者：李慧芹,华清远见嵌入式学院讲师。快速排序实质上是对“冒泡排序”的一种改进，整个排序过程可概括为：通过N趟的排序将原本的排序数据分为若干块进行分块排序，而在每趟排序过程中，以指定的关键字将待排数据分别分为比关键字大的部分和比关键字小的部分，反复上述过程，将整个待排数列分散为若干个小数列而分别进行排序操作。假设我们现对一列数进行快速排序，其C语言代码实现如下：#include
C语言之快速排序
m0_61545891的博客
01-19 1848
今天来讲下快速排序的实现逻辑和代码。 逻辑： 1.首先选取一个无序序列的某个数值作为中值prvot； 2.将大于prvot的数值排放在prvot的右边，小于i的放左边； 3.将prvot左侧和右侧的数值再次进行排放，直到个数为1. 到这时排序也就结束了； 这个排序体现了什么思想呢？——————就是分治和递归。 为了方便代码的实现，我们现在每次都把第一个数值作为prvot； 1.先写出主函数 int main() { int arr[1000] = { 0 }, n,i; scanf
c语言-快速排序
最新发布
安权_code的博客
12-01 1万+
快速排序作为多种排序方法中效率最高的一种，其底层原理被广泛运用，他的核心思想与二叉树结构中的递归逻辑相似，首先标记一个元素作为基准点，然后利用该基准点把数组分成左右两个区间，并且使小于该基准点的元素放在左区间，大于该基准点的元素放在右区间，如此反复递归，直到数组为一个有序数组。
C语言 快速排序
程序员大阳
07-06 1500
一，简介快速排序，用分治法提高了效率，简直就是“方法得当，效率提高”的典范之作。基本思路就是每次都把当前数据化为两部分，每次排序保证前面部分都小于后面部分，然后在对两部分分别快速排序。二，代码//快速排序#include<stdio.h>int FastSort(int* p,int start,int end) { int i,j,temp; if(start>=end)
C语言实现快速排序算法
qq_58417838的博客
11-18 1747
快速排序算法
快速排序的C语言实现（算法导论版）
11-02
算法导论版的快速排序的完整实现。C语言版。免积分送给需要的朋友。
C语言实现多种链表快速排序
05-08
在给定的文件中，`快速排序.cpp`可能包含了具体的C语言实现代码，`qsort.h`可能是自定义的快速排序函数头文件，用于处理链表数据。`vcxproj`文件是Visual Studio项目文件，用于编译和管理源代码，而`.filters`和`....
希尔排序与快速排序C语言实现
04-10
快速排序的C语言实现主要包括： 1. 选择一个基准元素 pivot。 2. 分区操作：重新排列数组，使得所有小于pivot的元素都在其左边，所有大于pivot的元素在其右边。 3. 递归调用快速排序函数，对左右两部分分别进行排序...
快速排序 c语言程序实现
03-30
快速排序c语言
045 快速排序 C语言 快速排序 C语言
06-01
以下是一个简单的C语言实现快速排序的代码示例： ```c #include // 交换两个元素 void swap(int* a, int* b) { int t = *a; *a = *b; *b = t; } // 分区操作 int partition(int arr[], int low, int high) { ...
快速排序（C语言版）
Thinker的专栏
09-30 3300
#include #include int findPivotIndex(int array[], int low, int high) { int pivot = array[low]; while(low < high) { while(low = pivot) { --high; } array[low] = array[high]
快速排序——C语言
qq_37258792的博客
07-09 555
快速排序是冒泡排序的进化版，冒泡原理是比我大的放在我后面或者前面，快速则是比我大的放在后面，比我小的放在前面（前后并不绝对，取决于你是升序或降序）下面举个例子便于更好理解一列数2   4   1   3   5  （贴上自己画的图）假设第一个数  2  为基准key，我们可以再设一个变量t把2赋给t，这样原来2的位置就空下来了。还设了两个指针（此指针仅代表移动方向，非*p这种）由图可以知道找出基准...
C语言快速排序
weixin_45743799的博客
02-23 1105
快速排序是对冒泡法排序的一种改进。 快速排序算法 的基本思想是：将所要进行排序的数分为左右两个部分，其中一部分的所有数据都比另外一 部分的数据小，然后将所分得的两部分数据进行同样的划分，重复执行以上的划分操作，直 到所有要进行排序的数据变为有序为止。 可能仅根据基本思想对快速排序的认识并不深，接下来以对n个无序数列A[0], A[1]…, A[n-1]采用快速排序方法进行升序排列为例进行讲解。 (...
快速排序算法
singleyw的专栏
06-09 1008
快速排序算法佚名  快速排序是对冒泡排序的一种改进。它的基本思想是：通过一躺排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一不部分的所有数据都要小，然后再按次方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。   假设要排序的数组是A[1]……A[N]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所
C语言-排序中的快速排序（简称快排）
weixin_62161976的博客
02-15 1万+
快速排序算法思想：（举例说明） （1）简单总结三步： 第一步，从后往前找比基准小的数据，往前挪 第二步，从前往后找比基准大的数据，往后挪 第三步，重复第一步和第二步 （2）eg: 34, 5, 6,22,56,88,11,2,4,0（一段非有序整数数据） 定义一个下标low指向这一段数据的第一个，即34；定义一个下标high指向这段数据的最后一个，即0； 找一个基准，一般找这一段数据的第一个就行，也就是low下标所指的值34； （3）依次进行（1）中所说步骤， 第一步， 因为0&
快速排序(快排) (C语言实现)
热门推荐
Brant_zero的博客
07-11 4万+
本篇博客学习内容是快速排序，快速排序有多种不同的版本和优化，我们这次的目的就是将这些版本都搞明白，废话不多说，我们开始。
C语言 快速排序
fpk2014的博客
05-25 552
快速排序简介 实现过程 代码实现 代码精简 快速排序简介 通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列，是对冒泡排序的一种改进。时间复杂度为O(nlogn)。 快速排序的模拟过程可以看链接：Quick...
快速排序 c语言
05-29
快速排序是一种常用的排序算法。它的基本思想是： 1. 选择一个基准数，将数组分成两部分。 2. 将大于基准数的数放在数组的右边，小于基准数的数放在数组的左边。 3. 对左右两部分分别使用快速排序。 以下是C语言实现的快速排序代码： ``` void quick_sort(int arr[], int left, int right) { int i, j, pivot; if (left < right) { i = left; j = right + 1; pivot = arr[left]; do { do i++; while (arr[i] < pivot); do j--; while (arr[j] > pivot); if (i < j) swap(arr[i], arr[j]); } while (i < j); swap(arr[left], arr[j]); quick_sort(arr, left, j - 1); quick_sort(arr, j + 1, right); } } ``` 这段代码是将快速排序实现为一个递归函数。它首先选择数组的第一个数为基准数，然后使用两个指针对数组进行划分。最后，递归地调用快速排序函数对划分后的两个子数组进行排序。
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

桑榆非晚ᴷ

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值