算法总结：时间复杂度低于O(N)的算法

约定不等于承诺〃 2022-11-13 11:29 189阅读 0赞

> 除了二分法（时间复杂度 log n ）以外，我们在面试中还会遇到哪些时间复杂度低于O(N)的算法呢？本文为你总结另外四种低于O(N)的算法。

### 四种算法 ###

*   *  快速幂算法
     *  辗转相除法
     *  题目实战：两个排序数组的中位数
     *  分解质因数
     *  分块检索算法（少见）

## 快速幂算法 ##

快速求得 an次方的算法，而不需要逐个相乘<**时间复杂度 O(N)**>，面试中常以下列形式出现：

求 an % b，其中a,b,n都是int范围(231 \-1)  
[LintCode 快速幂][LintCode]

首先我们需要知道递归的基本性质：

(a + b) % c = (a % c + b % c) % c;
    (a - b) % c = (a % c - b % c) % c;
    (a * b) % c = (a % c * b % c + c) % c;//取决于不同的语言对于负数%整数的返回值，因此最好+c确保结果正确
    
    //注意：除法是不满足的

因此 an可以拆分为：

*  n % 2 == 0, an= (an//2) 2
 *  n % 2 == 1, an= (an//2) 2 \* a

我们可以采用递归实现这个过程：

public int fastPower(int a, int b, int n) { 
            // write your code here
            if(n == 1){ 
                return a % b;
            }
            if(n == 0){ 
                return 1 % b;
            }
            long product = fastPower(a, b, n / 2);
            product = (product * product) % b;
            if(n % 2 == 1){ 
                product = (product * a) % b;
            }
            return (int)product;
        }

**为什么这里的product = (product \* product) % b**

把当前的二进制底数乘2，假设二进制时11011，我们现在使用的是最后一个1，在下次运算中我们要用的是倒数第二位，如果是1，再执行product\*a ，怎么用到倒数第二位，就是将当前位的值乘2

**非递归写法：**

public int fastPower(int a, int b, int n) { 
            // write your code here
            long ans = 1, tmp = a;
            
            while( n != 0){ 
                if(n % 2 == 1){ 
                    ans = (ans * tmp) % b;
                }
                tmp = (tmp * tmp) % b;
                n = n / 2;
            }
            return (int) ans % b;
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzU1MjIxMjM5_size_16_color_FFFFFF_t_70]

## 辗转相除法 ##

> 辗转相除法， 又名欧几里德算法，是求最大公约数的一种方法。  
> 它的具体做法是：用较大的数除以较小的数，再用除数除以出现的余数（第一余数），再用第一余数除以出现的余数（第二余数），如此反复，直到最后余数是0为止。如果是求两个数的最大公约数，那么最后的除数就是这两个数的最大公约数

Java:
    
    public int gcd(int big, int small) { 
        if (small != 0) { 
            return gcd(small, big % small);
        } else { 
            return big;
        }
    }
    
    Python版本:
    
    def gcd(big, small):
        if small != 0:
            return gcd(small, big % small)
        else:
            return big
    
    C++版本:
    
    int gcd(int big, int small) { 
        if (small != 0) { 
            return gcd(small, big % small);
        } else { 
            return big;
        }
    }

## 题目实战：两个排序数组的中位数 ##

[LeetCode 4. 两个排序数组的中位数][LeetCode 4.]

**题目描述**

在两个排序数组中，求他们合并到一起之后的中位数  
时间复杂度要求：O(log(n+m))，其中 n, m 分别为两个数组的长度

**解法**

基于 FindKth 的算法。整体思想类似于 median of unsorted array 可以用 find kth from unsorted array 的解题思路。  
基于二分的方法。二分 median 的值，然后再用二分法看一下两个数组里有多少个数小于这个二分出来的值。

**思路描述：**

先将找中点问题转换为找第 k 小的问题，这里直接令k = (n + m) / 2。那么目标是在 logk = log((n+m)/2) = log(n+m) 的时间内找到A和B数组中从小到大第 k 个。

比较 A 数组的第 k/2 小和 B 数组的第 k/2 小的数。谁小，就扔掉谁的前 k/2 个数。将目标寻找第 k 小修改为寻找第 (k-k/2) 小

回到第 2 步继续做，直到 k == 1 或者 A 数组 B 数组里已经没有数了。

**F.A.Q**

**Q: 如何 O(1) 时间移除数组的前 k/2 个数？**

A: 给两个数组一个起始位置的标记参数（相当于一个offset，偏移位），把这个起始位置 + k/2 就可以了。

**Q: 不是让我们找中点么？怎么变成了找第 k 小？**

A: 找第 k 小如果能在 log(k) 的时间内解决，那么找中点就可以在 log( (n+m)/2 ) 的时间内解决。

**Q.如何证明谁的第 k/2 个数比较小就扔掉谁的前 k/2 个数这个理论？**

A: 直观的，我们看一个例子

A=[1,3,5,7]
    B=[2,4,6,8]

假如我们要找第 4 小。也就是 k = 4。算法会去比较两个数组中第 2 小的数。也就是 A\[1\]=3 和 B\[1\]=4 这两个数的大小。然后会发现，3比较小，然后就决定扔掉 A 的前 k/2 = 2 个数。也就是，接下来，需要去找

A=[5,7]
    B=[2,4,6,8]

中的第 k-k/2=2 小的数。这里我们扔掉了 \[1,3\]，扔掉的这些数中，一定不会包含我们要找的第 4 小的数——4。因为从位置上，他们在 A 和 B合并到一起之后，都会排在 4 的前面。

抽象的证明一下：

`我们需要回顾一下 Merge Two Sorted Arrays 这道题目。算法的做法是，每一次比较两个数组中比较小的数，然后谁小，谁先被拿出来，放到最后的合并结果中。那么假设 A 和 B中 A[k/2 - 1] <= B[k/2 - 1]（反之同理）。我们会决定扔掉A[0..k/2-1]，因为这些数在 A 与 B 做简单的 Merge 的过程中，会优先于目标第 k 个数现出来。为什么？因为既然A[k/2-1] <= B[k/2-1]，那么当我们用最简单的 Merge Two Sorted Arrays 的算法一个个从A和B里拿数出来的时候，当 A[k/2 - 1] 出来的时候，B[k/2 - 1] 一定还没有被拿出来，那么此时A里出来了 k/2 个数，B里出来的数一定不够 k/2 个（因为第 k/2 个数都还没出来），所以加起来总共出来的数肯定不够k个，所以第k小的数一定还留在AB数组中。`

因此我们证明了：扔掉较小的一部分的前 k/2 个数，不会扔掉要找的第 k 小的数。

**Code：**

public class Solution { 
        public double findMedianSortedArrays(int A[], int B[]) { 
            int n = A.length + B.length;
            
            if (n % 2 == 0) { 
                return (
                    findKth(A, 0, B, 0, n / 2) + 
                    findKth(A, 0, B, 0, n / 2 + 1)
                ) / 2.0;
            }
            
            return findKth(A, 0, B, 0, n / 2 + 1);
        }
    
        // find kth number of two sorted array
        public static int findKth(int[] A, int startOfA,
                                  int[] B, int startOfB,
                                  int k){        
            if (startOfA >= A.length) { 
                return B[startOfB + k - 1];
            }
            if (startOfB >= B.length) { 
                return A[startOfA + k - 1];
            }
    
            if (k == 1) { 
                return Math.min(A[startOfA], B[startOfB]);
            }
            
            int halfKthOfA = startOfA + k / 2 - 1 < A.length
                ? A[startOfA + k / 2 - 1]
                : Integer.MAX_VALUE;
            int halfKthOfB = startOfB + k / 2 - 1 < B.length
                ? B[startOfB + k / 2 - 1]
                : Integer.MAX_VALUE; 
            
            if (halfKthOfA < halfKthOfB) { 
                return findKth(A, startOfA + k / 2, B, startOfB, k - k / 2);
            } else { 
                return findKth(A, startOfA, B, startOfB + k / 2, k - k / 2);
            }
        }
    }

## 分解质因数 ##

以 sqrt\{n\}（根号n） 为时间复杂度的算法并不多见，最具代表性的就是分解质因数了。

具体步骤

`记up = sqrt{n}，作为质因数k的上界, 初始化k=2。 当k <= up 且 n不为1 时，执行步骤3，否则执行步骤4。 当n被k整除时，不断整除并覆盖n，同时结果中记录k，直到n不能整出k为止。之后k自增，执行步骤2。 当n不为1时，把n也加入结果当中，算法结束。`

**几点解释：**

不需要判定k是否为质数，如果k不为质数，且能整出n时，n早被k的因数所除。故能整除n的k必是质数。

为何引入up？为了优化性能。当k大于up时，k已不可能整除n，除非k是n自身。也即为何步骤4判断n是否为1，n不为1时必是比up大的质数。  
步骤2中，也判定n是否为1，这也是为了性能，当n已为1时，可早停。

Java版本:
    
    public List<Integer> primeFactorization(int n) { 
        List<Integer> result = new ArrayList<>();
        int up = (int) Math.sqrt(n);
        
        for (int k = 2; k <= up && n > 1; ++k) { 
            while (n % k == 0) { 
                n /= k;
                result.add(k);
            }
        }
        
        if (n > 1) { 
            result.add(n);
        }
        
        return result;
    }
    
    
    Python版本:
    
    def primeFactorization(n):
        result = []
        up = int(math.sqrt(n));
        
        k = 2
        while k <= up and n > 1: 
            while n % k == 0:
                n //= k
                result.append(k)
            k += 1
                
        if n > 1:
            result.append(n)
            
        return result
    
    
    C++版本:
    
    vector<int> primeFactorization(int n) { 
        vector<int> result;
        int up = (int)sqrt(n);
        
        for (int k = 2; k <= up && n > 1; ++k) { 
            while (n % k == 0) { 
                n /= k;
                result.push_back(k);
            }
        }
        
        if (n > 1) { 
            result.push_back(n);
        }
        
        return result;
    }

**复杂度分析**  
最坏时间复杂度O(sqrt (n) )。当n为质数时，取到其最坏时间复杂度。  
空间复杂度O(log(n)), 当n质因数很多时，需要空间大，但总不会多于O(log(n))个

**延伸**  
质因数分解有一种更快的算法，叫做Pollard Rho快速因数分解。该算法时间复杂度为O(n^\{1/4\})，其理解起来稍有难度，有兴趣的同学可以进行自学，参考链接。

## 分块检索算法（少见） ##

> 将长度为 N 的区间分成 √N 的大小的小区间 总共 √N 个小区间，每个小区间统计局部的数据 因此在这些区间中进行增删查改的效率是  
> O(√N)

例题讲解：  
[LintCode 249 统计前面比自己小的数的个数][LintCode 249]

class Block { 
        public int total;
        public int[] counter;
        public Block(int blockSize) { 
            this.total = 0;
            this.counter = new int[blockSize];
        }
    }
    
    class BlockArray { 
        public Block[] blocks;
        public int blockSize;
        
        public BlockArray(int capacity) { 
            blockSize = (int) Math.sqrt(capacity);
            int blockCount = capacity / blockSize + 1;
            blocks = new Block[blockCount];
            for (int i = 0; i < blockCount; i++) { 
                blocks[i] = new Block(blockSize);
            }
        }
        
        public int countSmaller(int value) { 
            int index = value / blockSize;
            int count = 0;
            for (int i = 0; i < index; i++) { 
                count += blocks[i].total;
            }
            
            for (int i = 0; i + index * blockSize < value; i++) { 
                count += blocks[index].counter[i];
            }
            
            return count;
        }
        
        public void insert(int value) { 
            int index = value / blockSize;
            blocks[index].total++;
            blocks[index].counter[value - index * blockSize]++;
        }
    }
    
    public class Solution { 
        /** * @param A: an integer array * @return: A list of integers includes the index of the first number and the index of the last number */
        public List<Integer> countOfSmallerNumberII(int[] A) { 
            List<Integer> results = new ArrayList<>();
            if (A == null || A.length == 0) { 
                return results;
            }
            
            BlockArray blockArray = new BlockArray(10000);
            for (int i = 0; i < A.length; i++) { 
                results.add(blockArray.countSmaller(A[i]));
                blockArray.insert(A[i]);
            }
            
            return results;
        }
    }

[LintCode]: https://www.lintcode.com/problem/fast-power/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzU1MjIxMjM5_size_16_color_FFFFFF_t_70]: /images/20221022/6b55466f54e3490298dfc3744ef565fb.png
[LeetCode 4.]: https://leetcode-cn.com/problems/median-of-two-sorted-arrays/
[LintCode 249]: https://www.lintcode.com/problem/count-of-smaller-number-before-itself/