排序---冒泡排序

冒泡排序

• 冒泡排序原理

• Java代码

• 总结

---

冒泡排序原理

如图1：
冒泡排序：即将这样一连串的泡泡（各种可比较大小的数据），通过两两相比较的办法，排列出一定的顺序。
以从小到大的排序顺序为例，需要一下步骤：
1.从上到下依次两两相比较，若上面的大于下面的则交换位置，否则位置不变，直到最后两个元素比较完成，这样的操作称为一趟比较，第一趟比较一定是将最大的泡泡排在最后一个位置。
2.同理，第二趟是将第二大泡泡排在倒数第二位置，所以只需比较到倒数第二个位置，因为最后一个位置的泡泡已经确定。
3.依次方法，直到第一个泡泡位置确定
4.n个泡泡，每次确定一个泡泡的位置，所有一共需要n趟排序。

Java代码

package cn.com.mp.sort;

public class BubbleSort {
    public static void main(String[] args) {
        //int[] array = { 2, 3, 5, 6, 7, 9, 45, 56, 90 };
        int[]  array={56,2,8,5,9,46,53,7,1};
        sort(array);
    }

    /* 定义冒泡排序算法 */
    public static void sort(int[] array) {

        int len = array.length;//数组长度，一共多少元素
        /*
         * 1.从数组的最后一个元素到第一个元素，定义len趟排序
         * 2.倒着遍历数组的好处：方便控制每一趟里面进行多少次比较
         * 
         **/
        for (int i = len - 1; i >= 0; i--) {
            /*
             * 定义标识位flag=false；若发现交换则flag=true
             * 一趟比较结束，判断flag，若为false则证明整个一趟没有交换一个数据
             * 则也证明所有元素都已经是排序好的，此时为节省运行时间就可以马上结束程序，提高效率
             * */
            boolean flag = false;
            /*
             * 定义每一趟里面需要多少次比较,即判断条件为j<i,以第一趟为例
             * 1.第一趟：就需要比较0到len-2下标的元素，即第一个元素到倒数第二个元素
             * 2.不定义为j<=i原因：if语句中会对j+1进行判断，即也会判断到最后一个元素
             * 3.若条件定义为j<=i,则判断最后一个元素时，j+1已经不在数组中，会发生数组下标越界的错误
             * */
            for (int j = 0; j < i; j++) {
                /*
                 * 相邻元素两两进行比较，当前一个元素严格大于后一个元素时，两元素交换位置
                 * */
                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    flag = true;
                }
            }
            /*
             * 判断是否发生过交换，若没有，则结束比较，证明所有元素已经是排序好的
             * */
            if (!flag) {
                break;
            }
        }
        /*
         * 遍历输出结果
         * */
        for (int i = 0; i < len; i++) {
            System.out.print(array[i] + "   ");
        }
    }
}

运行结果：

总结：

1.时间复杂度：
最好情况，所有的元素都已经排序好，只进行一趟排序，一次for循环，所以时间复杂度为O(n)
最坏情况，元素乱序，需要进行n趟排序，两层for循环，所以时间复杂度为O(n^2)
2.稳定性
因为定一个严格的判断，只有if(array[i]>array[i+1]),即前一个元素完全大于后一个元素时才交换位置，相等时并不交换位置，保证了稳定性，所以冒泡排序是稳定性排序
3.建议
建议建立断点，使用Junit跟踪调试当数组已经是排序好的情况，用于验证flag标识位的优势。