时间复杂度分析快速入门：题型分类法

最近，有不少读者留言或私信问我时间复杂度的分析方法。时间复杂度说难也不难，说简单也不简单，但它一定是我们学习算法的过程中过不去的一道坎。这篇文章就想给大家介绍一种快速分析时间复杂度的方法 —— 题型分类法。

网络上关于时间复杂度分析的文章，大部分都充斥着教材里的陈词滥调：先讲一大堆数学概念，什么增长速度、渐进复杂度，看得让人摸不着头脑。我今天的文章不想跟你讲这些虚的，只想跟你讲讲最实用的技巧，让你迅速搞定面试中的时间复杂度分析。

我们在面试中需要分析时间复杂度，无非是以下两种情况：

• 在写代码之前，预估自己代码的时间复杂度

• 写好代码之后，给面试官分析代码的时间复杂度

无论是哪种情况，你一定都清楚这道题的题型。那么只要记住不同题型的时间复杂度分析方法，二叉树套用二叉树的分析法、动态规划套用动态规划的分析法，就能做到快速分析时间复杂度了。

下面是我总结出的不同题型的时间复杂度分析方法：

题型	时间复杂度 分析方法
数组 链表 动态规划	数循环法
二叉树 回溯法 DFS/BFS	整体法
分治法 二分查找	log n 分析法

本文将介绍「数循环法」与「整体法」两种方法、六类题型的全部分析技巧。针对这六类题型，文末有按不同题型分类的往期文章回顾，供大家参考！

一、数循环法

数循环法，就是看代码中有几个循环、每个循环会执行几次，来确定算法的时间复杂度。

我们必须要掌握的一个基础知识是：在程序的三大基本结构（顺序、分支、循环）中，只有循环能真正影响时间复杂度。一般情况下，我们可以直接忽略代码中的顺序结构、分支结构，直接看循环结构来判断时间复杂度。

程序的三大基本结构

数循环法典型题型：动态规划类题目

「数循环法」最典型的题型就是动态规划了。我们以一道经典的「最长公共子序列（LCS）」问题来看看数循环法是怎么发挥作用的。

（以下题解代码来自文章：LeetCode 例题精讲 | 15 最长公共子序列：二维动态规划的解法，不了解 LCS 问题或不清楚解法的同学，可以参考这篇文章。）

最长公共子序列（LCS）的题解代码如下：

public int longestCommonSubsequence(String s, String t) {
    if (s.isEmpty() || t.isEmpty()) {
        return 0;
    }
    int m = s.length();
    int n = t.length();
    int[][] dp = new int[m+1][n+1];
    for (int i = 0; i <= m; i++) {
        for (int j = 0; j <= n; j++) {
            if (i == 0 || j == 0) {
                dp[i][j] = 0;
            } else {
                if (s.charAt(i-1) == t.charAt(j-1)) {
                    dp[i][j] = dp[i-1][j-1] + 1;
                } else {
                    dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]);
                }
            }
        }
    }
    return dp[m][n];
}

根据数循环法的基本思路，我们可以直接忽略掉代码中的各个细节，只看循环结构：

public int longestCommonSubsequence(String s, String t) {
    ...
    for (int i = 0; i <= m; i++) {
        for (int j = 0; j <= n; j++) {
            ...
        }
    }
    ...
}

数循环法要数两个东西：循环的层数、每个循环执行的次数。在这个例子中，代码有两个循环，都是简单的 for-i 循环：

• 外层循环，执行 次，数量级是 ；

• 内层循环，执行 次，数量级是 。

那么，算法的时间复杂度就是内外层循环次数之积，也就是 。

循环的不同层数：数组类题目

很多数组类题目也可以用数循环法来分析时间复杂度。根据题目和解法的不同，循环可能有 1~3 层。数循环法对于不同层数的循环都是有效的。

例如，经典的「最大子数组和」题目（LeetCode 53. Maximum Subarray Sum），从暴力的三重循环到动态规划的单层循环解法都有。

• 暴力法，三重循环：

public int maxSubArray(int[] nums) {
    int n = nums.length;
    int res = Integer.MIN_VALUE;
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            int sum = 0;
            for (int k = i; k <= j; k++) {
                sum += nums[k];                    
            }
            res = Math.max(res, sum);
        }
    }
    return res;
}

时间复杂度 。

• 暴力法改进，二重循环：

public int maxSubArray(int[] nums) {
    int n = nums.length;
    int res = Integer.MIN_VALUE;
    for (int i = 0; i < n; i++) {
        int sum = 0;
        for (int j = i; j < n; j++) {
            sum += nums[j];
            res = Math.max(res, sum);
        }
    }
    return res;
}

时间复杂度