交换排序算法-冒泡排序

算法简介

冒泡排序（Bubble Sort）是一种比较简单的排序算法，它是一种稳定的排序算法，时间复杂度 O(n^2)，空间复杂度 O(1)

Java 实现

大致思路：

给出一个 int 数组从小到大排序，我们可以经过几次排序，每次排序都从第一个元素开始，通过两两冒泡的形式进行两个元素大小的比较，前者比后者大就交换一下二者位置，否则位置不变。这样每次排序之后都能找出当前排序中最大的那个数，并且置于当前排序的最后面

算法图解：

代码实现：

// 冒泡排序（从小到大）
public static int[] bubbleSort(int[] arr) {
    // 第一个循环代表排序的次数
    for(int i=1; i<=arr.length-1; i++) {
        // 第二个循环代表每次冒泡
        for(int j=0; j<=arr.length-i-1; j++) {
            if(arr[j+1] < arr[j]) {
                int tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
            }
        }
    }
    return arr;
}

稍微看下上面代码最好时间复杂度还是 O(n^2) 啊，怎么回事，不应该是 O(n) 吗，代码还可以优化的原来

// 冒泡排序（从小到大）(优化后)
public static int[] bubbleSort(int[] arr) {
    // 第一个循环代表排序的次数
    for(int i=1; i<=arr.length-1; i++) {
	    boolean flag = false;
        // 第二个循环代表每次冒泡
        for(int j=0; j<=arr.length-i-1; j++) {
            if(arr[j+1] < arr[j]) {
                int tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
                flag = true;
            }
        }
        if (flag == false)
        	return arr;
    }
    return arr;
}

时间复杂度

我们要循环多少次呢？O(n^2)

先看第一个 for 循环，循环次数定死是 n-1 次

再看第二个 for 循环，循环次数依据第几次循环来定：

• 第一次：n-1 次
• 第二次：n-2 次
• 第三次：n-3 次
• ……
• 第 n-1 次：n-(n-1) 次，即 1 次

这样我们可以得出时间复杂度：

循环总次数 = (n-1) + (n-2) + (n-3) + [n-(n-1)]
          = n(n-1) - [1 + 2 + 3 + ...... + (n-1)]
          = n^2 -n - n(n-1)/2
          = (n^2)/2 + n/2
时间复杂度为 (n^2)/2 + n/2
以最高次数为标准约为 O(n^2)

最坏时间复杂度 O(n^2)，最好时间复杂度 O(n)

空间复杂度

我们在使用冒泡排序过程中需要耗费多少辅助的空间资源呢？

O(1)

算法稳定性

冒泡排序一般来说是稳定的排序算法

数组中两个相同的数字在排序前和排序后可以保证相对位置不发生改变，当然它可以变成不稳定的排序，这样看代码的实现，如果把冒泡排序 arr[j+1] > arr[j] 改成 >= 那就是不稳定的了