排序算法---冒泡排序(含优化)

冒泡排序（Bubble Sort）

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

时间复杂度

平均情况：O(n^2)

逐步分析

原始数组：3, 9, -1, 10, 20
从3开始向右逐个两两比较，如果相邻的元素逆序就交换

• 第一趟排序

(1) 3, 9, -1, 10, 20
(2) 3, -1, 9, 10, 20
(3) 3, -1, 9, 10, 20
(4) 3, -1, 9, 10, 20

• 第二趟排序

(1) -1, 3, 9, 10, 20
(2) -1, 3, 9, 10, 20
(3) -1, 3, 9, 10, 20

• 第三趟排序

(1) -1, 3, 9, 10, 20
(2) -1, 3, 9, 10, 20

• 第四趟排序

(1) -1, 3, 9, 10, 20

冒泡排序规则

通过分析我们发现：

• 一共进行 数组的大小-1 次 大的循环
• 每一趟排序的次数在逐渐的减少

优化方法

若是特殊数组，如举例数组，如果我们发现在某趟排序中，没有发生一次交换， 可以提前结束冒泡排序。

代码

优化前

public class BubbleSort {
    public static void main(String[] args) {
        int arr[] = {3, 9, -1, 10, 20};
        BubbleSort(arr);
    }

    public static void BubbleSort(int arr[]) {
        //冒泡排序的时间复杂度为O(n^2)
        int temp = 0;       //临时变量
        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]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            System.out.println("第" + (i + 1) + "趟排序后的数组");
            System.out.println(Arrays.toString(arr));

                }
          }
    }

运行结果：

优化后

public class BubbleSort {
    public static void main(String[] args) {
        int arr[] = {3, 9, -1, 10, 20};
        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("第" + (i + 1) + "趟排序后的数组");
            System.out.println(Arrays.toString(arr));

            if (!flag) {//在一趟排序中，一次交换都没有发生过
                break;
            } else
                flag = false;//重置flag，进行下次判断
        }
    }
}

运行结果：

测试八万个数据耗时：12127ms