冒泡排序

void bubbleSort_1(int k[], int n) {
	int i, j, temp;
	for (i = 0; i < n; i++) {
		for (j = i + 1; j < n; j++) {
			if (k[i] > k[j]) {
				temp = k[i];
				k[i] = k[j];
				k[j] = temp;
			}
		}
	}
}

这种方式的比较流程是:

下标	Value	Value 第一趟	Value 第二趟
0	2	0	0
1	3	3	1
2	5	5	5
3	1	2	3
4	0	1	2
5	4	4	4
6	9	9	9
7	8	8	8
8	7	7	7
9	6	6	6

第0个和第1个比较,如果大,进行交换
再用第0个和第2个比较,如果大,进行交换,以此类推,直到第0个数是最小值.
然后进行第1个和第2个比较,再和第3个比较,以此类推
…
但是冒泡排序的定义是依次比较两个相邻的元素,上面一种方式不是依次比较两个相邻的元素,所以不应该是严格意义上的冒泡排序
严格意义上的冒泡排序:

void bubbleSort_2(int k[], int n) {
	int i, j, temp;
	for (i = 0; i < n - 1; i++) {
		for (j = n - 1; j > i; j--) {
			if (k[j - 1] > k[j]) {
				temp = k[j - 1];
				k[j - 1] = k[j];
				k[j] = temp;
			}
		}
	}
}

比较流程是:

下标	Value	Value 第一趟	Value 第二趟
0	2	0	0
1	3	2	1
2	5	3	2
3	1	5	3
4	0	1	5
5	4	4	4
6	9	6	6
7	8	9	7
8	7	8	9
9	6	7	8

第n-1个和第n-2个比较,如果小,进行交换
再用第n-2个和n-3个比较,如果小,进行交换,依次类推,直到第0个数是最小的为止
然后依据这个方法,找到第二小的数,以此类推
…
和上述方法相比,都可以正确排序,时间复杂度都为o(n²)
但是第二种方法可以有改进的方式,增加"哨兵":

void bubbleSort_3(int k[], int n) {
	int i, j, temp, flag;
	flag = 1;
	for (i = 0; i < n - 1 && flag; i++) {
		for (j = n - 1; j > i; j--) {
			flag = 0;
			if (k[j - 1] > k[j]) {
				temp = k[j - 1];
				k[j - 1] = k[j];
				k[j] = temp;
				
				flag = 1;
			}
		}
	}
}