【算法】快速排序及其拓展优化（单向快速排序、单链表的快速排序）

最新推荐文章于 2022-10-25 20:57:25 发布
最新推荐文章于 2022-10-25 20:57:25 发布
阅读量555 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jacky_Feng/article/details/103450333
版权

引言：

快速排序是排序算法中，因其优秀的时间复杂度被人们比较广泛使用。接下来我们就来看一下快速排序的递归算法及非递归算法实现，及快速排序的两个拓展，单向扫面的快速排序和单链表的快速排序。

一、普通快速排序（双向扫描）

1.快速排序算法模拟图

2.代码演示

2.1 递归法

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

template<typename T>
int partion(T* a, int left, int right)
{
	int i = left;
	int j = right;
	T tmp = a[left];
	while (i < j)
	{
		while (i<j && a[j]>tmp)
		{
			j--;
		}
		if (i < j)
		{
			a[i++] = a[j];
		}
		while (i<j && a[i]<tmp)
		{
			i++;
		}
		if (i < j)
		{
			a[j--] = a[i];
		}
	}
	a[i] = tmp;
	return i;
}

template<typename T>
void Quick_sort(T* a, int left, int right)
{
	if (left >= right){
		return;
	}
	else{
        int pos = partion(a, left, right);
	    Quick_sort(a, left, pos - 1);
	    Quick_sort(a, pos + 1, right);
	}
}

template<typename T>
void print(T* a,int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << setw(4) << a[i];
	}
	cout << endl;
}

int main()
{
	int a[] = { 55, 41, 26, 53, 58, 97, 93 };
	int len = sizeof(a) / sizeof(a[0]);

	Quick_sort<int>(a, 0, len - 1);
	print<int>(a, len);

	char arr[] = "whjikacds";
	int length = strlen(arr);

	Quick_sort<char>(arr, 0, length - 1);
	print<char>(arr, length);
}

以上代码运行结果：

2.2 非递归法

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

template<typename T>
int Partition(T* a, int left, int right)
{
	int i = left;
	int j = right;
	T tmp = a[left];
	while (i < j)
	{
		while (i<j && a[j]>tmp)
		{
			j--;
		}
		if (i < j)
		{
			a[i++] = a[j];
		}
		while (i<j && a[i]<tmp)
		{
			i++;
		}
		if (i < j)
		{
			a[j--] = a[i];
		}
	}
	a[i] = tmp;
	return i;
}

template<typename T>
void NonRec_quickSort(T* a,int len)
{
	if (len <= 1)
		return;
	stack<T> st;
	int mid = Partition(a, 0, len - 1);
	if (mid > 1){
		st.push(0);
		st.push(len - 1);
	}
	if (mid < len - 2){
		st.push(mid + 1);
		st.push(len - 1);
	}
	while (!st.empty())
	{
		int right = st.top();
		st.pop();
		int left = st.top();
		st.pop();
		mid = Partition(a, left, right);
		if (left < mid - 1){
			st.push(left);
			st.push(mid - 1);
		}
		if (right > mid + 1){
			st.push(mid+1);
			st.push(right);
		}
	}

}

template<typename T>
void print(T* a,int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << setw(4) << a[i];
	}
	cout << endl;
}

int main()
{
	int a[] = { 55, 41, 26, 53, 58, 97, 93 };
        int len = sizeof(a) / sizeof(a[0]);
	
   
	NonRec_quickSort(a, len);
	print(a, len);
    
	
	char arr[] = "whjikacds";
	int length = strlen(arr);

	NonRec_quickSort(a, length);
	print<char>(arr, length);
	
}

以上代码运行结果：

二、单向快速排序

上述的快速排序算法可以从两边扫描，若现在添加限定条件，只能从一边进行扫描，那么该如何实现快速排序呢？

 1.算法图解演示：

2.代码演示：

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

template<typename T>
int split(T* a, int left, int right)
{
	int i = left;    //i指向比较元素的期望位置
	T x = a[i];    //将该数组第一个元素设置为比较元素
	//从数组的第二个元素起开始遍历，若找到的元素大于比较元素，则跳过
	for (int j = left + 1; j <= right; j++)
	{	//若找到了小于比较元素的数，则将其与前面较大的数进行交换
		if (a[j] <= x)
		{
			i++;
			swap(a[i], a[j]);
		}
	}
	swap(a[left], a[i]);    //将比较元素交换到期望位置
	return i;
}


template<typename T>
void Quick_sort(T* a, int left, int right)
{
	if (left >= right){
		return;
	}
	else{
		int pos = split(a, left, right);
		Quick_sort(a, left, pos - 1);
		Quick_sort(a, pos + 1, right);
	}
}

template<typename T>
void print(T* a, int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << setw(4) << a[i];
	}
	cout << endl;
}

