Java算法--冒泡排序的分析优化

冒泡排序经典算法

数组有n个元素，对相邻两个数组元素进行比较，前一个数比后一个数大/小则交换两个数的值。
需要比较n-1轮，由外层循环控制;
第一轮比较n-1次，第二轮比较n-2次…以此类推。

需要排序的数组 int[] array = {1,2,9,4,7,5,6,3,10,11};

import java.util.Arrays;
public class JavaDemo {
    public static void main(String[] args) {
        int[]  array = {1,2,9,4,7,5,6,3,10,11};
        System.out.println("排序前:"+Arrays.toString(array));
        bubbleSort(array);
        System.out.println("排序后:"+Arrays.toString(array));
    }
    public static void bubbleSort(int[] tmparray){
        int tmp = 0;//临时变量保存交换值
        int count = 0,num = 0;//比较次数/循环轮数
        int swap = 0;//交换次数
        for (int i = 0; i < tmparray.length - 1; i++) {//外层循环控制比较轮数
            num++;
            for (int j = 0; j < tmparray.length -1 -i; j++) {//内层循环控制每轮比较次数
                if(tmparray[j] > tmparray[j + 1]){
                    tmp = tmparray[j];
                    tmparray[j] = tmparray[j + 1];
                    tmparray[j + 1] = tmp;
                    swap++;
                }
                count++;
            }
        }
        System.out.println("循环"+num+"轮\t比较"+count+"次\t交换"+swap+"次");
    }
}

输出结果：

排序前:[1, 2, 9, 4, 7, 5, 6, 3, 10, 11]
循环9轮	比较45次	交换11次
排序后:[1, 2, 3, 4, 5, 6, 7, 9, 10, 11]

冒泡排序优化01

如果数组在循环没有结束前就已经有序则提前退出程序，减少多余循环；
在代码中加一个变量作开关来控制循环中断。

import java.util.Arrays;
public class JavaDemo {
    public static void main(String[] args) {
        int[]  array = {1,2,9,4,7,5,6,3,10,11};
        System.out.println("排序前:"+Arrays.toString(array));
        bubbleSort(array);
        System.out.println("排序后:"+Arrays.toString(array));
    }
    public static void bubbleSort(int[] tmparray){
        int tmp = 0;//临时变量保存交换值
        int count = 0,num = 0;//比较次数/循环轮数
        int swap = 0;//交换次数
        for (int i = 0; i < tmparray.length - 1; i++) {//外层循环控制比较轮数
            boolean bool = true;//添加一个开关
            num++;
            for (int j = 0; j < tmparray.length - 1 -i; j++) {//内层循环控制每轮比较次数
                if(tmparray[j] > tmparray[j + 1]){
                    tmp = tmparray[j];
                    tmparray[j] = tmparray[j + 1];
                    tmparray[j + 1] = tmp;
                    bool = false;
                    swap++;

                }
                count++;
            }
            if(bool){//如果循环还未结束数组就已经提前有序则，则终止循环；
                break;
            }
        }
        System.out.println("循环"+num+"轮\t比较"+count+"次\t交换"+swap+"次");
    }
}

输出结果：

排序前:[1, 2, 9, 4, 7, 5, 6, 3, 10, 11]
循环6轮	比较39次	交换11次
排序后:[1, 2, 3, 4, 5, 6, 7, 9, 10, 11]

冒泡排序优化02

在上一次优化的基础上，记录每轮循环最后一次进行交换元素索引值，赋值给下一轮内层循环的循环体终止条件；

