快速排序（详解）

已于 2023-04-09 20:45:18 修改
阅读量448 收藏 3
点赞数 3
分类专栏： 数据结构初阶 文章标签： 算法 排序算法 数据结构
于 2023-04-09 16:50:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73790767/article/details/129940501
版权
文章详细介绍了快速排序算法的实现，包括朴素版的一层循环和递归，以及针对选取key值的改进方法，如随机数取法、三路取中和前后指针法。此外，还讨论了通过限制小区间来减少递归次数以及在小规模数据时使用插入排序的优化策略。
摘要由CSDN通过智能技术生成

快排

一.朴素版

1.一层循环

在这里插入图片描述

快排的每一层循环就是选出一个key值将其放到正确的位置（也就是放到已经完全有序时的位置）。

在这里插入图片描述

例如以上有一组数据，我们选择6为key值，这次循环我们要将6放到正确的位置。用一个left指针和一个right指针，分别指向左右两端，left指针向右走，遇到大于key值的数就停下，然后right指针向左走，遇到小于key值的数就停下。之后两指针所对应的数交换位置，直到两指针相遇，交换left所指向的数和key值，一次循环停止。就得到key数左边的数都小于等于key，右边的数都大于等于key。

在这里插入图片描述

此时一次循环结束6左边的数都小于等于6，右边的数都大于等于6。（一般令最左边的数为key值）

在这里插入图片描述

2.递归

每次循环找到一个数，那么依次递归当left>=right,也就是这次递归里已经没有元素时就说明排序完成。

void Swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

void QuickSort(int* a, int left, int right)
{
	if (left >= right)
		return;
	int begin = left, end = right;
	int key = left;
	while (right > left)
	{
		while (left<right&&a[right] >= a[key])
			right--;
		while (left<right&&a[left] <= a[key])
			left++;
		Swap(&a[left], &a[right]);
	}
	Swap(&a[left], &a[key]);
	key = left;
	QuickSort(a, begin,key-1);
	QuickSort(a, key + 1, end);
}

二.改进(选取key值)

缺陷

如果改数据已经是升序或者逆序的话，我们每次选最左边为key值，那么每次递归只能减少一个数（无法做到理想情况下的二分）。如果有100w个数，就容易造成栈溢出，所以需要改进。

1.随机数取法

其实快排的缺陷主要是由key值的选取造成的，那么我们可以随机选key值，就可以避免最坏的情况。

在这里插入图片描述

2.三路取中

选随机数是可行的，但有人认为太过于不确定了，所以又出炉了一个新方法，取中间（max>a[mid]>min）的坐标。

在这里插入图片描述

在这里插入图片描述

3.前后指针法

简单来说就是一个cur指针从最左边走起，pre初始位置在cur+1位置，pre向后走，如果a[pre]<a[key],就交换a[++cur]和a[pre]，直到pre走到最右边。

在这里插入图片描述

在这里插入图片描述

源代码

#include<stdio.h>
#include<time.h>
#include<stdlib.h>

void Swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

