（一）排序 —— 2. 冒泡排序

2. 邻居好说话——冒泡排序

2.1 简化版桶排序的缺点

现在分别有 5 个人的名字和分数:huhu 5 分、haha 3 分、xixi 5 分、hengheng 2 分和 gaoshou 8 分。请按照分数从高到低，输出他们的名字。

即，应该输出 gaoshou、huhu、xixi、haha、hengheng。

如果使用前一小节简化版的桶排序算法仅仅是把分数进行了排序。最终输出的也仅仅是分数，但没有对人本身进行排序。

也就是说，现在并不知道排序后的分数原本对应着哪一个人!

桶排序不仅有上述问题，更要命的是：它非常浪费空间！

2.2 冒泡排序的基本思想

思路：
每次比较两个相邻的元素，如果它们的顺序错误就把它们交换过来。

例如，需要将 12 35 99 18 76 这 5 个数进行从大到小的排序，也就是说越小的越靠后。

首先比较第1位和第2位的大小，现在第1位是12，第2位是35。发现12比35要小，因此需要交换这两个数的位置。

以此类推，4 次比较之后 5 个数的顺序是 35 99 18 76 12。

经过 4 次比较后，最小的一个数已经就位。每将一个数归位，将其称为**“一趟”**。

下面将继续重复刚才的过程，将剩下的 4 个数一一归位。

原理：
每一趟只能确定将一个数归位。

即，第一趟只能确定将末位上的数(即第 5 位)归位，第二趟只能将倒数第 2 位上的数(即第 4 位)归位，以此类推。

总结一下：

如果有 n 个数进行排序，只需将 n-1 个数归位，也就是说要进行 n-1 趟操作。

而“每一趟”都需要从第 1 位开始进行相邻两个数的比较，将较小的一个数放在后面，比较完毕后向后挪一位继续比较下面两个相邻数的大小，重复此步骤，直到最后一 个尚未归位的数，已经归位的数则无需再进行比较。

2.2 冒泡排序的代码实现

#include <stdio.h>

int main() {
	int a[100], i, j, t, n;
	scanf("%d", &n); //输入一个数n，表示接下来有n个数
	for (i=1; i<=n; i++) //循环读入n个数到数组a中
	{
		scanf("%d", &a[i]); 
	}
	for (i=1; i<=n-1; i++) //n个数排序，只用进行n-1趟
	{
		for (j=1; j<=n-i; j++) //从第1位开始比较直到最后一个尚未归位的数
		{
			if (a[j] < a[j+1]) //比较大小并交换
			{
				t = a[j]; a[j]=a[j+1]; a[j+1]=t;
			}
		}
	}
	for (i=1; i<=n; i++) //输出结果
	{
		printf("%d", a[i]);
	}
	getchar(); getchar();
	return 0;
}

输入数据：
10
8 100 50 22 15 6 1 1000 999 0

返回值：
0 1 6 8 15 22 50 100 999 1000

用于解决上述第一节遗留问题的冒泡排序实现：

#include <stdio.h>

struct student {
    char name[21];
    char score;
};

int main() {
    struct student a[100], t;
    int i, j, n;
    scanf("%d", &n);
    for (i=1; i<=n; i++) {
        scanf("%s %d", a[i].name, &a[i].score);
    }
    for (i=1; i<=n-1; i++) {
        for (j=1; j<=n-i; j++) {
            if (a[j].score < a[j+1].score) {
                t = a[j]; a[j] = a[j+1]; a[j+1] = t;
            }
        }
    }
    for (i=1; i<=n; i++) {
        printf("%s\n", a[i].name);
    }
    getchar();getchar();
    return 0;
}

输入数据：5
huhu 5
haha 3
xixi 5
hengheng 2
gaoshou 8

返回值：
gaoshou
huhu
xixi
haha
hengheng

2.3 冒泡排序的时间复杂度

冒泡排序的核心部分是双重嵌套循环。

冒泡排序的时间复杂度是 $O(N^2)$。

参考

《啊哈！算法》 —— 第1章 一大波数正在靠近——排序