NzN的数据结构--交换排序

最新推荐文章于 2024-06-10 21:11:07 发布

一个闪现必杀技

最新推荐文章于 2024-06-10 21:11:07 发布

阅读量606

点赞数 22

分类专栏：数据结构初阶文章标签：数据结构排序算法

本文链接：https://blog.csdn.net/2301_79676950/article/details/137627690

版权

数据结构初阶专栏收录该内容

13 篇文章 1 订阅

订阅专栏

篇接上文，今天要学习的就是交换排序，这么励志的日更博主，你怎么能不三连一下呢？

一、基本思想

所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

二、冒泡排序

void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
void BubbleSort(int* a, int n)
{
	for (int j = 0; j < n - 1; j++)
	{
		for (int i = 1; i < n - j; i++)
		{
			int flag = 0;
			if (a[i - 1] > a[i])
			{
				Swap(&a[i - 1], &a[i]);
				flag = 1;//发生交换就把flag改成1
			}
			//说明数组本来就有序
			if (flag == 0)
				break;
		}
	}
}

冒泡排序的特性总结：

容易理解
时间复杂度：
空间复杂度：
稳定性：稳定

三、快速排序

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

快速排序递归实现的主框架与二叉树前序遍历规则非常像，在写递归框架时可根据二叉树前序遍历规则即可快速写出来，后序只需分析如何按照基准值来对区间中数据进行划分的方式即可。将区间按照基准值划分为左右两半部分的常见方式有：

1. hoare版本

//快速排序（hoare版本）
void Quicksort(int* a, int begin, int end)
{

	if (begin >= end)
	{
		return;
	}
	int left = begin;
	int right = end;
	int key = begin;//把begin的位置作为key
	//小于a[key]  a[key]  大于a[key]（升序为例）
	while (left < right)
	{
		//循环里依旧需要加上left < right
		//防止right--和left++导致left < right不成立
		//当left找到大于key的，且right在小于key的位置，两个交换
		while (left < right && a[right] >= a[key])
		{
			right--;
		}
		while (left < right && a[left] <= a[key])
		{
			left++;
		}
		Swap(&a[right], &a[left]);
	}
	Swap(&a[left], &a[key]);
	key = left;//更新key所在的位置，a[key]此时元素位置固定
	//以key为分界，左右两边分别再次进行快速排序
	Quicksort(a, begin, key - 1);
	Quicksort(a, key + 1, end);
}

Q：为什么left和right相遇时所在的位置一定比a[key]小？

A：因为right先走，right负责找比a[key]小的位置，left跟right相遇时，right肯定已经停下来了，也就是right停在了比a[key]小的位置。

2. 挖坑法

void QuickSortHole(int* a, int begin, int end) 
{
	if (begin >= end) 
	{
		return; //递归结束条件
	}
	int key = a[begin]; //选取第一个元素作为key
	int left = begin;
	int right = end;
	//首元素作为坑位，把首元素取出，下标为0的位置变成坑位
	//right先走，找到小于key的，就把这个数放到首元素，right所在位置变成坑位
	//left再走，找到大于key的，放到坑位里，left所在位置再变成坑位
	//最后也能够达成 小于key  key  大于key
	while (left < right) {
		while (left < right && a[right] >= key) {
			right--;
		}
		a[left] = a[right]; //将找到的较小元素填到左边的坑里，此时右边形成一个新的坑

		while (left < right && a[left] <= key) {
			left++;
		}
		a[right] = a[left];
	}
	a[left] = key;
	QuickSortHole(a, begin, left - 1);
	QuickSortHole(a, left + 1, end);
}

3. 前后指针法

这种方法是我们最为推荐的！！

void QuickSort_p(int* a, int begin, int end) 
{
	if (begin >= end) 
	{
		return;
	}
	//首元素作为a[key]，a[key]保持不动
	//prev从首元素出发，cur从首元素的后一个元素开始走
	//cur≥prev，cur++
	//cur<prev，prev++，交换cur和prev的值，cur++
	//cur走到空的时候，比较prev所在位置的值和首元素a[key]
	//prev<a[key]就交换
	int prev = begin;
	int cur = begin + 1;
	int key = begin;
	while (cur <= end)
	{
		if (a[cur] < a[key] && ++prev != cur) 
		{
			Swap(&a[prev], &a[cur]);
		}
		++cur;
	}
	Swap(&a[key], &a[prev]);
	key = prev;
	QuickSortHole(a, begin, key - 1);
	QuickSortHole(a, key + 1, end);
}