int GetMid(int* a, int left, int right)
{
	int mid = (left + right) / 2;
	if (a[mid] > a[left])
	{
		if (a[mid] < a[right])
			return mid;
		else if (a[left] > a[right])
			return left;
		else
			return right;
	}
	else
	{
		if (a[mid] > a[right])
			return mid;
		else if (a[left] < a[right])
			return left;
		else
			return right;
	}
}

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

	//int begin = left, end = right;

	//随机选key
	//int randi =left+ rand() % (right - left);//让产生的随机数在left和right之间
	//Swap(&a[randi], &a[left]);//为了避免扰乱后面的排序，我们将其调到最左边的位置

	//三数取中
	int mid = GetMid(a, left, right);
	Swap(&a[mid], &a[left]);

	/*int key = left;
	while (right > left)
	{
		while (left<right&&a[right] >= a[key])
			right--;
		while (left<right&&a[left] <= a[key])
			left++;
		Swap(&a[left], &a[right]);
	}
	Swap(&a[left], &a[key]);
	key = left;
	QuickSort(a, begin,key-1);
	QuickSort(a, key + 1, end);*/
	
	//前后指针法
	int cur = left, pre = cur + 1,key=left;
	while (pre<=right)
	{
		if (a[pre] < a[key])
		{
			cur++;
			Swap(&a[pre], &a[cur]);
		}
		pre++;
	}
	Swap(&a[cur], &a[key]);
	key = cur;
	QuickSort(a, left, key-1);
	QuickSort(a, key + 1, right);
}
int main()
{
	int a[20000];
	srand((unsigned int)time(NULL));
	for (int i = 0; i < 20000; i++)
	{
		a[i] = rand() % 1000;
	}
	QuickSort(a,0,19999);
	int st = 0;
	for (int i = 0; i < 19998; i++)
	{
		if (a[i] > a[i + 1])
		{
			printf("%d->%d,%d\n", a[i], a[i + 1], i);
			st = 1;
			break;
		}
	}
	if (st)
	{
		printf("out of order");
	}
	else
	{
		printf("order");
	}
}

三，小区间（减少递归）

我们知道快排是按二叉树形式排列的，而在理想情况下，最后一层递归就占总递归的二分之一。实际上当每个子树只剩下10个数时，我们就可以考虑不再递归改用插入排序，那么这样（在理想情况下）就可以去除最后三层递归，也就会减少87.5%的递归。

在这里插入图片描述

不了解插入排序的可以看看这篇博客插入排序

在这里插入图片描述

#include<stdio.h>
#include<time.h>
#include<stdlib.h>

void Swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

int GetMid(int* a, int left, int right)
{
	int mid = (left + right) / 2;
	if (a[mid] > a[left])
	{
		if (a[mid] < a[right])
			return mid;
		else if (a[left] > a[right])
			return left;
		else
			return right;
	}
	else
	{
		if (a[mid] > a[right])
			return mid;
		else if (a[left] < a[right])
			return left;
		else
			return right;
	}
}

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

	//int begin = left, end = right;

	//随机选key
	//int randi =left+ rand() % (right - left);//让产生的随机数在left和right之间
	//Swap(&a[randi], &a[left]);//为了避免扰乱后面的排序，我们将其调到最左边的位置

	//三数取中
	int mid = GetMid(a, left, right);
	Swap(&a[mid], &a[left]);

	/*int key = left;
	while (right > left)
	{
		while (left<right&&a[right] >= a[key])
			right--;
		while (left<right&&a[left] <= a[key])
			left++;
		Swap(&a[left], &a[right]);
	}
	Swap(&a[left], &a[key]);
	key = left;
	QuickSort(a, begin,key-1);
	QuickSort(a, key + 1, end);*/

	//前后指针法
	if (right - left + 1 > 10)
	{
		int cur = left, pre = cur + 1, key = left;
		while (pre <= right)
		{
			if (a[pre] < a[key])
			{
				cur++;
				Swap(&a[pre], &a[cur]);
			}
			pre++;
		}
		Swap(&a[cur], &a[key]);
		key = cur;
		QuickSort(a, left, key - 1);
		QuickSort(a, key + 1, right);
	}
	else//插入排序
	{
		for (int i = 1; i < 10; i++)
		{
			int end = i - 1;
			int tmp = a[i];
			while (end >= 0)
			{
				if (a[end] > tmp)
				{
					a[end + 1] = a[end];
					end--;
				}
				else
				{
					break;
				}
			}
			a[end + 1] = tmp;
		}
	}
}
int main()
{
	int a[20000];
	srand((unsigned int)time(NULL));
	for (int i = 0; i < 20000; i++)
	{
		a[i] = rand() % 1000;
	}
	QuickSort(a,0,19999);
	int st = 0;
	for (int i = 0; i < 19998; i++)
	{
		if (a[i] > a[i + 1])
		{
			printf("%d->%d,%d\n", a[i], a[i + 1], i);
			st = 1;
			break;
		}
	}
	if (st)
	{
		printf("out of order");
	}
	else
	{
		printf("order");
	}
}

