热门排序各个版本代码 递归非递归都有 纯代码

最新推荐文章于 2024-05-30 16:17:47 发布
最新推荐文章于 2024-05-30 16:17:47 发布
阅读量89 收藏
点赞数
分类专栏： 算法 C排序 数据结构 文章标签： 算法 排序算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75324712/article/details/132059776
版权
C排序 同时被 3 个专栏收录
11 篇文章 0 订阅
订阅专栏
算法
8 篇文章 0 订阅
订阅专栏
数据结构
8 篇文章 0 订阅
订阅专栏

    //小区间优化 —— 利用其他排序去优化归并排序 快速排序 降低归并排序和快速排序的递归深度
    //快排优化三路

后面文章会更新

比较复杂的我之前已经出过单独的文章了 这里就不再阐述

排序的算法实现  后面的代码是辅助非递归 也就是模拟递归栈的实现

#define _CRT_SECURE_NO_WARNINGS 1
#include"Stack_Queue.h"



void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}


void InsertSort(int* arr, int sz)
{
	for (int i = 0; i < sz - 1; i++)
	{
		for (int j = i + 1; j >= 1; j--)
		{
			if (arr[j] < arr[j - 1])
			{
				Swap(&arr[j], &arr[j - 1]);
			}
			else
			{
				break;//将该元素安排到合适的位置之后就没必要再进行循环
			}
		}
	}
}
void Print(int* arr, int sz)
{
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}
//希尔排序

//void ShellSort(int* arr, int sz)//一组一组进行排序
//{
//	int gap = sz;
//	while (gap>1)
//	{
//		gap = gap / 3 + 1;
//		for (int i = 0;i<sz;i+=gap)
//		{
//			for (int j = i; j >=gap; j-=gap)
//			{
//				if (arr[j] < arr[j - gap])
//				{
//					Swap(&arr[j], &arr[j - gap]);
//				}
//				else
//				{
//					break;
//				}
//			}
//		}
//	}
//}

//void ShellSort(int* arr, int sz)//多组进行排序
//{
//	int gap = sz;
//	while (gap > 1)
//	{
//		gap = gap / 3 + 1;
//		for (int i = 0; i < sz-gap; i ++)
//		{
//			for (int j = i; j >= 0; j -= gap)
//			{
//				if (arr[j] > arr[j + gap])
//				{
//					Swap(&arr[j], &arr[j + gap]);
//				}
//				else
//				{
//					break;
//				}
//			}
//		}
//	}
//}
void ShellSort(int* arr, int sz)//多组进行排序
{
	int gap = sz;
	while (gap > 1)
	{
		gap = gap / 3 + 1;
		for (int i = 0; i < sz-gap; i++)
		{
			for (int j = i+gap; j >= gap; j -= gap)
			{
				if (arr[j] < arr[j - gap])
				{
					Swap(&arr[j], &arr[j - gap]);
				}
				else
				{
					break;
				}
			}
		}
	}
}


//选择排序 单趟
//void SelectSort(int* arr, int sz)
//{
//	//定义一个min 
//	for (int i = 0; i < sz; i++)
//	{
//		//int min = arr[i];
//		for (int j = i + 1; j < sz; j++)
//		{
//			//if (min > arr[j])
//			if(arr[i] > arr[j])
//			{
//				Swap(&arr[i], &arr[j]);
//			}
//		}
//	}
//}

//选择排序多趟进行
void SelectSort(int* arr, int sz)
{
	int left = 0, right = sz - 1;
	while (left <= right)
	{
		int min = left;
		int max = left;
		for (int i = left; i <= right; i++)
		{
			if (arr[i] < arr[min])
			{
				min = i;
			}
			if (arr[i] > arr[max])
			{
				max = i;
			}
		}
		Swap(&arr[left], &arr[min]);
		if (max == left)//特殊情况特殊处理 当一组数据中最大值出现在该数据的最左端 就会引起该情况
		{
			max = min;
		}
		Swap(&arr[max], &arr[right]);
		left++;
		right--;
	}
}



