经典排序之冒泡排序

冒泡排序(Bubble Sort)是一种比较经典的排序算法。

之所以称为“冒泡排序” ,是因为在排序中,越大(降序排列)或越小(升序排列)的相邻元素会经由交换逐渐“浮”到前面,有如 水中浮出的水泡,故形象地命名为“冒泡排序”。

冒泡排序主要对相邻的两个元素进行比较。

在时间复杂度方面,若数据集的初始状态是正序的,一趟扫描即可完成排序。这时,排序中的比较 次数和移动次数均达到最小值,其时间复杂度O(N)。

若数据集的初始状态是反序的,需要进行n-1趟排序;每趟排序要进行n-i次关键字的比较 (1≤i≤n-1)。在这种情况下,比较和移动次数均达到最大值,其时间复杂度为O(n²)。

总的来说,冒泡排序的平均时间复杂度为O(n²)。

我们接下来通过代码来看冒泡排序。

package 排序算法.冒泡排序;

import java.util.Arrays;

/**
 * 未优化的冒泡排序
 */
public class Demo1 {
    public static void main(String[] args) {
        int[] arr = new int[]{15, 32, 14, 86, 54, 78, 36};
        System.out.println("排序前的数组:" + Arrays.toString(arr));
        System.out.println("排序中:");
        int k = 0;
        for (int j = 0; j < arr.length - 1; j++) {
            for (int i = 0; i < arr.length - 1; i++) {
                if (arr[i] > arr[i + 1]) {
                    int temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                }
                System.out.println("第 " + (++k) + " 次:" + Arrays.toString(arr));
            }
        }
        System.out.println("排序后的数组:" + Arrays.toString(arr));
    }
}

   上述代码运行结果如下:

排序前的数组:[15, 32, 14, 86, 54, 78, 36]
排序中:
第 1 次:[15, 32, 14, 86, 54, 78, 36]
第 2 次:[15, 14, 32, 86, 54, 78, 36]
第 3 次:[15, 14, 32, 86, 54, 78, 36]
第 4 次:[15, 14, 32, 54, 86, 78, 36]
第 5 次:[15, 14, 32, 54, 78, 86, 36]
第 6 次:[15, 14, 32, 54, 78, 36, 86]
第 7 次:[14, 15, 32, 54, 78, 36, 86]
第 8 次:[14, 15, 32, 54, 78, 36, 86]
第 9 次:[14, 15, 32, 54, 78, 36, 86]
第 10 次:[14, 15, 32, 54, 78, 36, 86]
第 11 次:[14, 15, 32, 54, 36, 78, 86]
第 12 次:[14, 15, 32, 54, 36, 78, 86]
第 13 次:[14, 15, 32, 54, 36, 78, 86]
第 14 次:[14, 15, 32, 54, 36, 78, 86]
第 15 次:[14, 15, 32, 54, 36, 78, 86]
第 16 次:[14, 15, 32, 36, 54, 78, 86]
第 17 次:[14, 15, 32, 36, 54, 78, 86]
第 18 次:[14, 15, 32, 36, 54, 78, 86]
第 19 次:[14, 15, 32, 36, 54, 78, 86]
第 20 次:[14, 15, 32, 36, 54, 78, 86]
第 21 次:[14, 15, 32, 36, 54, 78, 86]
第 22 次:[14, 15, 32, 36, 54, 78, 86]
第 23 次:[14, 15, 32, 36, 54, 78, 86]
第 24 次:[14, 15, 32, 36, 54, 78, 86]
第 25 次:[14, 15, 32, 36, 54, 78, 86]
第 26 次:[14, 15, 32, 36, 54, 78, 86]
第 27 次:[14, 15, 32, 36, 54, 78, 86]
第 28 次:[14, 15, 32, 36, 54, 78, 86]
第 29 次:[14, 15, 32, 36, 54, 78, 86]
第 30 次:[14, 15, 32, 36, 54, 78, 86]
第 31 次:[14, 15, 32, 36, 54, 78, 86]
第 32 次:[14, 15, 32, 36, 54, 78, 86]
第 33 次:[14, 15, 32, 36, 54, 78, 86]
第 34 次:[14, 15, 32, 36, 54, 78, 86]
第 35 次:[14, 15, 32, 36, 54, 78, 86]
第 36 次:[14, 15, 32, 36, 54, 78, 86]
排序后的数组:[14, 15, 32, 36, 54, 78, 86]

上述是未优化的结果;,优化后的代码如下:

package 排序算法.冒泡排序;
import java.util.Arrays;
/**
 * 优化后的冒泡排序;相邻元素比较,小的浮上来
 */
public class Test {
    static void bubleSort(int[] intArr){
        int k=0;//统计每次排序后的状态
        for(int i=0;i<intArr.length-1;i++){
            boolean boo=false;//判断数组是否存在无序状态,false表示已经有序
            for(int j=0;j<intArr.length-1;j++){
                if(intArr[j]>intArr[j+1]){
                    boo=true;
                    int temp=intArr[j];
                    intArr[j]=intArr[j+1];
                    intArr[j+1]=temp;
                }
            }
            if(!boo){
                break;//如果数组已经有序,则不必再循环
            }
            k++;
            System.out.println("第"+k+"次排序:"+ Arrays.toString(intArr));
        }
    }
    public static void main(String[] args) {
        int[] arr=new int[]{15,32,14,86,54,78,36};
        System.out.println("排序前的数组:"+Arrays.toString(arr));
        bubleSort(arr);
        System.out.println("排序后的数组:"+Arrays.toString(arr));
    }
}

 

  上述代码运行结果如下:

排序前的数组:[15, 32, 14, 86, 54, 78, 36]
第1次排序:[15, 14, 32, 54, 78, 36, 86]
第2次排序:[14, 15, 32, 54, 36, 78, 86]
第3次排序:[14, 15, 32, 36, 54, 78, 86]
排序后的数组:[14, 15, 32, 36, 54, 78, 86]

  可见,优化后的代码,比原先重复排序(36-3=33)减少33次之多。

posted @ 2017-12-16 10:09  奔跑在梦想的道路上  阅读(285)  评论(0编辑  收藏  举报