数据结构-冒泡排序

今天凌晨，吉诺比利正式宣布退役，在推特中深情的写道：“今天，怀着一种复杂的心情，我要宣布自己从篮球界中退役。我对在过去的23年中出现在我生命里的每个人都怀着强烈而真挚的感谢（家人，朋友，队友，教练组，工作人员，球迷）。这是一趟美妙的旅程，远超我最狂野的梦想。”

马努-吉诺比利用自己的韶华，在马刺长达16年的职业生涯中换回了四座总冠军，以及球迷们无数美妙的回忆。“GDP组合”是马刺成就21世纪最佳球队的核心因素，他们不仅是联盟历史季后赛参赛场次和取胜场最高纪录保持者，为球队赢得荣誉无数，更重要的是，吉诺比利和蒂姆-邓肯、托尼-帕克之间的兄弟情谊，成就了过去20年间NBA最棒的更衣室文化。在这里，篮球已经不只是一项体育运动，更是维系情感的纽带。

为你的的退役感到欣慰，是时候陪伴自己家人了，感谢你和邓肯、帕克诠释给我们的友谊和团队精神以及那些不可思议的系列赛，祝福你，你的家人。。。

又让人再一次想起NBA历史上最伟大的大前锋邓肯的篮球哲学：坚持去做，静观其变，如果是对的，一直坚持下去。

2018.8.28 晚

追忆完伟大的球员现在我们进入主题谈谈冒泡排序啦

冒泡排序：

冒泡排序的英文 Bubble Sort，是一种最基础的交换排序,他是通过对相邻数据元素进行交换，逐步将待排序序列变成有序序列的过程。

算法思想：

反复扫描待排序序列，在扫描的过程中顺次比较相邻的两个元素的大小，如果逆序就交换位置。

以排升序为例，在第一趟冒泡排序中，从第一个元素开始，扫描整个待排序序列，若遇到相邻的两个元素逆序的情况，则交换二者的位置。最后必然会将待排序序列中最大的元素换到待排序序列的末尾，这也是最大元素该在的位置。

然后进行第二趟排序，对前 n-1 个元素进行同样的操作，其结果是将次大的元素被换到待排序序列的第 n-1 个元素的位置处。

如此进行下去，直到剩下一个最小的。每一趟冒泡排序会将一个元素换到它应该所处的位置处。

图形描述：

具体的步骤我们以 8 个数组成的一个无序数列：5，8，6，3，9，2，1，7 来说明（从小到大排序）

首先让5和8比较，发现5比8要小，因此元素位置不变。

接下来让8和6比较，发现8比6要大，所以8和6交换位置。

继续让8和3比较，发现8比3要大，所以8和3交换位置。

继续让8和9比较，发现8比9要小，所以元素位置不变。

接下来让9和2比较，发现9比2要大，所以9和2交换位置。

接下来让9和1比较，发现9比1要大，所以9和1交换位置。

最后让9和7比较，发现9比7要大，所以9和7交换位置。

这时候，我们的冒泡排序的第一轮结束了。数列最右侧的元素9可以认为是一个有序区域，有序区域目前只有一个元素。

第一趟排序完成后，相信大家对这个过程看的非常清楚也能理解此后的过程，至于后续的交换细节，我们这里就不详细描述了

第二轮排序结束后，我们数列右侧的有序区有了两个元素，顺序如下：

第三轮过后的状态如下：

第四轮过后状态如下：

第五轮过后状态如下：

第六轮过后状态如下：

第七轮过后状态如下（已经是有序了，所以没有改变）：

第八轮过后状态如下（同样没有改变）：

到此为止，所有元素都是有序的了，这就是冒泡排序的整体思路。

按照这里的思路，也就是按冒泡排序的定义写出的代码（第一版本）是 代码实现 块中的 BubbleSort_1。

优化处理：

优化一：

让我们回顾一下刚才描述的排序细节，仍然以5，8，6，3，9，2，1，7这个数列为例，当排序算法分别执行到第六、第七、第八轮的时候，数列状态如下：

