【排序算法】冒泡排序

一：排序算法

1.1 介绍

排序也称排序算法(Sort Algorithm)，排序是将一组数据，依指定的顺序进行排列的过程。

1.2 分类

1) 内部排序
指将需要处理的所有数据都加载到内部存储器中进行排序。
2) 外部排序法
数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。
3) 常见的排序算法分类

二：冒泡排序

2.1 基本介绍

冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始）,依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。
优化：因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在排序过程中设置
一个标志flag判断元素是否进行过交换。从而减少不必要的比较。(这里说的优化，可以在冒泡排序写好后，在进行)

2.2 图解冒泡排序算法

以3, 9, -1, 10, 20为例

第一趟排序
(1) 3, 9, -1, 10, 20 // 如果相邻的元素逆序就交换
(2) 3, -1, 9, 10, 20
(3) 3, -1, 9, 10, 20
(4) 3, -1, 9, 10, 20

第二趟排序
(1) -1, 3, 9, 10, 20 //交换
(2) -1, 3, 9, 10, 20
(3) -1, 3, 9, 10, 20

第三趟排序
(1) -1, 3, 9, 10, 20
(2) -1, 3, 9, 10, 20

第四趟排序
(1) -1, 3, 9, 10, 20

总结：
(1) 一共进行 数组的大小-1 次 大的循环
(2) 每一趟排序的次数在逐渐的减少
(3) 如果我们发现在某趟排序中，没有发生一次交换， 可以提前结束冒泡排序。这个就是优化

2.3 代码实现

/**
 * @author ikun
 * 冒泡排序
 */
public class BubbleSort {


    /**
     * 冒泡排序
     * 冒泡排序的时间复杂度为O(n的平方)
     *
     * @param array 排序前的数组
     * @return 排序后的数组
     */
    public static int[] bubbleSort(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            //标识符，表示有没有进行过交换
            boolean flag = false;
            //内层循环控制两两比较的次数
            //将最大的数排在最后，比较的次数就是数组长度减一次
            for (int j = 0; j < array.length - 1 - i; j++) {
                //两两比较交换位置,比较前后两个数，如果前面的数比后面的数大，则交换
                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    flag = true;
                }
            }
            //System.out.println("第" + (i + 1) + "次排序后的数组为：" + Arrays.toString(array));
            //表示没有发生过交换
            if (!flag) {
                //如果内层循环没有发生任何交换,则说明数组已经排好序了
                break;
            }
        }
        return array;
    }


    /**
     * 这个方法用来测试冒泡排序
     */
    public static void main(String[] args) {
        //int[] array = {59, 66, 14, 89, 12, 16, 20, 63};
        //测试一下冒泡排序的速度O(n的平方)，测试80000条数据
        long start = System.currentTimeMillis();
        int[] array = new int[8];
        for (int i = 0; i < array.length; i++) {
            //Math.random() * 80000生成0到80000的随机数
            array[i] = (int) (Math.random() * 100);
        }
        System.out.println("排序前的数组为：" + Arrays.toString(array));
        int[] bubbleSort = bubbleSort(array);
        System.out.println("排序后的数组为：" + Arrays.toString(bubbleSort));

        long end = System.currentTimeMillis();
        System.out.println("执行时间为：" + (end - start));

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

运行结果：

三：算法性能分析

3.1 时间复杂度

最优时间复杂度、最坏时间复杂度、平均时间复杂度都是O(n^2)。

3.2 空间复杂度

空间复杂度就是在交换元素时那个临时变量所占的内存空间；
最优的空间复杂度就是开始元素顺序已经排好了，则空间复杂度为：0；
最差的空间复杂度就是开始元素逆序排序了，则空间复杂度为：O(n)；
平均的空间复杂度为：O(1)；