算法中时间复杂度和空间复杂度简介

作为程序员，大家应该都听过这样一个公式：程序设计 = 算法 + 数据结构，我们所编写的程序都可以使用这个公式来概括，其中算法主要是针对世间和空间两个维度进行考核。

• 时间维度：执行当前算法所消耗的时间，即，时间复杂度；
• 空间维度：执行当前算法所消耗的空间，即，空间复杂度。

1、时间复杂度

1.1 计算表达式

要计算算法的时间消耗，可以通过加日志打印，获取该程序执行算消耗的时间，但在实际的使用中，我们不可能针对每一段程序都去通过时间的执行获取其消耗的时间，况且有些程序我们也没办法去通过实际运行去获取消耗的时间，此时我们需要通过的一定的公式去估算其消耗的时间，常见的表达方式如下：

T(n) = O(f(n))

该方法也就是我们常说的大O符号表示法，通过该方式可表示常见的时间复杂度，例如：

• 常数阶O(1)
• 对数阶O(logN)
• 线性阶O(n)
• 线性对数阶O(nlogN)
• 平方阶O(n²)
• K次方阶O(n^k)
• 指数阶(2^n)

以上的表达式的执行效率可通过该表模拟说明，其中横坐标表示n值，纵坐标表示时间的复杂度，可以看出如下结论：

• 当n<=4时：相对而言不同的表达式的时间复杂度基本相同；
• 当n>4时，不同表达式，时间复杂度相对变化较大，特别是n越大，其时间复杂度差别越大；
• 相对而言，以上表达式自上而下，时间复杂度差别越来越大，执行效率越来越低。

1.2 举例说明

1. 常数阶O(1)

        int num = 0;
        num++;
        System.out.println(num);

指程序执行过程为常数的次数，例如上面的num执行了一次++操作，写为O(1)，当然如果再执行3次，也可以写为O(3)，但是通常统称为O(1)的形式，即常数阶。

2.对数阶O(logN)

int num = 1;
while(num <n)
{
    num = num * 2;
}

指运算时，没执行一次num值就乘以2，假设执行x次后，num值就大于n，即 2^x =
n，那么x= log2 n，也就是logn的形式，其时间复杂度呈logn的形式。

3. 线性阶O(n)

        int num = 0;
        for (int i = 0; i <n ; i++) {
            num = i++;
            System.out.println(num);
        }

指运算时，该变量执行了n次，例如上例中经过一次for循环后，num执行了n次，因此是呈现线性阶O(n)。

4.线性对数阶O(nlogN)

        int num = 0;
        for (int i = 0; i <n ; i++) {
            while (num<i){
                num *= 2;
            }
        }

指运算时，在执行for的同时又嵌套了一次while，结合对数阶和线性阶可知为线性对数阶：O(nlogN)。

5.平方阶O(n²)

        for (int i = 0; i <n ; i++) {
            for (int j = 0; j <n ; j++) {
                num++;
                System.out.println(num);
            }
        }

结合线性阶可知，平方阶是指，运算时，嵌套了2次循环，即nn= n^2，如果将上述中的一个n修改为m，则为nm次。
同理可知：

• 如果嵌套循环3次，则为n^3；
• 如果是k次，则为n^k；
• 如果n为2，嵌套了n次，则为2^n次，即指数阶。

2、空间复杂度

空间复杂度是指该算法执行时，临时占用的空间大小，常见的表达式有：O(1)、O(n)、O(n²)。
1.复杂度O(1)

        int num = 0;
        System.out.println(num);

该运算过程中，num申请了一次内存，因此复杂度为O(1)，同理如果有可知的常数次也统称为O(1)。

2. 复杂度O(n)

        for (int i = 0; i <n ; i++) {
            int test = num++;
            System.out.println(num);
        }

该运算中，每次都会重新申请一个内存用于存储test，因此复杂度为O(n)。

3.复杂度O(n²)
同理在O(n)的基础上，如果再次嵌套一个循环，则空间复杂度为O(n²)。

3、 小结

基于时间和空间复杂度的计算，主要是用于编写程序时，大致估算程序的运行效率，特别是时间复杂度上，采用不同的方式，随着n的不断扩大，其时间的消耗甚至呈现指数型的增长。随着设备的存储不断扩大，在选择算法时，越来越多的采用空间换时间的方式来提升效率。
对于时间和空间的估算，需要把握以下两点：
时间：该算法在实际运行中，执行了几次？
空间：该算法在运行中，占用临时内存的大小 ？