冒泡排序的改进

冒泡排序简单的说就是每轮逐次比较并交换，排一个最小/大的元素到队尾，总共n-1轮。
常规的冒泡排序很简单，原理不赘述，两层for完事：

#include<bits/stdc++.h>
using namespace std;

int main()
{
	int n; cin >> n;
	vector<int> arr(n);
	for (int i = 0; i < arr.size(); i++)
		cin >> arr[i];		//冒泡排序：
	for (int turn = 1; turn < arr.size(); turn++) {
		for (int i = 0; i < arr.size() - turn; i++)
			if (arr[i] < arr[i + 1])
			{
				int temp = arr[i];
				arr[i] = arr[i + 1];
				arr[i + 1] = temp;
			}

		cout << "第" << turn << "轮:";
		for (int i = 0; i < arr.size(); i++)
		{
			cout << arr[i] << " ";
		}
		cout << "比较次数：" << arr.size() - turn << endl;
	}
	system("pause");
    return 0;
}

复杂度为o(n^2)，(n-1)+(n-2)+…+2+1

但是常规的冒泡排序有两个缺点：

1.若第turn轮结束，从第i个元素开始，之后没有发生交换，即第i个元素之后已经有序，但是之后的每轮排序依然会比较第i个元素之后的元素。
比如降序排：4 5 6 3 2 1

第一轮排序时，从3开始，之后的元素3 2 1并没有发生交换，这也意味着从第三个元素4开始已经有序了，那么之后再对4 3 2 1进行比较就没有意义了。
为什么是第三个元素4不是第四个元素3？因为对于前三个元素来说已经做了一轮小的冒泡排序，4已经是这三个元素中最小的，之后再做排序也不能改变4的位置，因此从4开始已经有序，之后的排序不需要再考虑4 3 2 1。

2.若第turn轮结束数组已经有序，程序会继续运行导致时间浪费
仍然是上面的例子

第二轮结束后已经有序，后面的轮次（3-5）浪费了，且第二轮只交换了第一个和第二个元素

改进：
针对缺点一，我们不妨每轮结束后改变下一轮比较的次数，即改变下一次for循环的次数，定义一个len，每轮结束后len为最后一次发生交换的元素的下标（两个交换元素的前者）
针对缺点二，每轮结束后记录最后一次做交换的元素下标，即定义一个index，每次发生交换都发生改变，值为发生交换的元素的下标（两个交换元素的前者）

代码：

#include<bits/stdc++.h>
using namespace std;

void bubble(vector<int> &arr)
{
	int len = arr.size() - 1; //第一轮比较的次数
	int index = 0; //记录最后一次比较的元素下标（两个比较元素的前者）
	//如果每轮结束后index不为0，那么需要排arr.size() - 1轮，index不为0代表：每轮都有第二个元素之后的交换
	for (int turn = 1; turn < arr.size(); turn++) {
		index = 0;
		for (int i = 0; i < len; i++)
			if (arr[i] < arr[i + 1])
			{
				int temp = arr[i];
				arr[i] = arr[i + 1];
				arr[i + 1] = temp;
				index = i;
			}

		cout << "第"<<turn<<"轮:";
		for (int i = 0; i < arr.size(); i++)
		{
			cout << arr[i] << " ";
		}
		cout <<"比较次数："<<len<< endl;

		len = index; //本轮最后一次交换的下标就是下一轮交换的长度，也就是说后面没交换的已经有序
		if (index == 0) //如果没有交换或者只交换了第一个和第二个元素，那么该数组已经有序
			return;
	}
}

int main()
{
	int n; cin >> n;
	vector<int> arr(n);
	for (int i = 0; i < arr.size(); i++)
		cin >> arr[i];
	bubble(arr);
	system("pause");
	return 0;
}

再来运行一下上面的例子：

本来第二轮比较4次，总共5轮，5+4+3+2+1=15次，现在只有5+1=6次

完全无序的例子：

像这种完全无序的例子，该代码仍然做到了优化，避免了多余的比较和多余的轮次，虽然只少了一轮和一次比较。
完美的冒泡！