int main()
{
	int a[] = { 55, 41, 26, 53, 58, 97, 93 };

	int len = sizeof(a) / sizeof(a[0]);

	Quick_sort<int>(a, 0, len - 1);
	print<int>(a, len);

	char arr[] = "whjikacds";
	int length = strlen(arr);

	Quick_sort<char>(arr, 0, length - 1);
	print<char>(arr, length);

}

以上代码的运行结果为：

三、单链表的快速排序

通过上述求解我们知道快速排序亦可以用在单向扫描，所以举一反三，我们如何对单链表进行快速排序呢？

其实和上述的单向扫描算法思想是一致的，只是表达上有些许区别

代码演示：

#include <iostream>
#include <algorithm>
#include <iomanip>
using namespace std;

//构造结点并初始化
typedef struct node
{
	int val;
	node * next;
	node(int x) :val(x), next(NULL){}
}mynode, *pmynode;

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

//定位
node *partion(node *pbegin, node * pend)
{
	if (pbegin == pend || pbegin->next == pend)
		return pbegin;

	int mykey = pbegin->val; //选择基准
	node* p = pbegin;
	node* q = pbegin->next;
	while (q != pend)
	{
		if (q->val< mykey)
		{
			p = p->next;
			swap(&p->val, &q->val); //小于则交换
		}
		q = q->next;//否则一直往下走
	}
	swap(&p->val, &pbegin->val); //定位
	return p;
}

void quick_sort(node *pbegin, node *pend)
{
	if (pbegin == pend || pbegin->next == pend)
		return;
	node *mid = partion(pbegin, pend);
	quick_sort(pbegin, mid);
	quick_sort(mid->next, pend);
}

node *mysort(node *head, node *end)
{  
	quick_sort(head, end);
	return head;
}

int main()
{
	node a(1);
	node b(4);
	node c(2);
	node d(2);
	node e(5);
	node f(7);
	a.next = &b;
	b.next = &c;
	c.next = &d;
	d.next = &e;
	e.next = &f;

	pmynode head = &a;
	//printf("%d", &a->val);
	//如果节点的指针不为空则打印节点
	while (head)
	{
		cout << setw(4) << head->val;
		head = head->next;
	}
	cout << endl;
	
	pmynode head0 = mysort(&a, &f);
	while (head0)
	{
		cout << setw(4) << head0->val;
		head0 = head0->next;
	}
	cout << endl;
	return 0;
}

以上代码运行结果为：

 四、快速排序的优化

我们知道快速排序越无序排序越快，当给定一个有序的数组进行排序的时候，它的时间复杂度仍为O（n),那么我们如何对快速排序进行优化，使其在各种情况下都是优秀的排序？

优化一：三位取中法

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


template<typename T>
int swap(T* a, T* b)
{
	T tmp = a;
	*a = *b;
	*b = T;
}


int Partition(int* a, int left, int right)
{
	int m = left + (right - left) / 2;
	if (a[left] > a[right])
	{
		swap(a[left], a[right]);
	}
	if (a[m] > a[right])
	{
		swap(a[m], a[right]);
	}
	if (a[m] > a[left])
	{
		swap(a[m], a[right]);
	}
	int i = left;
	int j = right;
	int tmp = a[left];
	while (i < j)
	{
		while (i<j && a[j]>tmp)
		{
			j--;
		}
		if (i < j)
		{
			a[i++] = a[j];
		}
		while (i<j && a[i]<tmp)
		{
			i++;
		}
		if (i < j)
		{
			a[j--] = a[i];
		}
	}
	a[i] = tmp;
	return i;
}

template<typename T>
void Quick_sort(T* a, int left, int right)
{
	if (left >= right){
		return;
	}
	else{
		int pos = Partition(a, left, right);
		Quick_sort(a, left, pos - 1);
		Quick_sort(a, pos + 1, right);
	}
}

template<typename T>
void print(T* a, int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << setw(4) << a[i];
	}
	cout << endl;
}

int main()
{
	int a[] = { 55, 41, 26, 53, 58, 97, 93 };

	int len = sizeof(a) / sizeof(a[0]);

	Quick_sort<int>(a, 0, len - 1);
	print<int>(a, len);

}

优化二：随机化

#include<math.h>
template<typename T>
int swap(T* a, T* b)
{
	T tmp = a;
	*a = *b;
	*b = T;
}


int Partition(int* a, int left, int right)
{
	swap(a[left], a[(int)(rand() % (right - left + 1)) + left]);
	int i = left;
	int j = right;
	int tmp = a[left];
	while (i < j)
	{
		while (i<j && a[j]>tmp)
		{
			j--;
		}
		if (i < j)
		{
			a[i++] = a[j];
		}
		while (i<j && a[i]<tmp)
		{
			i++;
		}
		if (i < j)
		{
			a[j--] = a[i];
		}
	}
	a[i] = tmp;
	return i;
}

