算法-冒泡排序

冒泡排序是最简单的排序算法，核心思想也很简单：
对比相邻的两个元素，如果第一个元素比第二个元素大，则交换这两个元素的位置，并且每次循环结束都能获取到数组的最大元素，并把该元素放置数组的最右位置，由于是两两对比，所以循环次数为n-1次；比如排序数组{3,2}，3跟2比较，3比2大，则互换位置为{2,3}，循环次数为：数组长度2-1=1次。

1、简单实现：

现在我们通过代码现实一下数组{1,3,2,7,5,4,8,9,6}的排序：

/**
     * 冒泡排序
     */
    public void bubbleSort() {
        int[] arr = {1, 3, 2, 7, 5, 4, 8, 9, 6};
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int a = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = a;
                }
            }
        }

        String str = "";
        for (int i : arr) {
            str += i;
        }
        System.out.println(str);
    }

这样我们就简单的通过冒泡排序实现了数组的排序，这里解释一下for循环为什么是arr.length - 1，因为元素是两两对比，那么当数组长度为2的时候我们只需要对比一次就能得出结果了，所以循环次数为arr.length - 1。

2、优化实现：

上面我们虽然简单的使用了冒泡排序，但能不能再进行优化呢？答案是可以的，我们一起来看一下，每次for循环后，我们都会获取到当前数组的最大元素，并放在数组的最后位置。那么我们下一次循环是否能够不再对上一次循环获取到的最大元素进行对比呢？就拿上面的数组{1,3,2,7,5,4,8,9,6}，在第一次循环后的结果是{1,2,3,5,4,7,8,6,9}，那么在第二次循环的时候不用再对比6跟9了，因为9已经是第一次循环获取到的数组中的最大元素了。根据这个思想，我们来做一下代码优化：

/**
     * 冒泡排序
     */
    public void bubbleSort() {
        int[] arr = {1, 3, 2, 7, 5, 4, 8, 9, 6};
        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]) {
                    int a = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = a;
                }
            }
        }

        String str = "";
        for (int i : arr) {
            str += i;
        }
        System.out.println(str);
    }

具体优化在：arr.length - 1 - i；由于每次循环能找出当次的最大值，所以下一次的对比数=arr.length - 1 - 当前循环的次数，即arr.length - 1 - i。

3、最优实现。

我们来看一组特殊的数组{2, 1, 3, 4, 5, 6, 7, 8, 9}，很明显这组数据只要循环一次就能把排序排好，那我们要如何优化呢？由于一次循环后便能排好序，那么在下次循环的时候便不会有元素交换位置。根据这个思想，我们来做一下代码优化：

/**
     * 冒泡排序
     */
    public void bubbleSort() {
        int[] arr = {2, 1, 3, 4, 5, 6, 7, 8, 9};
        for (int i = 0; i < arr.length - 1; i++) {
            boolean flag = true;//增加标记
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int a = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = a;
                    flag = false;
                }
            }
            if (flag)
                break;
        }

        String str = "";
        for (int i : arr) {
            str += i;
        }
        System.out.println(str);
    }

增加一个标记，当某一次循环没有元素更换位置的时候，便是数组排序好了。在这个时候结束循环就行了。

至此简单的冒泡排序便结束了。

4、冒泡排序优缺点

1.优点:比较简单，空间复杂度较低，是稳定的；

2.缺点:时间复杂度太高，效率慢；