第2章-分析复杂度来判断算法效率

一、时间复杂度
二、空间复杂度

算法复杂度用于分析算法运行所需计算机资源的量，需要的时间资源为时间复杂度，需要的空间资源为空间复杂度。

在判断一个算法的优劣时，可以抛开软件和硬件因素，只考虑问题的规模。编写程序前预先估计算法优劣，可以改进并选择更高效的算法。

一、时间复杂度

编程实现算法后，算法就是由一组语句构成，算法的执行效率就由各语句执行的次数所决定。一个算法花费的时间与算法中语句的执行次数成正比，把时间复杂度记为 $T(n)$ ，一般情况下，算法的基本操作重复执行的次数是关于模块 $n$ 的一个函数 $f(n)$ ，因此，可以把算法的时间复杂度记做： $T(n) = O(f(n))$ 。

随着模块 $n$ 的增大，算法执行的时间的增长率和 $f(n)$ 的增长率成正比，所以 $f(n)$ 越小，算法的时间复杂度越低，算法的效率越高。

研究复杂度的目的是要比较两个算法的效率的高低，并不需要仔细分析这个算法比那个算法多几次运算那么清，所以采用渐近复杂度分析来比较算法的效率。

在分析算法的时间复杂度时，一般都会规定各种输入情况得出最好情况下 $T_{max}(n)$ 、最坏情况下 $T_{min}(n)$ 和平均情况下 $T_{avg}(n)$ 。

1. 求绝对值

求一个整数的绝对值，代码如下：

public static int abs(int a) {
    return a < 0 ? -a : a;
}

该代码中只有一条运算指令语句，时间复杂度为 $O(1)$ 。

2. 数组求和

对数组内所有整数求和，代码如下：

public static int sum(int[] a) {
    int s = 0;
    for (int i : a) {
        s += i;
    }
    return s;
}

如果输入数组的大小为 $n$ ，执行语句中初始化赋值需要时间 $O(1)$ ，循环语句中的赋值操作需要时间为 $O(1)\times n$ ，所以语句执行的时间为：

O (1) + O (1) \times n \approx O (n + 1) \approx O (n)

$O(1)+O(1)\times n\approx O(n+1) \approx O(n)$

该时间复杂度随着规模大小趋势如下：

3. 二分查找

使用二分法在有序数组中找到某个元素的位置，代码如下：

public static int binarySearch(int[] a, int b) {
    int i, r = 0, l = a.length;
    while (r <= l) {
        i = (r + l) / 2;
        if (a[i] < b) {
            r = i + 1;
        } else if (a[i] > b) {
            l = i - 1;
        } else {
            return i;
        }
    }
    return -1;
}

假设这个循环执行了 $k$ 次，每一次循环都会将规模 $n$ 除以 2：

第 1 次，规模为 $n$ ；
第 2 次，规模为 $\frac{n}{2}$ ；
第 3 次，规模为 $\frac{n}{4}$ ；
第 $k$ 次，规模为 $\frac{n}{2^{k-1}}$ 。

当 $n=1$ 的时候，查找结束，所以需要满足 $\frac{n}{2^{k-1}}=1$ ，简化后得 $k=log_2n+1\approx log_2n$ ，所以二分查找的时间复杂度为 $O(log\ n)$ 。

4. 冒泡排序

使用冒泡算法对整型数组进行排序，代码实现如下：

public static int[] bubbleSort(int[] a) {
    int temp;
    for (int i = 0; i < a.length - 1; i++) {
        for (int j = 0; j < a.length - 1 - i; j++) {
            if (a[j] > a[j + 1]) {
                temp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = temp;
            }
        }
    }
    return a;
}

两层循环中比较的次数为 $(n-1)+(n-2)+(n-3)+...+1$ ，根据等差数列求和公式得出结果为 $\frac{n(n-1)}{2}$ ，忽略低次项，所以该算法的时间复杂度为 $O(n^2)$ 。

不是时间复杂越低的越好，要考虑数据规模，如果数据规模很小，甚至可以用 $O(n^2)$ 的算法比 $O(n)$ 的更合适。