1. for (int j = 0; j < nums.Length - 1; j++)
   
2.             {
   
3.                 for (int i = 0; i < nums.Length - 1 -j; i++)
   
4.                 {
   
5.                     if (nums[i] > nums[i + 1])
   
6.                     {
   
7.                         int temp = nums[i];
   
8.                         nums[i] = nums[i + 1];
   
9.                         nums[i + 1] = temp;
   
10.                     }
    
11.                 }
    
12.             }
    

复制代码

1. class java0331d2
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 int [] nums = new int [] {1,9,5,8,7,4,2,6,3};//创建数组 没啥说的
   
6. 
   
7.                 for (int j = 0; j < nums.length - 1; j++)//外圈循环，因为是与相邻的数进行比较 所以循环次数是数组元素数量减一。
   
8.             {
   
9.                 for (int i = 0; i < nums.length - 1 -j; i++)//内圈循环，理由同上。
   
10.                 {
    
11.                     if (nums[i] > nums[i + 1])//用数组中零角标位和相邻的角标位进行比较 所以是+1，如果结果是true就进行if语句里的语句
    
12.                     {
    
13.                         int temp = nums[i];//如果if的条件表达式结果是true就把大角标位的数和小角标位的数对换。
    
14.                         nums[i] = nums[i + 1];
    
15.                         nums[i + 1] = temp;
    
16.                     }
    
17.                 }
    
18.             }
    
19.                         for (int x=0;x<nums.length ;x++ )
    
20.                         {
    
21.                                 System.out.print(nums[x]);//打印出数组里的数
    
22.                         }
    
23.         }
    
24. }

复制代码

先发代码  描述在5楼

这个我可以来帮你解决一下子。。。
加入给你一个随机的待排序的一堆东西，如下:
8,99,7,87,174,156
第一次排序过程:
8,99，7，87，174，456
8，7，99，87，174，456
8，7，87，99，174，456
8，7，87，99，174，456；
第二次排序过程:
8，7，87，99，174，456；
7,8,87,99,174,456
第三次：
8，7，87，99，174，456；
第四次:
7,8,87,99,174,456
第五次:
7,8,87,99,174,456
第六次和第五次一样。
原理就是，每次当前未排序序列中最大的取出来，放到当前未排序序列最后的位置上，每次取一个

外圈是控制比较的次数,
内圈则是控制相邻两元素的比较.
外圈比较一次之后,得到一个最大值.当前面都比完后,最后一个数就不需要比较了,因此j < nums.Length - 1.
内圈是相邻两元素比较,因此有nums[i] > nums[i + 1].

你的代码中  获取数组元素数量的代码写错了  不是大写的L是小写的

你可以把数组想象成一个鱼缸，里面的元素是从下往上排列的  也就是0角标在鱼缸底下最大角标位在紧挨着水面。

水就是小的数  空气就是大的数  从最下开始气泡往上走他和它上面的水进行比较  水是小数所以气泡就向上

水之与和他相邻的数进行比较  我大我就往上 你小你就去下所以冒泡排序第一次就能把数组中的最大值放到最大角标位

这一利用这一点进行进行最大值的选取

冒泡就是第一个和第二个比，如果符合条件。就互换位置，然后第二个和第三个比，第四个和第五个比，以此类推，直到比完为止。最值会出现在最后一位
然后再从头比过，最后一个就不用再比了，反正它都最大或最小了。（不过比了也不碍事）这样每次都比出一个剩下的数中的最值，直到循环完为止

两层for循环： 外层for 控制未排序的元素个数， 里层for 实现将 未排序的元素中最大的数 挪到最后。

比方：5个座位，年长的人坐前面（数组后面），年后的人坐后面（数组前面），现有5个不同年龄的人，要坐这5个座位，可以用冒泡排序来处理。
流程如下：
先问2个人，如果年长的在前面，就不换位置，否则两人换；
再问第二个和第三个人，如果年长的在前面，就不换位置，否则两人换；
......
问完一轮，年长的就在最前面，肯定是坐对位置了；
再对剩下4人，按上面的过程问一遍，次长的人也肯定坐对位置了；
......
如此往复，每个人都坐对位置，OK

冒泡排序算法的运作：
1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
冒泡排序的过程图：

同意邵震     的~~~。学习了

刘焕新 发表于 2013-3-31 20:17

不要乱刷屏嘛！！

比如 10，20，30，40进行从大到小比较（只要前者〈后者，就互换位置），最简单的四个元素进行比较
20，30，40，10第1趟，比较3次
30，40，20，10，第2趟，比较2次
40，30，20，10第3趟，比较1次
假如有n个元素，就需要排n-1趟，第t趟就比较n-t次
i=0,第一趟，i=1,第二趟，如此类推，t=i+1，
如下：
int[]score={10,20,90,40,50,60,79,80};
            for (int i = 0; i < score.Length-1; i++)
            {
                for(int j=0;j<score.Length-1-i;j++)
                {
                    if (score[j] <score[j+1])
                    {
                      int  temp = score[j];
                        score[j] = score[j + 1];
                        score[j + 1] = temp;
                        
                    }
                }
            }
            for (int i = 0; i < score.Length; i++)
            {
                Console.WriteLine(score[i]);
            }
            Console.ReadKey();