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

Question

Given preorder and inorder traversal of a tree, construct the binary tree.

Note: You may assume that duplicates do not exist in the tree.

/**
 * 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;
        }
};

The for loop makes me think it is O(n) , but the algorithm takes significantly more time in milliseconds than other O(n) algorithms.

Answer 1

There's not only for loop in the given code, there are recursions, which may make your code O(n * log n). Master theorem will be helpful if you'd like to strictly prove the complexity of your algorithm.