一、问题？
1、输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。
2、例子
前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]
3、限制
0 <= 节点个数 <= 5000
二、解决方法
方法一
1、判断前序遍历的下标范围的开始和结束，若开始大于结束，则当前的二叉树中没有节点，返回空值 null。若开始等于结束，则当前的二叉树中恰好有一个节点，根据节点值创建该节点作为根节点并返回。
2、若开始小于结束，则当前的二叉树中有多个节点。在中序遍历中得到根节点的位置，从而得到左子树和右子树各自的下标范围和节点数量，知道节点数量后，在前序遍历中即可得到左子树和右子树各自的下标范围，然后递归重建左子树和右子树，并将左右子树的根节点分别作为当前根节点的左右子节点。
复杂度分析
时间复杂度：O(n)。对于每个节点都有创建过程以及根据左右子树重建过程。
空间复杂度：O(n)。存储整棵树的开销。
方法二
1、使用栈保存遍历过的节点。初始时令中序遍历的指针指向第一个元素，遍历前序遍历的数组，如果前序遍历的元素不等于中序遍历的指针指向的元素，则前序遍历的元素为上一个节点的左子节点。如果前序遍历的元素等于中序遍历的指针指向的元素，则正向遍历中序遍历的元素同时反向遍历前序遍历的元素，找到最后一次相等的元素，将前序遍历的下一个节点作为最后一次相等的元素的右子节点。其中，反向遍历前序遍历的元素可通过栈的弹出元素实现。
2、使用前序遍历的第一个元素创建根节点。
3、创建一个栈，将根节点压入栈内。
4、初始化中序遍历下标为 0。
5、遍历前序遍历的每个元素，判断其上一个元素（即栈顶元素）是否等于中序遍历下标指向的元素。
6、若上一个元素不等于中序遍历下标指向的元素，则将当前元素作为其上一个元素的左子节点，并将当前元素压入栈内。
7、若上一个元素等于中序遍历下标指向的元素，则从栈内弹出一个元素，同时令中序遍历下标指向下一个元素，之后继续判断栈顶元素是否等于中序遍历下标指向的元素，若相等则重复该操作，直至栈为空或者元素不相等。然后令当前元素为最后一个想等元素的右节点。
8、遍历结束，返回根节点。
package com.haoxiansheng.demo01.SwordfingerOffer;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import java.util.HashMap;
import java.util.Map;
import java.util.Stack;
/**
* @author flame
* @data 2020/10/19
*/
@Slf4j
public class BuildTree {
public static void main(String[] args) {
int [] preorder = {
3,9,20,15,7};
int [] inorder = {
9,3,15,20,7};
log.info("buildTree=>{}", buildTree(preorder, inorder));
log.info("buildTree2=>{}", buildTree2(preorder, inorder));
}
@Data
static class TreeNode {
private int val;
TreeNode left;
TreeNode right;
public TreeNode(int val) {
this.val = val;
}
}
// 方法一：递归
/**
* 前序遍历： 根 左 右
* 中序遍历： 左 根 右
* 后序遍历： 左 右 根
* <p>
* 复杂度分析
* 时间复杂度：O(n)。对于每个节点都有创建过程以及根据左右子树重建过程。
* 空间复杂度：O(n)。存储整棵树的开销。
*
* @param preorder
* @param inorder
* @return
*/
public static TreeNode buildTree(int[] preorder, int[] inorder) {
// 1、若为null 直接返回
if (preorder == null || preorder.length == 0) {
return null;
}
// 用Map 存放
// 使用一个 Map 存储中序遍历的每个元素及其对应的下标，目的是为了快速获得一个元素在中序遍历中的位置。
//调用递归方法，对于前序遍历和中序遍历，下标范围都是从 0 到 n-1，其中 n 是二叉树节点个数。
Map<Integer, Integer> tempMap = new HashMap<Integer, Integer>();
int len = preorder.length;
for (int i = 0; i < len; i++) {
tempMap.put(inorder[i], i);
}
TreeNode root = buildTree(preorder, 0, len - 1, inorder, 0, len - 1, tempMap);
return root;
}
public static TreeNode buildTree(int[] preorder, int preorderStart, int preorderEnd, int[] inorder, int inorderStart, int inorderEnd, Map<Integer, Integer> tempMap) {
// preorderStart > preorderEnd 说明为null
if (preorderStart > preorderEnd) {
return null;
}
// 先序遍历 开始为根
int rootVal = preorder[preorderStart];
TreeNode root = new TreeNode(rootVal);
// 如果开始和结尾值相等则说明只有一个
if (preorderStart != preorderEnd) {
// 活得根节点的索引
int rootIndex = tempMap.get(rootVal);
// 得到左右节点个数
int leftNodes = rootIndex - inorderStart;
int rightNodes = inorderEnd - rootIndex;
// 求左子树 左子树开始 左子树结束
TreeNode leftChildTree = buildTree(preorder, preorderStart + 1, preorderStart + leftNodes, inorder, inorderStart, rootIndex - 1, tempMap);
// 求右子树 右子树的开始位置和结束位置
TreeNode rightChildTree = buildTree(preorder, preorderEnd - rightNodes + 1, preorderEnd, inorder, rootIndex + 1, inorderEnd, tempMap);
root.left = leftChildTree;
root.right = rightChildTree;
// 封装返回
}
return root;
}
// 方法二：迭代
// 时间复杂度：O(n)。前序遍历和后序遍历都被遍历。
//空间复杂度：O(n)。额外使用栈存储已经遍历过的节点。
public static TreeNode buildTree2(int[] preorder, int[] inorder) {
if (preorder == null || preorder.length == 0) {
return null;
}
TreeNode root = new TreeNode(preorder[0]);
int length = preorder.length;
Stack<TreeNode> stack = new Stack<TreeNode>();
stack.push(root);
int inorderIndex = 0;
for (int i = 1; i < length; i++) {
int preorderVal = preorder[i];
TreeNode node = stack.peek();
if (node.val != inorder[inorderIndex]) {
node.left = new TreeNode(preorderVal);
stack.push(node.left);
} else {
while (!stack.isEmpty() && stack.peek().val == inorder[inorderIndex]) {
node = stack.pop();
inorderIndex++;
}
node.right = new TreeNode(preorderVal);
stack.push(node.right);
}
}
return root;
}
}