快排 递归三种方式+非递归 --排序

已于 2022-04-02 14:52:14 修改
阅读量834 收藏
点赞数
分类专栏： 数据结构 排序方法 文章标签： 算法 数据结构 排序
于 2021-10-03 16:34:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ds19415169988/article/details/120595774
版权

方法1–Hoare

#include"Sort.h"
void PrintArray(int* a, int n)
{
	for (int i = 0; i < n; ++i)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
}
void Swap(int* px, int* py)
{
	int tmp = *px;
	*px = *py;
	*py = tmp;
}
int PartSort1(int* a, int left, int right)
{
	int keyi = left;
	while (left < right)
	{
		// 左边做key，右边先走找小
		while (left < right && a[right] >= a[keyi])//等号是为了防止里面有和keyi相等的数据的时候会不动而产生的死循环
		{
			--right;
		}
		// 左边再走，找大
		while (left < right && a[left] <= a[keyi])
		{
			++left;
		}
		// 交换，把大的换到右边，小的换到左边
		Swap(&a[left], &a[right]);
	}
	Swap(&a[keyi], &a[left]);
	return left;
}
void QuickSort(int* a, int left, int right)
{
	if (left < right)
	{
		int keyi = PartSort1(a, left, right);
		// [0, keyi-1] keyi [keyi+1, right]
		QuickSort(a, left, keyi - 1);
		QuickSort(a, keyi + 1, right);
	}
}
void TestQuickSort()
{
	int	a[] = { 6, 1, 2, 7, 9, 3, 4, 5, 10, 8 };
	PrintArray(a, sizeof(a) / sizeof(int));
	QuickSort(a, 0, sizeof(a) / sizeof(int)-1);
	PrintArray(a, sizeof(a) / sizeof(int));
}

左边为keyi，让右边先走是如何保证相遇位置的值小于key的：
在这里插入图片描述
时间复杂度
最好的情况：每次取到的数都为中间的数即可以像一颗二叉树一样展开–高度为logN,每一层单趟排为N则O(NlogN)
在这里插入图片描述

最坏的情况：有序 O(N^2)
在这里插入图片描述

方法1改进–针对key取值导致时间复杂度可能为O(N^2)的改进

1、随机选key
2、三数取中选key，不是最大也不是最小。有了三数取中，快排就不怕有序的这种最坏情况了
Sort.c

