快速排序

快速排序
快速排序（Quick Sort）的基本思想是：通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序的目的。

我们来看下实现代码：

• (1)在待排序的序列中找一个基准值—[left, right)— 区间中最后一个元素
• (2)方法：按基准值将序列分割成左右两部分
• (3)排基准值的左边
• (4)排基准值的右边

void QuickSort(int *array, int left, int right)//递归
{
	if (right - left > 1)
	{
		//在[left, right)找基准值来划分区间，最后返回基准值在区间中的位置
		int boundary = Partion1(array, left, right);
		//int boundary = Partion2(array, left, right);
		//int boundary = Partion3(array, left, right);
		QuickSort(array, left, boundary);
		QuickSort(array, boundary + 1, right);
	}
}

复杂度分析

• 时间复杂度
  最优的情况下：O(n㏒n)
  最坏的情况下 ：O(n²)
  平均的情况：O(n㏒n)
• 空间复杂度
  就空间复杂度而言，主要是递归造成的栈空间的使用，最好情况下，递归树的深度为㏒₂n，其空间复杂度也就为O(㏒n)，最坏的情况，需要进行n-1递归调用，其空间复杂度为O(n)，平均情况，空间复杂度也为O(㏒n)。

稳定性分析
在中枢元素和序列中一个元素交换的时候，很有可能把前面的元素的稳定性打乱。还是看一个小实例：6 4 4 5 4 7 8 9，第一趟排序，中枢元素6和第三个4交换就会把元素4的原序列破坏，所以快速排序不稳定。

//三数取中法(通过这种方法降低取到极值的概率)
int GetMiddleIndex(int *array, int left, int right)
{
	int mid = left + ((right - left) >> 1);
	if (array[left] < array[right - 1])
	{
		if (array[mid] < array[left])
			return left;
		else if (array[mid] > array[right - 1])
			return right - 1;
		else
			return mid;
	}
	else
	{
		if (array[mid] > array[left])
			return left;
		else if (array[mid] < array[right - 1])
			return right - 1;
		else
			return mid;
	}
}

int Partion1(int *array, int left, int right)
{
	//找基准值
	int key;
	int begin = left;
	int end = right - 1;
	int index = GetMiddleIndex(array, left, right);
	if (index != right - 1)
		Swap(&array[index], &array[right - 1]);
	key = array[right - 1];
	
	while (begin < end )
	{
		//从左往右找比基准值大的元素
		while (begin < end && array[begin] <= key)
			begin++;
		
		//从右往左找比基准值小的元素
		while (begin < end && array[end] >= key)
			end--;

		if(begin < end)
			Swap(&array[begin], &array[end]);
	}

	if(begin != right-1)
		Swap(&array[begin], &array[right-1]);
	return begin;
}

//挖坑法
int Partion2(int *array, int left, int right)
{
	//找基准值
	int key = array[right - 1];
	int begin = left;
	int end = right - 1;
	
	while (begin < end)
	{
		//从左往右找比基准值大的元素
		while (begin < end && array[begin] <= key)
			begin++;

		if (begin < end)
		{
			array[end] = array[begin];
			end--;
		}

		//从右往左找比基准值小的元素
		while (begin < end && array[end] >= key)
			end--;

		if (begin < end)
		{
			array[begin] = array[end];
			begin++;
		}

	}

	array[begin] = key;
	return begin;
}

int Partion3(int *array, int left, int right)
{
	//找基准值
	int key = array[right - 1];
	int cur = left;
	int prev = cur - 1;

	while (cur < right)
	{
		if (array[cur] < key && ++prev != cur)
			Swap(&array[prev], &array[cur]);

		++cur;
	}

	if (++prev != right-1)
		Swap(&array[right-1], &array[prev]);

	return prev;
}

void QuickSort(int *array, int left, int right)//递归
{
	if (right - left > 1)
	{
		//在[left, right)找基准值来划分区间，最后返回基准值在区间中的位置
		int boundary = Partion1(array, left, right);
		//int boundary = Partion2(array, left, right);
		//int boundary = Partion3(array, left, right);
		QuickSort(array, left, boundary);
		QuickSort(array, boundary + 1, right);
	}
}


#include "Stack.h"
void QuickSortNor(int *array, int size)//循环
{
	int left;
	int right;
	Stack s;
	StackInit(&s);
	StackPush(&s, size);
	StackPush(&s, 0);

	while (!StackEmpty(&s))
	{
		left = StackTop(&s);
		StackPop(&s);
		
		right = StackTop(&s);
		StackPop(&s);

		if (left < right)
		{
			int boundary = Partion3(array, left, right);

			//排左侧-->将右半部分的区间压栈
			StackPush(&s, right);
			StackPush(&s, boundary + 1);

			//排右侧-->将左半部分的区间压栈
			StackPush(&s, boundary);
			StackPush(&s, left);
		}
	}
}

//打印函数
void PrintArray(int *array, int size)
{
	int i = 0;
	for (; i < size; i++)
	{
		printf("%d ", array[i]);
	}
	printf("\n");
}

//交换函数
void Swap(int *pLeft, int *pRight)
{
	int tmp = *pLeft;
	*pLeft = *pRight;
	*pRight = tmp;
}

/************************************/
//Stack.h

#pragma once

#define MAXSIZE 10

typedef int SDataType;


typedef struct Stack
{
	SDataType _array[MAXSIZE];
	int _top;   //标记栈顶元素
}Stack;

//初始化
void StackInit(Stack *ps);

//压栈
void StackPush(Stack *ps, SDataType data);

//出栈
void StackPop(Stack *ps);

//返回栈顶元素
SDataType StackTop(Stack *ps);

//返回栈空间长度
int StackSize(Stack *ps);

//栈是否为空
int StackEmpty(Stack *ps);

/****************************************/
//Stack.c
#include <assert.h>
#include <stdio.h>
#include <string.h>


//初始化
void StackInit(Stack *ps)
{
	assert(ps);
	ps->_top = 0;
}

//压栈
void StackPush(Stack *ps, SDataType data)
{
	assert(ps);
	if (MAXSIZE == ps->_top)
	{
		printf("栈空间已满，无法插入！！！\N");
		return;
	}
	ps->_array[ps->_top++] = data;
}

//出栈
void StackPop(Stack *ps)
{
	assert(ps);
	if (StackEmpty(ps))
		return;
	ps->_top--;
}

//返回栈顶元素
SDataType StackTop(Stack *ps)
{
	assert(ps);
	return ps->_array[ps->_top - 1];
}

//返回栈空间长度
int StackSize(Stack *ps)
{
	assert(ps);
	return ps->_top;
}

//栈是否为空
int StackEmpty(Stack *ps)
{
	assert(ps);
	return 0 == ps->_top;
}