//堆排序
//向上调整建堆
void AdjustUp(int* arr, int sz)
{
	int children = sz;
	int parent = (children - 1) / 2;
	while (children >= 0)
	{
		if (arr[parent] < arr[children])
		{
			Swap(&arr[parent], &arr[children]);
			children = parent;
			parent = (children - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

//向下调整 建堆
void AdjustDown1(int* arr, int i,int sz)
{
	int parent = i;
	int children = 2 * parent + 1;
	while (children < sz)
	{
		if (children + 1 < sz && arr[children] > arr[children + 1])
		{
			children++;
		}
		if (arr[parent] > arr[children])
		{
			Swap(&arr[parent], &arr[children]);
			parent = children;
			children = 2 * parent + 1;
		}
		else
		{
			break;
		}
	}
}

//向下调整不建堆
void AdjustDown(int* arr, int sz)
{
	int parent = 0;
	int children = 2 * parent + 1;
	while (children < sz)
	{
		if (children + 1 < sz && arr[children] < arr[children + 1])
		{
			children++;
		}
		if (arr[parent] < arr[children])
		{
			Swap(&arr[parent], &arr[children]);
		}
		else
		{
			break;
		}
		parent = children;
		children = 2 * parent + 1;
	}
}
void HeapSort(int* arr, int sz)
{
	//建堆
	//向上调整建堆
	for (int i = 0; i < sz; i++)
	{
		AdjustUp(arr, i);//建的是小堆
	}
	//向下调整建堆
	/*for (int i = (sz-1-1)/2; i >= 0; i--)//建立的小堆
	{
		AdjustDown1(arr, i,sz);
	}*/
	for (int i = sz - 1; i > 0; i--)
	{
		Swap(&arr[0], &arr[i]);
		AdjustDown(arr,i-1);
	}

}

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

//快速排序
//Hoare版本 起始版本
void _QuickSort1(int* arr, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	int begin = left, end = right;
	int key = arr[left];
	while (begin < end)
	{
		while (begin < end && arr[end] >= key)
		{
			end--;
		}
		while (begin < end && arr[begin] <= key)
		{
			begin++;
		}
		Swap(&arr[begin], &arr[end]);
	}
	Swap(&arr[left], &arr[begin]);
	int keyi = begin;
	_QuickSort1(arr, left, keyi - 1);
	_QuickSort1(arr, keyi + 1, right);
}
//快速排序挖坑版本 
void _QuickSort2(int* arr, int left,int right)
{
	if (left >= right)
	{
		return;
	}
	int begin = left, end = right;
	int key = arr[begin];
	int keyi = left;
	while (begin < end)
	{
		while (begin < end && key <= arr[end])
		{
			end--;
		}
		arr[begin] = arr[end];
		while (begin < end && key >= arr[begin])
		{
			 begin++;
		}
		arr[end] = arr[begin];
	}
	arr[begin] = key;
	_QuickSort2(arr, left, begin - 1);
	_QuickSort2(arr, begin + 1, right);
}

//前后指针法
void _QuickSort3(int* arr, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	int cur = left + 1, prev = left + 1;
	int key = arr[left];
	while (prev <= right)
	{
		if (arr[prev] >= key)
		{
			prev++;
		}
		else
		{
			Swap(&arr[prev], &arr[cur]);
			prev++;
			cur++;
		}
	}
	Swap(&arr[left], &arr[cur-1]);
	int keyi = cur - 1;
	_QuickSort3(arr, left, keyi - 1);
	_QuickSort3(arr, keyi + 1, right);
}
void QuickSort(int* arr, int sz)
{
	//_QuickSort1(arr, 0, sz - 1);//Hoare
	//_QuickSort2(arr, 0, sz - 1);//挖坑法
	_QuickSort3(arr, 0, sz - 1);//前后指针
}

void _MergeSort(int* arr, int left, int right,int* tmp)
{
	if (left >= right)
	{
		return;
	}
	int mid = (right - left) / 2 + left;
	_MergeSort(arr, left, mid,tmp);
	_MergeSort(arr, mid + 1, right,tmp);
	int i = left;
	int begin1 = left, end1 = mid;
	int begin2 = mid + 1, end2 = right;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (arr[begin1] <= arr[begin2])
		{
			tmp[i++] = arr[begin1++];
		}
		else
		{
			tmp[i++] = arr[begin2++];
		}
	}
	while (begin1 <= end1)
	{
		tmp[i++] = arr[begin1++];
	}
	while (begin2 <= end2)
	{
		tmp[i++] = arr[begin2++];
	}
	int j = 0;
	for (j = left; j <= right; j++)
		arr[j] = tmp[j];
}
//归并排序
void MergeSort(int* arr, int sz)
{
	int* tmp = (int*)malloc(sizeof(int) * sz);
	_MergeSort(arr, 0, sz - 1,tmp);
	free(tmp);
	tmp = NULL;
}

//Hoare版本非递归
int _QuickSortNonR1(int* arr, int left, int right)
{
	if (left >= right)return-1;
	int begin = left, end = right;
	while (begin < end)
	{
		while (begin < end && arr[end] >= arr[left])
			end--;
		while (begin < end && arr[begin] <= arr[left])
			begin++;
		Swap(&arr[end], &arr[begin]);
	}
	Swap(&arr[left], &arr[begin]);
	return begin;
}
//挖坑法非递归版本
int _QuickSortNonR2(int* arr, int left, int right)
{
	if (left >= right)return -1;
	int begin = left, end = right;
	int tmp = arr[left];
	while (begin < end)
	{
		while (begin < end && arr[end] >= tmp)
			end--;
		arr[begin] = arr[end];
		while (begin < end && arr[begin] <= tmp)
			begin++;
		arr[end] = arr[begin];
	}
	arr[begin] = tmp;
	return begin;
}

//前后指针法非递归版本
int _QuickSortNonR3(int* arr, int left, int right)
{
	if (left >= right)return-1;
	int cur = 0, prev = 1;
	while (prev <= right)
	{
		if (arr[prev] < arr[left])
		{
			prev++;
		}
		else
		{
			prev++;
			cur++;
			Swap(&arr[cur], &arr[prev]);
		}
	}
	return cur;
}
//非递归版本
void QuickSortNonR(int* arr, int sz)
{
	Stack st;
	StackInti(&st);
	StackPush(&st, sz - 1);//将右区间末端存入栈
	StackPush(&st, 0);//将左区间末端存入栈
	while (!StackEmpty(&st))
	{
		int left = StackTop(&st);
		StackPop(&st);
		int right = StackTop(&st);
		StackPop(&st);
		//int keyi = _QuickSortNonR1(arr, left, right);
		int keyi = _QuickSortNonR2(arr, left, right);

		if (keyi != -1)
		{
			StackPush(&st, right);
			StackPush(&st, keyi + 1);
			StackPush(&st, keyi - 1);
			StackPush(&st, left);
		}


	}
	StackDestroy(&st);
}

void MergeSortNonR(int* arr, int n)
{
	//开临时空间
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		return;
	}

	int gap = 1;
	while (gap < n)
	{
		int j = 0;//为了控制 tmp
		for (int i = 0; i < n; i +=2*gap)
		{
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i + gap, end2 = i + gap * 2 - 1;
			//该部分如果满足就不会再向下运行代码 那还不如结束循环
			if (end1 >= n || begin2 >= n)
			{
				break;
			}
			//if (end1 >= n)
			//{
			//	end1 = n - 1;

			//	//[begin2,end2]修改成不存在的区间
			//	begin2 = n;
			//	end2 = n - 1;
			//}
			//else if (begin2 >= n)
			//{
			//	//修改成不存在的区间
			//	begin2 = n;
			//	end2 = n - 1;
			//}
			if (end2 >= n)
			{
				end2 = n - 1;
			}
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (arr[begin1] <= arr[begin2])
				{
					tmp[j++] = arr[begin1++];
				}
				else
				{
					tmp[j++] = arr[begin2++];
				}
			}
			while (begin1 <= end1)
			{
				tmp[j++] = arr[begin1++];
			}
			while (begin2 <= end2)
			{
				tmp[j++] = arr[begin2++];
			}

			//将tmp中的数据拷贝到原数组中为下次排序做准备

			//当然在上面那写超出范围后修正的区间 并没有移动 
			memcpy(arr + i, tmp + i, sizeof(int) * (end2 - i + 1));
		}
		gap *= 2;
	}
	free(tmp);
}

void BubbleSort(int* arr, int sz)
{
	for (int i = 0; i < sz - 1; i++)
	{
		int falg = 0;
		for (int j = 0; j < sz - i - 1; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				falg = 1;
				Swap(&arr[j], &arr[j + 1]);
			}
		}
		if (falg == 0)
		{
			break;
		}
	}
}
void CountSort(int* arr, int sz)
{
	int max = INT_MIN;
	int min = INT_MAX;
	for (int i = 0; i < sz; i++)//寻找该数据的区间端点
	{
		min = min > arr[i] ? arr[i] : min;
		max = max < arr[i] ? arr[i] : max;
	}
	int* tmp = (int*)calloc((max - min + 1), sizeof(int));
	int d = max - min;
	for (int i = 0; i < sz; i++)
	{
		tmp[arr[i]-min]++;
	}
	int j = 0;//控制arr数组下标
	for (int i = 0; i < sz; i++)
	{
		while(tmp[i]!=0)
		{
			arr[j++] = min + i;
			tmp[i]--;
		}
	}
}
int main()
{

	//int arr[] = { 3,2,1 };
	int arr[] = { 9,8,7,6,5,4,3,2,1,10,12,0,11};
	int sz = sizeof(arr) / sizeof(arr[0]);
	//Print(arr, sz);

	//非递归——快排
	//QuickSortNonR(arr, sz);
	//MergeSortNonR(arr, sz);

	//Print(arr, sz);




	Print(arr, sz);
	/*printf("插入排序：");
	InsertSort(arr, sz);*/
	printf("希尔排序：");
	CountSort(arr, sz);
	//BubbleSort(arr, sz);
	//ShellSort(arr, sz);
	//SelectSort(arr, sz);
	//HeapSort(arr, sz);
	//QuickSort(arr,sz);
	//MergeSort(arr, sz);
	//快速排序非递归
	//归并排序非递归
	//三数取中
	

	//
	//小区间优化 —— 利用其他排序去优化归并排序 快速排序 降低归并排序和快速排序的递归深度
	//快排优化三路
	Print(arr, sz);

	//Stack st;
	//StackInti(&st);
	//if (!StackEmpty(&st))
	//{
	//	printf("栈为空\n");
	//}
	//StackPush(&st, 1);
	//StackPush(&st, 2);
	//StackPush(&st, 3);
	//StackPush(&st, 4);
	//StackPush(&st, 5);
	//StackPush(&st, 6);

	//StackPop(&st);
	//StackPop(&st);
	//StackPop(&st);

	//printf("%d \n", StackTop(&st));

	//if (StackEmpty(&st))
	//{
	//	printf("栈为不为空\n");
	//}

	//StackDestroy(&st);



	return 0;
}