import java.util.Arrays;
public class JavaDemo {
    public static void main(String[] args) {
        int[]  array = {1,2,9,4,7,5,6,3,10,11};
        System.out.println("排序前:"+Arrays.toString(array));
        bubbleSort(array);
        System.out.println("排序后:"+Arrays.toString(array));
    }
    public static void bubbleSort(int[] tmparray){
        int tmp = 0;//临时变量保存交换值
        int count = 0,num = 0;//比较次数/循环轮数
        int swap = 0;//交换次数
        int endPoint = tmparray.length - 1;//记录每轮循环最后一次进行交换元素索引值
        int tmpEnd = 0;//临时记录发生交换时的索引值
        for (int i = 0; i < tmparray.length - 1; i++) {//外层循环控制比较轮数
            num++;
            boolean bool = true;//添加一个开关
            for (int j = 0; j < endPoint; j++) {//内层循环控制每轮比较次数
                if(tmparray[j] > tmparray[j + 1]){
                    tmp = tmparray[j];
                    tmparray[j] = tmparray[j + 1];
                    tmparray[j + 1] = tmp;
                    bool = false;
                    swap++;
                    tmpEnd = j;
                }
                count++;
            }
            endPoint = tmpEnd;
            if(bool){//如果循环还未结束数组就已经提前有序则，则终止循环；
                break;
            }
        }
        System.out.println("循环"+num+"轮\t比较"+count+"次\t交换"+swap+"次");
    }
}

输出结果：

排序前:[1, 2, 9, 4, 7, 5, 6, 3, 10, 11]
循环6轮	比较29次	交换11次
排序后:[1, 2, 3, 4, 5, 6, 7, 9, 10, 11]

冒泡排序优化03

在上一次优化的基础上，每一次循环交换两个数的值，一次正向交换，把最大值放到最后，再一次反向交换，把最小值放到最前面。

import java.util.Arrays;
public class JavaDemo {
    public static void main(String[] args) {
        int[]  array = {1,2,9,4,7,5,6,3,10,11};
        System.out.println("排序前:"+Arrays.toString(array));
        bubbleSort(array);
        System.out.println("排序后:"+Arrays.toString(array));
    }
    public static void bubbleSort(int[] tmparray){
        int tmp = 0;//临时变量保存交换值
        int count = 0,num = 0;//比较次数/循环轮数
        int swap = 0;//交换次数
        int endPoint = tmparray.length - 1;//每轮排序最大次数
        int startPoint = 0;//反向查找最小值时起始位置
        int tmpEnd = 0;//记录每轮结束后最后交换位置
        int tmpStart = 0;//记录每轮结束后最前交换位置
        for (int i = 0; i < tmparray.length - 1; i++) {//外层循环控制比较轮数
            num++;
            /**一次优化 如果循环还未结束数组就已经有序则退出循环*/
            boolean bool = true;//添加一个开关
            //正向交换最大值
            for (int j = startPoint; j < endPoint; j++) {//内层循环控制每轮比较次数
                if(tmparray[j] > tmparray[j + 1]){
                    tmp = tmparray[j];
                    tmparray[j] = tmparray[j + 1];
                    tmparray[j + 1] = tmp;
                    bool = false;
                    swap++;
                    tmpEnd = j;
                }
                count++;
            }
            endPoint = tmpEnd;/**二次优化，每轮最后一次交换作为下一轮正向交换的最大值，跳过后续比较，同时
             作为后续反向查找最小值交换的起始位置*/
            if(bool){//如果循环还未结束数组就已经提前有序则，则终止循环；
                break;
            }
            //反向交换最小值
            /**三次优化 正向交换最大值的同时反向交换最小值*/
            for (int j = endPoint; j > startPoint ; j--) {
                if(tmparray[j] < tmparray[j-1]){
                    tmp = tmparray[j];
                    tmparray[j] = tmparray[j-1];
                    tmparray[j-1] = tmp;
                    bool = false;
                    swap++;
                    tmpStart = j;
                }
                count++;
            }
            startPoint = tmpStart;
            if(bool){//如果循环还未结束数组就已经提前有序则，则终止循环；
                break;
            }
        }
        System.out.println("循环"+num+"轮\t比较"+count+"次\t交换"+swap+"次");
    }
}

输出结果：

排序前:[1, 2, 9, 4, 7, 5, 6, 3, 10, 11]
循环3轮	比较22次	交换11次
排序后:[1, 2, 3, 4, 5, 6, 7, 9, 10, 11]