四.非递归

使用栈先进后出来模拟实现深度优先遍历。如果不了解栈可以看看这篇博客栈

在这里插入图片描述

#include"stack.h"


#include<stdio.h>
#include<time.h>
#include<stdlib.h>

void Swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

int GetMid(int* a, int left, int right)
{
	int mid = (left + right) / 2;
	if (a[mid] > a[left])
	{
		if (a[mid] < a[right])
			return mid;
		else if (a[left] > a[right])
			return left;
		else
			return right;
	}
	else
	{
		if (a[mid] > a[right])
			return mid;
		else if (a[left] < a[right])
			return left;
		else
			return right;
	}
}

int PartSort(int* a, int left, int right)
{
	// 三数取中
	int midi = GetMid(a, left, right);
	if (midi != left)
		Swap(&a[midi], &a[left]);

	int keyi = left;

	int prev = left;
	int cur = left + 1;
	while (cur <= right)
	{
		if (a[cur] < a[keyi] && ++prev != cur)
			Swap(&a[cur], &a[prev]);

		++cur;
	}

	Swap(&a[prev], &a[keyi]);
	keyi = prev;

	return keyi;
}

void QuickSort(int* a, int left, int right)
{
	ST st;
	STInit(&st);
	STPush(&st, right);
	STPush(&st, left);

	while (!STEmpty(&st))
	{
		int begin = STTop(&st);
		STPop(&st);
		int end = STTop(&st);
		STPop(&st);

		int keyi = PartSort(a, begin, end);
		// [begin,keyi-1] keyi [keyi+1, end]
		if (keyi + 1 < end)
		{
			STPush(&st, end);
			STPush(&st, keyi + 1);
		}

		if (begin < keyi - 1)
		{
			STPush(&st, keyi - 1);
			STPush(&st, begin);
		}
	}

	STDestroy(&st);
}
int main()
{
	/*int a[11] = {3,3,8,7,6,5,4,3,2,1,0};
	QuickSort(a, 0, 10);
	for (int i = 0; i < 10; i++) printf("%d ", a[i]);*/
	int a[200000];
	srand((unsigned int)time(NULL));
	for (int i = 0; i < 200000; i++)
	{
		a[i] = rand() % 1000;
	}
	QuickSort(a, 0, 199999);
	int st = 0;
	for (int i = 0; i < 199998; i++)
	{
		if (a[i] > a[i + 1])
		{
			printf("%d->%d,%d\n", a[i], a[i + 1], i);
			st = 1;
			break;
		}
	}
	if (st)
	{
		printf("out of order");
	}
	else
	{
		printf("order");
	}
}
咸蛋挞
关注
专栏目录
快速排序——quicksort
04-08
/********************快排算法************************/ void quicksort(int A[],int p,int r) { int q; if(p<r) { q=partition(A,p,r); quicksort(A,p,q-1); quicksort(A,q+1,r); } } /****************************************************/
快速排序详解
11-05
### 快速排序详解 #### 一、快速排序概述 快速排序是一种高效的排序算法，它在1962年由英国计算机科学家C.A.R. Hoare提出。作为一种分治策略的应用，快速排序的基本思想是通过一次排序操作将待排序的数据分割为...
白话经典算法系列之六 快速排序 快速搞定
稻草人技术博客
09-24 509
快速排序由于排序效率在同为O(N*logN)的几种排序方法中效率较高，因此经常被采用，再加上快速排序思想—-分治法也确实实用，因此很多软件公司的笔试面试，包括像腾讯，微软等知名IT公司都喜欢考这个，还有大大小的程序方面的考试如软考，考研中也常常出现快速排序的身影。 总的说来，要直接默写出快速排序还是有一定难度的，因为本人就自己的理解对快速排序作了下白话解释，希望对大家理解有帮助，达到快速排序，快速
快排 [随机数]
_计算机好苦
07-12 204
#include<iostream> #include<cstring> #include<algorithm> #include<string> #include<time.h> using namespace std; const int maxn = 100; int inquicksort(int a[], int left, int right) { int p = (int)(round(1.0 * rand() / RAND_MAX
算法笔记-快速排序（随机数）
m0_51711089的博客
02-17 510
快速排序： #include<iostream> #include<stdlib.h>// #include<time.h>//这两个都是调用随机数的函数; using namespace std; int n; const int maxn=100010; int a[maxn]; int partition(int a[],int left,int right){//快排划分区间; int num=rand()%(right-left+1)+left;//.
快速排序（Quick sort）
热门推荐
雪月清的博客
07-20 9万+
一、简介 快速排序是（Quick sort）是对冒泡排序的一种改进，是非常重要且应用比较广泛的一种高效率排序算法。 二、算法思路 快速排序是通过多次比较和交换来实现排序，在一趟排序中把将要排序的数据分成两个独立的部分，对这两部分进行排序使得其中一部分所有数据比另一部分都要小，然后继续递归排序这两部分，最终实现所有数据有序。 大致步骤如下： 首先设置一个分界值也就是基准值又是也称为监视哨，通过该分界值将数据分割成两部分。 将大于或等于分界值的数据集中到右边，小于分界值的数据集中到左边。一趟排序过后，左边部
JS排序之快速排序详解
01-21
本文为大家分享了JS快速排序的具体代码，供大家参考，具体内容如下 说明 时间复杂度指的是一个算法执行所耗费的时间 空间复杂度指运行完一个程序所需内存的大小 稳定指，如果a=b,a在b的前面，排序后a仍然在b的前面 ...
深入单链表的快速排序详解
01-20
然后分别对左、右两个子链表进行递归快速排序，以提高性能。但是，由于单链表不能像数组那样随机存储，和数组的快排序相比较，还是有一些需要注意的细节：1、支点的选取，由于不能随机访问第K个元素，因此每
c++快速排序详解
01-20
说一说快速排序 快速排序，实际中最常用的一种排序算法，速度快，效率高，在N*logN的同等级算法中效率名列前茅。·  基本思想：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分...
快速排序 产生随机数 c语言,快速排序里的学问：随机化快排
weixin_31896061的博客
05-23 413
前一篇文章讲到了选择枢纽元的几种方法，其实第二种是随机选择元素作为枢纽元。那么在这篇文章里就实现一个随机化排序。算法与前面《算法导论》里的例子差不多，只是在调用分割Partition时加入一个随机数，具体可以参看程序。C语言代码为：#include "stdio.h"#include "math.h"#include "stdlib.h"int num = 10;void swap(int *a,...
快速排序
qq_45369827的博客
01-18 124
快速排序 ​ 快速排序采用分治策略。1. 首先拿到数组的第一个数作为target标记数，把数组中比标记数大的都移到它的左边，比标记数小的都移到它的右边。2. 把数组分成标记数之前和之后的两部分，每个部分均按照步骤1中的思路排序。重复上述中1和2操作，直到分成的数组只有一个数时。因为此时数组已经是升序排序了。 ​ 很明显重复步骤1和2的操作，适合用递归来完成，而递归的边界条件就是数组中只有一个数。 public static void quickSort(int[] dp, int l, int r) {
【计算机算法设计与分析】快速排序（C++_分治递归）
ccql's Blog
11-20 667
问题描述 快速排序由C. A. R. Hoare在1960年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 （问题描述摘自百度百科） 闲话 在实际的算法编程中，快排使用的是algorithm库中的sort()函数（可以了解下，很简单也很好用），但是自己从来没有实现过这个排序算法… Code #include<bits/stdc
快速排序详解：算法与应用
快速排序是数据结构课程设计实验五的重要内容，它属于内部排序算法中的一种高效算法。排序是数据处理和软件设计中的基础操作，旨在将一组记录按特定顺序排列，便于后续查找和处理。内部排序通常发生在内存中，常见的...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

咸蛋挞

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

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

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

打赏作者

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

抵扣说明：

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

余额充值