栈的实现

stack.h

#define _CRT_SECURE_NO_WARNINGS 1

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

typedef int StackData;
typedef struct Stack
{
	StackData* arr;
	int sz;
	int capacity;
}Stack;

//栈的初始化
void StackInti(Stack* st);
//栈的插入
void StackPush(Stack* st,StackData x);
//出栈
StackData StackTop(Stack* st);
//栈的删除
void StackPop(Stack* st);
//栈的判空
bool StackEmpty(Stack* st);
//栈的销毁
void StackDestroy(Stack* st);

stack.c

#define _CRT_SECURE_NO_WARNINGS 1

#include"Stack_Queue.h"

void StackInti(Stack* st)
{
	st->arr = NULL;
	st->capacity = st->sz = 0;
}

void StackPush(Stack* st, StackData x)
{
	if (st->capacity == st->sz)
	{
		int newcapacity = (st->capacity == 0) ? 4: st->capacity * 2;
		StackData* tmp = (StackData*)realloc(st->arr, sizeof(StackData) * newcapacity);
		if (tmp == NULL)
		{
			printf("failed to allocate memory.\n");
			return;
		}
		st->arr = tmp;
		st->capacity = newcapacity;
	}
	st->arr[st->sz++] = x;
}

void StackPop(Stack* st)
{
	if(!StackEmpty(st))
		st->sz--;
}
StackData StackTop(Stack* st)
{
	if (!StackEmpty(st))
	{
		return st->arr[st->sz-1];
	}
}
bool StackEmpty(Stack* st)
{
	return st->sz == 0;
}


