冒泡排序

情景：对数组 int[] arr = {6,9,5,2,8,7}中的数据 从小到大排序

思路：从下标为0开始比较，如果arr[0] > arr[1],则交换；否则，不做任何处理。然后同理比较arr[1]和arr[2]，，，arr[maxSize-2]和arr[maxSize-1]。经过一轮比较，最大的数据排到最右侧，也就是maxSize-1的位置，此数据自此不再参与比较。接下来进行第二轮比较，也是从下表为0开始比较，一直比较到arr[maxSize-2]。同理，进行第三轮，第四轮，直至结束。注意，红色数字表示已排序。

第一轮排序后：6 5 2 8 7 9

第二轮排序后：5 2 6 7 8 9

第三轮排序后：2 5 6 7 8 9 

第四轮排序后：2 5 6 7 8 9 

第五轮排序后：2 5 6 7 8 9 

代码：

/**
 * 冒泡排序
 * @author D N
 *
 */
public class BubbleSort {
    private long[] a; 
    private int nElems;
    
    public BubbleSort(int max){
        a = new long[max];
        nElems = 0;
    }    
    
    public void insert(long value){
        a[nElems] = value;
        nElems++;
    }
    
    public void display(){
        for(int j=0;j<nElems;j++){
            System.out.print(a[j]+"   ");
        }
        System.out.println("");
    }
    // 交换两个对象
    public void swap(int one,int two){
        long temp = a[one];
        a[one] = a[two];
        a[two] = temp;
    }
    
    //冒泡排序算法 核心逻辑
    public void bubbleSort(){
        int in,out;
        for(out = nElems-1;out > 1;out--){
            for(in = 0;in < out;in++){
                if(a[in] > a[in+1]){
                    swap(in, in+1);
                }
            }
        }
    }
    
}

运行测试代码：

public class SortTest {
    public static void main(String[] args) {
        int maxSize = 10;
        BubbleSort arr = new BubbleSort(maxSize);
        arr.insert(88);
        arr.insert(99);
        arr.insert(22);
        arr.insert(66);
        arr.insert(33);
        arr.insert(77);
        arr.insert(11);
        arr.insert(44);
        arr.insert(55);
        arr.display();
        arr.bubbleSort();
        arr.display();
    }
}

运行结果：

88 99 22 66 33 77 11 44 55
11 22 33 44 55 66 77 88 99

效率分析：

一般来说，如果数组中有N个数据，那么在第一轮排序中会有N-1次比较，第二轮排序中会有N-2次比较。以此类推，所以大约进行了N²/2次比较，如果数据是随机的，大约会有N²/4次交换。比较和交换次数都和N²成正比所以，其时间复杂度为O_(n²)。