简化版的桶排序不仅仅有遗留的问题，更要命的是：它非常浪费空间。现在我们来学习另一种新的排序算法：冒泡排序。它可以很好地解决这两个问题。
冒泡排序的基本思想是：每次比较两个相邻的元素，如果它们的顺序错误就把它们交换过来。

输入输出

[Input Example]

  1. 10
  2. 8 100 50 22 15 6 1 1000 999 0

[Output Example]

  1. 1000 999 100 50 22 15 8 6 1 0

解析

例如我们需要将12 35 99 18 76 这5 个数进行从大到小的排序。既然是从大到小排序，也就是说越小的越靠后。
首先比较第1位和第2位的大小，现在第1位是12，第2位是35。发现12 比35 要小，因为我们希望越小越靠后嘛，因此需要交换这两个数的位置。交换之后这5个数的顺序是35 12 99 18 76。
按照刚才的方法，继续比较第2位和第3位的大小，第2位是12，第3位是99。12 比99 要小，因此需要交换这两个数的位置。交换之后这5个数的顺序是35 99 12 18 76。
根据刚才的规则，继续比较第3位和第4位的大小，如果第3位比第4位小，则交换位置。交换之后这5个数的顺序是35 99 18 12 76。
最后，比较第4位和第5位。4次比较之后5个数的顺序是35 99 18 76 12。
经过4次比较后我们发现最小的一个数已经就位（已经在最后一位，请注意12 这个数的移动过程），是不是很神奇。现在再来回忆一下刚才比较的过程。每次都是比较相邻的两个数，如果后面的数比前面的数大，则交换这两个数的位置。一直比较下去直到最后两个数比较完毕后，最小的数就在最后一个了。就如同是一个气泡，一步一步往后“翻滚”，直到最后一位。所以这个排序的方法有一个很好听的名字“冒泡排序”。
image.png
现在开始“第二趟”，目标是将第2小的数归位。首先还是先比较第1位和第2位，如果第1位比第2位小，则交换位置。交换之后这5个数的顺序是99 35 18 76 12。接下来依次比较第2位和第3位，第3位和第4位。注意此时已经不需要再比较第4位和第5位。因为在第一趟结束后已经可以确定第5位上放的是最小的了。第二趟结束之后这5个数的顺序是99 35 76 18 12。

“第三趟”也是一样的。第三趟之后这5 个数的顺序是99 76 35 18 12。
现在到了最后一趟“第四趟”。有的同学又要问了，这不是已经排好了吗？还要继续？当然，这里纯属巧合，你若用别的数试一试可能就不是了。你能找出这样的数据样例来吗？请试一试。
“冒泡排序”的原理是：每一趟只能确定将一个数归位。即第一趟只能确定将末位上的数（即第5 位）归位，第二趟只能将倒数第2位上的数（即第4位）归位，第三趟只能将倒数第3位上的数（即第3 位）归位，而现在前面还有两个位置上的数没有归位，因此我们仍然需要进行“第四趟”。

“第四趟”只需要比较第1位和第2位的大小。因为后面三个位置上的数归位了，现在第1位是99，第2位是76，无需交换。这5个数的顺序不变仍然是99 76 35 18 12。到此排序完美结束了，5个数已经有4个数归位，那最后一个数也只能放在第1位了。

最后我们总结一下：如果有n 个数进行排序，只需将n-1 个数归位，也就是说要进行n-1 趟操作。而“每一趟”都需要从第1 位开始进行相邻两个数的比较，将较小的一个数放在后面，比较完毕后向后挪一位继续比较下面两个相邻数的大小，重复此步骤，直到最后一个尚未归位的数，已经归位的数则无需再进行比较。

Solution

  1. import java.util.Scanner;
  3. public class Bubble_Sort {
  4.     static int N;
  5.     static int[] a;
  7.     public static void main(String[] args) {
  8.         Scanner sc = new Scanner(System.in);
  9.         N = sc.nextInt();
  10.         a = new int[N];
  12.         for(int i=0; i<N; i++)
  13.             a[i] = sc.nextInt();
  14.         sc.close();
  16.         for(int i=0; i<N-1; i++) {            //n个数排序，只用进行n-1趟
  17.             for(int j=0; j<N-i-1; j++) {    //从第1位开始比较直到最后一个尚未归位的数
  18.                 if(a[j] < a[j+1]) {
  19.                     int temp = a[j];
  20.                     a[j] = a[j+1];
  21.                     a[j+1] = temp;
  22.                 }
  23.             }
  24.         }
  26.         for(int i=0; i<N; i++)
  27.             System.out.print(a[i] + " ");
  28.     }
  29. }
  1. #include <stdio.h>
  2. int main() {
  3.     int a[100];
  4.     int N;
  5.     scanf("%d", &N);
  6.     for(int i=0; i<N; i++)
  7.         scanf("%d", &a[i]);
  9.     for(int i=0; i<N-1; i++) {
  10.         for(int j=0; j<N-i-1; j++) {
  11.             if(a[j] < a[j+1]) {
  12.                 int temp = a[j];
  13.                 a[j] = a[j+1];
  14.                 a[j+1] = temp;
  15.             }
  16.         }
  17.     }
  19.     for(int i=0; i<N; i++)
  20.         printf("%d ", a[i]);
  22.     getchar();getchar();
  23.     return 0;
  24. }

将上面代码稍加修改，就可以解决桶排序遗留的问题

输入输出

[Input Example]

  1. 5
  2. huhu 5
  3. haha 3
  4. xixi 5
  5. hengheng 2
  6. gaoshou 8

[Output Example]

  1. gaoshou
  2. huhu
  3. xixi
  4. haha
  5. hengheng

Solution

  1. import java.util.Scanner;
  3. public class Bubble_Sort {
  4.     static int N;
  5.     static int[] score;
  6.     static String[] name;
  8.     public static void main(String[] args) {
  9.         Scanner sc = new Scanner(System.in);
  10.         N = sc.nextInt();
  11.         name = new String[N];
  12.         score = new int[N];
  14.         for(int i=0; i<N; i++){
  15.             name[i] = sc.next();
  16.             score[i] = sc.nextInt();
  17.         }
  18.         sc.close();
  20.         for(int i=0; i<N-1; i++) {            //n个数排序，只用进行n-1趟
  21.             for(int j=0; j<N-i-1; j++) {    //从第1位开始比较直到最后一个尚未归位的数
  22.                 if(score[j] < score[j+1]) {
  23.                     int temp_score = score[j];
  24.                     score[j] = score[j+1];
  25.                     score[j+1] = temp_score;
  27.                     //注意String的深拷贝问题
  28.                     String temp_name = "";
  29.                     for(int k=0; k<name[j].length(); k++)
  30.                         temp_name += name[j].charAt(k);
  31.                     name[j] = "";
  32.                     for(int k=0; k<name[j+1].length(); k++)
  33.                         name[j] += name[j+1].charAt(k);
  34.                     name[j+1] = "";
  35.                     for(int k=0; k<temp_name.length(); k++)
  36.                         name[j+1] += temp_name.charAt(k);
  37.                 }
  38.             }
  39.         }
  41.         for(int i=0; i<N; i++)
  42.             System.out.println(name[i].toString());
  43.     }
  44. }

问题

冒泡排序的时间复杂度是O(N^2)。这是一个非常高的时间复杂度。