DSA之十大排序算法第一种：Bubble sort

冒泡排序
说起冒泡排序，作为最简单的排序算法之一，也是我们最为熟悉的排序算法。注：我们这里实现的所有排序算法，统一由小到大 C++实现。

排序步骤就是：

1. 机械地遍历要排序的数列，相邻的两个数据，两两比较。正序则继续向前
2. 发现逆序（前面数据 > 后面数据），则就地交换。完成之后 继续前进（到达数列最后一个元素，不用再进行比较）
3. 重复地进行遍历，直至发现数列中不存在逆序就可以停止
4. 整个过程 较大的元素像一块块大石头一样，沉入水底
   

分析具体实现：

如上图所示（从菜鸟网站“拿”来的）：面对上面的一组数据：

1,50,38,5,47,15,36,26,27,2,46,4,19,44,48

1和50，进行比较：正序则向前
50和之后的数据比较，都会接管控制权 一路下沉，而其他元素一路上浮。最后50就位

那么此时就相当于 继续对数列

1,38,5,47,15,36,26,27,2,46,4,19,44,48       50

进行排序。根据 减而治之 的策略，可以证明其正确性和有穷性。

分析具体算法：

1. 根据上面的动图显示：若是一开始这个数列就是有序的话，那么一趟扫描就可以结束。当然这也是冒泡排序最好的一种情况。其最优时间复杂度O（n）
2. 当然最坏的情况也就不言而喻了，计数列size。则需要size-1趟循环，且每一趟需要进行 size-1-i（0<=i<size -2）此刻总共进行比较的次数就是：（size-1）（size-1+1）/2 。其最差时间复杂度O（n^2）
3. 冒泡排序的过程就是把较大的元素 一个一个向下沉。比较操作是发生在相邻的两个元素，而数据的交换也发生在这两个元素之间。如果两个元素相等，这里也是不用再交换的。经过一段比较交换之后，即使这两个相等的元素相邻了，这个时候也不会交换，所以相同元素的在数列的先后顺序并没有改变，所以冒泡排序是一种稳定排序算法。

算法初始版本：

/* 
外层循环i表示排序的趟数，size个数据需要size-1趟比较
内层循环j表示每趟比较的次数，每趟将最大数排到最后，因此j进行size-1-i次遍历即可
*/
void Bubble_sort1(vector<int>& src)
{
	int size = src.size();
	for (int i = 0; i < size - 1; ++i)
	{
		for (int j = 0; j < size - i - 1; ++j)
		{
			if (src[j] > src[j + 1])
			{
				int temp = src[j];
				src[j] = src[j + 1];
				src[j + 1] = temp;
			}
		}
	}
}

算法优化版本：

如果是对于上面的排序过数列，再次进行排序。程序只需要检查出来这个数组已然有序即可。不必再进行（size-1）（size-1+1）/2次的比较了。因此增加flag标志位，如果发生了数据交换则flag = 假，否则不作变化。进行提前终止，以提高算法的效率。

void Bubble_sort2(vector<int>& src)
{
	int size = src.size();
	for (int i = 0; i < size - 1; ++i)
	{
		int flag = true;//每趟循环开始 默认有序 不需要交换
		for (int j = 0; j < size - i - 1; ++j)
		{
			if (src[j] > src[j + 1])
			{
				int temp = src[j];
				src[j] = src[j + 1];
				src[j + 1] = temp;
				flag = false;//标志为假 还需要排序
			}
		}
		if (flag)
		{
			cout << "已然有序 不需要继续排序" << endl;
			break;//
		}			
	}
}

算法测试打印：

#include <iostream>
#include <vector>
#include <iomanip>
using namespace std;

void Bubble_sort1(vector<int>& src)
{
	int size = src.size();
	for (int i = 0; i < size - 1; ++i)
	{
		for (int j = 0; j < size - i - 1; ++j)
		{
			if (src[j] > src[j + 1])
			{
				int temp = src[j];
				src[j] = src[j + 1];
				src[j + 1] = temp;
			}
		}

		cout << "第" << setw(2) << i + 1 << "次排序后，结果为：";
		for (int k=0;k<=size-1;++k)
		{
			cout << setw(2) << src[k] << " ";
		}
		cout << endl;
	}
}
void Bubble_sort2(vector<int>& src)
{
	int size = src.size();
	for (int i = 0; i < size - 1; ++i)
	{
		int flag = true;//每趟循环开始 默认有序 不需要交换
		for (int j = 0; j < size - i - 1; ++j)
		{
			if (src[j] > src[j + 1])
			{
				int temp = src[j];
				src[j] = src[j + 1];
				src[j + 1] = temp;
				flag = false;//标志为假 还需要排序
			}
		}
		cout << "第" << setw(2) << i + 1 << "次排序后，结果为：";
		for (int k = 0; k <= size - 1; ++k)
		{
			cout << setw(2) << src[k] << " ";
		}
		cout << endl;
		if (flag)
		{
			cout << "已然有序 不需要继续排序" << endl;
			break;//
		}		
	}
}
int main()
{
	int Array[] = { 1,50,38,5,47,15,36,26,27,2,46,4,19,44,48 };
	vector<int>myvec(begin(Array), end(Array));

	Bubble_sort1(myvec);
	cout << "排序结束后，最终结果：";
	for (int val : myvec)
	{
		cout << setw(2) << val << " ";
	}
	cout << endl;
	cout << "*******************************************" << endl;
	vector<int>myvec2(begin(Array), end(Array));
	Bubble_sort2(myvec2);

	cout << "排序结束后，最终结果：";
	for (int val : myvec2)
	{
		cout << setw(2) << val << " ";
	}
	cout << endl;
	return 0;
}

总结：这个数列的15个数据本需14趟比较，使用优化算法后，当第9步结束后，所有数据已经提前排序成功，无需之后的5趟比较，通过flag标志位结束了循环，提高了算法效率。在数据量巨大的时候，改良版明显更好。