【数据结构】快速排序(递归)

概念： 快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法。

基本思想为:任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

 将区间按照基准值划分为左右两半部分的常见方式有:

    1. hoare版本

    具体代码如下：

//hoare版本
void Swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

int PartSort1(int* a, int begin, int end)
{
	int key = a[0];
	int start = begin;
	while (begin < end)
	{
		//end从后面走，找到比key小的就停下来
		while (begin < end && a[end] >= key)
		{
			end--;
		}
		//begin从前面走，找到比key大的就停下来
		while (begin < end && a[begin] <= key)
		{
			begin++;
		}
		//交换begin和end
		Swap(&a[begin], &a[end]);
	}
	//此时begin和end相遇
	Swap(&a[begin], &a[start]);

	return begin;
}
void QuickSort(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	
	int div = PartSort1(a, left, right);
	//在以div为基准的左边区间去找新的key
	//左边区间:[left,div-1]
	QuickSort(a, left, div - 1);
	//在以div为基准的右边区间去找新的key
	//右边区间:[div+1,right]
	QuickSort(a, div + 1, right);
}

优化后的代码:

int GetMidIndex(int* a, int begin, int end)
{
	int mid = begin + ((end - begin) >> 1);
	if (a[begin] < a[mid])
	{
		if (a[mid] < a[end])
		{
			return mid;
		}
		else if (a[begin]>a[end])
		{
			return begin;
		}
		else//end<mid
		{
			return end;
		}
	}
	else//begin>mid
	{
		if (a[mid] > a[end])
		{
			return mid;
		}
		else if (a[begin] < a[end])
		{
			return begin;
		}
		else//end>mid
		{
			return end;
		}
	}
}

//为防止所给数据直接有序，进行三数取中的优化
int PartSort(int* a, int begin, int end)
{
	//三数取中
	int midindex = GetMidIndex(a, begin, end);
	Swap(&a[begin], &a[midindex]);
	int key = a[begin];
	int start = begin;
	while (begin < end)
	{
		//end从后面走，找到比key小的就停下来
		while (begin < end && a[end] >= key)
		{
			end--;
		}
		//begin从前面走，找到比key大的就停下来
		while (begin < end && a[begin] <= key)
		{
			begin++;
		}
		//交换begin和end
		Swap(&a[begin], &a[end]);
	}
	//此时begin和end相遇
	Swap(&a[begin], &a[start]);

	return begin;
}
//小区间优化
void QuickSort(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	if ((right - left + 1) < 10)
	{
		InsertSort(a + left, right - left + 1);
	}
	else
	{
		int div = PartSort(a, left, right);
		//在以div为基准的左边区间去找新的key
		//左边区间:[left,div-1]
		QuickSort(a, left, div - 1);
		//在以div为基准的右边区间去找新的key
		//右边区间:[div+1,right]
		QuickSort(a, div + 1, right);
	}
}

2.挖坑法

  具体代码:

//挖坑法
int PartSort2(int* a, int begin, int end)
{
	int key = a[begin];
	while (begin < end)
	{
		//end找比key小的数据
		while (begin < end && a[end] >= key)
		{
			end--;
		}
		//当end找到比key小的数据后，用此时的end填begin这个坑，end就变成了新的坑
		a[begin] = a[end];

		//begin找比key大的数据
		while (begin < end && a[begin] <= key)
		{
			begin++;
		}
		//当begin找到比key大的数据后，用此时的begin填end这个坑，begin又变成了新的坑
		a[end] = a[begin];
	}
	a[begin] = key;

	return begin;

}
void QuickSort2(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	
	int div = PartSort(a, left, right);
	//在以div为基准的左边区间去找新的key
	//左边区间:[left,div-1]
	QuickSort(a, left, div - 1);
	//在以div为基准的右边区间去找新的key
	//右边区间:[div+1,right]
	QuickSort(a, div + 1, right);
}

3.前后指针

具体代码如下:

//前后指针法
int PartSort3(int* a, int begin, int end)
{
	int key = a[begin];
	int prev = begin;
	int cur = begin + 1;
	while (cur <= end)
	{
		if (a[cur] < key && (++prev) != cur)//当cur小于key时，且++prev的值不等于cur的值时，才发生交换，当cur>key时，不交换，继续向前走
		{
			Swap(&a[prev], &a[cur]);
		}
		cur++;
	}
	Swap(&a[begin], &a[prev]);

	return prev;
}
void QuickSort(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	
	int div = PartSort3(a, left, right);
	//在以div为基准的左边区间去找新的key
	//左边区间:[left,div-1]
	QuickSort(a, left, div - 1);
	//在以div为基准的右边区间去找新的key
	//右边区间:[div+1,right]
	QuickSort(a, div + 1, right);
}

以上就是快速排序递归的几种思想及代码,

注:需要说明的是,如果要在vs下面运行的话,得有头文件,交换函数和测试数据等等,直接是运行不出来的.