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

定义：

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

时间复杂度：

最好情况 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);        }    }}