【数据结构】论如何拿捏快速排序？（含非递归）

最新推荐文章于 2024-05-08 22:04:44 发布
最新推荐文章于 2024-05-08 22:04:44 发布
阅读量1.3k 收藏 115
点赞数 142
分类专栏： 数据结构初阶 文章标签： 算法 数据结构 排序算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71676870/article/details/133562282
版权

目录

一，快速排序（递归）

1，快排思想

2，霍尔排序

3，挖坑法

4，前后指针法

5，快速排序优化

1，三数取中法选key

2，小区间优化

二，快速排序（非递归）

Stack.h

Stack.c

三，快速排序源代码

一，快速排序（递归）

1，快排思想

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止；

基本代码思想如下： 

// 假设按照升序对array数组中[left, right)区间中的元素进行排序
void QuickSort(int array[], int left, int right)
{
 if(right < left)
 return;
 
 // 按照基准值对array数组的 [left, right)区间中的元素进行划分
 int div = partion(array, left, right);
 
 // 划分成功后以div为边界形成了左右两部分 [left, div) 和 [div+1, right)
 // 递归排[left, div)
 QuickSort(array, left, div);
 
 // 递归排[div+1, right)
 QuickSort(array, div+1, right);
}

上述为快速排序递归实现的主框架，发现与二叉树前序遍历规则非常像，同学们在写递归框架时可想想二叉树前序遍历规则即可快速写出来，后序只需分析如何按照基准值来对区间中数据进行划分的方式即可；

2，霍尔排序

根据快排思想，我们需要实现的就是 partion 函数了----将区间按照基准值划分为左右两半部分；

常见的方式有很多，我们先来了解最初的版本 【霍尔排序】

思想图解：

对就是这样的，右边的小人先出发向左移动，找到比 key 小的数，然后左边的小人向右移动找到比  key 大的数，然后交换两个小人的值，直至他们相遇然后再交换 key 与任意一个小人的值；

这样一趟下来，他们相遇后，左边的数都比 key 小，右边的数都比 key 大；

思路实现：

//霍尔排序
int PartSort1(int* arr, int left, int right)
{
	int keyi = left;
	while (left < right)
	{
		//右边先走
		while (left<right && arr[right]>=arr[keyi])
		{
			right--;
		}
		//左边后走
		while (left < right && arr[left] <= arr[keyi])
		{
			left++;
		}
		//交换
		Swap(&arr[left], &arr[right]);
	}
	Swap(&arr[left], &arr[keyi]);
	return left;
}

然后我们运行一下：

//快速排序
void QuickSort(int* arr, int begin, int end)
{
	if (begin >= end)
	{
		return NULL;
	}
    //霍尔法
	int keyi = PartSort1(arr, begin, end);
	//排序[begin,keyi) & [keyi+1,end]
	QuickSort(arr, begin, keyi);
	QuickSort(arr, keyi + 1, end);
}

int main()
{
	int arr[] = { 9,1,2,5,7,4,8,6,3,5 };

	//快速排序
	QuickSort(arr, 0,sizeof(arr) / sizeof(arr[0])-1);
	PrintSort(arr, sizeof(arr) / sizeof(arr[0]));
	return 0;
}

可以看到是有序的，选择排序就 OK 了；

3，挖坑法

然后我们再来认识另一种方式 【挖坑法】，其实跟【霍尔排序】思路差不多，不过更容易理解一点；

思想图解:

对还是一样的思路，让第一个元素为坑位，然后右边的小人先出发向左走找比 key 小的数，然后填充坑位并且右边小人的位置变为新坑位，然后左边的小人向右走找比 key 大的数，然后填充坑位并且左边小人的位置变为新坑位，直至两个小人相遇于坑位然后再给坑位赋值 key ；

这样一趟下来，坑位左边的数都比 key 小，右边的数都比 key 大；

思路实现：

//挖坑法
int PartSort2(int* arr, int left, int right)
{
	int key = arr[left];
    //坑位
	int hole = left;
	while (left < right)
	{
        //右边找小
		while (left < right && arr[right] >= key)
		{
			right--;
		}
		arr[hole] = arr[right];
		hole = right;
        //左边找大
		while (left < right && arr[left] <= key)
		{
			left++;
		}
		arr[hole] = arr[left];
		hole = left;
	}
	arr[hole] = key;
	return hole;
}

