C#--冒泡排序

冒泡排序是计算机程序设计中的一种排序方式。

冒泡排序的过程就像它的名字一样，我们把较小的数比作气泡，排序的过程就像是气泡不断向上冒的过程，越小的数冒的越高。

冒泡排序是从最底层的元素开始，用它和它紧挨着的上一个元素比较，如果下面的元素小于上面的元素，就交换他们，否则保持

原样。重复上面的操作……

我们举一个例子，简单的了解一下冒泡排序的过程。

Code:

1. public class Demo   
2. {   
3.              public static void main(String args [])   
4.              {   
5.                              
6.                            //我们声明一个数组，来接受一组成绩   
7.                           int [] socre = new int[5]{88,89,67,94,98};   
8.                            //声明两个整型变量,以控制我们的循环   
9.                           int i,j;   
10.                           //声明一个临时变量   
11.                           int temp;   
12.                              
13.                           //开始排序  -----使用冒泡排序   
14.                          for(i = 0;i < score.length - 1;i ++)   
15.                          {   
16.                                      for(j = 0;j < score.length - i - 1;j ++)   
17.                                     {   
18.                                                if(score[j] > score[j + 1])   
19.                                               {   
20.                                                        //交换元素   
21.                                                         temp = socre[j];   
22.                                                         score[j] = score[j + 1];   
23.                                                         score[j + 1] = temp;                                               }   
24.                                     }   
25.                          }   
26.   
27.                             //重新打印出来   
28.                          for(int i = 0;i < score.length;i ++)   
29.                          {   
30.                              Console.WriteLine(score[i].ToString());   
31.                          }   
32.                              
33.                         
34.             }   
35. }  

我们从数组的第一位数开始，将当前元素同它后面的元素进行比较，每一轮比较都找到一个比较大的数放到数组的后面。也就是

说，大的气泡向后冒，外层循环控制比较多少轮，内层循环控制比较多少次。程序的关键是确定外层循环和内层循环的循环变量

的初始值和终止条件。

我们现在来一起走一遍:

当i = 0时，是第一轮比较，数组中的所有元素都参与比较。首先score[0]与score[1]比较，然后score[1]与score[2]比较，之后score[2]

与score[3]比较，最后score[3]与score[4]比较，每次比较都把大的数放到数组的后面，这样一轮下来，最大数就到了score[4]中。

当i = 1时,因为score[4]已经是最大的数了，所以没必要再参与比较了。那么就比较到score[3]，一轮下来，第二大的数交换到了

score[3];这一轮就比较了3次。

当i = 2时，score[3]的数就不用比较了，只需要比较到score[2],这一轮就比较了2次。

当i = 3时，score[2]的数不参与比较，只需要比较score[0]和score[1]这一次。

经过这4次比较后，所有的元素就从小到排好顺序了，你看出规律了吗？外层循环i 从0变化到3，也就是说外层循环的条件是i < 4,

而4也就是数组的长度 - 1。当i从0变化到3时，内层循环中的次数从4变到了1，也就是说j < 4-i,所以内层循环的终止条件是

j < 数组长度 - i - 1。

我们可以总结一个经验:

N个数字来排队，两两相比小靠前。

外层循环N-1,内层循环N - i - 1

如果要降序排序，只要把程序中的大于号换成小于号就行了。