排序篇(1)--冒泡排序

一、冒泡排序算法

基本思想：两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止。

二、冒泡排序代码实例

package Sort;

/**
 * Created by LKL on 2017/2/28.
 */
public class TestBubbleSort {

    public static void main(String[] args){
        int[] adj ={9,1,5,8,3,7,4,6,2};
        BubbleSort3(adj);
        for(int i:adj){
            System.out.print(i);
        }
    }
    private static void BubbleSort1(int[] adj){
        int i=0;
        int j=0;
        int temp=0;
        for(i=0;i<adj.length;i++){
            for(j=i+1;j<adj.length;j++){
                if(adj[i]>adj[j]){
                    temp=adj[i];
                    adj[i]=adj[j];
                    adj[j]=temp;
                }
            }
        }
    }
    //真正的冒泡排序，由下往上，一个个比较，当数据量达到十万级别，优势明显
    private static void BubbleSort2(int[] adj){
        int temp=0;
        for(int i=0;i<adj.length;i++){
            for(int j=adj.length-2;j>=i;j--){
                if(adj[j]>adj[j+1]){
                    temp=adj[j];
                    adj[j]=adj[j+1];
                    adj[j+1]=temp;
                }
            }
        }
    }
    //冒泡排序优化,应对一些特殊情况，比如说{2,1,3,4,5,6,7,8,9}
    private static void BubbleSort3(int[] adj){
        int i=0;
        int j=0;
        int temp=0;
        boolean flag=true;
        for(i=0;i<adj.length && flag;i++){
            flag=false;
            for(j=adj.length-2;j>=i;j--){
                if(adj[j]>adj[j+1]){
                    temp=adj[j];
                    adj[j]=adj[j+1];
                    adj[j+1]=temp;
                    flag=true;
                }
            }
        }
    }
}

上述实例中有三种方式，下面单独分析：

第一种：

int[] adj ={9,2,3,4,1,7,8,5,6};
int temp=0;
for(int i=0;i<adj.length;i++){
    for(int j=i+1;j<adj.length;j++){
        if(adj[i]>adj[j]){
            temp=adj[i];
            adj[i]=adj[j];
            adj[j]=temp;
        }
    }
}
//打印输出
for(int i : adj){
    System.out.print(i);
}

此种算法有缺陷，效率较低，比如上述实例中，在排序好1和2的位置后，对其余关键字并没有什么帮助。
第二种：

int[] adj={9,2,3,4,1,7,8,5,6};
int temp=0;
for(int i=0;i<adj.length;i++){
    for(int j=adj.length-2;j>=i;j--){
        if(adj[j]>adj[j+1]){
            temp=adj[j];
            adj[j]=adj[j+1];
            adj[j+1]=temp;
        }
    }
}

冒泡排序优化，应对一些特殊情况，比如说{2,1,3,4,5,6,7,8,9}
第三种：

int[] adj={9,2,3,4,1,7,8,5,6};
int temp=0;
boolean flag=true;
for(int i=0;i<adj.length&&flag;i++){
    for(int j=adj.length-2;j>=i;j--){
        if(adj[j]>adj[j+1]){
            temp=adj[j];
            adj[j]=adj[j+1];
            adj[j+1]=temp;
            flag=true;
        }
    }
}

以上三种情况，推荐使用第三种。

三、冒泡排序复杂度分析

最好的情况，需要排序的表本身就是有序的，则需要n-1比较，没有数据交换，此时的时间复杂度为O(n);
最坏的情况，待排序表是逆序的，此时需要比较1+2+3+4+…+(n-1)=n(n-1)/2,此时的时间复杂度为O(n^2)。

文章只是作为自己的学习笔记，借鉴了网上的许多案例，如果觉得阔以的话，希望多交流，在此谢过…