n刷:自己写出来了!开心开心开心
剑指Offer里也有盒盒盒,剑指 Offer 07 重建二叉树java题解,我莫得脑子
题目
方法一:递归
class Solution {
HashMap<Integer,Integer> map=new HashMap<>();//<数值,位置>
int len1,len2;
int[] preorder,inorder;
public TreeNode buildTree(int[] preorder, int[] inorder) {
/*
根据前序序列,找到在中序序列的位置,在中序序列中划分左子树和右子树
*/
this.preorder=preorder;
this.inorder=inorder;
len1=preorder.length;
len2=inorder.length;
for(int i=0;i<len2;i++){
map.put(inorder[i],i);
}
return build(0,0,len2-1);
}
//根节点,中序序列左端,中序序列右端
public TreeNode build(int pre_index,int start,int end){
if(start>end){
return null;
}
if(pre_index>=len1)
return null;
TreeNode root=new TreeNode(preorder[pre_index]);//构建根节点
int in_index=map.get(preorder[pre_index]);
root.left=build(pre_index+1,start,in_index-1);
root.right=build(pre_index+in_index-1-start+1+1,in_index+1,end);
return root;
}
}
代码
class Solution {
int[] preorder;
HashMap<Integer, Integer> dic = new HashMap<>();
public TreeNode buildTree(int[] preorder, int[] inorder) {
this.preorder = preorder;
for(int i = 0; i < inorder.length; i++)
dic.put(inorder[i], i);
return recur(0, 0, inorder.length - 1);
}
TreeNode recur(int root, int left, int right) {
if(left > right) return null; // 递归终止
TreeNode node = new TreeNode(preorder[root]); // 建立根节点
int i = dic.get(preorder[root]); // 划分根节点、左子树、右子树
node.left = recur(root + 1, left, i - 1); // 开启左子树递归
node.right = recur(root + i - left + 1, i + 1, right); // 开启右子树递归
return node; // 回溯返回根节点
}
}
复杂度
时间复杂度:O(n),其中 n 是树中的节点个数。
空间复杂度:O(n),除去返回的答案需要的 O(n) 空间之外,我们还需要使用O(n) 的空间存储哈希映射,以及 O(h)(其中 h是树的高度)的空间表示递归时栈空间。这里 h < n,所以总空间复杂度为 O(n)。
结果
方法二:迭代
我还不懂
分析
对于前序遍历的任意两个连续节点a和b,根据前序遍历的流程,我们可以知道a和b只有两种可能的关系:
1.b是a的左儿子。因为在遍历到a之后,下一个遍历的节点就是a的左儿子,即b。
2.a没有左儿子,并且b是a的某个祖先节点(或者a本身)的右儿子。如果a没有左儿子,那么下一个遍历的节点就是a的右儿子。如果a没有右儿子,我们就会向上回溯,直到遇到第一个有右儿子(且a不在它的右儿子的子树中)的节点aa,那么a就是aa的右儿子。
我们用一个栈和一个指针辅助进行二叉树的构造。初始时栈中存放了根节点(前序遍历的第一个节点),指针指向中序遍历的第一个节点;
我们依次枚举前序遍历中除了第一个节点以外的每个节点。如果 index 恰好指向栈顶节点,那么我们不断地弹出栈顶节点并向右移动 index,并将当前节点作为最后一个弹出的节点的右儿子;如果 index 和栈顶节点不同,我们将当前节点作为栈顶节点的左儿子;
无论是哪一种情况,我们最后都将当前的节点入栈。
复杂度
时间复杂度:O(n),其中 n 是树中的节点个数。
空间复杂度:O(n),除去返回的答案需要的 O(n) 空间之外,我们还需要使用 O(h)(其中 h 是树的高度)的空间存储栈。这里 h < n,所以(在最坏情况下)总空间复杂度为 O(n)。
代码
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public TreeNode buildTree(int[] preorder, int[] inorder) {
if(preorder==null||preorder.length==0)
return null;
Deque<TreeNode> stack=new LinkedList<TreeNode>();
TreeNode root=new TreeNode(preorder[0]);
stack.push(root);
int inorderIndex=0;
for(int i=1;i<preorder.length;i++){
int preVal=preorder[i];
TreeNode node1=stack.peek();
if(node1.val!=inorder[inorderIndex]){
node1.left=new TreeNode(preVal);
stack.push(node1.left);
}
else{
while(!stack.isEmpty()&&stack.peek().val==inorder[inorderIndex]){
node1=stack.pop();
inorderIndex++;
}
node1.right=new TreeNode(preVal);
stack.push(node1.right);
}
}
return root;
}
}