数据结构（快速排序——非递归实现）

快速排序

快速排序由C. A. R. Hoare在1962年提出。它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

在之前已经说过了快速排序的递归实现
递归实现：https://blog.csdn.net/wfea_lff/article/details/104341455
已经得到了快速排序的时间复杂度和空间复杂度以及稳定性

时间复杂度：O(nlogn)

空间复杂度：O(logn)

稳定性：不稳定

我们今天来说非递归的实现
我们还是先看一下快速排序的排序流程图，复习一下排序过程

在递归实现中，我们可以通过不断地调用函数用来完成i 到 j之间数字的排序
而在非递归中，我们必须要解决如何保存哪一步要排序的i 和 j的值，然后在不断的将保存的i和j之间待排序的数字进行排序，直到将我们所保存的i和j的值用完
所以我们不难想到，我们可以用栈，将i和j保存下来，不断地出栈排序入栈保存
想到这里问题就已经解决了一大半，下来我们就要想要申请多大空间的栈呢？
如果小了可能会崩掉，如果大了又会造成空间的浪费，在递归实现的时候我们已经得到了他的空间复杂度O(logn)，就用空间复杂度的大小开辟栈的空间，其他的与递归的方法基本一样

总结下来过程为
非递归实现快速排序 – 栈 或 队列 -> 存储数据序列的起始位置和结束位置这一对数据
1、初始化栈或者队列 ， 初始化空间的大小为O(logn) * 2 * sizeof(int)
2、将初始的起始位置（0）和结束位置（len-1）入栈或者入队列
3、循环 退出条件是：栈为空或者队列为空
3.1 出栈或者出队列，获取到本次要处理的序列的起始位置和结束位置
3.2 执行一次快排操作，得到到mod位置
3.3 判断mod的右边是否还有超过1个的数据， 如果有，将右边的起始位置和结束位置入栈或者入队列
3.4 判断mod的左边是否还有超过1个的数据， 如果有，将左边的起始位置和结束位置入栈或者入队列

快速排序的优化

1、对选择基准的方式的优化： 随机选择 三位（第一位，最后一位，中间一位）取中（中位数）
2、数据量越小，数据越有序，直接插入排序的效率越高 当快排的数据量小于一定值后，直接用直接插入排序
3、对重复数据： 每次划分将与key相等的元素集中到key的周围，处理左边或右边时，这些数据不再参与
4、多线程并行处理

参考代码

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

typedef struct Peer
{
	int left;
	int right;
}Peer;

typedef struct Stack       //栈
{
	Peer *data;
	int top;
}Stack;

int Getmid(int *arr,int left,int right)        //一次排序并找出中间值
{
	int tmp = arr[left];
	while(left<right)
	{

		while(left<right)
		{
			if(arr[right]>tmp)
			{
				right--;
			}
			else
			{
				arr[left] = arr[right];
				left++;
				break;
			}
		}

		while(left<right)
		{
			if(arr[left]<tmp)
			{
				left++;
			}
			else
			{
				arr[right] = arr[left];
				right--;
				break;
			}
		}
	}
	arr[right] = tmp;

	return left;
}

void QuickSortNor(int *arr,int len)        //快速排序，非递归实现
{
	Stack stack;
	int size = log((double)len)/log((double)2)+1;
	stack.data = (Peer *)malloc(size*sizeof(Peer));         //利用换底公式申请空间
	if(stack.data == NULL)
	{
		return ;
	}
	stack.top = 0;                 //栈的初始化

	Peer peer,peer2;
	peer.left = 0;
	peer.right = len-1;
	stack.data[stack.top] = peer;
	stack.top++;

	while(stack.top!=0)            //开始排序
	{
		stack.top--;
		peer = stack.data[stack.top];
		int mid = Getmid(arr,stack.data[stack.top].left,stack.data[stack.top].right);

		if((mid-peer.left > 1))
		{
			peer2.left = peer.left;
			peer2.right = mid-1;
			stack.data[stack.top] = peer2;
			stack.top++;
		}

		if((peer.right-mid) > 1)
		{
			peer2.left = mid+1;
			peer2.right = peer.right;
			stack.data[stack.top] = peer2;
			stack.top++;
		}
	}

	free(stack.data);          //释放空间
}

void ShowSort(int arr[],int len)     //打印
{
	for(int i=0;i<len;i++)
	{
		printf("%3d  ",arr[i]);
	}
	printf("\n");
}

int main()
{
	srand((unsigned int)time(NULL));

	int arr[LENGTH];

	for(int i=0;i<LENGTH;i++)
	{
		arr[i] = rand()%100;   //获得随机数
	}

	QuickSortNor(arr,LENGTH);

	ShowSort(arr,LENGTH);
	return 0;
}