冒泡排序 --分析及代码实现（含改进）

冒泡排序：冒泡排序的名字和排序的过程很形象，大的“泡泡”一点点向上移动。

思想： 比较相邻的两个元素，如果第一个比第二个大，则交换这两个元素。对每一对元素做相同的操作，直到没有元素需要比较。

编程实现：

public class bubbleSort {
    public static void main(String args[]){
        int [] a = {2,1,3,5,4,1,6,8,9,7,3,11};

        for (int i = 0 ;i <a.length;i++){
            System.out.println(sort(a)[i]);
        }
    }
    //冒泡排序
    public static int [] sort (int [] a){
        int temp;
        for (int i = 0;i < a.length-1;i++){
            for( int j = i;j<a.length-1;j++){
                if(a[j] > a[j+1]){
                    temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }
        return a;

    }
}

程序细节：外层循环的跳出判定式为 i <a.length-1,与选择排序类似，可以理解为外层的每一次遍历都将当前的最大值放在当前的位置上（eg:当 i = 0时，将最当前的最大值放在a[0]的位置，当i = x时，将未排序的元素a[x]~a[a.length-1]中的最大值放在a[x] 上），内层的循环是相邻两个元素进行比较，然后冒泡。内层的跳出判定为 j+1<=a.length,即 j <a.length -1。

时间复杂度：算法中有两层循环，外层循环的次数为n-1,内层循环的次数与n线性相关。最深循环中有比较操作,交换操作

最优时间复杂度：最优时间复杂度的情况发生在要排序的数组为正序（和排序后的数组一样），在上面的冒泡排序中代码里，外圈循环次数与数组长度 n 线性相关，内层循环次数也与数组长度线性相关，所以比较的次数近似为 n^2,交换的次数为0。所以上面的冒泡排序的最优时间复杂度为O(n^2)。上面代码可以进一步改进，改进过后的最优时间复杂度为O(n)。改进思路和代码在下面给出。

最坏时间复杂度：最坏时间复杂度的情况发生在要排序的数组为逆序时，上面的代码在最坏情况时，比较的操作为O(n^2),交换的操作也为O(n^2),所以时间复杂度为O(n^2)。

空间复杂度：使用的辅助空间不随数组的长度的改变而改变，所以是O(1)。

算法改进：

思路：对于正序或者尾部为正序时，程序会进行多次无用比较。当内层的循环没有发生交换时，即说明该数组后面为正序，此时因跳出循环。

改进代码：

public class bubbleSort {
    public static void main(String args[]){
        int [] a = {2,1,3,5,4,1,6,8,9,7,3,11};

        for (int i = 0 ;i <a.length;i++){
            System.out.println(sort(a)[i]);
        }
    }
    //改进后的冒泡排序
    public static int [] sort (int [] a){
        int temp;
        boolean flag =true;             //定义一个标志位，表示是否继续
        for (int i = 0;i < a.length-1&& flag;i++){
            flag = false;               //每次进入内层循环时，假设不继续（剩下的元素为正序）
            for( int j = i;j<a.length-1;j++){
                if(a[j] > a[j+1]){
                    temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                    flag =true;         //发生交换时，说明假设不成立，继续循环
                }
            }
        }
        return a;

    }
}

  改进后的代码对与正序的数组和数组尾部正序时，减少了很多的比较操作。在改进后的代码里，最优时间复杂度发生的情况为正序，比较操作执行n-1次，交换操作 0次，所以最优时间复杂度为 O(n),改进后的最坏时间复杂度和改进前一样，空间复杂度也没有改变。