冒泡排序性能优化详解

一、双重循环  

第一层for循环 控制排序的轮数回合的趟数，第二层相邻元素两两比较，交换元素，ints.length-i-1为无序数列的边界，随着趟数的变大，是不断缩小的

import java.util.Arrays;

public class BubbleSort_1 {
    //冒泡排序
    public static void sort(int[] ints){

        int temp = 0;
        //第一层for循环 控制排序的轮数回合的趟数
        for(int i=0;i<ints.length;i++){
            //第二层相邻元素两两比较，交换元素，ints.length-i-1为无序数列的边界，随着趟数的变大，是不断缩小的
            for(int j=0;j<ints.length-i-1;j++){
                if(ints[j] > ints[j+1]){
                    temp = ints[j];
                    ints[j]=ints[j+1];
                    ints[j+1]=temp;

                }
            }
        }
    }
    public static  void  main(String[] args){
        int[] arg = {7,8,9,4,1,2,5,3,6};
        sort(arg);
        System.out.print(Arrays.toString(arg));
    }
}

二、

改进一：由数列的长度来决定轮数，其实到第六轮排序，已经是有序的了，排序算法仍然执行第七、第八趟的比较。
解决：利用boolean 变量标记，如果没有数据交换，说明数列有序，跳出大循环

import java.util.Arrays;

public class BubbleSort_2 {
    //冒泡排序
    //缺点一：由数列的长度来决定轮数，其实到第六轮排序，已经是有序的了，排序算法仍然执行第七、第八趟的比较。
    //解决：利用boolean 变量标记，如果没有数据交换，说明数列有序，跳出大循环
    public static void sort(int[] ints){

        int temp = 0;
        boolean flag = false;
        for(int i=0;i<ints.length;i++){
            for(int j=0;j<ints.length-i-1;j++){
                if(ints[j] > ints[j+1]){
                    temp = ints[j];
                    ints[j]=ints[j+1];
                    ints[j+1]=temp;
                    //有元素交换，所以不是有序的
                    flag = true;
                }
            }
            //如果无元素交换，都是有序的，直接跳出循环
            if(!flag){
                break;
            }
        }
    }
    public static  void  main(String[] args){
        int[] arg = {3,4,2,1,5,6,7,8};
        sort(arg);
        System.out.print(Arrays.toString(arg));
    }
}

 三、

改进二：如果原来数列最后的元素已经是有序的，比如{4,1,2,5,3,6,7,8,9}，可是每一轮都还是进行了比较。 解决：关键对于数列的有序区界定，我们在每一轮排序的最后，记录最后一次交换的位置，这个位置就是无序数列的边界。往后就是有序区了。

import java.util.Arrays;

public class BubbleSort{
    //冒泡排序
    //缺点二：如果原来数列最后的元素已经是有序的，比如{4,1,2,5,3,6,7,8,9}，可是每一轮都还是进行了比较。
    //解决：关键对于数列的有序区界定，我们在每一轮排序的最后，记录最后一次交换的位置，这个位置就是无序数列的边界。往后就是有序区了。
    public static void sort(int[] ints){
        //记录最后一次交换的位置
        int lastIndex = 0;
        //无序数列的边界，每次比较只要比较到这里
        int bubble = ints.length - 1;
        int temp = 0;
        boolean flag = false;
        for(int i=0;i<ints.length;i++){
            for(int j=0;j<bubble;j++){
                if(ints[j] > ints[j+1]){
                    temp = ints[j];
                    ints[j]=ints[j+1];
                    ints[j+1]=temp;
                    flag = true;
                    //把无序数列的边界更新为最后一次交换的位置
                    lastIndex = j;
                }
            }
         bubble = lastIndex;
            if(!flag){
                break;
            }
        }
    }
    public static  void  main(String[] args){
        int[] arg = {4,1,2,5,3,6,7,8,9};
        sort(arg);
        System.out.print(Arrays.toString(arg));
    }
}

 

 

转载自 https://mp.weixin.qq.com/s/GrOzv30dM717gcA1FquiHw