template<typename T>
void Quick_sort(T* a, int left, int right)
{
	if (left >= right){
		return;
	}
	else{
		int pos = Partition(a, left, right);
		Quick_sort(a, left, pos - 1);
		Quick_sort(a, pos + 1, right);
	}
}

template<typename T>
void print(T* a, int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << setw(4) << a[i];
	}
	cout << endl;
}

int main()
{
	int a[] = { 55, 41, 26, 53, 58, 97, 93 };

	int len = sizeof(a) / sizeof(a[0]);

	Quick_sort<int>(a, 0, len - 1);
	print<int>(a, len);

}

 

Jacky_Feng
关注
数据结构与算法
qq_32279165的博客
08-04 322
1.二叉搜索树 1.非空左子树的所有键值小于其根节点的键值 2.非空右子树的所有键值大于其根节点的键值 3.左右子树都是二叉搜索树 二叉搜索树的应用场景：如果是没有退化称为链表的二叉树，查找效率就是lgn，效率不错，但是一旦退换称为链表了，要么使用平衡二叉树，或者之后的RB树，因为链表就是线性的查找效率。 2.红黑树的定义 红黑树是一种二叉查找树，但在每个结点上增加了一个存储位表示结点的颜色，可以是RED或者BLACK。通过对任何一条从根到叶子的路径上各个着色方式的限制，红黑树确保没有一条路径会比其他路径长
手把手指导编写数据结构（3.1）——链表拓展（C语言描述）
机计复计机
04-12 522
本章介绍补充介绍一些对功能进行增强的链表，也就是双向链表、循环链表以及循环双向链表。
快速排序之单向分区法
12-22
快速排序在许多竞赛，面试中经常考一个项目，常以填空，算法形式出现 static void quickSort(int[] arr,int begin,int end) {//分成若干个左子问题，右子问题 if(begin<end) { int q = partition(arr,begin,end); quickSort(arr, begin, q-1); quickSort(arr, q+1, end); } } 那么重点就是如何去划分，左边的比主元小于或等于，右边的比主元大 代码思路 扫描指针小于等于主元的时候扫描指针往后走 扫描指针大于主元的时候扫描指
快速排序（单向型1）
GJG666的博客
04-07 524
#include int main() {  int data[10]={6,1,2,7,9,3,4,5,10,8};    quicksort(data,0,9);  int i;  for(i=0;i     printf("%d",data[i]);     printf("\n");     return 0; } void quicksort(int data[]
275-快速排序算法(单向划分)
LINZEYU666的博客
04-18 299
快速排序算法(单向划分) 解题思路图解 我们希望把小于等于56的都集中在左边，大于56的集中在右边。 34<56，把i+1，i和j的位置交换。 j往下走，是23，小于56，i+1，i到达j，23和23交换。j往下走， 78大于56，不交换，j往下走，90大于56，不交换，j往下走，到12的位置。 12小于56，i+1到达78的位置，j和i的数据交换，也就是12和78交换。 i不动，j往下走，到45的位置。小于56，i+1,到90的位置。i和j的数据交换，90和45交换， 交换后，j往后走，都
单向链表快速排序
gensmusic的专栏
02-19 1521
第一次在这里发，排版不行，见谅啊，sorry，我就没排版。 对于快速排序,我以前只是用来排数组,从来没有排过链表,直到有一天,我使用了算法导论上 N.Lomoto版本的快速排序,发现这个版本也许可以用来排链表,于是就尝试了下,发现真的可以. 在此先说一下 N.Lomoto 版本和国内普遍使用的 Hoare(霍尔)版本的区别. 霍尔版本应该算是快速排序的正式版本,他改进了之前的算法,然后
Unity游戏开发客户端面经——数据结构（初级）
最新发布
Sea3752的博客
10-25 9058
Unity游戏开发客户端面经 之 数据结构篇
字节跳动3月面试遇到的高频算法题
Erazer_Control
05-01 1242
本文汇总了牛客2021.3.1~2021.3.30 两个月的牛客面经考到的Leetcode题目 最终的高频题榜单数据可以在CodeTop题库（https://codetop.cc）查询，支持按部门、岗位分类筛选。 CodeTop已包括字节跳动、腾讯、美团、快手等十余家公司，覆盖100多个部门。 字节跳动 数据研发 https://www.nowcoder.com/discuss/602031 2021.03.01 有100个方格，每个上面有毒蘑菇和体力蘑菇，毒蘑菇减体力体力
链表的搜索与查找算法：线性表查找与二分查找
在单向链表中，每个节点只能指向下一个节点，而在双向链表中，每个节点既指向下一个节点，又指向前一个节点。 ## 1.2 链表的分类及特点 根据链表的性质和特点，链表可以分为单链表、循环链表和双向链表。 - ...
快速排序——单向扫描分区法
一直浮浮的博客
04-07 622
快速排序——单向扫描分区法 思想 1、利用递归划分子问题 2、定主元，将小于主元的元素放在主元的左侧， 大于主元的元素放在主元的右侧 3、主元的左右两侧就是两个子问题，将每一个子问题重复第2步，即可使序列有序 实施方案 1、将主元定为每个序列或子序列的首元素 2、设置左指针与右指针，左指针指向主元的下一次元素，右指针指向最右边的元素 3、将左指针所指向的元素与主元比较，如果小于或等于主元，左指针向后移动，右指针不变；如果大于主元，则将左指针所指向的元素，与右指针指向的元素交换，左指针不变，
【决战西二旗】|快速排序的优化
kkkkk0826的专栏
12-02 421
1.前言 前面的一篇文章https://www.cnblogs.com/backnullptr/p/11934841.html讲了快速排序的基本概念、核心思想、基础版本代码实现等，让我们对快速排序有了一个充分的认识，但还无法达到面试中对快速排序灵活应对的程度。 快速排序是图领奖得主发明的算法，被誉为20世纪最重要的十大算法之一，快速排序为了可以在多种数据集都有出色的表现，进行了非常多的优化，因...
单向扫描的快速排序解法
猫哥
04-01 755
快速排序的难点在于，根据锚点划分为2个子区间，经典解法是这样： 使用 i、j 两个指针，从左右两边双向扫描，直到 i、j 相遇 一会移动 i 指针，一会移动 j 指针，容易弄晕 本文只需 1个指针，从左向右单向扫描，更加容易理解和记忆，大致思路如下： 经典解法是扫描结束后，才得到2个子区间 本解法初始就划分为2个子区间，其中 左区间：只有锚点 1个元素 右区间：有 n-1 个元素，待检测 从 left+1 ~ right 开始扫描 每遇到一个小于锚点的元素，就将其交换到左区间，左区间长
快速排序及其优化与扩展
Rookie
07-17 307
快速排序简介： 快速排序算法是二十世纪十大算法之一，最早由Tony Hoare爵士设计。 快速排序是从冒泡排序演变而来，同冒泡排序一样快速排序也属于交换排序。 不同的是，冒泡排序在每一轮中只把一个元素冒泡到数列的一端，而快速排序采用分治法 ，在每一轮挑选一个基准元素，并让其他比它大的元素移动到数列一边，比它小的元素移动到数列的另一边，从而把数列拆解成两部分。 下面主要分四大部分来详述快速排序的实现...
快速排序及优化
yangqiang1997的博客
09-19 145
int Partiotion(int A[], int low, int high) { int pivot = A[low]; while (low < high) { while (low < high && A[high] >= pivot)--high; A[low] = A[high]; while (low < high && A[low] <= pivot)++low; A[high] = A[low]; }
快速排序优化
小麦大大博客
12-19 208
优化点： 优化选取中轴元素 以上代码target 选取的位置是认定了数组元素的首位，但是若这个数值的大小不在整个数组的中间位置，会大大降低快排的性能。 target =array[low] 这句就成了一个潜在的性能瓶颈。因此快速排序的速度还取决于这个target关键元素在数组中的位置。 【改进方法】 三数取中法：去三个元素先进行排序，将中间数作为中轴元素，下面的代码选取数组的左、中、右三个数；...
快速排序的优化
qq_49881112的博客
03-11 1684
1.递归的快速排序优化 第一种优化思想： 1.首先快速排序对于大量数据比如以万为计量单位，那么快排的时间复杂度和空间复杂度都是相对于其他几个排序都是最好的，那么对于少量数据比如10个，100个，快速排序显然已经不是最好的了； 2.那么快速排序每次经过找基准，这样数据就在慢慢趋于有序，这个时候当low和high之间的数据小于一个给定的值的时候，比如100，我们就可以之间调用之间插入排序来进行排序； public static void quick(int[] arr,int low,int high){
快速排序及其优化
世上安得两全法？
05-30 798
算法思想：1.先从数组中取出一个元素作为枢轴，一般情况下选取数组的第一个。 2.首尾相向遍历，从左边选取一个比枢轴大的数，从右边选择一个比枢轴小的数，然后交换这两个数； 3.重复步骤2，直到在枢轴的左边都比枢轴小，枢轴右边的数都比枢轴大。 时间复杂度：O(nlogn) //快速排序代码实现 #include<iostream> #include<vector> u...
单链表快速排序详解：挑战与优化策略
深入单链表的快速排序详解主要介绍了如何在单链表数据结构上实现快速排序算法，这是一种与数组快速排序相似但存在独特挑战的方法。单链表的特性导致无法直接通过下标访问元素，因此处理方式与数组有所不同。 首先，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值