时间复杂度和空间复杂度

序：

在面试的时候，经常会询问到算法的题目，尤其是后端的面试，去一些互联网的大厂。那么解析一个题目的算法又很多种，面试官如何判断你这个算法是不是最优的算法。没错，判断一个算法的优秀程度，就是使用时间复杂度。

A.时间复杂度怎么计算？

个人总结出三个计算时间复杂度的规律

1、找到执行次数最多的语句

2、语句执行语句的数量级

3、用O表示结果

计算时间复杂度的3个出发点，掌握这三个出发点，那么一向搞不懂的时间复杂度就可以迎刃而解啦。

B.常用的时间复杂度所耗费的时间从小到大依次是：

O(1 )< O(logn) < O(n) < O(n*logn) < O(n^2) < O(n^3) < O(2^n) < O(n!) < O(n^n)

C.常见的时间复杂度例子

git地址：https://github.com/startYao/25-years-old-effort-basics-demo-01.git

1.对于一个循环，假设循环体的时间复杂度为 O(n)，循环次数为 m，则这个
循环的时间复杂度为 O(n×m)。

    /**
     * O(1)
     */
    private static void complexForO1() {
        System.out.println("O(1)");
    }

    /**
     * O(n)
     */
    private static void complexForOn(int n) {
        for (int i = 1; i < n; i++) {
            System.out.println("O(n)");
        }
    }

此时时间复杂度为 O(n × 1)，即 O(n)。

2.对于多个循环，假设循环体的时间复杂度为 O(n)，各个循环的循环次数分别是a, b, c...，则这个循环的时间复杂度为 O(n×a×b×c...)。分析的时候应该由里向外分析这些循环。

    /**
     * O(n^2)  demo1
     */
    private static void complexForOnSquare1(int n) {
        for (int i = 1; i < n; i++) {
            for (int j = 1; j < n; j++) {
                System.out.println("O(n^2)");
            }
        }
    }

此时时间复杂度为 O(n × n × 1)，即 O(n^2)。

3.对于顺序执行的语句或者算法，总的时间复杂度等于其中最大的时间复杂度。

    /**
     * O(n^2)  demo2
     */
    private static void complexForOnSquare2(int n) {
        for (int i = 1; i < n; i++) {
            for (int j = 1; j < n; j++) {
                System.out.println("O(n^2)");
            }
        }

        for (int i = 1; i < n; i++) {
            System.out.println("O(n)");
        }
    }

此时时间复杂度为 max(O(n^2), O(n))，即 O(n^2)。

4.对于条件判断语句，总的时间复杂度等于其中 时间复杂度最大的路径 的时间复杂度。

    /**
     * O(n^2)  demo3
     */
    private static void complexForOnSquare3(int n) {
        if (n >= 0) {
            // 第一条路径时间复杂度为 O(n^2)
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    System.out.println("O(n^2)");
                }
            }
        } else {
            // 第二条路径时间复杂度为 O(n)
            for (int j = 0; j < n; j++) {
                System.out.println("O(n)");
            }
        }
    }

此时时间复杂度为 max(O(n^2), O(n))，即 O(n^2)。

5.O(log(n))

    /**
     * O(log(n))
     *
     * 假设循环次数为 t，则循环条件满足 2^t < n。
     * 可以得出，执行次数t = log(2)(n)，即 T(n) = log(2)(n)，可见时间复杂度为 O(log(2)(n))，即 O(log n)
     */
    private static void complexForOnLog(int n) {
        for (int i = 1; i < n; i++) {
            i *= 2;
            System.out.println("O(log(n))");
        }
    }

6.O(2^n)

    /**
     * O(2^n)
     * 显然运行次数，T(0) = T(1) = 1，同时 T(n) = T(n - 1) + T(n - 2) + 1，这里的 1 是其中的加法算一次执行。
     * 显然 T(n) = T(n - 1) + T(n - 2) 是一个斐波那契数列，通过归纳证明法可以证明，当 n >= 1 时 T(n) < (5/3)^n，同时当 n > 4 时 T(n) >= (3/2)^n。
     * 所以该方法的时间复杂度可以表示为 O((5/3)^n)，简化后为 O(2^n)
     */
    private static int complexForO2SquareN(int n) {
        if (n <= 1) {
            return 1;
        } else {
            return complexForO2SquareN(n - 1) + complexForO2SquareN(n - 2);
        }
    }

剩余的，后续待补充...