冒泡排序

冒泡排序就是把数大的放到后面，

趟，从头比到“尾”（没有排序好的最后一个数），比出最大的一个。

比较次数，在没有比较好的一堆数组里，找出最大的用的次数！
每比较一次的过程中，可以看作有两个指针一直往前移动，比较前面的指针指的数 与 后面指针指的数的大小。 所以，每一趟中，剩下几个没比较好的数-1，就是要比较的次数。

稳定
稳定是指排序之后两个相同的数的相对位置有没有变化，没有就是稳定

时间复杂度，要比较 n-1+…+1 次，根据规则去掉最低项，去掉常数，系数，就是 O（n2）(平方的意思)
若文件的初始状态是正序的，一趟扫描即可完成排序。所需的关键字比较次数C和记录移动次数M均达到最小值：Cmin = N - 1, Mmin = 0。所以，冒泡排序最好时间复杂度为O(N)。
若初始文件是反序的，需要进行 N -1 趟排序。每趟排序要进行 N - i 次关键字的比较(1 ≤ i ≤ N - 1)，且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下，比较和移动次数均达到最大值：
Cmax = N(N-1)/2 = O(N2)
Mmax = 3N(N-1)/2 = O(N2)
冒泡排序的最坏时间复杂度为O(N2)。
因此，冒泡排序的平均时间复杂度为O(N2)。
总结起来，其实就是一句话：当数据越接近正序时，冒泡排序性能越好。

冒泡排序可以优化，当有一次没有交换时，就时有序了！

（下面比较的一堆是从kkun博客中copy的，懒…）
原始待排序数组| 6 | 2 | 4 | 1 | 5 | 9 |

第一趟排序(外循环)

第一次两两比较6 > 2交换(内循环)

交换前状态| 6 | 2 | 4 | 1 | 5 | 9 |

交换后状态| 2 | 6 | 4 | 1 | 5 | 9 |

第二次两两比较,6 > 4交换

交换前状态| 2 | 6 | 4 | 1 | 5 | 9 |

交换后状态| 2 | 4 | 6 | 1 | 5 | 9 |

第三次两两比较,6 > 1交换

交换前状态| 2 | 4 | 6 | 1 | 5 | 9 |

交换后状态| 2 | 4 | 1 | 6 | 5 | 9 |

第四次两两比较,6 > 5交换

交换前状态| 2 | 4 | 1 | 6 | 5 | 9 |

交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |

第五次两两比较,6 < 9不交换

交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |

交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |

第二趟排序(外循环)

第一次两两比较2 < 4不交换

交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |

交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |

第二次两两比较,4 > 1交换

交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |
交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

第三次两两比较,4 < 5不交换

交换前状态| 2 | 1 | 4 | 5 | 6 | 9 |
交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

第四次两两比较,5 < 6不交换

交换前状态| 2 | 1 | 4 | 5 | 6 | 9 |

交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

第三趟排序(外循环)

第一次两两比较2 > 1交换

交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

第二次两两比较,2 < 4不交换

交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |
交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

第三次两两比较,4 < 5不交换

交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |
交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

第四趟排序(外循环)无交换

第五趟排序(外循环)无交换

排序完毕,输出最终结果1 2 4 5 6 9

import java.util.*;

public class Main {

    static int bubbo_sort(int[] unsorted) {
        int length = unsorted.length;

        for(int i=0;i<length-1;i++) {//这么多趟阿
            int temp =0;
            for(int j=0;j<length-1-i;j++) {//第i趟要比较这么多次
                if(unsorted[j]>unsorted[j+1]) {//这里说明冒泡排序是稳定的
                    temp = unsorted[j+1];
                    unsorted[j+1] = unsorted[j];
                    unsorted[j] = temp;
                }
            }
        }

        for(int i=0;i<length;i++) {
            System.out.print(unsorted[i]+" ");
        }


        return 1;
    }

    public static void main(String[] args) {
        int[] a = {2,7,3,9,6,9};
        bubbo_sort(a);
    }
}

一个挺好的：http://www.cnblogs.com/jingmoxukong/p/4302718.html