C++实现冒泡排序

Bubble Sort 即冒泡排序

这种算法相当于相邻的数字两两比较，并且规定：“谁大谁站右边”。经过 n−1 轮，数字就从小到大排序完成了。整个过程看起来就像一个个气泡不断上浮，这也是“冒泡排序法”名字的由来，先来理解算法思想：

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

3. 针对所有的元素重复以上的步骤，除了最后一个。

4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 

代码：

#include <iostream>
using namespace std;
const int INIT = 10;
class Bubble {
public:
	void bubble(int arr[],int n) {
	
		for (int i = 0; i < n-1; i++)
		{
			for (int j = 0; j < n - 1 - i; j++) {
				if (arr[j] > arr[j + 1]) {
					//左大右小，则交换，保持始终右边最大
					int tmp = arr[j];//tmp暂存大值
					arr[j] = arr[j+1];
					arr[j+1] = tmp;
				}
			}
		}
	}
};
int main()
{
	Bubble b1;
	int n = 0;
	int arr[INIT];
	cout << "Input n=";
	cin >> n;
	for (int i = 0; i < n; i++)
		//依次输入元素
		cin >> arr[i];

    b1.bubble(arr,n);
	for (int j= 0; j < n; j++)
		cout << arr[j] <<"	";
	return 0;
}

测试用例：

输入 n=5  并依次输入5 4 3 2 1

运行截图如下：

冒泡排序算法优化：

最外层的 for 循环每经过一轮，剩余数字中的最大值仍然是被移动到当前轮次的最后一位。这种写法相对于第一种写法的优点是：如果一轮比较中没有发生过交换，则立即停止排序，因为此时剩余数字一定已经有序了。

看下动图演示：

#include <iostream>
using namespace std;
const int INIT = 10;
class Bubble {
public:
	void bubble(int arr[], int n) {

		for (int i = 0; i < n - 1; i++)
		{
			for (int j = 0; j < n - 1 - i; j++) {
				if (arr[j] > arr[j + 1]) {
					//左大右小，则交换，保持始终右边最大
					int tmp = arr[j];//tmp暂存大值
					arr[j] = arr[j + 1];
					arr[j + 1] = tmp;
				}
			}
		}
	}
	void BubbleSort(int arr[], int n)
	{
		int i = 0;
		int tmp = 0;
		for (i = 0; i < n - 1; i++)//确定排序趟数
		{
			int j = 0;
			int flag = 0;
			for (j = 0; j < n - 1 - i; j++)//确定比较次数
			{
				if (arr[j] > arr[j + 1])
				{
					//交换
					tmp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = tmp;
					flag = 1;   // 置1，表示发生了交换
				}
			}
			if (flag == 0)//如果没有交换过元素，则已经有序
			{
				 break;
			}
		}
	}
};
int main()
{
	Bubble b1;
	int n = 0;
	int arr[INIT];
	cout << "Input n=";
	cin >> n;
	for (int i = 0; i < n; i++)
		//依次输入元素
		cin >> arr[i];

	b1.BubbleSort(arr, n);
	for (int j = 0; j < n; j++)
		cout << arr[j] << "	";
	return 0;
}

测试用例：

输入 n=5  并依次输入2 3 5 6 4

运行截图如下：

时间复杂度 & 空间复杂度

冒泡排序从 1956 年就有人开始研究，之后经历过多次优化。它的空间复杂度为O(1)，时间复杂度为 O(n^2)，第二种冒泡排序由于经过优化，最好的情况下只需要 O(n) 的时间复杂度。

最好情况：在数组已经有序的情况下，只需遍历一次，由于没有发生交换，排序结束。

最差情况：数组顺序为逆序，每次比较都会发生交换。

正如 Donald E. Knuth（19741974 年图灵奖获得者）所言：“冒泡排序法除了它迷人的名字和导致了某些有趣的理论问题这一事实外，似乎没有什么值得推荐的。”