在開發中，對一組數據進行有序地排列是經常需要做的事情，所以掌握幾種甚至更多的排序算法是絕對有必要的

這裏要介紹的是排序算法中較簡單的一種算法：冒泡排序。

先嘗試用最簡單的想法去實現排序，以此來比較學習冒泡排序

設有一數組，其大小為10個元素（int str[10]）數組內的數據是無序。現在要求我們通過編程將這個無序的數組變成一個從小到大排序的數組（從下標為0開始） 。

按照題目的要求，毫無疑問，正確的結果應該就像這樣： 1 2 3 4 5 6 7 8 9 10 要做到這樣，最簡單和最直接想到的方法就是進行對比交換。

• 首先，把10個數裏最小的個數放到下標為0的位置上（
  str[0]）
• 通過將下標為0的數（str[0]）與剩下其余9個數進行對比交換（將較少者放置在下標為0的位置上），就可以得到這10個數最小的那個
• 10個數最小的那位確定後，接下來就要找剩下9個數最小的那個。
• 因為已經確定出一個最小的數，所以就不要動str[0]，直接從str[1]開始，與剩下的8個數對比交換，找出9個數中最小的那位放到下標為1（str[1]）的位置上
• 繼續按照這個思路就可以將這十個數變成有序的（從小到大）的數組。

代碼：

1. #include <stdio.h>
3. void swap(int *a, int *b); //交換兩個數
5. int main()
6. {
7. int
   str[10];
8. int i, j;
9. //初始化數組為10 9 8 7 6 5 4 3 2 1
10. for (i = 0; i < 10; i++)
11. {
12. str[i] = 10 - i;
13. }
14. //排序，從a[0]開始排，從小到大
15. for (i = 0; i < 10; i++)
16. {
17. for (j = i + 1; j < 10; j++)
18. {
19. if (str[i] > str[j])
20. {
21. swap(&str[i], &str[j]);
22. }
23. }
24. }
25. //將十個數輸出
26. for (i = 0; i < 10; i++)
27. printf("%d\n", str[i]);
28. return 0;
29. }
30. void swap(int *a, int *b)
31. {
32. int c;
33. c = *a;
34. *a = *b;
35. *b = c;
36. }

這個方法是比較容易想到的實現方法。但存在不足：就是本來位於前面的較小數被交換到後面。

例如：

開始：9 4 5 6 8 3 2 7 10 1 （下標從左到右分別是0~9）按照上面的程序進行對比交換

第一次：4 9 5 6 8 3 2 7 10 1

第二次：4 9 5 6 8 3 2 7 10 1

。。。：（沒有交換）

第五次：3 9 5 6 8 4 2 7 10 1

第六次：2 9 5 6 8 3 4 7 10 1

。。。：（沒有交換）

第十次：1 9 5 6 8 3 4 7 10 2

可以看出，原來較小的數是在前面的，經過一輪的交換後放到後面了

那麽怎樣解決這個不足呢？可以使用冒泡排序。

什麽是冒泡排序呢？

你可以這樣理解：（從小到大排序）存在10個不同大小的氣泡，由底至上地把較少的氣泡逐步地向上升，這樣經過遍歷一次後，最小的氣泡就會被上升到頂（下標為0），然後再從底至上地這樣升，循環直至十個氣泡大小有序。

在冒泡排序中，最重要的思想是兩兩比較，將兩者較少的升上去 。

代碼：

1. #include <stdio.h>
2. void swap(int *a, int *b);
3. int main()
4. {
5. int array[10] = {15, 225, 34, 42, 52, 6, 7856, 865, 954, 10};
6. int i, j;
7. for (i = 0; i < 10; i++)
8. {
9. //每一次由底至上地上升
10. for (j = 9; j > i; j--)
11. {
12. if (array[j] < array[j-1])
13. {
14. swap(&array[j], &array[j-1]);
15. }
16. }
17. }
18. for (i = 0; i < 10; i++)
19. {
20. printf("%d\n", array[i]);
21. }
22. return 0;
23. }
24. void swap(int *a, int *b)
25. {
26. int temp;
27. temp = *a;
28. *a = *b;
29. *b = temp;
30. }

冒泡排序算法只會將較少的逐步向上推，不會造成文章前面所說的不足。

javascript中的冒泡排序法