Java冒泡排序算法详解及其优化

Java冒泡排序算法

基本思想

对当前还未排好序的范围内的所有数。自上而下对相邻的俩个数依次进行比較和调整，让较大的数下沉。较小的数往上冒。

即每当俩相邻的数比較后发现他们的排序与排序的要求相反时。就将他们交换。每次遍历都可确定一个最大值放到待排数组的末尾，下次遍历，对该最大值以及它

之后的元素不再排序（已经排好）。

代码实现

话不多说，直接上代码，部分解释在代码中以注释形式进行讲解

package array;

import java.util.Arrays;

public class Demo03 {



    public static void main(String[] args) {
        int[] array = {2,6,4,1,8,5,3,9,7};
        sort(array);
        printArray(array);
        System.out.println("\n\n\n\n\n");
        int[] array1 = {2,6,4,1,8,5,3,9,7};
        sort1(array1);
        printArray(array1);
        System.out.println("\n\n\n\n\n");
        int[] array2 = {2,6,4,1,8,5,3,9,7};
        sort2(array2);
        printArray(array2);
        System.out.println("\n\n\n\n\n");
        int[] array3 = {2,6,4,1,8,5,3,9,7};
        sort2(array3);
        printArray(array3);
        System.out.println("\n\n\n\n\n");
    }





    //定义一个打印数组的方法
    public static void printArray(int[] array){
        System.out.println("**************************************************");
        System.out.println("排序后的数组为："+Arrays.toString(array));
        System.out.println("**************************************************");
    }






    //初级冒泡排序方法
    /*用最初级的冒泡排序我们可以发现存在这样一种现象：
    当第4次外层循环执行完毕后，数组已经排序完成，但是后面4次外层循环还是会进行，这是对内存资源以及效率的浪费
    */

    public static void sort(int[] array){
        int temp = 0;
        //外层循环
        for (int i=0;i<array.length-1;i++){
            //内层循环
            for (int j=0;j<array.length-i-1;j++){
                if (array[j]>array[j+1]){
                    temp = array[j+1];
                    array[j+1] = array[j];
                    array[j] = temp;
                }
            }
            //打印每次外层循环一次后的数组排序
            System.out.println("第"+(i+1)+"次外层循环后的数组排序为：");
            System.out.println("__________________________________________");
            System.out.println(Arrays.toString(array));
        }
    }




    //改进冒泡排序方法1
    /*上面已经分析过。冒泡排序的效率比較低，所以我们要通过各种方法改进。
    最简单的改进方法是增加一标志性变量flag，用于标志某一趟排序过程中是否有数据交换.
    假设进行某一趟排序时并没有进行数据交换。则说明数据已经按要求排列好，可马上结束排序，避免不必要的比較过程
    在上例中，第4轮排序之后实际上整个数组已经是有序的了。最后4轮的比較不是必需进行。
    改进后的代码例如以下：*/
    public static void sort1(int[] array){
        int temp = 0;
        for (int i=0;i<array.length-1;i++){
            boolean flag = false;
            for (int j=0;j<array.length-i-1;j++){
                if (array[j] > array[j+1]){
                    temp = array[j+1];
                    array[j+1] = array[j];
                    array[j] = temp;
                    //当发生了数据交换现象，flag为true
                    flag = true;
                }
            }
            System.out.println("第"+(i+1)+"次外层循环后的数组排序为：");
            System.out.println("__________________________________________");
            System.out.println(Arrays.toString(array));
            if(!flag){
                break;//假设上一轮没有发生交换数据。证明已经是有序的了。结束排序
            }
        }
    }







    //改进冒泡排序方法2
    /*第1轮排序之后，11、18、20已经是有序的了，后面的几次排序后它们的位置都没有变化，
    可是依据冒泡算法。18依旧会在第2轮參与比較，11依旧会在第2轮、第3轮參与比較，事实上都是无用功。
    我们能够对算法进一步改进：设置一个pos指针。pos后面的数据在上一轮排序中没有发生交换，下一轮排序时，就对pos之后的数据不再比較*/
    public static void sort2(int[] array){
        int temp;
        int counter = 1;
        int endPoint = array.length-1;  //endPoint代表最后一个须要比較的元素下标

        while(endPoint>0){
            int pos = 1;
            for(int j=1;j<=endPoint;j++){
                if(array[j-1]>array[j]){  //假设前一位大于后一位。交换位置
                    temp= array[j-1];
                    array[j-1]= array[j];
                    array[j]= temp;

                    pos= j;  //下标为j的元素与下标为j-1的元素发生了数据交换
                }
            }
            endPoint= pos-1;  //下一轮排序时仅仅对下标小于pos的元素排序，下标大于等于pos的元素已经排好

            System.out.println("第"+counter+"轮排序结果："+Arrays.toString(array));
            System.out.println("__________________________________________");
            counter++;
        }
    }





