【剑指offer】重建二叉树&&二叉树的递归与非递归遍历

前序遍历：先根节点，左子结点，右子节点。
中序遍历：先左子节点，根节点，右子节点。
后序遍历：先左子结点，右子节点，根节点。

题目：输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

import java.util.Stack;

class TreeNode {
          int val;
          TreeNode left;
          TreeNode right;
          TreeNode(int x) { val = x; }
}
public class Solution {
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        return reConTree(pre,0,pre.length-1,in,0,in.length-1);
    }
    public TreeNode reConTree(int[] pre,int preleft, int preright,int[] in,int inleft,int inright){
        if(preleft>preright||inleft>inright){
            return null;
        }
        TreeNode root = new TreeNode(pre[preleft]);
        for(int i=inleft;i<=inright;i++){
            if(pre[preleft]==in[i]){
                //构建左子树，区间长度为(i-inleft),先序区间为[preleft+1,preleft+(i-inleft)]，中序区间为[inleft,i-1]
                root.left=reConTree(pre,preleft+1,preleft+(i-inleft),in,inleft,i-1);
                //构建右子树，区间长度为(inright-i),先序区间为[左子树右区间+1,先序右区间末]，中序区间为[i+1,inright];
                root.right=reConTree(pre,preleft+(i-inleft)+1,preright,in,i+1,inright);
            }
        }
        return root;
    }

    /**
     * 递归遍历二叉树
     * @param node
     */

    public static void traverseBinTree(TreeNode node){
        if (node==null){
            return;
        }
        //System.out.println(node.val);          //前序遍历
        if(node.left!=null){
            traverseBinTree(node.left);
        }
        //System.out.println(node.val);          //中序遍历
        if(node.right!=null){
            traverseBinTree(node.right);
        }
        System.out.println(node.val);         //后序遍历
    }
    /**
     * 非递归版先序遍历
     * 
     * 即对于任一结点，其可看做是根结点，因此可以直接访问。
     * 访问完之后，若其左孩子不为空，按相同规则访问它的左子树
     * 当访问其左子树时，再访问它的右子树。
     * 
     * @param node
     */
    public static void preOrder(TreeNode node){
        Stack<TreeNode> tree = new Stack<TreeNode>();
        while(node!=null || !tree.empty()){
            while(node!=null){
                System.out.println(node.val);
                tree.push(node);
                node = node.left;
            }
            if(!tree.empty()){
                node = tree.pop();
                node = node.right;
            }
        }
    }
    /**
     * 非递归版中序遍历
     * 
     * 对于任一结点，优先访问其左孩子，而左孩子结点又可以看做一根结点。
     * 然后继续访问其左孩子结点，直到遇到左孩子结点为空的结点才进行访问。
     * 按相同的规则访问其右子树。
     * 
     * @param node
     */
    public static void inOrder(TreeNode node){
        Stack<TreeNode> tree = new Stack<TreeNode>();
        while(node!=null || !tree.empty()){
            while(node!=null){
                tree.push(node);
                node = node.left;
            }
            if(!tree.empty()){
                node = tree.pop();
                System.out.println(node.val);
                node = node.right;
            }
        }
    }
    /**
     * 非递归版后序遍历1
     * 
     * 要保证根结点在左孩子和右孩子访问之后才能访问，因此对于任一结点P，先将其入栈。
     * 如果P不存在左孩子和右孩子，则可以直接访问它；
     * 或者P存在左孩子或者右孩子，但是其左孩子和右孩子都已被访问过了，则同样可以直接访问该结点。
     * 若非上述两种情况，则将P的右孩子和左孩子依次入栈，这样就保证了每次取栈顶元素的时候。
     * 左孩子在右孩子前面被访问，左孩子和右孩子都在根结点前面被访问。
     * 
     * @param node
     */
    public static void postOrder(TreeNode node){
        Stack<TreeNode> tree = new Stack<TreeNode>();
        TreeNode pre = null;  //前一个访问的节点
        TreeNode cur ;   //当前节点
        tree.push(node);
        while(!tree.empty()){
            cur = tree.peek();  //访问栈顶元素
            //如果当前结点没有孩子结点（情况一）或者孩子节点都已被访问过 （情况二）[pre!=null]
            if((cur.left==null&&cur.right==null)||(pre!=null&&(pre==cur.left||pre==cur.right))){
                System.out.println(cur.val);
                tree.pop();
                pre = cur;
            }else{
                //注意入栈先后顺序，右子节点点先入栈
                if(cur.right!=null){
                    tree.push(cur.right);
                }
                if(cur.left!=null){
                    tree.push(cur.left);
                }
            }
        }
    }
    /**
     * 非递归版后序遍历2
     * 
     * 对于任一结点P，将其入栈，然后沿其左子树一直往下搜索，直到搜索到没有左孩子的结点。
     * 此时该结点出现在栈顶，但是此时不能将其出栈并访问，因此其右孩子还为被访问。
     * 所以接下来按照相同的规则对其右子树进行相同的处理。
     * 当访问完其右孩子时，该结点又出现在栈顶，此时可以将其出栈并访问。
     * 
     * @param node
     */
        public static void postOrder2(TreeNode node){
            Stack<TreeNode> tree = new Stack<TreeNode>();
            Stack<Integer> counts = new Stack<Integer>();
            Integer i = new Integer(1);
            while(node != null || !tree.empty()){
                while(node!=null){
                    tree.push(node);
                    counts.push(new Integer(0));
                    node = node.left;
                }
                while(!tree.empty()&&counts.peek().equals(i)){
                    counts.pop();
                    System.out.println(tree.pop().val);
                }
                if(!tree.empty()){
                    counts.pop();
                    counts.push(new Integer(1));  //标记有访问右孩子
                    node = tree.peek();
                    node = node.right;
                }
            }

        }
    public static void main(String[] args) {
        int[] pre = new int[]{1,2,4,7,3,5,6,8};
        int[] in = new int[]{4,7,2,1,5,3,8,6};
        TreeNode tree = new Solution().reConstructBinaryTree(pre, in);
        postOrder(tree);
    }
}