然后我们运行一下：

//快速排序
void QuickSort(int* arr, int begin, int end)
{
	if (begin >= end)
	{
		return NULL;
	}
    //挖坑法
	int keyi = PartSort2(arr, begin, end);
	//排序[begin,keyi) & [keyi+1,end]
	QuickSort(arr, begin, keyi);
	QuickSort(arr, keyi + 1, end);
}

可以看到是有序的，选择排序就 OK 了；

4，前后指针法

然后呢，在介绍最后一种排序方式了 【前后指针】法；

这个呢就比较新颖了，跟之前的都不一样；

请看图解：

这个呢就是，定义两个指针，从首元素开始走，快指针（cur）刚开始领先慢指针（prev）一个身位，然后 cur 先走找比 key 小的数，然后与 prev 的下一个数交换，直至 cur 越界，然后再让 prev 与 key 交换；

这样一趟下来，prev 左边的数都比 key 小，右边的数都比 key 大；

 思路实现：

//前后指针法
int PartSort3(int* arr, int left, int right)
{
	int keyi = left;
	int slow = left, fast = left+1;
	while (fast<=right)
	{
		if (arr[fast] < arr[keyi] && ++slow!=fast)
		{
			//交换
			Swap(&arr[fast], &arr[slow]);
		}
		fast++;
	}
	Swap(&arr[slow], &arr[keyi]);
	return slow;
}

然后我们运行一下：

//快速排序
void QuickSort(int* arr, int begin, int end)
{
	if (begin >= end)
	{
		return NULL;
	}
	int keyi = PartSort3(arr, begin, end);
	//排序[begin,keyi) & [keyi+1,end]
	QuickSort(arr, begin, keyi);
	QuickSort(arr, keyi + 1, end);
}

可以看到是有序的，选择排序就 OK 了；

5，快速排序优化

1，三数取中法选key

这第一个呢，就是对 key 的取值进行优化，当 key 的值太过于小或者大时，遍历数组的时间会增加，所以我们尽量让 key 的取值随机；

我们可以取首元素，尾元素，中间元素的值进行比较选 key ；

思路实现：

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

这样我们选择的 key 就不会受 首元素的束缚了；

我们还可不可以在这个基础上再优化一下呢？

答案是肯定的！

我们可以用随机数来取代中间数；

//三数取中
int middle(int* arr, int left, int right)
{
	//随机数取中
	int mid = left + (rand() % (right - left));
	if (arr[left] < arr[mid])
	{
		if (arr[mid] < arr[right])
		{
			return mid;
		}
		if (arr[left] < arr[right])
		{
			return right;
		}
		else
		{
			return left;
		}
	}
	//arr[mid]<=arr[left]
	else
	{
		if (arr[mid] > arr[right])
		{
			return mid;
		}
		if (arr[left] > arr[right])
		{
			return right;
		}
		else
		{
			return left;
		}
	}
}

这样子才是真正意义上的随机值，这样 key 就不受束缚了，再任何场景下都可以排序自如；

我们选完 key 的下标后，要让数组首元素的值与之交换，这样后面不动就 OK 了；

以【前后指针法】为例：

//前后指针法
int PartSort3(int* arr, int left, int right)
{
	//三数取中
	int ret = middle(arr, left, right);
	Swap(&arr[left], &arr[ret]);
	int keyi = left;
	int slow = left, fast = left+1;
	while (fast<=right)
	{
		if (arr[fast] < arr[keyi] && ++slow!=fast)
		{
			//交换
			Swap(&arr[fast], &arr[slow]);
		}
		fast++;
	}
	Swap(&arr[slow], &arr[keyi]);
	return slow;
}

主函数需要写 srand 函数来引用随机值；

//快速排序
void QuickSort(int* arr, int begin, int end)
{
	srand(time(0));
	if (begin >= end)
	{
		return NULL;
	}
	int keyi = PartSort3(arr, begin, end);
	//排序[begin,keyi) & [keyi+1,end]
	QuickSort(arr, begin, keyi);
	QuickSort(arr, keyi + 1, end);
}

