冒泡排序

1：概念

  就是对待排序的序列，从前往后的依次比较相邻的数据之间的大小关系，如果满足排序则交换位置，这样子每一次排序就找到当前的最大值放在最边上！优化设计：若有一次排序中，没有任何数据进行交换！则可以设置标志位，代码此序列已经是有序的了，不用再继续比较，从而进行优化！

 

2：设计思想

经过冒泡算法的定义，可以知道我们通过一次外循环和一次内循环可以构建算法复杂度为O(n^2)的算法来实现冒泡算法。

内循环从0开始进行相邻的数据数据的判断，然后如果满足大小顺序，则交换，外循环变量控制内循环的循环次数即范围。

同时增加了，判断序列是否已经是有序的标志位flag，即当内循环在一次循环后，若没有数据进行交换，意味着所有数据已经是有序的了！

package sort;

public class BubbleSortTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] array = new int[] {
                3,4,51,2,3,44,213,12,51,99,2
        };
        
        System.out.println("排序前的序列：");
        for(int i:array) {
        System.out.print(i+" ");
        }
        
        BubbleSort bs = new BubbleSort(array);
        bs.startSort();
        System.out.println("");
        System.out.println("排序后的序列：");
        for(int i:array) {
        System.out.print(i+" ");
        }
    }

}

//冒泡排序算法
class BubbleSort{
    //时间复杂度为O(n^2)
    private int temp ;//定义变量temp，用来交换中的缓存数据
    private boolean flag;//是否进行过交换的标志？false代表没有交换过，true则代表交换过
    private int[] array;//待排序的数组
    private int length;//待排序的数组长度
    
    
    public BubbleSort(int[] a) {
        this.array = a;
        this.temp = 0;
        this.flag = false;
        this.length = array.length;
    }
    //冒泡排序
    //若一次循环后，没有数据交换过,即flag始终为false，则说明上一次的循环，没有数据交换过，则意味着已经是有序得了！
    public void startSort() {
        for(int i=0;i<this.length-1;i++) {
            for(int j=0;j<this.length-i-1;j++) {
                if(this.array[j]>this.array[j+1]) {//如果第i个数大于i+1的数，则交换
                    this.temp = this.array[j];
                    this.array[j] = this.array[j+1];
                    this.array[j+1] = this.temp;
                    this.flag = true;//代表着序列已经交换过！
                }
            }
            if(this.flag == false) {//经过一次排序后，没有数据交换，则意味着，数据已经是有序的了，直接退出即可！
                break;
            }
            else {
                this.flag = false;//至false，为下一次循环准备。
            }
        }
    }
}