算法复杂度分析

复杂度分析

时间复杂度

每一个算法题，都会有一个时间限制和空间限制。本文就拿时间限制为 1s 来讨论.

就目前来说个人计算机 1s 大概可以执行 3e8次运算左右。

所以时限 1s ，我们要保证程序运算次数不超过 3e8

时间复杂度一般分为 $ O(n^2) $ $O(nlo{g}_{2}n)$ $O(n)$ $O(lo{g}_{2}n)$ $O(1)$

• $O(n^2) $ 相当于两次 for 循环
• $O(n)$ 相当于一次 for 循环
• $O(lo{g}_{2}n)$ 最典型的就是二分
• $O(1)$ 在常数的时间内解决

在某一题中：

如果 n > 100000000 , 就需要考虑用 常数的时间去解决 或者 $O(lo{g}_{2}n)$ 的时间复杂度

如果 n 在 100000 左右， 就可以考虑 $O(nlo{g}_{2}n)$ $O(n)$ 的算法

如果 n 在 10000 左右， 那么 $O(n^2)$ 的算法也可以

如果 n 在 500 左右， 那么 $O(n^3)$ 的算法也行

一般我们算时间复杂度的时候，只要估算一下就可以了，不需要算到具体的值。

举个例子：

int ans = 0, n = 100000;
for (int i = 0; i <= n; ++i)
    ans += 1;
for (int i = 1; i <= n; i *= 2)
    ans += 1;

第一个 for 循环一共运算 n 次， 所以是 $O(n)$ 的

第二个 for 循环 i 每次 乘 2， 所以是 $O(lo{g}_{2}n)$ 的

所以两个 for 循环加在一起， 就是 $O(n+lo{g}_{2}n)$ 的，由于 $n$ 很大， $lo{g}_{2}n$ 相比于 $n$ 来说，可以忽略不计，所以时间复杂度就是 $O(n)$ 的。

再举个例子：

题目：

给定一个整数数组 nums 和一个目标值 target，数组的值是升序排列的，数组的长度为 n。

请你在该数组中找出和为目标值的那 两个 整数，每个数只能被用一次，并返回他们的数组下标。

示例：

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

如果 n < 1000 , 我们就可以用 $O(n^2)$ 的方法做。

这个方法就是两重 for 循环，枚举两个位置，判断这两个位置的和是不是 target 。

class Solution {
    public int[] twoSum(int[] nums, int target, int n) {
        int[] ans = new int[2];
        for (int i = 0; i < n; ++i){
            for (int j = 0; j < n; ++j){
                if (i != j && nums[i] + nums[j] == target){
                    ans[0] = i; ans[1] = j;
                    return ans;
                }
            }
        }
        return ans;
    }
}

如果n < 100000, 这个时候 $O(n^2)$ 的方法就行不通了，但是可以使用 $O(nlo{g}_{2}n)$ 的方法

先循环一遍，把所有的值和对应的下标存到 hashmap 中， hashmap 每次的查询时间是 $O(lo{g}_{2}n)$ 的，

再循环一遍每个位置，让 sub = target - nums[i] ， 在 hashmap 中找 sub， 如果可以找到，就存在这样两个位置。

总的时间复杂度为 $O(n+nlo{g}_{2}n)$ , 也可以说成 $O(nlo{g}_{2}n)$

class Solution {
    public int[] twoSum(int[] nums, int target, int n) {
        int[] ans = new int[2];
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < n; ++i)
            map.put(nums[i], i); // 把数据放到 hashmap 中
        for (int i = 0; i < n; ++i){
            int sub = target - nums[i];
            if (map.containsKey(sub) && map.get(sub) != i){ // 在 hashmap 中查找 sub 是不是存在，如果存在 判断下标位置和 i 是不是一样。
                ans[0] = i;
                ans[1] = map.get(sub);
                return ans;
            }
        }
        return ans;
    }
}

如果 n < 10000000, $O(nlo{g}_{2}n)$ 的方法也不行了， 这个时候就需要 $O(n)$ 的算法。

需要注意到这个数组是升序的。

先设两个指针 i = 0, j = n-1; 代表我要找的两个位置。

如果 i 向右移动， 两个位置的加和会变大，

如果 j 向左移动， 两个位置的加和会变小。

首先让 nums[i] + nums[j] 如果和大于 target ， j 向左移动， 如果和小于 target， i 向右移动， 知道找到最后的位置。

如果 i >= j ， 就会跳出循环， 所以每个位置只会被访问一次，时间复杂的也就是 $O(n)$

class Solution {
    public int[] twoSum(int[] nums, int target, int n) {
        int i = 0, j = n-1;
        int[] ans = new int[2];
        while(i < j){
            if (nums[i] + nums[j] == target){
                ans[0] = i; ans[1] = j;
                return ans;
            }
            if (nums[i] + nums[j] > target) j--; else i++;
        }
    }
}

空间复杂度

空间复杂度就是看额外开了多少空间。

如果开了常数个空间，那就是 $O(1)$ 的

如果开了一个数组，有 n 位， 那么就是 $O(n)$ 的

一般的题目不太会卡空间，空间复杂度也就是和时间复杂度差不多算就可以了。