如何解决在给定有序和预序遍历的情况下,如何导出该公式的证明以使二叉树成为正确的子代? 仅适用于Python C ++
我正在看leetcode上的这个question。给定两个数组,即有序和预排序,您需要构造一个二叉树。我得到了问题的一般解决方案。
预遍历遍历会访问根,左和右,因此左子节点将是当前预订购节点索引+1。根据该值,您可以使用inorder数组知道树的左侧有多少个节点。在答案中,用于获取合适的孩子的公式是“ preStart + inIndex-inStart + 1”。
我不想记住公式,所以我想知道是否有证明吗?我浏览了那里的讨论区,但仍然缺少链接。
解决方法
仅适用于Python
-
在Python中,即使效率不高(尽管会通过),我们也可以使用
pop(0)
解决此问题。 -
由于效率低下,我们可以将
deque()
与popleft()
一起使用,但是不能在LeetCode上使用,因为我们无法控制树。
class Solution:
def buildTree(self,preorder,inorder):
if inorder:
index = inorder.index(preorder.pop(0))
root = TreeNode(inorder[index])
root.left = self.buildTree(preorder,inorder[:index])
root.right = self.buildTree(preorder,inorder[index + 1:])
return root
对于Java和C ++,这就像您所说的(没有证据)有些不同,但是也许this post会有所帮助:
public class Solution {
public static final TreeNode buildTree(
final int[] preorder,final int[] inorder
) {
return traverse(0,inorder.length - 1,inorder);
}
private static final TreeNode traverse(
final int preStart,final int inStart,final int atEnd,final int[] preorder,final int[] inorder
) {
if (preStart > preorder.length - 1 || inStart > atEnd) {
return null;
}
TreeNode root = new TreeNode(preorder[preStart]);
int inorderIndex = 0;
for (int i = inStart; i <= atEnd; i++)
if (inorder[i] == root.val) {
inorderIndex = i;
}
root.left = traverse(preStart + 1,inStart,inorderIndex - 1,inorder);
root.right = traverse(preStart + inorderIndex - inStart + 1,inorderIndex + 1,atEnd,inorder);
return root;
}
}
C ++
// The following block might slightly improve the execution time;
// Can be removed;
static const auto __optimize__ = []() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.tie(nullptr);
return 0;
}();
// Most of headers are already included;
// Can be removed;
#include <cstdint>
#include <vector>
#include <unordered_map>
using ValueType = int;
static const struct Solution {
TreeNode* buildTree(
std::vector<ValueType>& preorder,std::vector<ValueType>& inorder
) {
std::unordered_map<ValueType,ValueType> inorder_indices;
for (ValueType index = 0; index < std::size(inorder); ++index) {
inorder_indices[inorder[index]] = index;
}
return build(preorder,inorder,inorder_indices,std::size(inorder) - 1);
}
private:
TreeNode* build(
std::vector<ValueType>& preorder,std::vector<ValueType>& inorder,std::unordered_map<ValueType,ValueType>& inorder_indices,ValueType pre_start,ValueType in_start,ValueType in_end
) {
if (pre_start >= std::size(preorder) || in_start > in_end) {
return nullptr;
}
TreeNode* root = new TreeNode(preorder[pre_start]);
ValueType pre_index = inorder_indices[preorder[pre_start]];
root->left = build(preorder,pre_start + 1,in_start,pre_index - 1);
root->right = build(preorder,pre_start + 1 + pre_index - in_start,pre_index + 1,in_end);
return root;
}
};
版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 dio@foxmail.com 举报,一经查实,本站将立刻删除。