冒泡排序（Bubble Sort）

       好记忆不如烂笔头，排序算法记过很多次了，好久不用就忘了，可能主要还是没有真正理解的过吧，再次总结一次，权当加深记忆，哎，还是比较相信记忆啊。

       冒泡排序的原理： 比较两个相邻的元素，如果它们顺序错误就交换位置，直至没有相邻的元素需要交换为止。

       优点：冒泡排序只交换顺序错误的元素，如果两个相等的元素相邻及相邻后是不会交换的，所以它是一个稳定的排序算法。

       举例：

             正序排序：8，7，6，5，4，3，2，1，10，9

             第一次排序：

                         第一次交换： 7, 8，6，5，4，3，2，1，10，9

                         第二次交换： 7，6，8，5，4，3，2，1，10，9

                         第三次交换： 7，6，5，8，4，3，2，1，10，9

                         第四次交换：7，6，5，4，8，3，2，1，10，9

                         第五次交换： 7，6，5，4，3，8，2, 1，10，9   

                         第六次交换： 7，6，5，4，3，2，8，1，10，9   

                         第七次交换： 7，6，5，4，3，2，1，8，10，9

                         第八次交换：7，6，5，4，3，2，1，8，9，10

            第一次排序结果为： 7，6，5，4，3，2，1，8，9，10

            以此类推：

           第二次排序结果为： 6，5，4，3，2，1，7、8，9，10

           第三次排序结果为： 5，4，3，2，1，6、7、8，9，10

           第四次排序结果为： 4，3，2，1，5、6、7、8，9，10

          第五次排序结果为：  3，2，1，4、5、6、7、8，9，10

           第六次排序结果为： 2，1，3、4、5、6、7、8，9，10

           第七次排序结果为： 1、2，3、4、5、6、7、8，9，10             --------》已正序，但是为了兼顾最坏的情况，需要排序完length-1次，所以还得进行到第九次排序，自己可以以（10，9，8，7，6，5，4，3，2，1）为例进行排序，所以在此可以对冒泡排序进行优化。

          下面是常规的冒泡排序：

          

public void bubbleSort(int[] sort) {
        for (int i=0;i<sort.length-1;i++){
            for (int j=0;j<sort.length-i-1;j++) {
                if(sort[j] > sort[j+1]) {
                    int temp = sort[j];
                    sort[j] = sort[j+1];
                    sort[j+1] = temp;
                }
            }
        }
    }

 优化后的冒泡排序：

public void bubbleSort1(int[] sort) {
        boolean flag;
        int temp;
        for (int i=0;i<sort.length-1;i++){
            flag = false;
            for (int j=0;j<sort.length-i-1;j++) {
                if(sort[j] > sort[j+1]) {
                    temp = sort[j];
                    sort[j] = sort[j+1];
                    sort[j+1] = temp;
                    flag = true;
                }
            }
            if (!flag) {
                break;
            }
        }
    }

经测试： 如果最坏的情况下两者的速度不相上下，但如果最好的情况下，优化后的速度不止一点点。所以说你会选哪一个呢。

记得亲手测试哦~