排序算法-冒泡排序

     冒泡排序，是一种比较简单的排序算法，它的每次比较两个相邻的元素，交换顺序。

冒泡排序的主要思想

1.外循环遍历每一个元素

2.内循环比较相邻的两个元素，把极值元素放到最后

假设【12、35、99、18、76】

第一次：35 12 99 18 76

第二次：35 99 12 18 76

第三次：35 99 18 12 76

第四次：35 99 18 76 12

此时最小数已经排好序了

具体实现代码如下：

/**
     * 冒泡排序
     * @param a
     * @param n
     */
    public void BubbleSort(int[] a, int n){
        for(int i=0; i<n-1; i++){ //最多n-1次排序
            boolean flag = false;
            for(int j=0; j<n-i-1; j++){
                if (a[j] < a[j+1]){
                    int temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                    flag = true;
                }
            }
            if (!flag) break;
        }
    }

时间复杂度分析

外层循环执行 N - 1次排序，内层循环最多的时候执行N次，最少的时候执行1次，所以平均执行 (N+1)/2 次。
所以循环体内的比较交换约执行 (N - 1)(N + 1) / 2 = (N^2 -1) / 2，所以时间复杂度为O(N^2)

空间复杂度分析

因为该算法借助的是临时空间，所以平均空间复杂度为O(1)

冒泡算法的性能优化，加入给定的整数序列为 [5,1,2,3,4] ，省略内层循环，外层循环要执行n-1次，即要运行4次

5, 1, 2, 3, 4    i = 0

1, 2, 3, 4, 5    i = 1

1, 2, 3, 4, 5    i = 2  

1, 2, 3, 4, 5    i = 3

可以这么理解，当一次外层循环中，内层循环的元素没有交换位置，就表示数组的元素已经是有序的了，此时可以直接跳出循环。

这里可以加入一个布尔变量标志，判断外层循环中是否有元素交换

/**
     * 冒泡排序优化
     * @param a
     * @param n
     */
    public void BubbleSort(int[] a, int n){
        for(int i=0; i<n-1; i++){ //最多n-1次排序
            boolean flag = false;
            for(int j=0; j<n-i-1; j++){
                if (a[j] < a[j+1]){
                    int temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                    flag = true;
                }
            }
            if (!flag) break;
        }
    }

改进后的冒泡排序，对于一个已经排好序的序列来说，最优的时间复杂度为O(n).