现在我们运行测试一下：

其实速度是更快的，大家可以在【力扣】上测试一下；

2，小区间优化

还有一种优化方式是当递归到小的子区间时，可以考虑使用插入排序；

当数组的区间不大时，使用【插入排序】是会更快的，同时也可以减少压栈的次数，也就是降低【空间复杂度】；

//快速排序
void QuickSort(int* arr, int begin, int end)
{
	srand(time(0));
	if (begin >= end)
	{
		return NULL;
	}
	if (end - begin <10)
	{
		InsertSort1(arr,begin,end);
	}
	else
	{
		int keyi = PartSort3(arr, begin, end);
		//排序[begin,keyi) & [keyi+1,end]
		QuickSort(arr, begin, keyi);
		QuickSort(arr, keyi + 1, end);
	}
}

然后我们还需要改变一下插入排序，之前都是传数组元素个数的，现在我们要传区间需要改造一下；

//插入排序(改造版)
void InsertSort1(int* arr, int left, int right)
{
	int i = 0;
	for (i = left; i < right; i++)
	{
		int end = i;
		int tmp = arr[end + 1];
		while (end >= 0)
		{
			if (arr[end] >= tmp)
			{
				//交换
				Swap(&arr[end], &arr[end + 1]);
				end--;
			}
			else
			{
				break;
			}
		}
		arr[end + 1] = tmp;
	}
}

这样就可以了，现在我们运行测试一下：

可以看到是有序的，选择排序就 OK 了；

二，快速排序（非递归）

之前咱们拿捏了递归版的快速排序，现在咱们来秒杀非递归版的快速排序；

我们之前了解到，快速排序与二叉树的前序遍历相似，所以我们非递归也要用这种手法来表示；

所以我们需要借助【栈】来帮助我们来实现；

因为【栈】的特性（后进先出）很符合二叉树的前序遍历的思想，这样我们可以先排序最左边的序列，在排序右边的，前面的都放在【栈】里等后面排序；

所以我们需要一个【栈】：

Stack.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

typedef int STDataType;
typedef struct StackTop
{
	STDataType* a;
	int top;
	int capacity;
}ST;

//初始化
void STInit(ST* ps);
//销毁
void STDestroy(ST* ps);
//插入
void STPush(ST* ps, STDataType x);
//删除
void STPop(ST* ps);
//返回栈顶
STDataType STInsert(ST* ps);
//数量
int STSize(ST* ps);
//判断是否为空
int STEmpty(ST* ps);

Stack.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Stack.h"

