经典算法系列之冒泡排序实战讲解

本文以java语言进行实例讲解冒泡排序，以及此算法的两种优化方法，希望能帮助你们。

1.什么是冒泡排序

冒泡排序：依次比较相邻的数据，将小数据放在前，大数据放在后；即第一趟先比较第1个和第2个数，大数在后，小数在前，再比较第2个数与第3个数，大数在后，小数在前，以此类推则将最大的数”滚动”到最后一个位置；第二趟则将次大的数滚动到倒数第二个位置……第n-1(n为无序数据的个数)趟即能完成排序。

废话不多说了，下面是代码实现

package 八大排序算法;

public class BubbleSort1 {
    private int[] testArray={49,38,65,97,76,13,27,49,55,04};
    private int[] sortArray;
    private long startTime,endTime;
    public BubbleSort1(){
        startTime=System.nanoTime();
        sortArray=bubbleSort1(testArray);
        for(int a:sortArray){
            System.out.print(a+" ");
        }
        endTime=System.nanoTime();
        System.out.println("\n程序运行时间："+(endTime-startTime)+"ns");
    }
    public int[] bubbleSort1(int[] target){
        if(target!=null&&target.length>1){
            for(int i=0;i<target.length-1;i++){
                for(int j=target.length-1;j>i;j--){
                    if(target[j]<target[j-1]){
                        int tmp=target[j];
                        target[j]=target[j-1];
                        target[j-1]=tmp;
                    }
                }
            }
        }
        return target;
    }
    public static void main(String[] args) {
        new BubbleSort1();
    }

}

优化冒泡排序1

package 八大排序算法;

public class BubbleSort2 {
    private int[] testArray={49,38,65,97,76,13,27,49,55,04};
    private int[] sortArray;
    private long startTime,endTime;
    public BubbleSort2(){
        startTime=System.nanoTime();
        sortArray=bubbleSort2(testArray);
        for(int a:sortArray){
            System.out.print(a+" ");
        }
        endTime=System.nanoTime();
        System.out.println("\n程序运行时间："+(endTime-startTime)+"ns");
    }
    public int[] bubbleSort2(int[] target){
        int n = target.length;
        if (target != null && n != 1) {
//最多需要进行n-1躺，每一趟将比较小的元素移到前面，比较大的元素自然就逐渐沉到最后面了，这就是冒泡
            for (int i = 0; i < n-1; i++) {      
                boolean exchange = false;
                for (int j = n-1; j > i; j--) {
                    if(target[j] < target[j-1]){
                        int temp = target[j];
                        target[j] = target[j-1];
                        target[j-1] = temp;
                        exchange = true;
                    }
                }
                if (!exchange){    // 若 i 到 n-1 这部分元素已经有序，则直接返回
                    return target;
                }
            }
        }
        return target;
    }
    public static void main(String[] args) {
        new BubbleSort2();
    }
}

优化冒泡排序2

package 八大排序算法;
/*
此种情况对应的是如果有100个数的数组，仅前面10个无序，后面90个都已排好序且
都大于前面10个数字，那么在第一趟遍历后，最后发生交换的位置必定小于10，
且这个位置之后的数据必定已经有序了，记录下这位置，第二次只要从数组头部遍历
到这个位置就可以了。
 */
public class BubbleSort3 {
    private int[] testArray={49,38,65,97,76,13,27,49,55,04};
    private int[] sortArray;
    private long startTime,endTime;
    public BubbleSort3(){
        startTime=System.nanoTime();
        sortArray=bubbleSort3(testArray);
        for(int a:sortArray){
            System.out.print(a+" ");
        }
        endTime=System.nanoTime();
        System.out.println("\n程序运行时间："+(endTime-startTime)+"ns");
    }
    public int[] bubbleSort3(int[] target){
        if(target!=null&&target.length>1){
            int flag=target.length;
            while(flag>0){
                int k=flag;
                flag=0;
                for(int j=1;j<k;j++){
                    if(target[j-1]>target[j]){
                        int tmp=target[j];
                        target[j]=target[j-1];
                        target[j-1]=tmp;
                        flag=j;
                    }
                }
            }
        }
        return target;
    }
    public static void main(String[] args) {
        new BubbleSort3();

    }

}

不足之处：
为了测试各个算法的运行时间，加了时间函数来测试，不过，每次运行的实际时间都不定，导致第三个的运行时间不一定小于第一个以及第二个。
只能通过时间复杂度及空间复杂度来计算一个算法的优劣。