数据结构与算法——冒泡排序

冒泡排序（Bubble Sort）一种交换排序，它的基本思想是：两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止。

方法一：（初级版本的冒泡排序算法）从第一位开始循环比较，让每一个关键字都和它后面的每一个关键字比较，如果大则交换。

public class BubbleSort {
    public void bubbleSort(int[] arr) {
        if(arr==null || arr.length==1) {
            return;
        }
        int i,j;
        int len=arr.length;
        for(i=0;i<len;i++) {
            for(j=i+1;j<len;j++) {
                if(arr[i]>arr[j]) {
                    swap(arr,i,j);
                }
            }
        }    
    }
    public void swap(int[] arr,int i,int j) {
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }
}

方法二：（正宗的冒泡排序算法）

public class BubbleSort {
    public void bubbleSort(int[] arr) {
        if(arr==null || arr.length==1) {
            return;
        }
        int i,j;
        int len=arr.length;
        for(i=0;i<len;i++) {
            for(j=len-1;j>i;j--) {//注意j是从后往前循环
                if(arr[j-1]>arr[j]) {
                    swap(arr,j-1,j);
                }
            }
        }    
    }
    public void swap(int[] arr,int i,int j) {
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }
}

方法三：（优化的冒泡排序算法）

public class BubbleSort {
    public void bubbleSort(int[] arr) {
        if(arr==null || arr.length==1) {
            return;
        }
        int i,j;
        boolean flag=true;    //flag用来作为标记
        int len=arr.length;
        for(i=0;i<len && flag;i++) {   //若flag为false则退出循环
            flag=false;                //初始为false
            for(j=len-1;j>i;j--) {
                if(arr[j-1]>arr[j]) {
                    swap(arr,j-1,j);
                    flag=true;         //如果有数据交换，则flag为true
                }
            }
        }    
    }
    public void swap(int[] arr,int i,int j) {
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }
}

冒泡排序复杂度分析

• 算法最好的时间复杂度为O(n)
• 算法最坏的时间复杂度为1+2+3+…+(n-1)=(n(n-1))/2次
• 算法的平均时间复杂度为O(n²)
• 算法的稳定性：冒泡排序算法是稳定的（相同元素的前后顺序并没有改变）