快速排序——hoare版本+挖坑法+双指针法一.hoare法二.挖坑法三.双指针法

74 阅读 0 评论 49 点赞

我是靠谱客的博主怕孤独秋天，最近开发中收集的这篇文章主要介绍快速排序——hoare版本+挖坑法+双指针法一.hoare法二.挖坑法三.双指针法，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

一.hoare法

快排的基本思想是将数组中选出来的key值，通过左右数值比较大小的方式，把该key值调至它应该在数组中的位置（以升序为例）

实现hoare版本的快排，需要先实现快排的单趟排序，单趟排序的目标是实现左边的值比key要小，右边的值比key要大。快排的结构图如下所示：

单趟快速排序代码如下所示：

// 快速排序hoare版本
int PartSort1(int* a, int left, int right)
{
	int keyi = left;
	while (right > left)
	{
		//右边，找小
		while (right > left && a[right] >= a[keyi])//此处大于等于是为了防止数组里的数据相同的时候，进入死循环
		{							
			right--;
		}
		//左边，找大
		while (right > left && a[left] <= a[keyi])//此处right > left是为了防止数组越界
		{
			left++;
		}
		swap(&a[keyi], &a[left]);
	}
	swap(&a[left], &a[right]);

	return left;
}

单趟排序排完，比key小的都放在了左边，比key大的都在右边，如果左子区间有序，右子区间有序有序，整体就又续了，因此可以采用递归的方式来实现。

快速排序的递归实现：

void QuickSort(int* a, int left, int right)
{
	if (left >= right)//递归结束条件
	{
		return;
	}
	int keyi = PartSort1(a, left, right);//找出key的下标，然后进行左右分组递归
	QuickSort(a, 0, keyi - 1);
	QuickSort(a, keyi + 1, right);
}

快速排序的时间复杂度是：O（N*log(N)），但是当面对有序数组的时候，快排的时间复杂度就会变成O(N^2)

为了解决最坏情况下的快排，需要用到三数取中的方法来解决，就是比较左值，右值和中位值，然后得出中间值，将中间值替换到左值，再进行快速排序，即可解决有序情况下，快排时间复杂度为O(N^2)的情况，提高性能，面对有序情况下，时间复杂度变成O(N*log(N))。

取中值的代码如下：

int GetmidIndex(int* a, int left, int right)
{
	right++;
	int mid = (left + right) / 2;
	if (a[left] > a[mid])
	{
		if (a[mid] > a[right])
		{
			return mid;
		}
		else if(a[right] < a[left])
		{
			return right;
		}
		else
		{
			return left;
		}

	}
	else  //(a[left] <= a[mid])
	{
		if (a[right] > a[mid])
		{
			return mid;
		}
		else if(a[left] > a[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
}

最终的递归代码如下所示：

// 快速排序hoare版本
int PartSort1(int* a, int left, int right)
{
	int mid = GetmidIndex(a, left, right);
	swap(&a[mid], &a[left]);
	int keyi = left;
	while (right > left)
	{
		//右边，找小
		while (right > left && a[right] >= a[keyi])//此处大于等于是为了防止数组里的数据相同的时候，进入死循环
		{							
			right--;
		}
		//左边，找大
		while (right > left && a[left] <= a[keyi])//此处right > left是为了防止数组越界
		{
			left++;
		}
		swap(&a[keyi], &a[left]);
	}
	swap(&a[left], &a[right]);

	return left;
}

二.挖坑法

快排的挖坑法是hoare的变形，它的示意图如下所示：

代码实现：

// 快速排序挖坑法
int PartSort2(int* a, int left, int right)
{
	int mid = GetmidIndex(a, left, right);
	swap(&a[mid], &a[left]);
	int key = a[left];
	int hole = left;
	while (right > left)
	{
        //右边找小，找到之后放到左边坑位上
		while (a[right] >= key && right > left)
		{
			right--;
		}
		a[hole] = a[right];
		hole = right;
        //左边找大，找到之后放到右边坑位上
		while (a[left] <= key && right > left)
		{
			left++;
		}
		a[hole] = a[left];
		hole = left;
	}
	a[hole] = key;
	return hole;
}

三.双指针法

思路：定义三个变量：prev，key，cur。最初的时候prev指向数组第一个元素，cru指向prev数组的下一个数组，key设定为左边第一个元素的值，此时cur在数组中找比key小的元素，如果找到就，prev++，然后将prev位置上的值与cur位置上的值交换，并且cur++；如此循环往复，知道cur等于数组最后一个元素的下标才停止，最后将key和prev位置的值互换。下面为示意图：

实现代码如下：

// 快速排序前后指针法
int PartSort3(int* a, int left, int right)
{
	int mid = GetmidIndex(a, left, right);
	swap(&a[mid], &a[left]);
	int cur = left + 1;
	int prev = left;
	int key = a[left];
	while (cur <= right)
	{
		if (a[cur] < key && ++prev != cur)//++prev != cur是为了防止prev与cur相等的时候还进行互换操作
		{
			swap(&a[prev], &a[cur]);
			cur++;
		}
		else
		{
			cur++;
		}
	}
	swap(&a[prev], &a[left]);
	return prev;
}

void QuickSort(int* a, int left, int right)
{
	if (left >= right)//递归结束条件
	{
		return;
	}
	int keyi = PartSort1(a, left, right);//找出key的下标，然后进行左右分组递归
	QuickSort(a, 0, keyi - 1);
	QuickSort(a, keyi + 1, right);
}