6.3排序——冒泡排序+快速排序

E_han

已于 2024-09-12 23:06:40 修改

阅读量836

点赞数 20

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

于 2024-09-12 17:10:52 首次发布

本文链接：https://blog.csdn.net/E_han/article/details/142077985

版权

数据结构与算法专栏收录该内容

15 篇文章 0 订阅

订阅专栏

本篇博客梳理冒泡排序与快速排序算法
以下排序均排成升序

一、冒泡排序

1.算法思想：两两比较，不符合就交换

第一趟：最大的数冒到最后
第二趟：次大的数冒到倒数第二，以此类推…

注意与插入排序区分，冒泡排序是每次都从左边开始冒
第一趟：与右边的n-1个数比较
第二趟：与右边的n-2个数比较（最大的数已经冒到了最后，不需要另外比较）
…
第n-2趟：与右边的2个数比较
第n-1趟：与右边仅剩的一个数比较，排序完成

2.具体代码实现

// 冒泡排序
void BubbleSort(int* a, int n)
{
	int i = 0;
	for (i = 0; i < n - 1; i++)
	{
		for (int j = 0; j < n - i - 1; j++)
		{
			if (a[j] > a[j + 1])
			{
				int tmp = a[j];
				a[j] = a[j+1];
				a[j+1] = tmp;
			}
		}
	}
}

二、快速排序

1．hoare版本

hoare版本

（1）单趟：定好一个数位置的同时做好分割

①L和R都找到时，交换，再往下走（小的往左甩，大的往右甩）
②L和R相遇时，就交换该位置与key
如第一趟结束：6就不用动了

（2）整体

6不动了，分成6的左边和6的右边两个子序列（递归）
递归最小子问题：左/右序列只有一个数或者没有数

区间不存在：left>right
区间只有一个值：left==right

注意：左边作key，右边先走，则相遇处的值一定比key小，所以可以放心交换
证明：假定key还是6

（3）快排整体思路分析

快排整体思路分析
时间复杂度：o(N·logN)
缺陷：有序的情况下会栈溢出，假设最左边是最小值，那么R要找小，就得一直往左找，而L不动（因为L指向的key是最小值），R走完了整个序列才能和L相遇，递归下去的子问题也是类似的情况

（4）快速排序优化

①三数取中法选key

