冒泡排序

来源：互联网发布：淘宝二维码用微信打开编辑：程序博客网时间：2024/06/17 11:43

欢迎Java爱好者品读其他算法详解：

简单比较排序：http://blog.csdn.net/ysjian_pingcx/article/details/8652091

选择排序： http://blog.csdn.net/ysjian_pingcx/article/details/8656048

直接插入排序：http://blog.csdn.net/ysjian_pingcx/article/details/8674454

快速排序： http://blog.csdn.net/ysjian_pingcx/article/details/8687444

快速排序优化：http://blog.csdn.net/ysjian_pingcx/article/details/8687444

冒泡排序法<详解+优化>

冒泡排序法，是个大学生都听过吧，游泳时也会吹个泡泡什么的，这个排序算法被老师作为排序算法的入门算法，很基础，由于名字比较特别，我就一直记住了，今天想把这个写下来。

冒泡思想：

假如将不同的数放在不同的气泡中，依次是最小的数放在最大的气泡中，那么，我们知道，在水中，这些气泡会上浮，越大越容易上浮，那么，当一连串气泡挨在一起时，两个相邻的气泡就会在浮力东风作用下交换位置，浮力大的，也就是大的气泡上浮，就这样，一次交换下去，最后是最大的气泡在最上面。

冒泡排序：

Bubble sort 属于一种交换排序，两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止。

两两比较:

@反序：两两交换。

@正序：指针后移，下两个记录两两比较。

看一个冒泡排序一轮排序的的过程：

也就是两两比较，以数组为例，比较过程：

第一轮：数组下标为0的元素与1的元素相比，25<36,正序，指针后移，36>21反序，交换36和21，指针后移，36<45正序，指针后移，45<98正序，指针后移，98>13反序，交换98和13，最后98位于为底端，也就是数组的末尾。比较次数为(n-1)

第二轮：还是从数组下标为0开始两两比较，在第一比较后的结果98就不参与比较，比较次数为(n-2);

......

核心比较和交换的代码：

[java] view plain copy
/** 
     * 原始的冒泡排序法,时间复杂度为O(n2) 
     *  
     * @param array 
     */  
    public void bubbleSort(int... array) {  
        int length = array.length;  
        for (int i = 0; i < length - 1; i++) {  
            for (int j = 0; j < length - i - 1; j++) {// 内部循环的边界要比长度小一  
                if (array[j] > array[j + 1]) {  
                    swap(j, j + 1, array);//相邻的两个元素比较，将大的放到最右边  
                }  
            }  
        }  
    }  

@注意上边的外部循环的边界是 length-1,因为最后一个元素不用比较了。

[java] view plain copy
for (int i = 0; i < length - 1; i++)  

@内部循环的边界随着外部循环的变化而变化，也就是在前面比较后的记录就不用参与下一轮的比较。

[java] view plain copy
for (int j = 0; j < length - i - 1; j++)  

@swap依然是一个交换数组两个元素的函数：

[java] view plain copy
/** 
     * 内部实现，用于交换数组的两个引用值 
     *  
     * @param beforeIndex 
     * @param afterIndex 
     * @param arr 
     */  
    private void swap(int oneIndex, int anotherIndex, int[] array) {  
        int temp = array[oneIndex];  
        array[oneIndex] = array[anotherIndex];  
        array[anotherIndex] = temp;  
    }  

那么将完整的代码列出来：

[java] view plain copy
/** 
 * 冒泡排序法 
 *  
 * @author PingCX 
 *  
 */  
public class BubbleSort {  
  
    public static void main(String[] args) {  
        BubbleSort bubbleSort = new BubbleSort();  
        int[] array = { 25, 36, 21, 45, 98, 13};  
        System.out.println(Arrays.toString(array));  
        bubbleSort.bubbleSort(array);// 调用快速排序的方法  
        System.out.println(Arrays.toString(array));// 打印排序后的数组元素  
    }  
  
    /** 
     * 原始的冒泡排序法,时间复杂度为O(n2) 
     *  
     * @param array 
     */  
    public void bubbleSort(int... array) {  
        int length = array.length;  
        for (int i = 0; i < length - 1; i++) {  
            for (int j = 0; j < length - i - 1; j++) {// 内部循环的边界要比长度小一  
                if (array[j] > array[j + 1]) {  
                    swap(j, j + 1, array);//相邻的两个元素比较，将大的放到最右边  
                }  
            }  
        }  
    }  
  
    /** 
     * 内部实现，用于交换数组的两个引用值 
     *  
     * @param beforeIndex 
     * @param afterIndex 
     * @param arr 
     */  
    private void swap(int oneIndex, int anotherIndex, int[] array) {  
        int temp = array[oneIndex];  
        array[oneIndex] = array[anotherIndex];  
        array[anotherIndex] = temp;  
    }  
}  

小结：冒泡排序法最核心的地方就是两两比较交换了，这种排序法容易被人理解和记忆，实现起来不难，性能稍高于比较排序算法，时间复杂度也是O(n²)

有一个问题来了：就是如果一个数组开始是有序的，照上面的算法，每一次都要进行比较，这样对有序的数组来说是多余的，我们是不是可以做一些改进，在第一轮比较之后，如果发现有序的，就是没有数据交换，后面的比较可以省去，直接跳出循环呢？

----->答案是可以的，这是我们需要一个标记，boolean flag = true;辅助我们，看看下面的代码：

