原题链接:https://www.acwing.com/problem/content/description/23/
每个节点的值都互不相同,所以我们可以使用哈希表。 我们在初始化时,用哈希表(unordered_map<int,int>)记录每个值在中序遍历中的位置,这样我们在递归到每个节点时,在中序遍历中查找根节点位置的操作,只需要 O(1)O(1) 的时间。此时,创建每个节点需要的时间是 O(1)O(1),所以总时间复杂度是 O(n)O(n)。
参考题解:https://www.acwing.com/solution/content/2244/
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
/*
用dfs算法构建子树。
1. 首先, 把整个前序(pre)数组已经(in)中序数组的索引传入dfs程序。
2. 接着, 找到pre数组的第一个数,这就是剩下所有的子树的根,如果其为空,则返回为0.
3. 如果不为空,那么找到其在中序数组中所在的位置,记为k。
4. 接着遍历地生成左子树以及右子树。
5. 假设本次的pre数组的范围是[pl,pr],而in数组的范围是[il,ir]。
6. 那么,左子树的pre数组范围是[pl+1,pl+k-il],因为在左子树的起始点肯定从pl+1开始,
而由于是pre前序遍历,前面遍历的肯定都是左子树的,然而现在这个树可能是上一层的右子树,
也就是有il个点遍历过了,所以还要遍历k-il个点。
7. 左子树的in数组范围是[il,k-1],刚好在k号点之前的元素,这个很简单不需要解释。
8. 右子树的pre数组的范围是[pl+k-il+1,pr],也就是刚好是剩下的那些点。
9. 右子树的in数组的范围是[k+1,ir],也就是剩下的点。
把边界搞清楚了,编程就很容易了。下面是java代码
时间复杂度分析:blablabla
作者:轻叶
链接:https://www.acwing.com/solution/content/2244/
来源:AcWing
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
*/
class Solution {
public:
// 用哈希表(unordered_map<int,int>)记录每个值
// 在中序遍历中的位置,这样我们在递归到每个节点时,
// 在中序遍历中查找根节点位置的操作,只需要 O(1)的时间。
unordered_map<int, int> pos;
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
int n = preorder.size();
for(int i = 0; i < n; i ++)
pos[inorder[i]] = i;
return dfs(preorder, inorder, 0, n-1, 0, n-1);
}
// pl,pr是这颗树在前序遍历序列中的位置。il和ir是这棵树在中序遍历序列中的位置
TreeNode* dfs(vector<int>& pre, vector<int>& in, int pl, int pr, int il, int ir)
{
if(pl > pr) return NULL;
// k是左子树节点数量, 即中序序列中原始的根节点位置 - 前面已经建立过的可能的其他树
// 前边又il个点遍历了:从0 到 il-1
int k = pos[pre[pl]] - il;
TreeNode* root = new TreeNode(pre[pl]);
root->left = dfs(pre, in, pl + 1, pl + k, il, il + k - 1);
root->right = dfs(pre, in, pl + k + 1, pr, il + k + 1, ir);
return root;
}
};
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution(object):
def buildTree(self, preorder, inorder):
"""
:type preorder: List[int]
:type inorder: List[int]
:rtype: TreeNode
"""
self.pos = {}
self.preorder = preorder
for i, val in enumerate(inorder):
self.pos[val] = i
return self.recur(0, 0, len(inorder) - 1)
def recur(self, pre_left, in_left, in_right):
if in_left > in_right:
return
val = self.preorder[pre_left]
root = TreeNode(val)
k = self.pos[val]
left_length = k - in_left
root.left = self.recur(pre_left + 1,
in_left, k - 1)
root.right = self.recur(pre_left + 1 + left_length, k + 1, in_right)
return root