这个算法是 BTree 构造的，O(n) 时间复杂度吗？答案

【问题标题】：Is this algorithm for BTree Construction, O(n) time complexity?这个算法是 BTree 构造的，O(n) 时间复杂度吗？
【发布时间】：2021-01-10 06:43:28
【问题描述】：

给定树的前序和中序遍历，构造二叉树。

注意：您可以假设树中不存在重复项。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
    public:
        TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
            
            if (preorder.empty()) return nullptr;
            

            TreeNode* root;
            
            //inorder val , index
            unordered_map<int, int> inOrderMap;
            unordered_map<int, int> preOrderMap;
            for (int i = 0; i < inorder.size(); i++) {
                preOrderMap.insert({preorder.at(i), i});
                inOrderMap.insert({inorder.at(i), i});
            }
            
            root = recursiveHelper(preorder, preOrderMap, inorder, inOrderMap, 0, inorder.size() - 1);
            
            return root;
        }
    
    private: 
        TreeNode* recursiveHelper(const vector<int>& preorder, 
                                  const unordered_map<int, int>& preOrderMap,
                                  const vector<int>& inorder, 
                                  const unordered_map<int, int>& inOrderMap, int i1, int j1) {
            
            
            if (i1 > j1) return nullptr;
            
            //minPre should be the first index in preorder where a value of inorder from i1->j1 appears
            //minIN should be the index of the inorder number that first appears in preorder
            int minPre = INT_MAX;
            int minIn;
            int corresp;
            for (int i = i1; i <= j1; i++) {
                corresp = preOrderMap.at( inorder.at(i) );
                if (corresp < minPre) {
                    minPre = corresp;
                    minIn = i;
                }
            }
            
            TreeNode* root = new TreeNode( preorder.at(minPre) );
            
            root->left = recursiveHelper(preorder, preOrderMap, inorder, inOrderMap, i1, minIn - 1);
            root->right = recursiveHelper(preorder, preOrderMap, inorder, inOrderMap, minIn + 1, j1);
            
            return root;
        }
};

for 循环让我觉得它是 O(n)，但该算法比其他 O(n) 算法花费的时间要多得多（以毫秒为单位）。

【问题讨论】：

与其他算法比较它所花费的时间没有多大意义。您需要测量该算法的运行时如何随着输入的增长而扩展。
@cigien 我明白你在说什么，但我注意到这个算法大约需要 250 毫秒，而其他算法需要 4-20 毫秒（显然它是在标准化机器上运行的，等等）跨度>

标签： c++ algorithm time-complexity big-o

【解决方案1】：

给定代码中不仅有 for 循环，还有递归，这可能会使您的代码 O(n * log n)。如果您想严格证明算法的复杂性，Master theorem 会很有帮助。

【讨论】：