Java数据结构和算法（八）排序算法之冒泡排序

冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始）, 依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。

一步一步实现冒泡排序:

public class BubbleSort {

    public static void main(String[] args) {
        sort();
    }

    /**
     * 从小到大排序，拆分步骤，便于理解
     */
    private static void sort() {
        int[] arr = {4, 3, 2, 1};
        System.out.println("排序前的数组：");
        System.out.println(Arrays.toString(arr));

        int temp;
        // 第一次排序
        for (int i = 0; i < arr.length - 1 - 0; i++) {
            if (arr[i] > arr[i + 1]) {
                temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }
        System.out.println("第一次排序后的数组：");
        System.out.println(Arrays.toString(arr));
        // 第二次排序
        for (int i = 0; i < arr.length - 1 - 1; i++) {
            if (arr[i] > arr[i + 1]) {
                temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }
        System.out.println("第二次排序后的数组：");
        System.out.println(Arrays.toString(arr));
        // 第三次排序
        for (int i = 0; i < arr.length - 1 - 2; i++) {
            if (arr[i] > arr[i + 1]) {
                temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }
        System.out.println("第三次排序后的数组：");
        System.out.println(Arrays.toString(arr));
    }
}

测试结果:

排序前的数组：
[4, 3, 2, 1]
第一次排序后的数组：
[3, 2, 1, 4]
第二次排序后的数组：
[2, 1, 3, 4]
第三次排序后的数组：
[1, 2, 3, 4]

理解上面的步骤后, 封装一下:

// 记录比较次数
static int count = 0;

/**
 * 冒泡排序
 */
public static void bubbleSort(int[] arr) {
    // 临时变量
    int temp;
    // 数组中含有元素的个数减1，就是需要排序的次数
    for (int i = 0; i < arr.length - 1; i++) {
        for (int j = 0; j < arr.length - 1 - i; j++) {
            count++;
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        System.out.println("第" + (i + 1) + "次排序后的数组：");
        System.out.println(Arrays.toString(arr));
    }
    System.out.println("比较次数：" + count);
}

再次优化：
因为排序的过程中，各元素不断接近自己的位置， 如果一趟比较下来没有进行过交换 ， 就说明序列有序，因此要在排序过程中设置一个标志 flag 判断元素是否进行过交换。从而减少不必要的比较。

/**
 * 优化冒泡排序，减少不必要的比较
 */
public static void bubbleSortPlus(int[] arr) {
    // 临时变量
    int temp;
    // 交换标识，默认没交换
    boolean flag = false;
    // 数组中含有元素的个数减1，就是需要排序的次数
    for (int i = 0; i < arr.length - 1; i++) {
        for (int j = 0; j < arr.length - 1 - i; j++) {
            count++;
            if (arr[j] > arr[j + 1]) {
                flag = true;
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        System.out.println("第" + (i + 1) + "次排序后的数组：");
        System.out.println(Arrays.toString(arr));
        if (!flag) {
            break;
        } else {
            // 重置标志，进行下次判断
            flag = false;
        }
    }
    System.out.println("比较次数：" + count);
}