先序遍历: 1,2,7,4,5,3,6,8
中序遍历:7,2,5,4,1,6,3,8
后序遍历:7,5,4,2,6,8,3,1
根据先序遍历和中序遍历重构二叉树
- 先序遍历的第一个节点为根节点
1
- 在中序遍历中找到根节点
1
,其左侧的就是这个节点的左子树的中序遍历7,2,5,4
,右侧的就是右子树的中序遍历6,3,8
- 在先序遍历中找到左右子树的先序遍历
2,7,4,5
,3,6,8
- 递归左右子树重构二叉树(左子树的先序遍历的第一个节点即为左子树的根节点…)
根据中序遍历和后序遍历重构二叉树
与前面差不多,后序遍历的最后一个节点为根节点,然后去中序遍历中找根节点的左右子树。
Tip: 中序遍历的根节点在中间,后序遍历的根节点在最后,取子树的遍历的时候能用到,如:
第一次递归中,根节点1
的在中序遍历中是第5个节点,那么其左子树就是左边4个(1 ~ 5-1),右子树为右3个(5+1 ~ 8);左子树的后续遍历为前4个(1 ~ 5-1),右子树为连着的后面的3个(5~7)。
注意:根据先序遍历和后续遍历不能重构唯一的二叉树
package utils;
import java.util.Arrays;
class Node {
int val;
Node left;
Node right;
public Node() {}
public Node(int val) {
this.val = val;
}
}
public class BinaryTree {
// 先序遍历 根-左-右
private static void firstOrder(Node root) {
if (root ==null)return;
System.out.print(root.val);
firstOrder(root.left);
firstOrder(root.right);
}
// 中序遍历 左-根-右
private static void inOrder(Node root) {
if (root ==null)return;
inOrder(root.left);
System.out.print(root.val);
inOrder(root.right);
}
// 后序遍历 左-右-根
private static void lastOrder(Node root) {
if (root ==null)return;
lastOrder(root.left);
lastOrder(root.right);
System.out.print(root.val);
}
// 根据先序遍历和后序遍历重构二叉树
private static Node reConstructBinaryTree(int[] preOrder, int[] inOrder) {
if (preOrder.length == 0 || inOrder.length == 0) {
return null;
}
int len = preOrder.length;
Node node = new Node(preOrder[0]);
for (int i=0; i<len; i++) {
if (preOrder[0] == inOrder[i]) {
node.left = reConstructBinaryTree(
Arrays.copyOfRange(preOrder, 1, i+1),
Arrays.copyOfRange(inOrder, 0, i)
);
node.right = reConstructBinaryTree(
Arrays.copyOfRange(preOrder, i+1, len),
Arrays.copyOfRange(inOrder, i+1, len)
);
}
}
return node;
}
// 根据中序遍历和后续遍历重构二叉树
private static Node reConstructBinaryTree2(int[] inOrder, int[] lastOrder) {
if (lastOrder.length == 0 || inOrder.length == 0) {
return null;
}
int len = lastOrder.length;
Node node = new Node(lastOrder[len-1]);
for (int i=0; i<len; i++) {
if (lastOrder[len-1] == inOrder[i]) {
node.left = reConstructBinaryTree2(
Arrays.copyOfRange(inOrder, 0, i),
Arrays.copyOfRange(lastOrder, 0, i)
);
node.right = reConstructBinaryTree2(
Arrays.copyOfRange(inOrder, i+1, inOrder.length),
Arrays.copyOfRange(lastOrder, i, lastOrder.length-1)
);
}
}
return node;
}
public static void main(String[] args) {
int[] preOrder = {1,2,7,4,5,3,6,8};
int[] inOrder = {7,2,5,4,1,6,3,8};
int[] lastOrder = {7,5,4,2,6,8,3,1};
Node root = reConstructBinaryTree(preOrder, inOrder);
lastOrder(root);
System.out.println();
root = reConstructBinaryTree2(inOrder, lastOrder);
firstOrder(root);
}
}