Java经典冒泡排序算法的优化解析

思想：在普通冒泡排序的基础上，增加一个flag标志记录，添加一个flag标记，如果该数已经做出排序则置为true，，没有做出排序证明已经是正常顺序，无需再排序，默认flag为false。

代码如下：

public class OptimizationBubbleAlgorithm {
    public static void main(String[] args) {
        int[] nums={2,7,25,13,6,8};
        System.out.println("最初顺序: "+Arrays.toString(nums));
        Long startTime=System.currentTimeMillis();
        int[] result=bubbleSort(nums);
        System.out.println("优化后，六个数据的简单冒泡排序时间(ms)："+(System.currentTimeMillis()-startTime));
        System.out.println("最后结果: "+Arrays.toString(result));
    }
    private static int[] bubbleSort(int[] nums){

        int len=nums.length;
        if(len==0||len==1){
            return nums;
        }
        boolean flag;
        //外层循环 判定一个数要走多少次走到最大位置
        for(int i=0;i<len-1;i++){
            添加一个flag标记，如果该数已经做出排序则置为true，，没有做出排序证明已经是正常顺序，无需再排序，默认flag为false
            flag=false;
            //内部循环 判断比较两个数，若前一个数比后一个大则交换位置
            for(int j=0;j<len-1-i;j++){
                if(nums[j]>nums[j+1]){
                    int tmp=nums[j];
                    nums[j]=nums[j+1];
                    nums[j+1]=tmp;
                    flag=true;
                }
            }

            System.out.println("第 "+i+"次排序后： "+Arrays.toString(nums));
            if(flag==false){
                System.out.println("第 "+i+"次排序,跳出for循环");
                break;
            }
        }
        return nums;
    }

}

输出结果如下：

最初顺序: [2, 7, 25, 13, 6, 8]
第 0次排序后： [2, 7, 13, 6, 8, 25]
第 1次排序后： [2, 7, 6, 8, 13, 25]
第 2次排序后： [2, 6, 7, 8, 13, 25]
第 3次排序后： [2, 6, 7, 8, 13, 25]
第 3次排序,跳出for循环
优化后，六个数据的简单冒泡排序时间(ms)：0
最后结果: [2, 6, 7, 8, 13, 25]

结果分析：电脑是i7第九代六核，不优化的基础上是1ms跑完排序代码，可见，优化后，大大提升了效率。