// Hoare
#include"Sort.h"
void PrintArray(int* a, int n)
{
	for (int i = 0; i < n; ++i)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
}
void Swap(int* px, int* py)
{
	int tmp = *px;
	*px = *py;
	*py = tmp;
}
// 三数取中---left,right三个数比较大小取中间的那个数的下标
//获取那个适合的数的下标
int GetMidIndex(int* a, int left, int right)
{
	//int mid = (left + right) / 2;
	//为了防止越界
	int mid = left + (right - left) / 2;
	if (a[left] < a[mid])
	{
		if (a[mid] < a[right])
		{
			return mid;
		}
		else if (a[left] < a[right])
		{
			return right;
		}
		else
		{
			return left;
		}
	}
	else  //(a[left] > a[mid])
	{
		if (a[mid] > a[right])
		{
			return mid;
		}
		else if (a[left] < a[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
}
int PartSort1(int* a, int left, int right)
{
    //获取到那个数的下标
	int midi = GetMidIndex(a, left, right);
	//交换一下key和那个数，让那个数当key
	Swap(&a[left], &a[midi]);
	int keyi = left;
	while (left < right)
	{
		// 左边做key，右边先走找小
		//内循环的left<right是为了防止left和right跳过不相遇, a[right] >= a[keyi]，等号是为了防止key的值和left/right的值相等的时候产生死循环
		while (left < right && a[right] >= a[keyi])
		{
			--right;
		}
		// 左边再走，找大
		while (left < right && a[left] <= a[keyi])
		{
			++left;
		}
		// 交换，把大的换到右边，小的换到左边
		 Swap(&a[left], &a[right]);
	}
	//相遇后交换，相遇的值一定比key小
	    Swap(&a[keyi], &a[left]);
   //返回key的位置
	return left;
}
void QuickSort(int* a, int left, int right)
{
     if(left>=right)
     {
       return ;
     }
	//if (left < right)
	//{
		int keyi = PartSort1(a, left, right);
		// [0, keyi-1] keyi [keyi+1, right]
		QuickSort(a, left, keyi - 1);
		QuickSort(a, keyi + 1, right);
	//}
}
void TestQuickSort()
{
	int	a[] = { 6, 1, 2, 7, 9, 3, 4, 5, 10, 8 };
	PrintArray(a, sizeof(a) / sizeof(int));
	QuickSort(a, 0, sizeof(a) / sizeof(int)-1);
	PrintArray(a, sizeof(a) / sizeof(int));
}

test.c

#include <time.h>
#include <stdlib.h>
#include "Sort.h"
void TestOP()
{
	srand(time(0));
	const int N = 100000;
	int* a1 = (int*)malloc(sizeof(int)*N);
	int* a2 = (int*)malloc(sizeof(int)*N);
	int* a3 = (int*)malloc(sizeof(int)*N);
	int* a4 = (int*)malloc(sizeof(int)*N);
	int* a5 = (int*)malloc(sizeof(int)*N);
	int* a6 = (int*)malloc(sizeof(int)*N);
	int* a7 = (int*)malloc(sizeof(int)*N);
	for (int i = 0; i < N; ++i)
	{
		a1[i] = rand();
		a2[i] = a1[i];
		a3[i] = a1[i];
		a4[i] = a1[i];
		a5[i] = a1[i];
		a6[i] = a1[i];
		a7[i] = a1[i];
	}

	int begin5 = clock();
	//QuickSort(a5, 0, N - 1);
	int end5 = clock();
	
	int begin6 = clock();
	//(a6, N);
	int end6 = clock();
	 printf("QuickSort:%d\n", end5 - begin5);
	free(a1);
	free(a2);
	free(a3);
	free(a4);
	free(a5);
	free(a6);
}
int main()
{
	//TestInsertSort();
	//TestShellSort();
	//TestSelectSort();
	//TestHeapSort();
	TestOP();
	return 0;
}

在这里插入图片描述

时间复杂度：：O（N*logN)—像一颗二叉树一样展开–高度为logN,每一层单趟排为N
空间复杂度：O(logN)

方法2–挖坑法

Sort.c

#include"Sort.h"
void PrintArray(int* a, int n)
{
	for (int i = 0; i < n; ++i)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
}
void Swap(int* px, int* py)
{
	int tmp = *px;
	*px = *py;
	*py = tmp;
}
// 三数取中---中间，left,right三个数比较大小取第二大的那个数的下标
//获取那个适合的数的下标
int GetMidIndex(int* a, int left, int right)
{
	//int mid = (left + right) / 2;
	//为了防止越界
	int mid = left + (right - left) / 2;
	if (a[left] < a[mid])
	{
		if (a[mid] < a[right])
		{
			return mid;
		}
		else if (a[left] < a[right])
		{
			return right;
		}
		else
		{
			return left;
		}
	}
	else  //(a[left] > a[mid])
	{
		if (a[mid] > a[right])
		{
			return mid;
		}
		else if (a[left] < a[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
}
int PartSort2(int* a, int left, int right)
{
   //获取到那个数的下标
	int midi = GetMidIndex(a, left, right);
	//交换一下key和那个数，让那个数当key
	Swap(&a[left], &a[midi]);
    //一开始让left为坑，右边先去找小的数放到坑中，再左边取去找大的数放到右边刚产生的坑
	int key = a[left];
	int hole = left;
	while (left < right)
	{
		while (left < right && a[right] >= key)
		{
			--right;
		}
		//把右边找的小的，填到左边的坑，自己形成新的坑
		a[hole] = a[right];
		hole = right;	
		while (left < right && a[left] <= key)
		{
			++left;
		}
		//把左边找的大的，填到右边的坑，自己形成新的坑
		a[hole] = a[left];
		hole = left;
	}
	//key填到最后剩下的坑
	a[hole] = key;
	return hole;
}
void QuickSort(int* a, int left, int right)
{
	if (left >= right)
		return;
	int keyi = PartSort2(a, left, right);
	//PrintArray(a+left,right-left + 1);
	// [left, keyi-1] keyi [keyi+1, right]
	QuickSort(a, left, keyi - 1);
	QuickSort(a, keyi + 1, right);
}
void TestQuickSort()
{
	int	a[] = { 6, 1, 2, 7, 9, 3, 4, 5, 10, 8 };
	PrintArray(a, sizeof(a) / sizeof(int));
	QuickSort(a, 0, sizeof(a) / sizeof(int)-1);
	PrintArray(a, sizeof(a) / sizeof(int));
}

test.c

#include <time.h>
#include <stdlib.h>
#include "Sort.h"
void TestOP()
{
	srand(time(0));
	const int N = 100000;
	int* a1 = (int*)malloc(sizeof(int)*N);
	int* a2 = (int*)malloc(sizeof(int)*N);
	int* a3 = (int*)malloc(sizeof(int)*N);
	int* a4 = (int*)malloc(sizeof(int)*N);
	int* a5 = (int*)malloc(sizeof(int)*N);
	int* a6 = (int*)malloc(sizeof(int)*N);
	int* a7 = (int*)malloc(sizeof(int)*N);
	for (int i = 0; i < N; ++i)
	{
		a1[i] = rand();
		a2[i] = a1[i];
		a3[i] = a1[i];
		a4[i] = a1[i];
		a5[i] = a1[i];
		a6[i] = a1[i];
		a7[i] = a1[i];
	}
	int begin5 = clock();
	//QuickSort(a5, 0, N - 1);
	int end5 = clock();

	int begin6 = clock();
	//(a6, N);
	int end6 = clock();
	printf("QuickSort:%d\n", end5 - begin5);
	free(a1);
	free(a2);
	free(a3);
	free(a4);
	free(a5);
	free(a6);
}
int main()
{
	//TestInsertSort();
	//TestShellSort();
	//TestSelectSort();
	//TestHeapSort();
	TestOP();
	return 0;
}

在这里插入图片描述
方法1和方法2的缺陷：
1、都是假设左边（右边）做key就得右边（左边）先走才能保证相遇的位置的值比小
2、且有可能方法1和方法2产生的排序结果不一致–所以遇到要求第一次快排后的数组顺序的选择题两种方法都验证一下是否正确

方法3–前后指针

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

int PartSort3(int* a, int left, int right)
{
	int midi = GetMidIndex(a, left, right);
	Swap(&a[left], &a[midi]);
	int keyi = left;
	int prev = left;
	int cur = prev + 1;
	while (cur <= right)
	{
		//里面写while还要判断越界情况，里面用if可以把越界的情况丢给外循环while
		if (a[cur] < a[keyi])
		{
			Swap(&a[++prev], &a[cur]);
			cur++;
		}
		else
		{
			cur++;
		}
		//更好写法
		当cur找到比keyi要小的值且++prev以后不和它相等，相等的时候不交换也可以
		//if (a[cur] < a[keyi] && ++prev != cur)
		//	Swap(&a[prev], &a[cur]);
		无论什么条件cur都得++
		//++cur;
	}
	Swap(&a[prev], &a[keyi]);
		return prev;
}
void QuickSort(int* a, int left, int right)
{
	//	if (left >= right)
	//		return;
	if (left < right)
	{
		int keyi = PartSort3(a, left, right);
		QuickSort(a, left, keyi - 1);
		QuickSort(a, keyi + 1, right);
	}
}
void TestQuickSort()
{
	int	a[] = { 6, 1, 2, 7, 9, 3, 4, 5, 10, 8 };
	PrintArray(a, sizeof(a) / sizeof(int));
	QuickSort(a, 0, sizeof(a) / sizeof(int)-1);
	PrintArray(a, sizeof(a) / sizeof(int));
}

方法四–非递归

递归是正确的，但是递归的深度太深会奔溃即栈溢出

int func(int n)
{
	if (n <= 1)
	{
		return n;
	}
	else
	{
		return func(n - 1) + n;
	}
}
int main()
{
	printf("%d\n", func(100000\));
	return 0;
}

任何一个递归程序，我们要掌握把他改成非递归

  • 循环
  • 栈+循环

方法：栈+循环
在这里插入图片描述
Sort.c

#include"Stack.h"
int PartSort3(int* a, int left, int right)
{
	int midi = GetMidIndex(a, left, right);
	Swap(&a[left], &a[midi]);
	int keyi = left;
	int prev = left;
	int cur = prev + 1;
	while (cur <= right)
	{
		//里面写while还要判断越界情况，里面用if可以把越界的情况丢给外循环while
		if (a[cur] < a[keyi])
		{
			Swap(&a[++prev], &a[cur]);
			cur++;
		}
		else
		{
			cur++;
		}
	}
	Swap(&a[prev], &a[keyi]);
		return prev;
}
void QuickSort(int* a, int left, int right)
{
	if (left < right)
	{
		int keyi = PartSort3(a, left, right);
		QuickSort(a, left, keyi - 1);
		QuickSort(a, keyi + 1, right);
	}
}
void QuickSortNonR(int* a, int left, int right)
{
	ST st;
	StackInit(&st);
	StackPush(&st, right);
	StackPush(&st, left);
	while (!StackEmpty(&st))
	{
		int begin = StackTop(&st);
		StackPop(&st);
		int end = StackTop(&st);
		StackPop(&st);
        //先单趟排
		int keyi = PartSort3(a, begin, end);
		//  [begin, keyi-1] keyi [keyi+1, end]
		//1、想要先处理左边，则需要右边先入栈
		if (keyi + 1 < end)
		{
		    //先入右
			StackPush(&st, end);
			//再入左
			StackPush(&st, keyi + 1);
		}
		//2、左边再入栈
		if (begin < keyi - 1)
		{
		    //先入右
			StackPush(&st, keyi - 1);
			//再入左
			StackPush(&st, begin);
		}
	}
	StackDestroy(&st);
}
void TestQuickSort()
{
	int	a[] = { 6, 1, 2, 7, 9, 3, 4, 5, 10, 8 };
	PrintArray(a, sizeof(a) / sizeof(int));
	QuickSort(a, 0, sizeof(a) / sizeof(int)-1);
	QuickSortNonR(a, 0, sizeof(a) / sizeof(int)-1);
	PrintArray(a, sizeof(a) / sizeof(int));
}

Stack.h

#pragma once
#include<assert.h>
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
// ̬
//#define N 100
//typedef int STDatatype;
//struct Stack
//{
//	STDatatype a[N];
//	int top;    // ջ
//};
typedef int STDatatype;
typedef struct Stack
{
	STDatatype* a;
	int top;		// ջ
	int capacity;
}ST;
void StackInit(ST* ps);
void StackDestroy(ST* ps);
void StackPush(ST* ps, STDatatype x);
void StackPop(ST* ps);
bool StackEmpty(ST* ps);
int StackSize(ST* ps);
STDatatype StackTop(ST* ps);

Stack.c

#include "Stack.h"
void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = 0; // -1
	ps->capacity = 0;
}
void StackDestroy(ST* ps)
{
	assert(ps);
	if (ps->a)
	{
		free(ps->a);
	}
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}
void StackPush(ST* ps, STDatatype x)
{
	assert(ps);
	// 检查空间够不够，不够就增容
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDatatype* tmp = realloc(ps->a, sizeof(STDatatype)*newcapacity);
		if (tmp == NULL)
		{
			printf("rellaoc fail\n");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}
void StackPop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	--ps->top;
}
bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}
int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}
STDatatype StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->a[ps->top - 1];
}

在这里插入图片描述

入木
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 中快排的递归和非递归实现
01-21
快排的递归 void quickSort1(int* root,int low,int high) { int pat=root[low]; if(low,j>pat) j--; root[i]=root[j]; while(i<j&&root[i]<pat) i++; root[j]=root[i]; } root[i]=pat; quickSort...
快速排序算法（递归非递归，三种方法实现，优化）
卜及中的博客
03-18 2846
有关快速排序算法的相关问题，三种方式，递归与非递归的代码实现，以及优化
[ 数据结构 -- 手撕排序算法第五篇 ] 快速排序 非递归实现
CSDN博客
04-21 6871
手撕排序算法系列之第五篇：快速排序（下） 从本篇文章开始，我会介绍并分析常见的几种排序，大致包括直接插入排序，冒泡排序，希尔排序，选择排序，堆排序，快速排序，归并排序等。 大家可以点击此链接阅读其他排序算法：排序算法_大合集（data-structure_Sort） 快速排序的递归实现方法全部总结在这篇：快速排序 ＜包含hoare法，挖坑法，前后指针法＞ 及其算法优化 这篇文章我们将一起讨论快速排序的非递归实现方法~ 1.快排非递归的实现思想 快排的非递归实现方法是利用了栈（栈 S...
《排序算法篇》快排的递归与非递归
m0_62171658的博客
04-21 8953
快排的思想 实现单趟快排的三种方式（hoare、挖坑、前后指针） 递归实现快排 对快排进行优化（三数取中，小区间优化） 非递归实现快排（栈或队列实现）
【数据结构与算法】快速排序的非递归实现方法
旋律 | 话语 | 色彩 | 情景
04-09 1620
【数据结构与算法】快速排序的非递归实现方法
快速排序（四）—— 非递归排序
challenglistic的博客
03-13 4746
前面实现了快排的递归实现，并对其进行优化 但是递归需要在栈上为函数开辟空间，32位下，栈可使用的内存大小不超过2G，如果递归较深，依然可能会发生栈溢出 这个时候递归排序就不大适用，所以需要非递归出场 ...
快速排序的非递归算法.doc
05-26
用C实现了快速排序的非递归算法. int quickpass ( sqlist &R, int low, int high ) { ... } void quicksort ( sqlist &r, int low, int high ) { ... }
在排序2的基础上，再次对快排进行优化，其次增加快排非递归，归并排序，归并排序非递归版.zip
最新发布
04-27
直接插入排序（Straight Insertion Sort）是一种简单且古老的排序算法，其基本思想是将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增1的有序表。12 直接插入排序的算法过程如下： 假设待排序...
[排序算法] 9. 归并排序递归与非递归实现及算法复杂度分析(分治算法、归并排序、复杂度分析)
01-06
文章目录1. 基本思想2. 代码实现2.1 递归实现2.2 优化—非递归实现3. 性能分析 1. 基本思想 在数列排序中，如果只有一个数，那么它本身就是有序的；...快排 Link：[排序算法] 6. 快速排序多种递归、非递归实现及性能
快速排序的非递归实现
06-08
利用栈来消除递归 模拟快速排序的过程 实现非递归的快速排序
【数据结构】快速排序递归实现 _三种方法详解+优化
Bitdancing的专栏
11-28 3620
常见的排序算法有以上八种，所以预估会分成几期来讲，感兴趣的朋友们不妨点个收藏专栏。 ღ( ´･ᴗ･` )比心 OJ链接 快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为： 任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。 将区间按照基准值划分为左右两半部分的常见方式: Hoare法、挖坑法、前后指针法。 快排又.
排序算法-----快速排序（递归）
m0_73633088的博客
09-14 1988
详细讲解快速排序算法的过程，图文并茂，步骤详细，有过程示例，附C语言代码实现快速排序，快进来看看吧！
快速排序————非递归实现
2201_75943325的博客
06-11 944
大家有可能会想是不是因为递归非常的占用空间，我们都知道我们的局部变量是保存在栈上的我们的函数参数也是在栈上开辟的，所以说递归是不是会占用我们非常多的栈空间，同时呢我们的递归是一个非常深的一个操作，我们往往会因为一个函数递归出来的结果而去让这个函数重复调用多次去解决我们当前的问题，我们的快速排序非递归就是这样的方式，也包括之前的一个斐波那契数列使用递归去解决都是使用了栈；这样的方法在递归的深度不大的时候不会产生什么问题但是如果我们需要去处理的数据非常多，递归的深度非常深那么我们这个时候递归真的不会出现问题吗。
快速排序（递归实现）
m0_73455775的博客
11-20 824
快速排序是排序很厉害的排序之一 下面介绍一下快排 源码在最后面！！！ （hoare版本）首先看一下快速排序的单趟排序 这个是(hoare版本的单趟排序) 下面是双指针法 单趟，双指针法比较简单（推荐） 下面是如何递归实现 这就是递归实现 可以结合起来看一看 上面的这两个是函数测试用的 通过主函数调用 给展示一下成果 其中这两个测试用例可以测试快排的性能（数据量有点小，如果想要测试的话多放一些数据），其中快排
快速排序递归方法和非递归方法详解
Xpccccc的博客
09-28 1093
快速排序递归方法和非递归方法详解
快排3种递归方法实现及优化（动图详解）
lzf的博客
04-06 2121
3种递归方法，教你搞懂快速排序，还有优化性能的小技巧。
排序——快排（递归/非递归）
finish_speech的博客
12-25 856
快排
快速排序(非递归)
weixin_49312527的博客
03-13 4906
快速排序非递归: 基本思想(默认升序):从数组中选取一个数来作为标准数,所有比这个数小的数全部放到其前面,比这个数字大的数放到其后面,此时这个标准数所处的位置就是其在有序数组中的位置,因此该标准数就不用在移动了,我们对其左右两边的数字继续执行之前的操作,这样每次都可以确定一个标准数在有序数组中的位置,直到所有数字都处在正确的位置为止,此时这个数组就为有序数组. 优化: 三数取中:我们取标准数的时候,取的数越居中则算法的时间复杂度越低越接近O(N*logN)效率越高,我们取的数越极端越接近最大或最小值则
非递归算法——快速排序、归并排序
保护小周ღ的博客
07-15 3963
​哈喽大家好，我是保护小周ღ，本期为大家带来的是常见排序算法中的快速排序、归并排序非递归算法，分享所有源代码，粘贴即可运行，保姆级讲述，包您一看就会，快来试试吧~ ​
快速排序非递归 python
11-03
下面是Python的非递归快排实现代码： ```python def QuickSort_No_Stack(nums:list,left:int,right:int) -> list: temp = [left,right] while temp: j = temp.pop() # j = right i = temp.pop() # i = left ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值