算法-排序-冒泡排序算法

资料参考：
1、《大话数据结构》

1、基本思想

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

2、前期准备和说明

1、以下所有版本的都已升序为主。

2、存储排序值的类，是一个自定义的类型：

public class ArrayList {

    private int MAXSIZE = 10; //链表的最大空间，可根据需要修改

    private int length =0; //用于记录顺序链表的实际长度

    private int[] nodes = null; //用于要存储节点的容器（数组）

    public  ArrayList(){
        nodes = new int[MAXSIZE];
    }
    public ArrayList(int MAXSIZE){
        this.MAXSIZE = MAXSIZE;
        nodes = new int[MAXSIZE];
    }

    /**
     * 插入数据
     * @param value
     */
    public void add(int value){
        if(nodes.length==0){
            nodes[0] = value;
            length+=1;
        }else if (length<MAXSIZE){
           nodes[length] = value;
           length+=1;
        }else if (length==MAXSIZE){
            nodes[length] = value;
        }else{
            try {
                throw new Exception();
            } catch (Exception e) {
               System.out.println("空间满了");
            }
        }

    }

    public void update(int offset ,int value){
        nodes[offset] = value;
    }

    /**
     * 交换i，j的位置
     */
    public void swap(int i,int j){
        int temp = getNote(i);
        update(i,getNote(j));
        update(j,temp);
    }
    /**
     * 获取指定下标对应的节点。
     * @param offset
     * @return
     */
    public Integer getNote(int offset){
        if(offset>=length || offset<0){
            return null;
        }
        return  nodes[offset];
    }

    public int getMAXSIZE() {
        return MAXSIZE;
    }

    public int getLength() {
        return length;
    }

    @Override
    public String toString() {
        StringBuffer str = new StringBuffer();
        for(int node:nodes){
            str.append(node).append(" ");
        }
        return str.toString();
    }
}

3、最简单的实现版本

思路：让每一个关键字，都和他后面的关键字比较，如果大则交换。

说明：这种方式严格意义上说，不算是标准的冒泡排序算法，因为他不满足“两两比较相邻记录”的冒泡排序思想，它更应该是最最简单的交换排序而已。

代码：

    // 输入：9 1 5 8 3 7 4 6 2
public void bubbleSort(ArrayList arrayList){
    for(int i=0;i<arrayList.getLength();i++){
        for(int j=i+1;j<arrayList.getLength();j++){
            if(arrayList.getNote(i)>arrayList.getNote(j)){
                arrayList.swap(i,j); //保证i一直都是最小的
            }
        }
    }
    System.out.println(arrayList.toString());//输出：1 2 3 4 5 6 7 8 9
}

图例：

缺点：在上图，排序好1和2的位置后，对其余关键字的排序没有什么帮助（数字3反而还被换到了最后一位）。这个算法的效率非常低。

4、正宗的冒泡排序算法

思路：两两比较相邻关键字，如果反序列则交换，差异在于内循环采用的是反向循环。
图例说明：
序列[9,1,5,8,3,7,4,6,2],长9，下标从0到8；
第一次循环：变量 i=0,变量 j=7，变量j从7反向循环到0，逐个比较，将较小值交换到前面，直到最后找到最小的值放置在第0位上。同时我们还把关键字2从第8位提到第2位置上，在很多数据排序过程中，这种差异会明显体现出来。看下图较小的数字如同气泡般慢慢浮到上面，因此该算法叫冒泡算法。

第二次循环：变量 i=1,变量 j=7，变量j从7*反向循环*到1，逐个比较，将较小值交换到前面，关键字4和3有所提升，如下图：

代码：

// 输入： 9 1 5 8 3 7 4 6 2
public void bubbleSort(ArrayList arrayList){
   for(int i=0;i<arrayList.getLength();i++){
            //每次都从倒数第二位开始遍历（反向遍历）
            for(int j=arrayList.getLength()-2;j>=i;j--){ 
                if(arrayList.getNote(j)>arrayList.getNote(j+1)){
                   //一直保证当前循环中的i是最小的
                    arrayList.swap(j,j+1);  
                }
            } 
        }
    }
    System.out.println(arrayList.toString());//输出：1 2 3 4 5 6 7 8 9
}

5、冒泡排序算法优化

思路：代码的改动就在于加了一个标识flag，在移动之前判断flag是否为false。经过这样的改动，冒泡排序在性能上就有了一些提示，可以避免因已经有序的情况下的无意义的循环判断
代码：

// 输入： 9 1 5 8 3 7 4 6 2
public void bubbleSort(ArrayList arrayList){
     boolean flag = true;
     for(int i=0;i<arrayList.getLength();i++){
         if(!flag) break;
         flag = false;
         for(int j=arrayList.getLength()-2;j>=i;j--){  //每次都从倒数第二位开始遍历
             if(arrayList.getNote(j)>arrayList.getNote(j+1)){
                 arrayList.swap(j,j+1);
                 flag = true;
             }
         }
     }
    System.out.println(arrayList.toString());//输出：1 2 3 4 5 6 7 8 9
}

6、冒泡排序复杂度分析

n是表的长度，当最好的情况，也就是要排序的表本身就是有序的，根据算法“冒泡排序优化” 可知我们比较次数是n-2（从0开始）次的比较，没有数据交换，时间复杂度为O[n]。当最坏的情况，即待排序表是逆序的情况下，此时需要比较：

即 n^2 次，并做同等数量级的记录移动，因此总的时间复杂度为O[n^2]。

等式说明：(n-2-i+1）是一次循环的时间复杂度，求和后就是多次循环后的时间复杂度。