Java, c++ 中序和前序 或 中序和后序构建二叉树

利用递归，构建二叉树的时候主要就是要搞清楚，前序和中序，后序与中序的关系，然后要递归地往下构建，先建当前节点的左孩子，再右孩子，然后我利用另外一种序列遍历来验证 构建的二叉树是否正确。

#include <iostream>
#include <cstdio>
using namespace std;
const int maxn = 35;
int in[maxn];
int pre[maxn];
struct node {
int data;
node *lchild;
node *rchild;
};

//inOrder和preOrder创建 树
/*
inOrder: 12 11 20 17 1 15 8 5
preOrder: 1 11 12 17 20 5 8 15
*/
// or
//
//use the inOrder and preOrder create the binary tree
node *Create(int preL, int preR, int inL,int inR) {
if ( preL > preR ) return NULL;
node *root = new node();
root->data = pre[preL];
int index;
for ( index = inL; index <= inR; index++ ) {
if ( in[index] == pre[preL] )break;
}
int numLeft = index - inL;
root->lchild = Create(preL+1, preL+numLeft, inL, index-1);
root->rchild = Create(preL+numLeft+1, preR, index+1, inR);
return root;
}

void PostOrderTraversal(node *root) {
if ( root != NULL ) {
PostOrderTraversal(root->lchild);
PostOrderTraversal(root->rchild);
cout << root->data << " ";
}
}
int main() {
int n;
cin >> n;

for ( int i = 0 ; i < n; i++ ) {
cin >> in[i];
}
for ( int i = 0; i < n; i++ ) {
cin >> pre[i];
}
node *root;
root = Create(0,n-1,0,n-1);

PostOrderTraversal(root);

return 0;
}

#include <iostream>
#include <cstdio>
using namespace std;
const int maxn = 35;
int in[maxn];
int post[maxn];
struct node {
int data;
node *lchild;
node *rchild;
};
//inOrder和postOrder 创建 树
/*
inOrder:12 11 20 17 1 15 8 5
postOrder:12 20 17 11 15 8 5 1
*/
// use the inOrder and postOrder create the binary tree
//
node *Create(int postL, int postR, int inL, int inR) {
if ( postL > postR ) return NULL;
node *root = new node();
root->data = post[postR];
int index;
for ( index = inL; index <= inR; index++ ) {
if ( in[index] == post[postR] )break;
}
int numLeft = index - inL;
root->lchild = Create(postL, postL+numLeft-1, inL, index-1);
root->rchild = Create(postL+numLeft, postR-1, index+1, inR);
return root;
}
void PreOrderTraversal(node *root) {
if ( root != NULL ) {
cout << root->data << " ";
PreOrderTraversal(root->lchild);
PreOrderTraversal(root->rchild);
}
}
int main() {
int n;
cin >> n;
for ( int i = 0 ; i < n; i++ ) {
cin >> in[i];
}
for ( int i = 0; i < n; i++ ) {
cin >> post[i];
}
node *root;
root = Create(0,n-1,0,n-1);
PreOrderTraversal(root);
return 0;
}

Java 先序和中序为例:

public class Solution {
public static TreeNode reConstructBinaryTree(int [] pre,int [] in) {
int in_size = in.length;
if (in_size == 0) return null;
int val = pre[0];
TreeNode treeNode = new TreeNode(val);
int i;
for (i = 0; i < in_size; i++) {
if (in[i] == val) break;
}
int[] pre_left = new int[i];
int[] in_left = new int[i];
int[] pre_right = new int[in_size-i-1];
int[] in_right = new int[in_size-i-1];
//left tree
if (i > 0) {
for (int j = 0; j < i; j++) {
pre_left[j] = pre[j+1];
in_left[j] = in[j];
}
treeNode.left = reConstructBinaryTree(pre_left, in_left);
} else {
treeNode.left = null;
}
//right tree
if (in_size-i-1 > 0) {
for (int j = i+1; j < in_size; j++) {
pre_right[j-i-1] = pre[j];
in_right[j-i-1] = in[j];
}
treeNode.right = reConstructBinaryTree(pre_right, in_right);
} else {
treeNode.right = null;
}
return treeNode;
}
public static class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
public static void PostTraversal(TreeNode treeNode) {
if (treeNode != null){
PostTraversal(treeNode.left);
PostTraversal(treeNode.right);
System.out.print(treeNode.val+" ");
}
}
static int[] pre = {1, 2, 4, 7, 3, 5, 6, 8};
static int[] in = {4, 7, 2, 1, 5, 3, 8, 6};
public static TreeNode BuildTree(int PreL, int PreR, int inL, int inR) {
if (PreL > PreR) return null;
int val = pre[PreL];
TreeNode treeNode = new TreeNode(val);
int i;
for (i = inL; i <= inR; i++) {
if (in[i] == val) break;
}
int numleft =  i - inL;
treeNode.left = BuildTree(PreL+1, PreL+numleft, inL, i-1);
treeNode.right = BuildTree(PreL+numleft+1, PreR, i+1, inR);
return treeNode;
}

public static void main(String[] args) {

TreeNode treeNode1 = reConstructBinaryTree(pre, in);
PostTraversal(treeNode1);
int len = pre.length;
System.out.println();
TreeNode treeNode2 = BuildTree(0, len-1, 0, len-1);
PostTraversal(treeNode2);
}
}