Java冒泡排序

冒泡排序

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

算法步骤：

1）比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2）对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

3）针对所有的元素重复以上的步骤，除了最后一个。

4）持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

算法图示

算法基本性能

排序算法	平均情况	最好情况	最坏情况	控件复杂度	稳定性
冒泡排序	O(n2)	O(n)(优化的版本)	O(n2)	O(1)	稳定

Java代码

按照定义的版本，每一次交换相邻的两个元素(优化前)

package com.sort;

import java.util.Random;

public class Main4 {

    // 从小到大
    private static void sort(int[] array) {
        if (array.length <= 1) {
            return;
        }
        for (int i = 0; i < array.length - 1; i++) {
            /**
             * 范围逐步缩小
             */
            for (int j = 1; j < array.length - i; j++) {
                if (array[j - 1] > array[j]) {
                    int temp = array[j];
                    array[j] = array[j - 1];
                    array[j - 1] = temp;
                }
            }
        }
    }

    /**
     * 获取指定长度的随机数组
     */
    public static int[] getRandomArray(int n) {
        int[] array = new int[n];
        Random random = new Random();
        for (int i = 0; i < array.length; i++) {
            array[i] = random.nextInt(500);
        }
        return array;
    }

    /**
     * 打印指定数组
     */
    public static void outputArray(int[] array) {
        for (int i : array) {
            System.out.print(i + " ");
        }
        System.out.println("");
    }

    public static void main(String[] args) {
        int[] array = getRandomArray(10);
        outputArray(array);
        sort(array);
        outputArray(array);
    }
}

在上面的算法性能中我们可以看到，冒泡排序最好的时间复杂度是O(n)，也就是在排序之前，已经有序了，如果采用上面的代码，那么时间复杂度还是O(n²)。还有一种普遍的情况是，如果有100个数的数组，仅前面10个无序，后面90个都已排好序且都大于前面10个数字，那么在第一趟遍历后，最后发生交换的位置必定小于10，且这个位置之后的数据必定已经有序了，记录下这位置，第二次只要从数组头部遍历到这个位置就可以了。

Java冒泡排序针对排序之前数据部分有序优化。

// 从小到大
    private static void sort(int[] array) {
        if (array.length <= 1) {
            return;
        }
        // flag为最后一次交换的位置
        int flag = array.length;
        while (flag > 0) {
            // k保存上一最后交换的位置
            int k = flag;
            flag = 0;
            // 一直比较相邻元素到上一次最后交换的位置
            for (int i = 1; i < k; i++) {
                if (array[i - 1] > array[i]) {
                    int temp = array[i];
                    array[i] = array[i - 1];
                    array[i - 1] = temp;
                    // 每一次交换都记录下交换的位置，那么最后留下的就是最后一次交换的位置
                    flag = i - 1;
                }
            }
        }
    }

参考博客:快客网、CSDN