算法-冒泡排序算法

1.基本介绍

   冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。

   它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

   这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

2.算法原理

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。 

2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 

3. 针对所有的元素重复以上的步骤，除了最后一个。 

4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

3.算法推演

现有数组10, 3, 20, -1, -5，按照冒泡算法的思想进行排序

第一轮排序：

原数组：10, 3, 20, -1, -5

（1）3,10,20，-1，-5//相邻两个元素顺序排列

（2）3,10,20，-1，-5

（3）3,10，-1,20，-5

（4）3,10，-1，-5,20

一个大小为5的数组，经过四次冒泡比较相邻两个数大小，筛选出该数组最大的一个数值，但此时其他四个数，还是杂序，仍需进行再次冒泡比较。

 

第二轮排序：

第一轮排序结果：3,10，-1，-5,20

（1）3,10，-1，-5,20//虽然此处3<10但其实就算法而言，前四个数仍需再次进行比较，此处后面可优化

（2）3，-1,10，-5,20

（3）3，-1，-5,10,20//因为第一轮已经筛选出最大值了，因此可以少进行一次比较

 

第三轮排序：

第二轮排序结果：3，-1，-5,10,20

（1）-1,2，-5,10,20

（2）-1，-5,2,10,20

 

第四轮排序：

第三轮排序结果：-1，-5,2,10,20

（1）-5，-1,2,10,20

总结：

根据上面算法推理可得出结论：

（1）一共进行数据组大小-1轮循环

（2）每一轮实际进行的排序比前一次少一次

（3）对于某轮中不需要进行比较大小的时候，可以作为优化点

 

4.代码实现

public class BubbleSort {
    public static void main(String[] args) {
        int[] arrays = {10, 3, 20, -1, -5};

        int temp = 0;
        for (int i = 0; i < arrays.length - 1; i++) {
            for (int j = 0; j < arrays.length - 1; j++) {
                if (arrays[j] > arrays[j + 1]) {
                    temp = arrays[j];
                    arrays[j] = arrays[j + 1];
                    arrays[j + 1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arrays));
    }
}

运算结果：

5.算法优化

当有些数组在进行某次排序的时候，可以不全部比较就能得到顺序排列的数组时，就没必要全部进行排序，节省一些计算资源，优化方案如下：

public class BubbleSort {
    public static void main(String[] args) {
        int[] arrays = {10, 3, 20, -1, -5};
        boolean flag = false;//交换标志
        int temp = 0;
        for (int i = 0; i < arrays.length - 1; i++) {
            for (int j = 0; j < arrays.length - 1; j++) {
                if (arrays[j] > arrays[j + 1]) {
                    flag = true;
                    temp = arrays[j];
                    arrays[j] = arrays[j + 1];
                    arrays[j + 1] = temp;
                }
            }
            if (!flag) {
                break;
            } else {
                flag = false;
            }
        }
        System.out.println(Arrays.toString(arrays));
    }
}

 

6.时间复杂度

一般为O(n²)，当然数组本身有序，或者大部分有序的特例不做标准。