排序算法篇 - 冒泡排序

基本介绍

冒泡排序（Bubble Sort）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始），依次比较相邻元素的值，若发现逆序则交换，使值较大的元素主键从前移向后部，就像水底下的气泡一样逐渐向上冒。因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在排序过程中设置一个标志flag判断元素是否进行过交换，从而减少不必要的比较。

推导过程

原始数组：3，9，-1，10，2

#第一趟排序
(1) 3，9，-1，10，2 #arr[0]和arr[1]比较，3小于9则不交换
(2) 3，-1，9，10，2 #arr[1]和arr[2]比较，9大于-1则发生交换 
(3) 3，-1，9，10，2 #arr[2]和arr[3]比较，9小于10则不交换 
(4) 3，-1，9，2，10 #arr[3]和arr[4]比较，10大于2则发生交换，则找到最大数“10”

#第二趟排序
(1) -1，3，9，2，10 #arr[0]和arr[1]比较，3大于-1则发生交换
(2) -1，3，9，2，10 #arr[1]和arr[2]比较，3小于9则不交换 
(3) -1，3，2，9，10 #arr[2]和arr[3]比较，9大于2则发生交换，则找到该次最大数“9”

#第三趟排序
(1) -1，3，2，9，10 #arr[0]和arr[1]比较，-1小于3则不交换
(2) -1，2，3，9，10 #arr[1]和arr[2]比较，3大于2则发生交换 ，则找到该次最大数“3”

#第四趟排序
(1) -1，2，3，9，10 #arr[0]和arr[1]比较，-1小于2则不交换，则找到该次最大数“2”

说明：
（1）共进行数据大小减1次的循环
（2）每一趟排序的次数在逐渐减少
（3）如果我们发现某趟排序中，没有发生任何交换，可以提前结束

代码分解

public class BubbleSort {

    public static void main(String[] args) {

        int arr[] = {3,9,-1,10,2};

        bubbleSort(arr);
    }

    public static void bubbleSort(int[] arr) {

        int temp = 0; // 临时变量，用来交换时使用

        // 第一趟排序，将最大的数排在最后
        for (int j = 0; j < (arr.length - 1); j++) {

            // 如果前面的数比后面的数大，则发生交换
            if (arr[j] >= arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }

        System.out.println("第一趟排序结果:" + Arrays.toString(arr));

        // 第二趟排序，将倒数第二大的数排在倒数第二位
        for (int j = 0; j < (arr.length - 1 - 1); j++) {

            // 如果前面的数比后面的数大，则发生交换
            if (arr[j] >= arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }

        System.out.println("第二趟排序结果:" + Arrays.toString(arr));

        // 第三趟排序，将倒数第三大的数排在倒数第三位
        for (int j = 0; j < (arr.length - 1 - 2); j++) {

            // 如果前面的数比后面的数大，则发生交换
            if (arr[j] >= arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }

        System.out.println("第三趟排序结果:" + Arrays.toString(arr));

        // 第四趟排序，将倒数第四大的数排在倒数第四位
        for (int j = 0; j < (arr.length - 1 - 3); j++) {

            // 如果前面的数比后面的数大，则发生交换
            if (arr[j] >= arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }

        System.out.println("第四趟排序结果:" + Arrays.toString(arr));
    }
}

运行结果：
第一趟排序结果:[3, -1, 9, 2, 10]
第二趟排序结果:[-1, 3, 2, 9, 10]
第三趟排序结果:[-1, 2, 3, 9, 10]
第四趟排序结果:[-1, 2, 3, 9, 10]

优化代码

public class BubbleSort {

    public static void main(String[] args) {

        int arr[] = {3,9,-1,10,2};

        bubbleSort(arr);
    }

    // 冒泡排序
    public static void bubbleSort(int[] arr) {

        // 冒泡排序时间复杂度O(n^2)
        int temp = 0; // 临时变量
        boolean flag = false; // 标识变量，表示是否进行交换
        for (int i = 0; i < (arr.length - 1); i++) {

            for (int j = 0; j < (arr.length - 1 - i); j++) {

                // 如果前面比后面的数大，则交换
                if (arr[j] > arr[j + 1]) {
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            //System.out.println(Arrays.toString(arr));
            if (!flag) { // 在该趟排序中一次都未交换
                break;
            }

            flag = false;
        }
    }
}