1. public static void bubbleSort(int[] arr)
   
2. 
   
3. 03.        {
   
4. 
   
5. 04.                for(int x=0; x<arr.length-1; x++)
   
6. 
   
7. 05.                {                                                                        
   
8. 
   
9. 06.                        for(int y=0; y<arr.length-x-1; y++)
   
10. 
    
11. 07.                        {
    
12. 
    
13. 08.                                if(arr[y]<arr[y+1])
    
14. 
    
15. 09.                                {
    
16. 
    
17. 10.                                        int temp = arr[y];
    
18. 
    
19. 11.                                        arr[y] = arr[y+1];
    
20. 
    
21. 12.                                        arr[y+1] = temp;
    
22. 
    
23. 13.                                        swap(arr,y,y+1);
    
24. 
    
25. 14.                                }
    
26. 
    
27. 15.                        }
    
28. 
    
29. 16.                }
    
30. 
    
31. 17.        }
    

复制代码

这个是怎么实现的啊？ for循环遍历我知道，那arr.length-1是为何呢？？？  那个temp是什么啊？



啊  知道了 谢谢大家的帮忙

1.         /**arr
   
2.         传入一个int 数组进行冒泡排序
   
3. 
   
4.         */
   
5.         public  void bubbleSort(int[] arr) {
   
6. 
   
7.                 for (int k = 0; k < arr.length - 1; k++) {
   
8.                         for (int i = 0; i < arr.length - k - 1; i++) {
   
9.                                 if (arr[i] > arr[i + 1]) {
   
10. 
    
11.                                         int temp = arr[i + 1];
    
12.                                         arr[i + 1] = arr[i];
    
13.                                         arr[i] = temp;
    
14.                                 }
    
15.                         }
    
16.                 }
    
17.                 for (int i = 0; i < arr.length; i++)
    
18.                         System.out.println(arr[i]);
    
19.         }

复制代码

arr.length是指数组长度，  arr.length-1 就是数组下标最后一个。
｛1，2，3，4，5｝  数组长度是5
   0    1   2   3   4  这是角标   
temp是用来做交换的第三方变量。你可以随便换个名字。
c=a
a=b
b=c   这样子看得懂吗？
还有个不用第三方变量的比较方式，不使用第三方数据可以保证数据精度。
a=a+b
b=a-b
a=a-b
看得懂吗~~~~
冒泡算法的概念  你可以这样想 。
现在有五个抽屉，假设第一个里面有个苹果。
打开抽屉，把苹果从第一个抽屉放到第二个抽屉。
然后打开第三个抽屉，把苹果从第二个抽屉放倒第三个抽屉。
他是相邻两个数之间比较交换。

冒泡排序：就是将数组中的各个元素对应的值相互之前两两进行比较，用来将数组中元素值大小按照从左到右或者从右至左的方式排列出来。
一个数组arr的长度是arr.length，假如这个数组有5个元素，那么arr.length = 5，先将0角标和1角标两个元素进行对比，在内循环里面通过定义temp临时变量的方式将相邻的两个元素的值进行交换，将较小的数换到左边，将较大的数换到右边。
当比到最后一个元素的时候，没有元素和它进行对比了，所以就将角标位减1，防止程序报错。

temp是用来做交换值的第三方变量。
变量A=1变量B=2如果要互相交换变量AB的值的话，顺序是把A赋给C，然后A=B，B=C。
arr.length-1是用来控制输出的次数。arr.length是指数组长度，  arr.length-1 就是数组下标最后一个。

可以用debug调试，如果你不会的话，就要一步一步分析，

1. 
   
2. <P>
   
3. <P>public static void bubbleSort(int[] arr)
   
4. 
   
5. 03. {
   
6. 
   
7. 04. for(int x=0; x<arr.length-1; x++)//这个for循环，控制外循环，当x=0时，进入里面的for循环。
   
8. 
   
9. 05. {
   
10. 
    
11. 06. for(int y=0; y<arr.length-x-1; y++)
    
12. /*进入这个循环后，从y=0开始循环，直到 y<arr.length-x-1不成立。当这个for走一个循环后，跳到外面的for循环。这个时候外面循环的x=1，然后继续进行里面的循环，通过if判断，把剩下的数中的最大值，排到最后。并继续跳出循环，不断的这样往复循环。不断的把剩下的最大值排到后面。这个就是冒泡排序的原理。*/
    
13. 07. {
    
14. 
    
15. 08. if(arr[y]<arr[y+1])//每次循环，都进行if判断。通过判断，把最大的值排列到数组的最后面。
    
16. 
    
17. 09. {
    
18. 
    
19. 10. int temp = arr[y];
    
20. 
    
21. 11. arr[y] = arr[y+1];
    
22. 
    
23. 12. arr[y+1] = temp;
    
24. 
    
25. 13. swap(arr,y,y+1);
    
26. 
    
27. 14. }
    
28. 
    
29. 15. }
    
30. 
    
31. 16. }
    
32. 
    
33. 17. }</P></P>

复制代码

就是循环比较数组元素大小啊，建个临时变量用来存大的，小的往前移一位，在给数组下标为大的位置上赋予临时变量即可。

x=0; x<arr.length-1;x++  这里x只得是数组角标或者下标，比如数组arr=｛1，2，3，4｝，arr.length意思是计算数组长度，常识数组下标或角标是从0开始的，这里有5个数组元素，所以是从0到3（arr.length=4,4-1=3）,以后在遇到数组名.length-1就表示数组下标或角标最后一个；
temp单词意思是临时文件啦，在java里习惯用它表示第三变量，比如有变量a，b，需要把a和b的值互换，这里就需要用到第三方变量（临时变量），

temp=a；1st先把a赋给临时变量temp，此时a内存空了
a=b;         2end再把b赋给a
b=temp;  3rd最后把临时变量temp赋给b，这样就完成了a和b的互换

啊  知道了   谢谢大家的帮忙

冒泡排序就是相邻的两个元素进行比较，如果符合条件就换位。arr.length-1  是因为第一个元素不需要与自己比较，直接与第二个元素比较，所以比较的次数是数组的长度减一。temp是一个临时变量，用于交换位置使用。