排序算法（二）：冒泡排序

定义：

将待排序的记录两两比较，如果是反序的则交换，直到没有反序记录为止。

时间复杂度：

最好情况 O(n)，最坏情况O(n^2)

实现：

待排序记录

 int[] array = {9,1,5,8,3,7,4,6,2};

1、由前向后排序

public class BubbleF2T {
    public void sort(int[] array){
        for(int i=0;i<array.length;i++){
            for(int j=i+1;j<array.length;j++){
                if(array[i] > array[j]){
                    SortUtils.Swap(array,i,j);  //交换元素
                }
            }
            SortUtils.print(array);
        }
    }
}

排序输出：

Sort Front To Tail...
1 9 5 8 3 7 4 6 2 
1 2 9 8 5 7 4 6 3 
1 2 3 9 8 7 5 6 4 
1 2 3 4 9 8 7 6 5 
1 2 3 4 5 9 8 7 6 
1 2 3 4 5 6 9 8 7 
1 2 3 4 5 6 7 9 8 
1 2 3 4 5 6 7 8 9 
1 2 3 4 5 6 7 8 9

2、由后向前排序

public class BubbleT2F {

    public void sort(int[] arr){
        for(int i=0;i<arr.length;i++){
            for(int j=arr.length-2;j>=i;j--){
                if(arr[j] > arr[j+1]){
                    SortUtils.Swap(arr,j,j+1); //交换元素
                }
            }
            SortUtils.print(arr);
        }
    }
}

排序输出

Sort Tail To Front...
1 9 2 5 8 3 7 4 6 
1 2 9 3 5 8 4 7 6 
1 2 3 9 4 5 8 6 7 
1 2 3 4 9 5 6 8 7 
1 2 3 4 5 9 6 7 8 
1 2 3 4 5 6 9 7 8 
1 2 3 4 5 6 7 9 8 
1 2 3 4 5 6 7 8 9 
1 2 3 4 5 6 7 8 9

冒泡排序的优化：

当待排序记录已经是有序的序列时，再继续进行排序不会有任何元素发生移动，这时继续排序是没有必要的，排序可以提前结束。

public class BubbleT2FOpt {
    public void sort(int[] arr){
        boolean flag=true;
        for(int i=0;i<arr.length && flag;i++){
            flag=false;
            for(int j=arr.length-2;j>=i;j--){
                if(arr[j]>arr[j+1]){
                    SortUtils.Swap(arr,j,j+1);
                    flag=true;
                }
            }
            SortUtils.print(arr);
        }
    }
}