保姆级教学第二弹：手把手教你写冒泡排序及其优化O(n)

冒泡排序

按从小到大排序来讲，其实就是通过一遍遍循环，每一次，都把“最大”的数放到每一次循环的最后位置，待排序数列通过相邻两数比较再进行位置交换。而上一篇文章：选择排序，选择排序其实就是，每一次循环，把“最小”的数放到每一次循环的最前面，待排序数列永远与待排序队列的第一个位置的数进行比较，跳着进行交换（这也是为什么选择排序不稳定的原因）。
冒泡排序核心，也就是比较两个相邻的元素，将值大的元素交换到右边。
tips:

对算法一筹莫展时，可以把算法里固定的功能，分解到方法里。对这个方法起个有意义的名字。然后在编写算法程序时，调用这些方法，会帮助到你更快理解算法。
举个简单的例子，表达一下这个意思，可能不太合适，你们懂就行了。 比如，冒泡和选择排序的固定功能都有个交换,所以你就可以起个名字swap,把那三条语句封装起来，再在算法里直接去调用。

static void swap(int a[], int i, int j) {
	int temp = a[i];
	a[i] = a[i + 1];
	a[i + 1] = temp;
}

弄懂什么是冒泡排序后，开始编写程序。和上篇文章思路一样，如果你无从下手，不知道如何安排内外侧循环，就先从自己会写的开始。

1. 会定义数组吧，给自己个信心，人人都可以写代码滴

int a[] = { 9,3,1,4,6,8,7,5,2 };
int length = sizeof(a) / sizeof(a[0]);

2. 会写第一个数的比较交换吧，进行最开始的第一次遍历，把“最大数”放到“后面”。

for (int i = 0; i < length-1; i++) {
			if (a[i] > a[i + 1]) {
				//封装
				swap(a, i, i + 1);
			}
		}

这样就完成了第一轮的比较交换。

然后，再加个外层循环，控制进行多少轮，内层循环，控制循环比较多少次嘛

for (int j = length - 1; j > 0; j--) { //外层循环，控制进行length-1轮
		for (int i = 0; i < j; i++) {   //内层循环，控制比较多少趟
		if (a[i] > a[i + 1]) {
			/*int temp = a[i];
			a[i] = a[i + 1];
			a[i + 1] = temp;*/
			//封装
			swap(a, i, i + 1);
	}
		}
	}

这样，一个基本的冒泡排序就完成了。他的时间复杂度为O(n^2),最坏情况下。空间复杂度为O(1)。
最好情况下，冒泡排序的时间复杂度是O(n)。
为什么是O(n)呢？
当时是优化过后的冒泡排序算法了。

冒泡排序优化到O(n)

当循环还没有结束，但是待排序数列已经是排好的时候，这时算法还是循环进行一一比较，所以复杂度是O(n^2)。
针对上述情况，设立一个flag，当待排序数组不再发生交换行为时，停止排序。

int main() {
		int a[] = { 9,3,1,4,6,8,7,5,2 };
		int length = sizeof(a) / sizeof(a[0]);
		bool flag;
		for (int i = length - 1; i > 0; i--) {
			flag = false;
			for (int j = 0; j < i; j++) {
				if (a[j] > a[j + 1]) {
					swap(a, j, j + 1);
					flag = true;
				}
			}
			if (!flag)
				break;
		}
		for (auto i : a)
			cout << i << " ";
}

这样，当最好情况，是正序排列的数列时，时间复杂度为O(n).
End.