谁能详细解释下这串代码的每一个部分的每一条语句的功能, 我在冒泡升序法这块来来回回看了两天了, 就是看不明白, 希望能遇到有缘人帮忙点化一下
实例代码如下, 希望有牛人给我写个超级详细的注释!
public class BubbleSort{
        public static void main(String args[]){
                int[] array ={63,4,24,1,3,15};
                BubbleSort sorter=new BubbleSort();
                sorter.sort(array);
        }

        public void sort(int[] array){
                for (int i=1;i<array.length; i++){
                        for (int j=0;j<array.length-i;j++){
                                if (array[j]>array[j+1]){
                                        int temp=array[j];
                                        array[j]=array[j+1];
                                        array[j+1]=temp;
                                }
                        }
                }
                showArray(array);
        }
        public void showArray(int[] array){
                for (int i: array){
                        System.out.print(">"+i);
                }
                System.out.println();
        }
}

抛开代码研究下思想,我以例子说明:

1. /*
   
2.        //看时对应下,我调整半天对不齐
   
3.          冒泡排序:(从小到大,从零趟开始为了操作方便)
   
4.          算法思想:
   
5.           相邻两个数比较,两两比较得到的较大数,较大数不断后移,
   
6.           最终每趟最大数沉底.
   
7.           例如:三个数:5,3,1:5>3->true->交换 3 5 1->5>1->true->交换 3 1 5->那么5一定为三个数中最大的.以下也就是这种思想.
   
8.           示例:下标  0 1 2 3 4
   
9.                      i      5 3 7 9 1
   
10.                      
    
11.                           3 5 7 9 1 5>3交换
    
12.           第零趟:    3 5 7 9 1 5<7不动
    
13.                           3 5 7 9 1 7<9不动
    
14.                           3 5 7 1 9 9>1交换-->9为最大,arr[4]为9
    
15.                                  共比较4(arr.length-0(趟数)-1)次
    
16.           第一趟:   3 5 7 1   -->9不用在参与比较
    
17.                          3 5 7 1   3<5不动
    
18.                          3 5 7 1   5<7不动
    
19.                           3 5 1 7   7>1交换-->7为次大,arr[3]为7
    
20.                                  共比较3(arr.length-1-1)次
    
21.           第二趟:   3 5 1     -->7不用再参与比较
    
22.                          3 5 1     3<5不动
    
23.                          3 1 5     5>1交换-->arr[2]为5
    
24.                      共比较2(arr.length-2-1)次
    
25.           第三趟:   3 1       -->5不用再参与比较
    
26.                          1 3       3>1交换-->arr[1]为3
    
27.                                  共比较1(arr.length-3-1)次
    
28.           共走了4(arr.length-1)趟
    
29.           最后一定剩余一个数字1,不用再参与比较,肯定最小      
    
30.         */

复制代码

学习了，顶一下

冒泡法就是依次把最大的数移动到最后，第一次移动最大的，依次减小，直到排完，每一轮俩俩比较，往后平移，比如5 4 3 这3个数字我们把它按照由小到大的顺序排列， 从前往后相临两位比较大小，如果前一位比后一位大就把它俩 换位，5比4大就把5和4换位，得到453 5又比3大 5和3换位 得到435 依次类推最后得到 435 这样就把最大的一个数字移到最后面了 然后不看5 ，剩下43 再用上面的方法把4移动到最后 得到 345 在不看45 剩下3。 最终得到345 ，思想基本就这样吧！