    //改进冒泡排序方法3
    /*对的算法来说。没有最好。仅仅有更好。上面的两种改进方法事实上治标不治本，是一种“扬汤止沸”的改进。以下我们来一次“釜底抽薪”的改进。
    传统的冒泡算法每次排序仅仅确定了最大值，我们能够在每次循环之中进行正反两次冒泡，分别找到最大值和最小值，如此可使排序的轮数降低一半*/
    public static void sort3(int[] array){
        int temp;
        int low = 0;
        int high = array.length-1;
        int counter = 1;
        while(low<high){

            for(int i=low;i<high;++i){   //正向冒泡，确定最大值
                if(array[i]>array[i+1]){  //假设前一位大于后一位。交换位置
                    temp= array[i];
                    array[i]= array[i+1];
                    array[i+1]= temp;
                }
            }
            --high;

            for(int j=high;j>low;--j){   //反向冒泡，确定最小值
                if(array[j]<array[j-1]){  //假设前一位大于后一位，交换位置
                    temp= array[j];
                    array[j]= array[j-1];
                    array[j-1]= temp;
                }
            }
            ++low;
            System.out.print("第"+counter+"轮排序结果：");
            counter++;
        }
    }
}








//运行结果为：
第1次外层循环后的数组排序为：
__________________________________________
[2, 4, 1, 6, 5, 3, 8, 7, 9]
第2次外层循环后的数组排序为：
__________________________________________
[2, 1, 4, 5, 3, 6, 7, 8, 9]
第3次外层循环后的数组排序为：
__________________________________________
[1, 2, 4, 3, 5, 6, 7, 8, 9]
第4次外层循环后的数组排序为：
__________________________________________
[1, 2, 3, 4, 5, 6, 7, 8, 9]
第5次外层循环后的数组排序为：
__________________________________________
[1, 2, 3, 4, 5, 6, 7, 8, 9]
第6次外层循环后的数组排序为：
__________________________________________
[1, 2, 3, 4, 5, 6, 7, 8, 9]
第7次外层循环后的数组排序为：
__________________________________________
[1, 2, 3, 4, 5, 6, 7, 8, 9]
第8次外层循环后的数组排序为：
__________________________________________
[1, 2, 3, 4, 5, 6, 7, 8, 9]
**************************************************
排序后的数组为：[1, 2, 3, 4, 5, 6, 7, 8, 9]
**************************************************






第1次外层循环后的数组排序为：
__________________________________________
[2, 4, 1, 6, 5, 3, 8, 7, 9]
第2次外层循环后的数组排序为：
__________________________________________
[2, 1, 4, 5, 3, 6, 7, 8, 9]
第3次外层循环后的数组排序为：
__________________________________________
[1, 2, 4, 3, 5, 6, 7, 8, 9]
第4次外层循环后的数组排序为：
__________________________________________
[1, 2, 3, 4, 5, 6, 7, 8, 9]
第5次外层循环后的数组排序为：
__________________________________________
[1, 2, 3, 4, 5, 6, 7, 8, 9]
**************************************************
排序后的数组为：[1, 2, 3, 4, 5, 6, 7, 8, 9]
**************************************************






第1轮排序结果：[2, 4, 1, 6, 5, 3, 8, 7, 9]
__________________________________________
第2轮排序结果：[2, 1, 4, 5, 3, 6, 7, 8, 9]
__________________________________________
第3轮排序结果：[1, 2, 4, 3, 5, 6, 7, 8, 9]
__________________________________________
第4轮排序结果：[1, 2, 3, 4, 5, 6, 7, 8, 9]
__________________________________________
第5轮排序结果：[1, 2, 3, 4, 5, 6, 7, 8, 9]
__________________________________________
**************************************************
排序后的数组为：[1, 2, 3, 4, 5, 6, 7, 8, 9]
**************************************************






第1轮排序结果：[2, 4, 1, 6, 5, 3, 8, 7, 9]
__________________________________________
第2轮排序结果：[2, 1, 4, 5, 3, 6, 7, 8, 9]
__________________________________________
第3轮排序结果：[1, 2, 4, 3, 5, 6, 7, 8, 9]
__________________________________________
第4轮排序结果：[1, 2, 3, 4, 5, 6, 7, 8, 9]
__________________________________________
第5轮排序结果：[1, 2, 3, 4, 5, 6, 7, 8, 9]
__________________________________________
**************************************************
排序后的数组为：[1, 2, 3, 4, 5, 6, 7, 8, 9]
**************************************************

冒泡排序的算法分析：

待排数组中一共同拥有9个数。第一轮排序时进行了8次比較。第二轮排序时进行了5比較。依次类推，最后一轮进行了一次比較。

增加元素总数为N，则一共须要的比較次数为：

(N-1)+ (N-2)+ (N-3)+ …1=N*(N-1)/2

这样，算法约做了N2/2次比較。由于仅仅有在前面的元素比后面的元素大时才交换数据，所以交换的次数少于比較的次数。假设数据是随机的，大概有一半数据须要交换。则交换的次数为N2/4（只是在最坏情况下，即初始数据逆序时，每次比較都须要交换）。

交换和比較的操作次数都与N2成正比，由于在大O表示法中。常数忽略不计，冒泡排序的时间复杂度为O(N2)。

O(N2)的时间复杂度是一个比較糟糕的结果。尤其在数据量非常大的情况下。所以冒泡排序通常不会用于实际应用