题解
相关知识点
(1) 二叉树的四种遍历方式:
(2) 图解二叉树遍历(节点遍历顺序1~5):
方法一:递归
思路
对于任意一棵树而言,前序遍历的形式总是:
[根节点,左子树的前序遍历,右子树的前序遍历]
即根节点总是前序遍历的第一个节点,而中序遍历的形式总是:
[左子树的中序遍历,根节点,右子树的中序遍历]
只要我们在中序遍历中定位到根节点的位置,那么我们便可以分别知道左子树和右子树中节点的数目。由于同一颗子树中的前序遍历和中序遍历的长度是相同的,那么我们便可以对应到前序遍历的结果中,对上述形式的所有左右括号进行定位。
这样我们便知道了左子树的前序遍历和中序遍历结果,以及右子树的前序遍历和中序遍历结果,那么我们便可以递归的构造左子树和右子树,再将这两颗子树连接到根节点的左右位置。
细节
在中序遍历中对根节点进行定位时,一种简单的方法是直接扫描整个中序遍历的结果并找出根节点,但这样做的时间复杂度较高。我们可以考虑使用哈希映射(hashmap)来快速的定位根节点位置。对于哈希映射中的每个键值对,键表示一个元素(节点的值),值表示中序遍历中节点的位置。在构造二叉树之前,我们先对中序遍历进行一遍扫描,这样就可以构造出哈希映射。在此后构造二叉树的过程中,我们只需要O(1)时间便可以定位根节点的位置。
Code
cpp
class Solution {
private:
unordered_map<int, int> index;
public:
TreeNode* myBuildTree(const vector<int>& preorder, const vector<int>& inorder, int preorder_left, int preorder_right, int inorder_left, int inorder_right) {
if (preorder_left > preorder_right) {
return nullptr;
}
// 前序遍历中的第一个节点就是根节点
int preorder_root = preorder_left;
// 在中序遍历中定位根节点
int inorder_root = index[preorder[preorder_root]];
// 先把根节点建立出来
TreeNode* root = new TreeNode(preorder[preorder_root]);
// 得到左子树中的节点数目
int size_left_subtree = inorder_root - inorder_left;
// 递归地构造左子树,并连接到根节点
// 先序遍历中「从 左边界+1 开始的 size_left_subtree」个元素就对应了中序遍历中「从 左边界 开始到 根节点定位-1」的元素
root->left = myBuildTree(preorder, inorder, preorder_left + 1, preorder_left + size_left_subtree, inorder_left, inorder_root - 1);
// 递归地构造右子树,并连接到根节点
// 先序遍历中「从 左边界+1+左子树节点数目 开始到 右边界」的元素就对应了中序遍历中「从 根节点定位+1 到 右边界」的元素
root->right = myBuildTree(preorder, inorder, preorder_left + size_left_subtree + 1, preorder_right, inorder_root + 1, inorder_right);
return root;
}
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
int n = preorder.size();
// 构造哈希映射,帮助我们快速定位根节点
for (int i = 0; i < n; ++i) {
index[inorder[i]] = i;
}
return myBuildTree(preorder, inorder, 0, n - 1, 0, n - 1);
}
};
python
class Solution:
def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
def myBuildTree(preorder_left: int, preorder_right: int, inorder_left: int, inorder_right: int):
if preorder_left > preorder_right:
return None
# 前序遍历中的第一个节点就是根节点
preorder_root = preorder_left
# 在中序遍历中定位根节点
inorder_root = index[preorder[preorder_root]]
# 先把根节点建立出来
root = TreeNode(preorder[preorder_root])
# 得到左子树中的节点数目
size_left_subtree = inorder_root - inorder_left
# 递归地构造左子树,并连接到根节点
# 先序遍历中「从 左边界+1 开始的 size_left_subtree」个元素就对应了中序遍历中「从 左边界 开始到 根节点定位-1」的元素
root.left = myBuildTree(preorder_left + 1, preorder_left + size_left_subtree, inorder_left, inorder_root - 1)
# 递归地构造右子树,并连接到根节点
# 先序遍历中「从 左边界+1+左子树节点数目 开始到 右边界」的元素就对应了中序遍历中「从 根节点定位+1 到 右边界」的元素
root.right = myBuildTree(preorder_left + size_left_subtree + 1, preorder_right, inorder_root + 1, inorder_right)
return root
n = len(preorder)
# 构造哈希映射,帮助我们快速定位根节点
index = {element: i for i, element in enumerate(inorder)}
return myBuildTree(0, n - 1, 0, n - 1)
方法二:迭代
思路
迭代法是一种非常巧妙的实现方法。
对于前序遍历中的任意两个连续节点 u 和 v,根据前序遍历的流程,我们可以知道 u 和 v 只有两种可能的关系:
-
v 是 u 的左儿子。这是因为在遍历到 u 之后,下一个遍历的节点就是 u 的左儿子,即 v;
-
u 没有左儿子,并且 v 是 u 的某个祖先节点(或者 u 本身)的右儿子。如果 u 没有左儿子,那么下一个遍历的节点就是 u 的右儿子。如果 u 没有右儿子,我们就会向上回溯,直到遇到第一个有右儿子(且 u 不在它的右儿子的子树中)的节点 ua ,那么 v 就是 ua 的右儿子。
算法
算法流程:
-
我们用一个栈 s t a c k stack stack 和一个指针 i n d e x index index 辅助进行二叉树的构造。初始时栈中存放了根节点(前序遍历的第一个节点),指针指向中序遍历的第一个节点;
-
我们依次枚举前序遍历中除了第一个节点以外的每个节点。如果 i n d e x index index 恰好指向栈顶节点,那么我们不断地弹出栈顶节点并向右移动 i n d e x index index,并将当前节点作为最后一个弹出的节点的右儿子;如果 i n d e x index index 和栈顶节点不同,我们将当前节点作为栈顶节点的左儿子;
-
无论是哪一种情况,我们最后都将当前的节点入栈。
最后得到的二叉树即为答案。
Code
cpp
class Solution {
public:
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
if (!preorder.size()) {
return nullptr;
}
TreeNode* root = new TreeNode(preorder[0]);
stack<TreeNode*> stk;
stk.push(root);
int inorderIndex = 0;
for (int i = 1; i < preorder.size(); ++i) {
int preorderVal = preorder[i];
TreeNode* node = stk.top();
if (node->val != inorder[inorderIndex]) {
node->left = new TreeNode(preorderVal);
stk.push(node->left);
}
else {
while (!stk.empty() && stk.top()->val == inorder[inorderIndex]) {
node = stk.top();
stk.pop();
++inorderIndex;
}
node->right = new TreeNode(preorderVal);
stk.push(node->right);
}
}
return root;
}
};
python
class Solution:
def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
if not preorder:
return None
root = TreeNode(preorder[0])
stack = [root]
inorderIndex = 0
for i in range(1, len(preorder)):
preorderVal = preorder[i]
node = stack[-1]
if node.val != inorder[inorderIndex]:
node.left = TreeNode(preorderVal)
stack.append(node.left)
else:
while stack and stack[-1].val == inorder[inorderIndex]:
node = stack.pop()
inorderIndex += 1
node.right = TreeNode(preorderVal)
stack.append(node.right)
return root
参考:
附:python 打印二叉树
def print_tree_mid(root):
"""
中序遍历打印二叉树节点值
:param root: 根节点
:return: None
"""
if type(root) == TreeNode:
print_tree(root.left)
print(root.val)
print_tree(root.right)
def print_tree_front(root):
"""
前序遍历打印二叉树节点值
:param root: 根节点
:return: None
"""
if type(root) == TreeNode:
print(root.val)
print_tree(root.left)
print_tree(root.right)