很明显可以看出经过第六轮排序，整个数列已然是有序的了。可是我们的排序算法仍然“兢兢业业”地继续执行第七轮、第八轮。

这种情况下，如果我们能判断出数列已经有序，并且做出标记，剩下的几轮排序就可以不必执行，提早结束工作。

按照这里的改进思路，我们写出冒泡排序的（第二版本）代码，在 代码实现 块中的 BubbleSort_2。

这一版代码做了小小的改动，利用 flag 作为标记。如果在本轮排序中，元素有交换，则说明数列无序；如果没有元素交换，说明数列已经有序，直接跳出大循环。

优化二：

为了说明问题看以上这个新的数列，这个数列的特点是前半部分（3，4，2，1）无序，后半部分（5，6，7，8）升序，并且后半部分的元素已经是数列最大值。

让我们按照冒泡排序的思路来进行排序，看一看具体效果：

第一轮

元素3和4比较，发现3小于4，所以位置不变。

元素4和2比较，发现4大于2，所以4和2交换。

元素4和1比较，发现4大于1，所以4和1交换。

元素4和5比较，发现4小于5，所以位置不变。

元素5和6比较，发现5小于6，所以位置不变。

元素6和7比较，发现6小于7，所以位置不变。

元素7和8比较，发现7小于8，所以位置不变。

第一轮结束，数列有序区包含一个元素：

第二轮

元素3和2比较，发现3大于2，所以3和2交换。

元素3和1比较，发现3大于1，所以3和1交换。

元素3和4比较，发现3小于4，所以位置不变。

元素4和5比较，发现4小于5，所以位置不变。

元素5和6比较，发现5小于6，所以位置不变。

元素6和7比较，发现6小于7，所以位置不变。

元素7和8比较，发现7小于8，所以位置不变。

第二轮结束，数列有序区包含两个元素：

按照现有的逻辑，有序区的长度和排序的轮数是相等的。比如第一轮排序过后的有序区长度是1，第二轮排序过后的有序区长度是2 ......

实际上，数列真正的有序区可能会大于这个长度，比如例子中仅仅第二轮，后面5个元素实际都已经属于有序区。因此后面的许多次元素比较是没有意义的。

如何避免这种情况呢？我们可以在每一轮排序的最后，记录下最后一次元素交换的位置，那个位置也就是无序数列的边界，再往后就是有序区了。

按照这里的改进思路，我们写出冒泡排序的（第三版本）代码，在 代码实现 块中的 BubbleSort_3。

代码实现：

//冒泡排序的第一版本代码
void BubbleSort_1(int a[],int n)
{
	int i, j;
	for (i = 0; i < n;++i)  //控制趟数
	for (j = 0; j < n - i - 1; ++j)  //对每轮的冒泡处理
	{
		int tmp = a[j];
		if (a[j] > a[j + 1])
		{
			a[j] = a[j + 1];
			a[j + 1] = tmp;
		}
	}
}

//冒泡排序第二版代码
void BubbleSort_2(int a[], int n)
{
	int i, j,flag;
	for (i = 0; i < n; ++i)
	{
		flag = 0;
		for (j = 0; j < n - i - 1; ++j)
		{
			int tmp = a[j];
			if (a[j] > a[j + 1])
			{
				a[j] = a[j + 1];
				a[j + 1] = tmp;

				flag = 1;
			}
		}
		if (flag == 0)
			break;
	}
}

//冒泡排序第三版代码：
void BubbleSort_3(int a[], int n)
{
	int flag,tmp;
	int lastExchangeIndex = 0;  //用该变量记录最后一次交换的位置
	int sortBorder = n - 1;  	//无序数列的边界，每次比较只需要比到这里为止
	for (int i = 0; i < n; ++i)
	{
		flag = 0;
		for (int j = 0; j < sortBorder; j++)
		{
			if (a[j] > a[j + 1])
			{
				tmp = a[j];
				a[j] = a[j + 1];
				a[j + 1] = tmp;

				flag = 1;
				lastExchangeIndex = j;  //把无序数列的边界更新为最后一次交换元素的位置
			}
		}
		sortBorder = lastExchangeIndex;
		if (flag == 0)
			break;
	}
}