[java] view plain copy
/** 
     * 优化的冒泡排序法,时间复杂度为O(n2) 
     *  
     * @param array 
     */  
    public void bubbleSort(int... array) {  
        int length = array.length;  
        boolean flag = true; //一个标记  
        for (int i = 0; i < length - 1 && flag; i++) {//加这个条件就是当有序的时候就不用重复后面的操作了  
            flag = false;  
            for (int j = 0; j < length - i - 1; j++) {  
                if (array[j] > array[j + 1]) {  
                    swap(j, j + 1, array);// 相邻的两个元素比较，将大的放到最右边  
                    flag = true;  
                }  
            }  
        }  
    }  

@上边的代码多了一个 boolean flag = true;

@外部循环的条件也有所改变：

[java] view plain copy
for (int i = 0; i < length - 1 && flag; i++)  

@开始flag为true，能进入循环，已进入循环就将flag = false;：

[java] view plain copy
for (int i = 0; i < length-1 && flag; i++) {//加这个条件就是当有序的时候就不用重复后面的操作了  
    flag = false;//进入循环体，就置为false  

@在内部循环中，如果存在反序,又将flag置为true，下一轮就可以进入，反之就直接退出外部循环了：

[java] view plain copy
if (array[j] > array[j + 1]) {  
    swap(j, j + 1, array);// 相邻的两个元素比较，将大的放到最右边  
    flag = true;//存在反序的就将flag置为true  
}  

这样就解决了有序数组重复比较的问题，对象能有所优化。

完整代码如下：

[java] view plain copy
/** 
 * 优化的冒泡排序法 
 *  
 * @author PingCX 
 *  
 */  
public class BubbleSortOpt {  
  
    public static void main(String[] args) {  
        BubbleSortOpt bubbleSort = new BubbleSortOpt();  
        int[] array = { 25, 36, 21, 45, 98, 13};  
        System.out.println(Arrays.toString(array));  
        bubbleSort.bubbleSort(array);// 调用快速排序的方法  
        System.out.println(Arrays.toString(array));// 打印排序后的数组元素  
    }  
  
    /** 
     * 优化的冒泡排序法,时间复杂度为O(n2) 
     *  
     * @param array 
     */  
    public void bubbleSort(int... array) {  
        int length = array.length;  
        boolean flag = true; //一个标记  
        for (int i = 0; i < length-1 && flag; i++) {//加这个条件就是当有序的时候就不用重复后面的操作了  
            flag = false;//进入循环体，就置为false  
            for (int j = 0; j < length - i - 1; j++) {  
                if (array[j] > array[j + 1]) {  
                    swap(j, j + 1, array);// 相邻的两个元素比较，将大的放到最右边  
                    flag = true;//存在反序的就将flag置为true  
                }  
            }  
        }  
    }  
  
    /** 
     * 内部实现，用于交换数组的两个引用值 
     *  
     * @param beforeIndex 
     * @param afterIndex 
     * @param arr 
     */  
    private void swap(int oneIndex, int anotherIndex, int[] array) {  
        int temp = array[oneIndex];  
        array[oneIndex] = array[anotherIndex];  
        array[anotherIndex] = temp;  
    }  
}  

上面是对int[] 进行的排序，那么面向对象的这这应用不能只局限于int[] 数组中，也就是任何可以比较的类型都可以用冒泡来排序，下面是优化后的代码的实现：

[java] view plain copy
/** 
 * 冒泡排序法 
 *  
 * @author PingCX 
 *  
 */  
public class BubbleSortTOpt {  
  
    public static void main(String[] args) {  
        BubbleSortTOpt bubbleSort = new BubbleSortTOpt();  
        Integer[] array = { 25, 36, 21, 45, 98, 13};  
        System.out.println("Before sorting:");  
        System.out.println(Arrays.toString(array));  
        bubbleSort.bubbleSort(array);// 调用冒泡排序的方法  
        System.out.println("After sorting：");  
        System.out.println(Arrays.toString(array));// 打印排序后的数组元素  
    }  
  
    /** 
     * 冒泡排序法,时间复杂度为O(n2) 
     *  
     * @param array 
     */  
    public <T extends Comparable<T>> void bubbleSort(T[] array) {  
        int length = array.length;  
        boolean flag = true;  
        for (int i = 0; i < length - 1 && flag; i++) {  
            flag = false;  
            for (int j = 0; j < length - i - 1; j++) {  
                if (array[j].compareTo(array[j + 1]) > 0) {  
                    swap(j, j + 1, array);// 相邻的两个元素比较，将大的放到最右边  
                    flag = true;  
                }  
            }  
        }  
    }  
  
    /** 
     * 内部实现，用于交换数组的两个引用值 
     *  
     * @param beforeIndex 
     * @param afterIndex 
     * @param arr 
     */  
    private <T extends Comparable<T>> void swap(int oneIndex, int anotherIndex,  
            T[] array) {  
        T temp = array[oneIndex];  
        array[oneIndex] = array[anotherIndex];  
        array[anotherIndex] = temp;  
    }  
}  

冒泡冒泡，浮力大了，就会上浮，我们要充实自己，沉淀自己...

"做一个丰盈的男人，不虚华，不浮躁，以先锋的姿态去拼搏奋斗；做一个明媚的女子，不倾国，不倾城，以优雅的姿势去摸爬滚打"