在a[left]，a[mid]，a[right]中找大小在中间的值（要两两比较才能出结果）
找到之后先把a[left]和a[mid]换了再说【key的值为中间大小才能二分递归下去，产生o(N·logN）的效果】，后面的逻辑不变，还是拿第一个作key

int GetMidScript(int* a, int left, int right)
{
	//三数取中法选key，返回中间值的下标
	int mid = (left + right) / 2;
	if (a[left] < a[mid])
	{
		if (a[mid] < a[right])
			return mid;
		//a[mid] >= a[right]
		else if (a[left] < a[right])
			return right;
		else
			return left;
	}
	else//a[left]>=a[mid]
	{
		if (a[mid] > a[right])
			return mid;
		else if (a[left] > a[right])
			return right;
		else
			return left;
	}
}

②小区间优化

递归到小的子区间时，可以使用插入排序
虽然快排的递归算法始终操作的是同一个数组,但是左右区间不断递归的过程,可以想象成一棵二叉树的展开(快排思路分析中的图片也是这么画的),比如6是第一层的根,3是第二层的根,2是第三层的根
想象一棵二叉树，二叉树底层子节点很多，不用递归可以很有效地规避栈溢出

if(right-left+1<10)
	//插入排序;
else
	//递归;

（5）hoare版本代码实现


void Swap(int* x, int* y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}
// 直接插入排序（假设排成升序）
void InsertSort(int* a, int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		//单趟
		int end = i;//end最大是n-2
		int tmp = a[end + 1];//end+1最大是n-1
		while (end >= 0)
		{
			if (tmp < a[end])
			{
				a[end + 1] = a[end];//往后挪数据
				--end;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = tmp;//插入数据
	}
}
int GetMidScript(int* a, int left, int right)
{
	//三数取中法选key，返回中间值的下标
	int mid = (left + right) / 2;
	if (a[left] < a[mid])
	{
		if (a[mid] < a[right])
			return mid;
		//a[mid] >= a[right]
		else if (a[left] < a[right])
			return right;
		else
			return left;
	}
	else//a[left]>=a[mid]
	{
		if (a[mid] > a[right])
			return mid;
		else if (a[left] > a[right])
			return right;
		else
			return left;
	}
}
void QuickSortHoare(int* a, int left, int right)
{
	if (left >= right)
		return;

	//小区间优化
	if ((right - left + 1) < 10)//用插入排序
	{
		InsertSort(a + left, right - left + 1);
	}
	else//此处有两个版本，一个是hoare版本，另一个是双指针版本
	{
		int midScript = GetMidScript(a, left, right);//三数取中
		Swap(&a[left], &a[midScript]);//把中间的数换到最左边
		int keyScript = left;//经过三数取中，此时的key不会是最大值或者最小值
		int begin = left;
		int end = right;
		while (begin < end)//begin找大，end找小
		{
			//左边作key，右边先走，可以保证相遇处的值一定比key小
			while (begin < end && a[end] >= a[keyScript])
				end--;
			while (begin < end && a[begin] <= a[keyScript])
				begin++;
			//到此begin和end都找到了
			Swap(&a[begin], &a[end]);
		}
		//此时begin==end
		Swap(&a[begin], &a[keyScript]);
		keyScript = begin;
		QuickSortHoare(a, left, keyScript - 1);//排左子区间
		QuickSortHoare(a, keyScript + 1, right);//排右子区间
	}
}

2．前后指针版本（性能与hoare版本一致）

（1）单趟：cur找小

①若a[cur]<key，++prev，交换a[cur]和a[prev]（小的往左甩，大的往右甩），然后++cur
②若a[cur]>key，++cur（保证cur和prev中间夹着的都是>key的值）
③当cur越界，交换key和a[prev]=>循环结束条件：cur>right
前后指针

（2）整体：与hoare版本类似

（3）前后指针版本代码实现

void QuickSortDoublePointer(int* a, int left, int right)
{
	if (left >= right)
		return;
	//小区间优化
	if ((right - left + 1) < 10)
	{
		InsertSort(a + left, right - left + 1);
	}
	else
	{
		int midScript = GetMidScript(a, left, right);
		Swap(&a[left], &a[midScript]);
		int prev = left;
		int keyScript = left;
		int cur = prev + 1;
		while (cur <= right)
		{
			//cur找小
			if (a[cur] < a[keyScript])//依旧选最左边的值作为key
			{
				++prev;
				Swap(&a[cur], &a[prev]);
			}
			++cur;//不管什么情况都要++cur，干脆放外面
		}
		Swap(&a[keyScript], &a[prev]);
		keyScript = prev;
		QuickSortDoublePointer(a, left, prev - 1);
		QuickSortDoublePointer(a, prev + 1, right);
	}
}

3．非递归版本：用栈来模拟递归过程

注意:栈的实现可以参考4.1栈和队列基本概念+经典OJ题
递归时函数栈帧中存的东西：本质是区间,只要掌握了左右区间,便可对该区间内的序列进行排序操作

（1）入栈

一次入两个数，代表一个区间,先入右边界,再入左边界

（2）具体操作

循环每走一次，取栈顶区间，进行单趟排序。排完之后该区间的右、左子区间依次入栈，这样就可以先取出左区间（相当于先递归左区间），一直进行到栈为空为止
例如：数组中一共有十个数,[0,9]排完以后，区间被分割成[0，4]和[6，9]，先排左子区间[0,4]；[0,4]排完之后区间又被分割成[0,1]和[3,4]，以此类推…
非递归版本