void StackDestroy(Stack* st)
{
	st->arr = NULL;
	st->capacity = st->sz = 0;
}

希望给位大佬指点一二 如有不对评论区指教或私信~ 代码有点小多 就不做文字讲解

菜鸡爱玩
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C#归并排序的实现方法(递归,非递归,自然归并)
09-05
C#归并排序的实现方法(递归,非递归,自然归并)，需要的朋友可以参考一下
JAVA上百实例源码以及开源项目源代码
09-17
　Java二进制IO类与文件复制操作实例，好像是一本书的例子，源代码有的是独立运行的，与同目录下的其它代码文件互不联系，这些代码面向初级、中级Java程序员。 Java访问权限控制源代码 1个目标文件 摘要:Java源码,...
快速排序----JAVA非递归及递归源代码
m0_59317219的博客
05-04 218
快速排序 递归与非递归的实现代码
八大排序算法之归并排序(递归实现+非递归实现)
小青菜的博客
03-25 7200
归并排序(递归实现+非递归实现)
【五一创作】排序篇：冒泡排序，快速排序的递归与非递归实现(C语言)
2301_76269963的博客
05-03 1963
排序篇：冒泡排序，快速排序的递归与非递归实现(C语言)
java快速排序非递归_【Java】快速排序的非递归实现
weixin_39884832的博客
02-12 266
快速排序一般采用递归方法(详见思路分析采用非递归的方法，首先要想到栈的使用，通过阅读递归调用部分的代码，思考如何用栈来代替。递归调用的核心代码是 pivot = partition(a, low, high); 每次循环都必须包含这句核心代码，可以想到，如果要对该行代码实现循环，只能对low和high采取操作，所以我们在栈中压入low和high，每个循环弹出一对low和high，用于核心代码的实现...
【数据结构初阶】一文带你学会归并排序（递归&非递归）
weixin_61654591的博客
03-14 650
归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。自上而下的递归（所有递归的方法都可以用迭代重写，所以就有了第 2 种方法）；自下而上的迭代；和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是 O(nlogn) 的时间复杂度。代价是需要额外的内存空间。我们今天讲解了归并排序的递归和非递归的实现方法，码文不易，希望可以对大家有所帮助。
【归并排序的简要理解】递归及非递归方式
m0_62572672的博客
07-05 305
归并排序算法的两种实现方式
归并排序 - 递归与非递归实现
weixin_66672501的博客
09-17 400
归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。时间复杂度：O(N*logN)空间复杂度：O(N)稳定性：稳定。
【八大排序】二路归并排序(非递归 + 递归)
W1024201的博客
03-17 7152
目录 前言 两两融合规则 二、代码实现 1.非递归实现 2.递归实现 总结 前言 归并排序（Merge Sort）是建立在归并操作上的一种有效，稳定的排序算法，该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。 这些子问题解决的方法都是类似的，解决掉这些小的问题之后，归并子问题的结果，就得到了“大”问题的解。 时间复杂度：..
快速排序的非递归实现
xx123427的博客
10-07 1495
快速排序的思想是先从一数列中找出一个枢轴点，这个枢轴点左边的数都比它小，右边的数都比它大，也就是说枢轴点的位置已经是有序的了。例如 5 1 7 9  2   3 8   使用一次快速排序后会变成这样· · · 5 · · ·。 1，2，3会在5的左边，7，8，9在5的右边，5在第四个位置，5是枢轴点，且不会再变动了。  如果最终排序完毕，数列会是   1 2 3  5  7 8 9
c语言递归方法排序,归并排序，递归法，C语言实现。
weixin_42664597的博客
05-23 1156
利用归并排序法对序列排序的示意图(递归法)：一、算法分析：利用递归的分治方法：1、将原序列细分，直到成为单个元素；2、在将分割后的序列一层一层地按顺序合并，完成排序。细分通过不断深入递归完成，合并通过递归　　　一层层返回完成。二、C语言代码1、完成排序的三个函数void MergeSort(int l[],int lenght){int tmp[lenght];MSort(l,tmp,,lengh...
Visual C++ 2010入门经典(第5版)--源代码及课后练习答案
12-15
CruiseYoung提供的带有详细书签的电子书籍目录 http://blog.csdn.net/fksec/article/details/7888251 该资料是《Visual C++ 2010入门经典(第5版)》的源代码及课后练习答案 对应的书籍资料见: Visual C++ 2010...
Oracle SQL高级编程(资深Oracle专家力作，OakTable团队推荐)--随书源代码
02-04
CruiseYoung提供的带有详细书签的电子书籍目录 http://blog.csdn.net/fksec/article/details/7888251 该资料是《Oracle SQL高级编程》的源代码 对应的书籍资料见: Oracle SQL高级编程(资深Oracle专家力作，...
Leecode---347：输出前k个高频元素（使用unordered_map）
最新发布
qq_41920323的博客
05-30 244
unordered_map实现输出前k个高频元素
算法训练营day41
stmfresher的博客
05-27 328
动态规划理论基础（主要就是确定动态规划的几个步骤）
算法每日一题（python,2024.05.24) day.6
L613Z的博客
05-27 453
数字比较型可以用双指针法寻找数字相同（或构成其他关系）的俩个数值（或其他类型），涉及到与数值有关的列表问题可以思考到sort()排序方法加以辅助。
一千题，No.0037（组个最小数）
2301_76783671的博客
05-29 583
给定数字 0-9 各若干个。你可以以任意顺序排列这些数字，但必须全部使用。目标是使得最后得到的数尽可能小（注意 0 不能做首位）。例如：给定两个 0，两个 1，三个 5，一个 8，我们得到的最小的数就是 10015558。输入在一行中给出 10 个非负整数，顺序表示我们拥有数字 0、数字 1、……整数间用一个空格分隔。10 个数字的总个数不超过 50，且至少拥有 1 个非 0 的数字。现给定数字，请编写程序输出能够组成的最小的数。在一行中输出能够组成的最小的数。
并查集拓展（扩展域并查集）
Qlarkstar的博客
05-29 910
事实证明，扩展域并查集应该在带权并查集前面讲的，因为比较好理解，而且回过头看带权并查集可能也会更轻松一些。
C++ 快速排序 非递归版本 代码
03-04
快速排序是一种常用的排序算法，其非递归版本的代码如下： ``` void quickSort(int arr[], int left, int right) { int stack[right - left + 1]; int top = -1; stack[++top] = left; stack[++top] = right; while (top >= ) { right = stack[top--]; left = stack[top--]; int pivot = partition(arr, left, right); if (pivot - 1 > left) { stack[++top] = left; stack[++top] = pivot - 1; } if (pivot + 1 < right) { stack[++top] = pivot + 1; stack[++top] = right; } } } int partition(int arr[], int left, int right) { int pivot = arr[right]; int i = left - 1; for (int j = left; j < right; j++) { if (arr[j] < pivot) { i++; swap(arr[i], arr[j]); } } swap(arr[i + 1], arr[right]); return i + 1; } ``` 该算法使用了一个栈来模拟递归调用，从而实现了非递归版本的快速排序。具体来说，每次将待排序区间的左右端点入栈，然后循环执行以下操作： 1. 出栈左右端点，对该区间进行分区操作，得到枢轴元素的位置。 2. 如果枢轴元素左边的区间长度大于1，则将左右端点入栈。 3. 如果枢轴元素右边的区间长度大于1，则将左右端点入栈。 当栈为空时，排序完成。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

菜鸡爱玩

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

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

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

打赏作者

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

抵扣说明：

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

余额充值