1. class A5 {
   
2.         public static void main(String[] args) {
   
3.                 int[] arr = { 1, 5, 2, 6, 3 };
   
4.                 for (int i = 0; i < arr.length; i++) {
   
5.                         for (int j = 0; j < arr.length-i-1; j++) {
   
6.                                 if (arr[j]>arr[j+1]) {
   
7.                                         int temp=arr[j];
   
8.                                         arr[j]=arr[j+1];
   
9.                                         arr[j+1]=temp;
   
10.                                 }
    
11.                         }
    
12.                         System.out.print(arr[i]);
    
13.                 }
    
14. 
    
15.         }
    
16. }

复制代码

1. class A5
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 int[] arr = { 1, 5, 2, 6, 3 };
   
6.                 for (int i = 0; i < arr.length; i++)
   
7.                 {
   
8.                         for (int j = 0; j < arr.length - i - 1; j++)
   
9.                         {
   
10.                                 if (arr[j] > arr[j + 1]) // 如果不减1, i = 0的时候, j 最大值能取 arr.length-1,
    
11.                                 {                        // if (arr[j] > arr[j + 1]) 这里的 arr[j+1] 加1之后 角标 =arr.length ; 角标越界,出错
    
12.                                         int temp = arr[j];
    
13.                                         arr[j] = arr[j + 1];
    
14.                                         arr[j + 1] = temp;
    
15.                                 }
    
16.                         }
    
17.                         System.out.print(arr[i]);
    
18.                 }
    
19.         }
    
20. }

复制代码

class A5 {
        public static void main(String[] args) {
                int[] arr = { 1, 5, 2, 6, 3 };
                for (int i = 0; i < arr.length; i++) {
                         //内循环j<arr.length-i-1,,,
                       //减1是因为下面会判断arr[j+1],防止下标越界,,这样相当于循环判断条件是j+1<arr.length
                       //减i是因为每循环一次,都可以少判断一个数,
                       //比如每比较一次都把大的数往后换位,那么第一轮循环完,数组的最后一个位置上肯定是最大的数,下一轮就不用再比较它,内循环就可以少循环一次.,这个次数就是用-i来控制
                        for (int j = 0; j < arr.length-i-1; j++) {
                                if (arr[j]>arr[j+1]) {
                                        int temp=arr[j];
                                        arr[j]=arr[j+1];
                                        arr[j+1]=temp;
                                }
                        }
                        System.out.print(arr[i]);
                }

        }
}

建议第一个for语句也-1。因为最后一个数不需要比较，可以提高点效率。第二个for语句-1是因为后面有个j+1.这样就不会越界了

D.reamJA 发表于 2014-10-18 20:19
建议第一个for语句也-1。因为最后一个数不需要比较，可以提高点效率。第二个for语句-1是因为后面有个j+1.这 ...

额，那为什么还要减x呢？

香草芭芙 发表于 2014-10-18 20:11

额，多谢解答

cxdzh 发表于 2014-10-18 20:19
class A5 {
        public static void main(String[] args) {
                int[] arr = { 1, 5, 2, 6 ...

谢谢你的解释

如果你不减1的话  运行到最后会角标越界。因为进行比较的是y 与y+1;

减1就不说了，减x是后面已经排好序的数，不用在进行比较了。x外循环，循环1次，内循环就少比较1次，循环x次就少比较x次。所以减x。   没有减x也是对的，就是后面已排序的数还进行比较，多余的比较而已

inception 发表于 2014-10-19 14:28
减1就不说了，减x是后面已经排好序的数，不用在进行比较了。x外循环，循环1次，内循环就少比较1次，循环x次 ...

额，原来如此，多谢

减少判断次数，防止越界