冒泡排序是所有排序算法中最簡單、最易實現的算法，有時也稱為起泡排序算法。

使用冒泡排序算法對 n 個數據進行排序，實現思路是：從待排序序列中找出一個最大值或最小值，這樣的操作執行 n-1 次，最終就可以得到一個有序序列。

舉個例子，對 {14, 33, 27, 35, 10} 序列進行升序排序（由小到大排序），冒泡排序算法的實現過程是：

● 從 {14, 33, 27, 35, 10} 中找到最大值 35；

● 從 {14,33,27,10} 中找到最大值 33；

● 從 {14, 27, 10} 中找到最大值 27；

● 從 {14, 10} 中找到最大值 14；

由此，我們就得到了一個有序序列 {10, 14, 27, 33, 35}。

那么，如何從待排序序列中找到最大（或最小）的值呢？以找最大值為例，遍歷待排序序列，過程中不斷地比較相鄰兩個元素的值，如果后者比前者的值小就交換它們的位置。遍歷完成后，最后一個元素就是當前待排序序列中最大的。

例如，從 {14, 33, 27, 35, 10} 中找到最大值 35 的過程如下：

1) 比較 14 和 33 的大小，顯然后者更大，不需要交換它們的位置，序列不發生改變。

2) 比較 33 和 27 的大小，前者大于后者，交換它們的位置，新的序列如下圖所示。

3) 比較 33 和 35 的大小，后者更大，不需要交換它們的位置，序列不發生改變。

4) 比較 35 和 10 的大小，前者大于后者，交換它們的位置，新的序列如下圖所示。

可以看到，序列中值最大的元素 35 被移動到了序列的末尾。整個查找最大值的過程中，最大的元素就像水里的氣泡一樣，一點一點地“冒”了出來，這也是將該算法命名為冒泡排序算法的原因。

采用同樣的方法，我們可以很輕松地從 {14, 27, 33, 10} 中找到最大值 33。找到 33 后的新序列為：

從 {14, 27, 10} 中找到最大值 27 后，新的序列如下圖所示：

從 {14, 10} 中找到最大值 14 后，新的序列如下圖所示：

所有比 10 大的數都被一一找到，所以 10 必然是最小的數，這也是為什么“對 n 個數據進行排序，找最大值的過程只重復 n-1 次”的原因。

冒泡排序算法的具體實現

如下是冒泡排序算法實現升序排序的偽代碼：

Bubble_sort(list): // list 表示待排序序列
		for i <- 0 to length(list)-1: // 對于元素個數為 n 的 list 序列，需遍歷 n-1 次，這里用 [0,length(list)-1) 表示。
		for j <- 1 to length(list) - i: // 從第 1 個元素開始遍歷，遍歷區間為 [1,length(list)-i)。
		if list[j] > list[j+1]: // 若進行降序排序，則改成 < 小于號
			swap(list[j] , list[j+1]) // 交換 2 個相鄰元素的位置
	return list // 返回排好序的序列

————————————

根據偽代碼，冒泡排序算法的時間復雜度為O(n2)。

如下是用冒泡排序算法對 {14, 33, 27, 35, 10} 完成升序排序的 C 語言程序：

#include<stdio.h>
#define N 5 //設定待排序序列中的元素個數
//實現冒泡升序排序算法的函數，list[N] 為待排序數組
void Bubble_sort(int list[N]) {
	int i, j;
	int temp = 0;
	// N 個元素，遍歷 N-1 次
		for (i = 0; i < N - 1; i++) {
		// 從第 1 個元素開始遍歷，遍歷至 N-1-i
		for (j = 0; j < N - 1 - i; j++) {
		//比較 list[j] 和 list[j+1] 的大小
		if (list[j] > list[j + 1]) {
		//交換 2 個元素的位置
			temp = list[j];
			list[j] = list[j + 1];
			list[j + 1] = temp;
			}
		}
	}
}
	int main() {
	int i = 0;
	int list[N] = { 14,33,27,35,10 };
			Bubble_sort(list);
			//輸出已排好序的序列
			for (i = 0; i < N; i++) {
			printf("%d ", list[i]);
		}
	return 0;
}

—————————

程序的輸出結果為：