4. hoare版本优化

hoare版本在数组有序时为最坏情况，时间复杂度为。因此可以在数组中随意选一个数作为a[key]。

void Quicksort(int* a, int begin, int end)
{

	if (begin >= end)
	{
		return;
	}
	//明确left不一定从0开始，end也不一定是数组的最后一个下标
	int left = begin;
	int right = end;
	//选[left,right]区间中的随机数做key
	int randi = rand() % (right - left + 1);//这一步得到的randi不一定在区间内
	randi += left;//能确保randi在区间内
	Swap(&a[left], &a[randi]);
	int key = left;
	//小于a[key]  a[key]  大于a[key]（升序为例）
	while (left < right)
	{
		//循环里依旧需要加上left < right
		//防止right--和left++导致left < right不成立
		//当left找到大于key的，且right在小于key的位置，两个交换
		while (left < right && a[right] >= a[key])
		{
			right--;
		}
		while (left < right && a[left] <= a[key])
		{
			left++;
		}
		Swap(&a[right], &a[left]);
	}
	Swap(&a[left], &a[key]);
	randi = left;//更新key所在的位置，a[key]此时元素位置固定
	//以key为分界，左右两边分别再次进行快速排序
	Quicksort(a, begin, randi - 1);
	Quicksort(a, randi + 1, end);
}

除此之外，还有一种更为经典的写法—三数取中法。

int Getmidi(int* a, int left, int right)
{
	//数组有序时，midi就是key，这样就解决了hoare版本的最坏情况
	int mid = (left + right) / 2;
	//比较begin、midi和end对应元素的大小，选择位于中间大小的作为a[key]
	if (a[left] < a[mid])
	{
		if (a[mid] < a[right])
			return mid;
		else if (a[left] > a[right])
			return left;
		else
			return right;
	}
	else //a[left] > a[mid]
	{
		if (a[mid] > a[right])
			return mid;
		else if (a[right] < a[left])
			return right;
		else
			return left;
	}
}

void Quicksort(int* a, int begin, int end)
{
	if (begin >= end)
	{
		return;
	}
	int left = begin;
	int right = end;
	//小区间走插入排序
	if (right - left + 1 < 15)
	{
		InsertSort(a + left, right - left + 1);
		//a+left指向小区间的起始位置
		//right-left+1是小区间长度
	}
	//三数取中
	int midi = Getmidi(a, left, right);
	Swap(&a[left], &a[midi]);
	int key = left;
	while (left < right)
	{
		while (left < right && a[right] >= a[key])
		{
			right--;
		}
		while (left < right && a[left] <= a[key])
		{
			left++;
		}
		Swap(&a[right], &a[left]);
	}
	Swap(&a[left], &a[key]);
	key = left;
	Quicksort(a, begin, key - 1);
	Quicksort(a, key + 1, end);
}

5. 非递归实现快速排序

我们前面讲过，当我们需要把递归算法改成非递归算法时，经常会用到栈，这里就需要用到栈的内容。

//非递归实现快速排序
//深度较大时，递归效率很低，可能会出现栈溢出
//递归->非递归有两种方法：变成循环；使用栈
void QuicksortST(int* a, int left, int right)
{
	//核心：栈存区间，取栈顶区间进行单趟排序
	//然后右左子区间入栈
	ST st;
	STInit(&st);
	//先入右，再入左，把数组元素的首尾全部入栈
	STPush(&st, right);
	STPush(&st, left);

	while (!STEmpty(&st))
	{
		//先压入right，先出的就是left
		int begin = STTop(&st);
		STPop(&st);
		//再出的才是right
		int end = STTop(&st);
		STPop(&st);
		//单趟排序
		int prev = begin;
		int cur = begin + 1;
		int key = begin;
		while (cur <= end)
		{
			if (a[cur] < a[key] && ++prev != cur)
			{
				Swap(&a[prev], &a[cur]);
			}
			++cur;
		}
		Swap(&a[key], &a[prev]);
		key = prev;
		//key到达了正确的位置，对两边进行分别排序
		//对大于a[key]的数据进行排序
		if (key + 1 < end)
		{
			STPush(&st, key + 1);
			STPush(&st, end);
		}
		//对小于a[key]的数据进行排序
		if (key - 1 > begin) 
		{
			STPush(&st, key - 1);
			STPush(&st, begin);
		}
	}
	STDestroy(&st);
}

以上就是交换排序的内容，大家下去重点自主实现快速排序，下一节我们向大家介绍归并排序！记得三连哦!!!