//初始化
void STInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}
//销毁
void STDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}
//插入
void STPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		ps->capacity = ps->top == 0 ? 4 : ps->capacity*2;
		ps->a = (STDataType*)realloc(ps->a,sizeof(STDataType)*ps->capacity);
	}
	ps->a[ps->top] = x;
	ps->top++;
}
//删除
void STPop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);
	ps->top--;
}
//返回栈顶
STDataType STInsert(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);
	return ps->a[ps->top-1];
}
//数量
int STSize(ST* ps)
{
	assert(ps);
	return ps->top;
}
//判断是否为空
int STEmpty(ST* ps)
{
	assert(ps);
	if (ps->top == 0)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

然后我们就可以实现代码了；

我们的思路是：

将两边的下标存进【栈】，然后再取栈顶元素进行排序（霍尔或者其他），每取一个栈顶元素之后要把栈顶元素删除，然后再存放 keyi 两边的区间，再重复上面的过程，直至【栈】为空排序结束；

//快速排序(非递归)
void QuickNon(int* arr, int begin, int end)
{
	srand(time(0));
	ST ps;
	//初始化
	STInit(&ps);
	if (begin >= end)
	{
		return;
	}
	//插入
	STPush(&ps, end);
	STPush(&ps, begin);
	//栈不为空就进去
	while (!STEmpty(&ps))
	{
		int left = STInsert(&ps);//栈顶元素
		STPop(&ps);//删除
		int right = STInsert(&ps);
		STPop(&ps);

		int keyi = PartSort1(arr, left, right);
		//排序[left,keyi-1] & [keyi+1,right]
		if (keyi + 1 < right)
		{
			//插入
			STPush(&ps, right);
			STPush(&ps, keyi + 1);
		}
		if (left < keyi - 1)
		{
			//插入
			STPush(&ps, keyi - 1);
			STPush(&ps, left);
		}
	}
	//销毁
	STDestroy(&ps);
}

我们运行测试一下：

可以看到也是完全 OK 的；

这就是快速排序的非递归实现！

三，快速排序源代码

以上的快速排序的全部代码如下（不包括【栈】）：

//三数取中
int middle(int* arr, int left, int right)
{
	//int mid = (left +right)/ 2;
	//随机数取中
	int mid = left + (rand() % (right - left));
	if (arr[left] < arr[mid])
	{
		if (arr[mid] < arr[right])
		{
			return mid;
		}
		if (arr[left] < arr[right])
		{
			return right;
		}
		else
		{
			return left;
		}
	}
	//arr[mid]<=arr[left]
	else
	{
		if (arr[mid] > arr[right])
		{
			return mid;
		}
		if (arr[left] > arr[right])
		{
			return right;
		}
		else
		{
			return left;
		}
	}
}

//霍尔排序
int PartSort1(int* arr, int left, int right)
{
	//三数取中
	int ret = middle(arr, left, right);
	Swap(&arr[left], &arr[ret]);
	int keyi = left;
	while (left < right)
	{
		//右边先走
		while (left<right && arr[right]>=arr[keyi])
		{
			right--;
		}
		//左边后走
		while (left < right && arr[left] <= arr[keyi])
		{
			left++;
		}
		//交换
		Swap(&arr[left], &arr[right]);
	}
	Swap(&arr[left], &arr[keyi]);
	return left;
}

//挖坑法
int PartSort2(int* arr, int left, int right)
{
	//三数取中
	int ret = middle(arr, left, right);
	Swap(&arr[left], &arr[ret]);
	int key = arr[left];
	int hole = left;
	while (left < right)
	{
		while (left < right && arr[right] >= key)
		{
			right--;
		}
		arr[hole] = arr[right];
		hole = right;
		while (left < right && arr[left] <= key)
		{
			left++;
		}
		arr[hole] = arr[left];
		hole = left;
	}
	arr[hole] = key;
	return hole;
}

//前后指针法
int PartSort3(int* arr, int left, int right)
{
	//三数取中
	int ret = middle(arr, left, right);
	Swap(&arr[left], &arr[ret]);
	int keyi = left;
	int slow = left, fast = left+1;
	while (fast<=right)
	{
		if (arr[fast] < arr[keyi] && ++slow!=fast)
		{
			//交换
			Swap(&arr[fast], &arr[slow]);
		}
		fast++;
	}
	Swap(&arr[slow], &arr[keyi]);
	return slow;
}

//插入排序(改造版)
void InsertSort1(int* arr, int left, int right)
{
	int i = 0;
	for (i = left; i < right; i++)
	{
		int end = i;
		int tmp = arr[end + 1];
		while (end >= 0)
		{
			if (arr[end] >= tmp)
			{
				//交换
				Swap(&arr[end], &arr[end + 1]);
				end--;
			}
			else
			{
				break;
			}
		}
		arr[end + 1] = tmp;
	}
}

//快速排序
void QuickSort(int* arr, int begin, int end)
{
	srand(time(0));
	if (begin >= end)
	{
		return NULL;
	}
	if (end - begin <10)
	{
		InsertSort1(arr,begin,end);
	}
	else
	{
		int keyi = PartSort1(arr, begin, end);
		//排序[begin,keyi) & [keyi+1,end]
		QuickSort(arr, begin, keyi);
		QuickSort(arr, keyi + 1, end);
	}
}

//快速排序(非递归)
void QuickNon(int* arr, int begin, int end)
{
	srand(time(0));
	ST ps;
	//初始化
	STInit(&ps);
	if (begin >= end)
	{
		return;
	}
	//插入
	STPush(&ps, end);
	STPush(&ps, begin);
	//栈不为空就进去
	while (!STEmpty(&ps))
	{
		int left = STInsert(&ps);//栈顶元素
		STPop(&ps);//删除
		int right = STInsert(&ps);
		STPop(&ps);

		int keyi = PartSort1(arr, left, right);
		//排序[left,keyi-1] & [keyi+1,right]
		if (keyi + 1 < right)
		{
			//插入
			STPush(&ps, right);
			STPush(&ps, keyi + 1);
		}
		if (left < keyi - 1)
		{
			//插入
			STPush(&ps, keyi - 1);
			STPush(&ps, left);
		}
	}
	//销毁
	STDestroy(&ps);
}
 特性总结：

1，快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序

2.，时间复杂度：O(N*logN)

3.，空间复杂度：O(logN) 

4， 稳定性：不稳定

第三阶段就到这里了，带大家啃块硬骨头磨磨牙！

后面博主会陆续更新；

如有不足之处欢迎来补充交流！

完结。。

再次祝大家国庆节快乐！

手法king
关注
  • 142
    点赞
  • 踩
  • 115
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 172
    评论
专栏目录
哈工大数据结构实验5_冒泡排序与快速排序
03-26
（4） 递归和非递归的归并排序。 2． 产生不同规模和分布的数据，以 Excel 生成算法执行时间 T(n)关于输入规模 n 的曲线的形式，给出输入规模和分布对排序方法运行时间变化趋势的影响， 并与理论分析结果比较。 3． ...
数据结构之八大排序
X_do_myself的博客
03-05 1501
功不唐捐 ，玉汝于成！
堆排序、快速排序、归并排序算法详解
LibraRhy的博客
08-06 1478
手把手带你拿捏终极排序算法。
跟着Datawhale重学数据结构与算法(3)---排序算法
猪猪侠的博客
04-22 882
开源链接：【】【
超详细八大排序+基数排序（图文并茂+动图演示+C语言代码演示）
总结日常学习内容
04-02 1117
图文详解秒懂各大排序
万字手撕七大排序（代码+动图演示）
热门推荐
m0_57304511的博客
04-29 1万+
万字手撕七大排序（代码+动图演示）
【基础算法】八大排序算法：直接插入排序，希尔排序，选择排序，堆排序，冒泡排序，快速排序(快排)，归并排序，计数排序
Welcome home | Jian Liao 's blog
04-26 926
🚩排序可谓是老生常谈了，在这里，我给大家带来一些常用的排序算法。直接插入排序，希尔排序，选择排序，堆排序，冒泡排序，快速排序(快排)，归并排序，计数排序。每一个排序算法都有其独特的思想，我们不仅要学会它的思想，还要能够在合适的场景中选出合适的排序算法。因此，这一块，要很熟练很熟练。🚩本章所有的排序均以升序为例来讲解，弄懂了升序，降序也是不在话下。💝掌握八大排序，排序这一块就够用了，当然还有桶排序，基数排序，文件外排序之类的，大家可以查阅相关资料进行学习。❤️‍🔥。
数据结构----树
m0_54524462的博客
05-25 449
文章目录0.PTA得分截图1.本周学习总结（5分）引入——关于基于树的递归和分治思想。(递归与分治思想的例题)-----6-3 求二叉树高度 (20 分)1.0 树的基本概念和性质1.0.1 树中的基本术语：1.0.1 树中的基本性质：1.1 二叉树结构1.1.1 二叉树的两种存储结构1.1.2 二叉树的构造1.1.3 二叉树的遍历1.1.4 线索二叉树1.1.5 二叉树的应用--表达式树1.2 多叉树结构1.2.1 多叉树结构1.2.2 多叉树遍历1.3 哈夫曼树1.3.1 哈夫曼树定义1.3.2 哈夫曼
数据结构：一篇拿捏十大排序(超详细版)
黑夢的博客
10-19 914
十大排序：直接插入排序、希尔排序、直接选择排序、堆排序、冒泡排序、快速排序、归并排序、计数排序、基数排序、桶排序，稳定性分析，时间复杂度，空间复杂度。
猅猅排牌牌『排序专题』
m0_73499016的博客
05-17 232
partition 过程使用两个索引值（i、j）用来遍历数组v代表标定值将小于 v 的元素放在索引 i 所指向位置的左边而将大于 v 的元素放在索引 j 所指向位置的右边三路快速排序是双路快速排序的进一步改进版本把排序的数据分为三部分分别为小于 v，等于 v，大于 v（v 为标定值）这样三部分的数据中，等于 v 的数据在下次递归中不再需要排序。
非线性数据结构的实现与应用(非递归).pdf
08-09
数据结构大实验，适合在校大学生，AVL树的非递归实现，树排序的实现，整套程序运行成功，欢迎大家下载！！！
数据结构从入门到精通-快速排序
03-23
数据结构从入门到精通-快速排序
笔试强训-day17_T2 十字爆破
weixin_46186903的博客
05-03 821
模拟即可，但是由于数据量过⼤，我们可以提前把每⼀⾏以及每⼀列的和存起来，⽅便统计总和。解法二：提前把每⼀⾏以及每⼀列的和存起来，然后输入输出使用快速的IO方式，解答如下所示。解法一：暴力遍历，这种方法很容易想到，并且也容易编写出代码，但是会超时。因为1+2+3=6，1+2+4=7，1+3+4=8，2+3+4=9。牛牛选择一个方格，可以得到和这个方格同行、同列的所有数之和的得分。现在牛牛想知道下一步选择每个格子的得分情况，你可以帮帮他吗？m个方格，每个方格中有一个整数。
LeetCode 35.搜索插入位置
最新发布
tus00000的博客
05-08 162
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。输入: nums = [1,3,5,6], target = 5。输入: nums = [1,3,5,6], target = 2。输入: nums = [1,3,5,6], target = 7。此算法时间复杂度为O(logn)，空间复杂度为O(1)。请必须使用时间复杂度为 O(log n) 的算法。nums 为 无重复元素 的 升序 排列数组。
异或思想的算法题
aaa114514aaaa的博客
05-02 2081
有关异或思想的两道题目的详细解析和代码实现。 1.消失的数字（简单） 2.只出现一次的数字（较难）
【算法】高精度乘法
m0_73209194的博客
05-02 501
高精度乘法
代码随想录算法训练营第四十四天
weixin_41902984的博客
05-05 258
因为存在不同顺序算不同的方法，所以for循环的内外循环需要变更，先遍历空间，再遍历物品。否则物品是有先后顺序的。01背包：物品在只能用一次，所以用背包空间去减当前物品的重量，然后去看是否需要用这个物品。sad的一天，明天开始上班，而且娃还行，媳妇儿状态不稳定，太难了也！随想录：这个递推公式大家应该不陌生了，我在讲解01背包题目的时候在这篇。完全背包：用当前物品的重量去填满背包空间，然后用不同的物品去放。518. 零钱兑换 II。377. 组合总和 Ⅳ。
快速排序的非递归算法
12-09
快速排序是一种常用的排序算法，其非递归实现可以使用栈来模拟递归调用的过程。具体实现步骤如下： 1. 定义一个栈，将数组的起始位置和终止位置入栈。 2. 以栈空为条件开始进行循环，取出栈中的两个元素作为区间进行一次快排调用。 3. 函数会返回一个标准值所在的位置，以其左侧的起点和终点、右侧的起点和终点进行判断，在起点小于终点的情况下分别对其进行入栈。 4. 继续循环直到栈空为止。 下面是快速排序的非递归算法的Python实现： ```python def quicksort(arr): if len(arr) <= 1: return arr stack = [(0, len(arr) - 1)] while stack: low, high = stack.pop() if low < high: pivot = partition(arr, low, high) stack.append((low, pivot - 1)) stack.append((pivot + 1, high)) return arr def partition(arr, low, high): pivot = arr[high] i = low - 1 for j in range(low, high): if arr[j] < pivot: i += 1 arr[i], arr[j] = arr[j], arr[i] arr[i + 1], arr[high] = arr[high], arr[i + 1] return i + 1 ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

手法king

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

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

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

打赏作者

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

抵扣说明：

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

余额充值