数据结构之【时间复杂度和空间复杂度】

如何去评价一个代码它的效率高不高呢？ 我们通常从两个方面去看！

• 时间复杂度：主要衡量一个算法的运行速度
• 空间复杂度：主要衡量一个算法所需要的额外空间

1. 时间复杂度

1.1 时间复杂度的定义

在计算机科学中，算法的时间复杂度是一个数学函数，它定量描述了该算法的运行时间。一个算法执行所耗费的时间，从理论上说，是不能算出来的，只有你把你的程序放在机器上跑起来，才能知道。但是我们需要每个算法都上机测试吗？是可以都上机测试，但是这很麻烦，所以才有了时间复杂度这个分析方式。一个算法所花费的时间与其中语句的执行次数成正比例，算法中基本操作的执行次数，为算法的时间复杂度。

1.2 大O渐进表示法

public class test {
    void fun(int N){
        int count = 0;
        for (int i = 0; i < N; i++) {                      // 执行了 n*n 次
            for (int j = 0; j < N; j++) {
                count++;
            }
        }
        
        for (int i = 0; i < 2*N; i++) {                   // 执行 2n 次
            count++;
        }
        
        int N= 10;
        while ((N--)>0){                                // 执行 10 次
            count++;
        }
    }

所以 fun()方法 执行的基本次数为：

                                                     F（N）= N^2 + 2N + N

在实际中我们计算时间复杂度时，并不一定要计算精确的执行次数，而只需要大概执行次数，所以我们使用大O（是用于描述函数渐进行为的数学符号）的渐进表示法。

1.3 推导大O阶方法

• 1、用常数1取代运行时间中的所有加法常数
• 2、在修改后的运行次数函数中，只保留最高阶项
• 3、如果最高阶项存在且不是1，则去除最高阶项的系数。得到的结果就是大O阶。
  使用大O的渐进表示法以后，func1的时间复杂度为： O(N^2)
  
  通过以上我们可以看出 大O的渐进表示法去掉了那些对结果影响不大的项，简洁明了的表示了执行次数。

1.4 时间复杂度存在三种情况

• 最坏情况：任意输入规模的最大运行次数（上界）
• 平均情况：任意输入规模的期望运行次数
• 最好情况：任意输入规模的最小运行次数（下界）

举个最简单的例子：在一个长度为N的数组中查找一个x
最好情况：1次找到，在开头
最坏情况：N次找到，在末尾
平均情况：N/2次找到，（1+2+3+…N）/ N = N/2 + 1/2 => N/2 （每个数据要找的次数/数组的长度)

一般在没有特殊情况的说明下，都是指最坏时间复杂度。

1.5 几个常见的求时间复杂度的例子

实例1：

// 计算折半查找的时间复杂度
    int binarySearch(int[] array, int value) {
        int left= 0;
        int right = array.length - 1;
        while (left <= right ) {
            int mid = left + ((right - left ) / 2);
            if (array[mid] < value)
                left = mid + 1;
            else if (array[mid] > value)
                right = mid - 1;
            else
                return mid;
        }
        return -1;
    }

最好情况下：O(1) ；最差情况下：O(logN).

---

实例二：

// 计算递归求阶层的时间复杂度
long factorial(int N){
	return N < 2 ? N : factorial(N - 1) * N;
}

递归的时间复杂度：递归次数 * 每次递归后代码的执行次数

所以 递归次数 * 每次递归后代码的执行次数 = 3 * 1 = 3 ---------- 递归次数 N * 1 = N

2. 空间复杂度

空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度 。空间复杂度不是程序占用了多少bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。空间复杂度计算规则基本跟时间复杂度类似，也使用大O渐进表示法。

例1：

    void bubbleSort(int[] array) {
        for (int end = array.length; end > 0; end--) {
            boolean sorted = true;
            for (int i = 1; i < end; i++) {
                if (array[i - 1] > array[i]) {
                    Swap(array, i - 1, i);
                    sorted = false;
                }
            }
            if (sorted == true) {
                break;
            }
        }
    }

在上述代码中 boolean sorted = true 就是临时使用的常数个额外空间，所以空间复杂度为O(1)。
又因为此算法执行时所需的辅助空间相对于输入数据而言是个常数，则称此算法为原地工作，空间复杂度为O(1).

---

例二：

    long[] fibonacci(int n) {
        long[] fibArray = new long[n + 1];
        fibArray[0] = 0;
        fibArray[1] = 1;
        for (int i = 2; i <= n; i++) {
            fibArray[i] = fibArray[i - 1] + fibArray[i - 2];
        }
        return fibArray;
    }

可以看出 随着 n 越来越大，数组也越来越大，所以空间复杂度为O(N)。

3. 常见的时间复杂度所耗时间的大小排列

0(1) < O(logN) < O(N) < O(nlogN) < O(N^2) < O(N ^3) < O(2 ^N) < O(N!) < O(N ^N)