都知道冒泡循环写法  这里就不写了  我想问下 第2个循环中
for (int j=0;j<数组长度.length-i-1   ;j  ++)
里面额 -i我去掉过  输出也是循环 ~~
求高手来解释下为什么~~~   有-i和没有-i什么区别 ？为什么我去掉-i时候也能输出排序

木有人回答呢？？？？？？                   好郁闷

那个区别就大了，因为每一次的内循环次数要受i的值的影响。
其实冒泡排序有多种写法，我一般这样写：

1. for (int i = 0; i < stuArr.Length; i++)
   
2.             {
   
3.                 for (int j = 0; j < stuArr.Length - i - 1; j++)
   
4.                 {
   
5.                     if (stuArr[j].Score < stuArr[j + 1].Score)
   
6.                     {//交换
   
7.                         tempStudent = stuArr[j];
   
8.                         stuArr[j] = stuArr[j + 1];
   
9.                         stuArr[j + 1] = tempStudent;
   
10.                     }
    
11.                 }
    
12.             }

复制代码

这个叫着下沉排序（也是冒泡排序的思想）：

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

复制代码

-i后  进行比较的次数减少了  如果没有减-i  执行内部循环时  还会和已经排好序的元素进行比较  而-i之后就避免了

补充点吧。。。
在排序的过程中始终有两个区域：有序区和无序区，内循环的作用是每一次将“最轻”的元素放到无序区的最上面，然后有序区范围+1、无序区范围-1,这样通过array.length-1次外循环整个数组都有序了，也就是说i的作用是用来控制无序区的范围的，与其说你不明白-i和不减i的区别还不如说你不明白什么叫冒泡排序！

iamheima 发表于 2012-9-15 14:54
补充点吧。。。
在排序的过程中始终有两个区域：有序区和无序区，内循环的作用是每一次将“最轻”的元素放 ...

嗯 虽然我不明白 但是我绝不会不懂装懂 像你这么拿一堆代码来贴上 然后又说一些 跟本和我问的不搭边的 解释  又贴了一个下沉排序 你是在炫耀自己么？？ 你把冒泡排序里面if的< 换成>会发生什么啊 ？ 拿代码唬人~~~  还真有你的

我想外层for(int i=0;i<数组名.length-1;i++)你应该是明白的，那我们就主要分析内层循环。

举一个例子来说明吧：
对3、4、1、5、2、6这六个数进行由大到小冒泡排序。for (int j=0;j<数组名.length-i-1;j++) 这是减 i 的情况
第一次循环后（外层1次）：3、4、5、2、6、1
第二次循环后（外层1次）：3、4、5、6、2、1（这里的2没有和1进行比较）
后面的类似

对3、4、1、5、2、6这六个数进行由大到小冒泡排序。 for (int j=0;j<数组名.length-1;j++) 这是不减 i 的情况
第一次循环后（外层1次）： 3、4、5、2、6、1
第二次循环后（外层1次）：3、4、5、6、2、1（这里的2和1进行了比较）
后面的类似

综上所述：
后一种方法比前一种方法的比较次数更多，这是没有必要的。
因为每次冒泡之后，冒上去的数一定是最小的，那我们剩下的数进行比较的时候显然不用和它们进行比较了。

不-i的话,i的值每自增一次,j就要做一次0到lengh-1的自加循环..  因为前面的顺序已经确立了,这明显是多余的啊

额，我个人觉得区别不大，就是外层每次循环，内层的计算次数多一点而已，现在的计算机硬件，你懂得~
当然能少计算更好不是吗？我一般是背下来这段代码

让数组中的元素两两比较，（第i个与第i+1个比较），进过n(i-1)遍两两比较，
数组中的元素能按照我们预期的规律排序。 要从大到小排序，我们进行两两
比较的时候用<
10，20，30，40，50，60，70 原始数据7个元素
20，30，40，50，60，70，10第一趟比较6次。
30，40，50，60，70，20，10第二趟比较5次。
40，50，60，70，30，20，10第三趟比较4次。
50，60，70，40，30，20，10第四趟比较3次。
60，70，50，40，30，20，10第五趟比较2次。
70，60，50，40，30，20，10第六趟比较1次

也就是n个数需要排n-1趟

第t趟比较的次数为：N-t次

For(inti=0;i<numbers.length-1;i++)//外层控制趟数
{
   For(int j =0;j<numbers.length-1-i;j++)//控制比较
      {
              if(>)
                {
                     
                        交换
                }

           }

   }

苏坤老师的冒泡排序讲得很详细。可以回答你的问题。

iamheima 发表于 2012-9-15 14:54
补充点吧。。。
在排序的过程中始终有两个区域：有序区和无序区，内循环的作用是每一次将“最轻”的元素放 ...

骚年~~太猖狂了~~特来一顶！

我喜欢把i从1开始算，看起来比较爽
for (int i = 1; i <= intArray.Length - 1; i++)
            {
                for (int j = 0; j < intArray.Length - i; j++)
                {