算法-冒泡排序

1. 原理：比较两个相邻的元素，将较大的元素交换至右端

2. 思路：依次比较相邻的元素，将较大的元素交换到右侧；

3. 代码解析

public static void main(String[] args) {
    int[] arr={10,9,8,7,6,5,4,3,2,1};
    //外层循环控制着总共的排序次数，排序趟数为元素个数-1
    for(int i=0;i<arr.length-1;i++){
        //每一趟排序结束，意味着最后一位已变为最大元素，下次排序跳过
        for(int j=0;j<arr.length-1-i;j++){
            if(arr[j]>arr[j+1]){
                int temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }
        System.out.print("第"+(i+1)+"趟排序结果");
        for(int g:arr){
            System.out.print(g+" ");
        }
        System.out.println();
    }
}

第1趟排序结果9 8 7 6 5 4 3 2 1 10 
第2趟排序结果8 7 6 5 4 3 2 1 9 10 
第3趟排序结果7 6 5 4 3 2 1 8 9 10 
第4趟排序结果6 5 4 3 2 1 7 8 9 10 
第5趟排序结果5 4 3 2 1 6 7 8 9 10 
第6趟排序结果4 3 2 1 5 6 7 8 9 10 
第7趟排序结果3 2 1 4 5 6 7 8 9 10 
第8趟排序结果2 1 3 4 5 6 7 8 9 10 

第9趟排序结果1 2 3 4 5 6 7 8 9 10 

4.算法优化（加控制,优化空排序）

public static void main(String[] args) {
    int[] arr={0,1,2,3,4,5,3,2,1};
    boolean flag;
    //外层循环控制着总共的排序次数，排序趟数为元素个数-1
    for(int i=0;i<arr.length-1;i++){
        flag=false;
        //每一趟排序结束，意味着最后一位已变为最大元素，下次排序跳过
        for(int j=0;j<arr.length-1-i;j++){
            if(arr[j]>arr[j+1]){
                int temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
                flag=true;
            }
        }
        System.out.print("第"+(i+1)+"趟排序结果");
        for(int g:arr){
            System.out.print(g+" ");
        }
        System.out.println();
        if(!flag){
            return;
        }
    }
}