Java——冒泡排序算法与简单优化

冒泡排序

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端。

Java实现

    public static void bubbleSort(int[] array){
        for (int i = array.length; i > 1; i--) {
            for (int j = 0; j < i - 1; j++) {
                if ( array[j] > array[j + 1] ){
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
            //输出每一趟的结果
            System.out.print("第" + (array.length-i+1) + "趟:");
            display(array);
        }
    }
    public static void main(String[] args) {

        int[] a = new int[]{5, 7, 9, 8, 6, 3, 4, 2, 1};
        bubbleSort(a);
        System.out.print("排序后：");
        display(a);
    }

运行结果

第1趟:5 7 8 6 3 4 2 1 9 
第2趟:5 7 6 3 4 2 1 8 9 
第3趟:5 6 3 4 2 1 7 8 9 
第4趟:5 3 4 2 1 6 7 8 9 
第5趟:3 4 2 1 5 6 7 8 9 
第6趟:3 2 1 4 5 6 7 8 9 
第7趟:2 1 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，3，4，5，6，7，8，9）得到如下结果：

第1趟:1 2 3 4 5 6 7 8 9 
第2趟:1 2 3 4 5 6 7 8 9 
第3趟:1 2 3 4 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

从运行结果中可见，程序执行了8趟冒泡，实际上在第一趟时就已经发现序列是有序的。为了让程序更效率一些，我们对代码进行简单优化，在代码中加入flag标记序列是否有序，当序列有序是，提前停止冒泡。

    public static void bubbleSort(int[] array){
        for (int i = array.length; i > 1; i--) {
            boolean flag = true;
            for (int j = 0; j < i - 1; j++) {
                if ( array[j] > array[j + 1] ){
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    flag = false;
                }
            }
            //输出每一趟的结果
            System.out.print("第" + (array.length-i+1) + "趟:");
            display(array);
            if(flag) break;
        }
    }

运行结果为：

第1趟:1 2 3 4 5 6 7 8 9 
排序后：1 2 3 4 5 6 7 8 9 

算法特点

• 冒泡排序是稳定的排序算法
• 时间复杂度O(n²)
• 空间复杂度O(1)