重建二叉树

经典的二叉树重建问题。去哪儿的笔试题 根据前序和中序，分层打印二叉树

1.已知前序遍历和中序遍历 重建二叉树

方法一 递归

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
    return helper(0, 0, inorder.length - 1, preorder, inorder);
}

public TreeNode helper(int preStart, int inStart, int inEnd, int[] preorder, int[] inorder) {
    if (preStart > preorder.length - 1 || inStart > inEnd) {
        return null;
    }
    TreeNode root = new TreeNode(preorder[preStart]);
    int inIndex = 0; // Index of current root in inorder
    for (int i = inStart; i <= inEnd; i++) {
        if (inorder[i] == root.val) {
            inIndex = i;
        }
    }
    root.left = helper(preStart + 1, inStart, inIndex - 1, preorder, inorder);
    root.right = helper(preStart + inIndex - inStart + 1, inIndex + 1, inEnd, preorder, inorder);
    return root;
}
}

方法二：使用栈或者队列来做。

import java.lang.Thread.State;
import java.util.Stack;

public class reconstructTree {
    public TreeNode reconst(int pre[],int in[]){
        if(pre.length==0) return null;
        Stack<Integer> sta = new Stack<>();
        Stack<TreeNode> statr=new Stack<>();
        TreeNode root  = new TreeNode(pre[0]);
        int i=0,j=0,f=0;
        TreeNode t =null,r=null;
        sta.push(pre[i]);
        statr.push(root);
        t =root;
        i++;
        
        while(i<pre.length){
            
            if(!statr.isEmpty()&&statr.peek().val==in[j]){
                t = statr.pop();
                sta.pop();
                f=1;j++;
            }
            else{
                
                if(f==0){
                    sta.push(pre[i]);
                    t.left = new TreeNode(pre[i]);
                    t= t.left;
                    statr.push(t);
                    i++;
                }
                
                else{
                    f=0;
                    sta.push(pre[i]);
                    t.right = new TreeNode(pre[i]);
                    t=t.right;
                    statr.push(t);
                    i++;
                    
                }
                
            }
        }
        
        return root;
        
        
        }
    }

2.已知中序和后序，重建二叉树

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public TreeNode buildTree(int[] inorder, int[] postorder) {
       return  dfs(postorder.length-1,0,inorder.length-1,inorder,postorder);
        
    }
    public TreeNode dfs(int endpost,int instart,int inend,int [] inorder,int [] postorder){
        if(inorder.length-1<endpost||inend<instart||endpost<0) return null;
        TreeNode root=new TreeNode(postorder[endpost]);
        int index=0;
        
        for(int i=instart;i<=inend;i++){
            if(inorder[i]==postorder[endpost])
            index=i;
            
        }
        root.left=dfs(endpost-(inend-index)-1,instart,index-1,inorder,postorder);
        root.right=dfs(endpost-1,index+1,inend,inorder,postorder);
        
        return root;
        
    }
}