后序，中序构建二叉树

package review;


import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class Main {
	
//	public static void preorder(BinaryTreeNode root) {
//		if(root==null) {
//			return;
//		}
//		System.out.println(root.value);
//		preorder(root.left);
//		preorder(root.right);
//	}
//	public static void postorder(BinaryTreeNode root) {
//		if(root==null) {
//			return;
//		}
//		postorder(root.left);
//		postorder(root.right);
//		System.out.println(root.value);
//	}
//	public static void inorder(BinaryTreeNode root) {
//		if(root==null) {
//			return;
//		}
//		inorder(root.left);
//		System.out.println(root.value);
//		inorder(root.right);
//	}
	public static void preorder(BinaryTreeNode root) {
		Stack<BinaryTreeNode> stack=new Stack<>();
		BinaryTreeNode node=root;
		while(node!=null|| !stack.isEmpty()) {
			while(node!=null) {
				System.out.println(node.value);
				stack.push(node);
				node=node.left;
			}
			if(!stack.isEmpty()) {
				node=stack.pop();
				node=node.right;
			}

		}
	}
	public static LinkedList<Character> postorder(BinaryTreeNode root) {
		Stack<BinaryTreeNode> stack=new Stack<>();
		LinkedList<Character> l=new LinkedList<>();
		BinaryTreeNode node=root;
		while(node!=null||!stack.isEmpty()) {
			while(node!=null) {
				stack.push(node);
				l.add(0, node.value);
				node =node.right;				
			}
			node=stack.pop();
			if(node!=null)
				node=node.left;	
		}
		return l;
	}
	public static void inorder(BinaryTreeNode root) {
		Stack<BinaryTreeNode> stack=new Stack<>();
		BinaryTreeNode node =root;
		while(!stack.isEmpty()||node!=null) {
			while(node!=null) {
				stack.push(node);
				node=node.left;
			}
			if(!stack.isEmpty()) {
				node=stack.pop();
				System.out.println(node.value);
				node=node.right;		
			}

		}
	}
	public static void traversal(BinaryTreeNode root) {
		Queue<BinaryTreeNode> queue=new LinkedList<BinaryTreeNode>();
		if(root!=null) {
			queue.offer(root);
		}
		BinaryTreeNode node;
		while(!queue.isEmpty()) {
			for(int i=0;i<queue.size();i++) {
				node=queue.poll();
				if(node!=null) {
					System.out.println(node.value);
					queue.offer(node.left);
					queue.offer(node.right);						
				}
			}
		}
	}
//	public static BinaryTreeNode buildTree(char preorder[],char inorder[]) {
//		if(preorder.length==0) { //如果二叉树是空树，则返回一个空树
//			return null;
//		}
//		HashMap<Character,Integer> hashmap=new HashMap<>();//用hashmap存储中序序列是为了寻找前序根节点位置在中序序列的位置
//		for(int i=0;i<inorder.length;i++) {
//			hashmap.put(inorder[i],i);
//		}
//		return buildTree(preorder,0,preorder.length-1,inorder,0,inorder.length-1,hashmap);
//	}
//	public static BinaryTreeNode buildTree(char preorder[],int prei,int prej,char inorder[],int ini,int inj,HashMap<Character,Integer> hashmap) {
//		//inorder已经由hashmap存储，不用再传递
//		if(prej<prei||inj<ini) {//递归终止条件
//			return null;
//		}
//		
//		BinaryTreeNode node=new BinaryTreeNode(preorder[prei]);//非空树，由先序序列得到二叉树的根节点
//		int index=1;
//		if(hashmap.containsKey(preorder[prei])) {//根据先序根节点，在中序中找到这个根节点在中序的位置index
//			index=hashmap.get(preorder[prei]);
//		}
//		int leftlen=index-ini;//左子树的长度
//		//中序前index个元素为左子树的中序遍历 ini,index-1
//		//前序从根节点的下一个位置prei+1开始，长度为leftlen的左子树的前序遍历，下标为prei+1+leftlen-1
//		node.left=buildTree(preorder,prei+1,prei+leftlen,inorder,ini,index-1,hashmap);
//		//中序从index+1,到最后为右子树的中序遍历 
//		//前序从index+1,到最后为左子树的前序遍历
//		node.right=buildTree(preorder,prei+leftlen+1,prej,inorder,index+1,inj,hashmap);
//		return node;
//	}
	
	public static BinaryTreeNode buildTree(char inorder[],char postorder[]) {
		if(postorder.length==0) {
			return null;
		}
		HashMap<Character,Integer> hashmap=new HashMap<>();
		for(int i=0;i<inorder.length;i++) {
			hashmap.put(inorder[i], i);
		}
		return buildTree(postorder,0,postorder.length-1,hashmap,0,inorder.length-1);
	}
	public static BinaryTreeNode buildTree(char postorder[],int posti,int postj,HashMap<Character,Integer> hashmap,int ini,int inj) {
		if(posti>postj||ini>inj) {
			return null;
		}
		int index=1;
		BinaryTreeNode node=new BinaryTreeNode(postorder[postj]);
		if(hashmap.containsKey(postorder[postj])) {
			index=hashmap.get(postorder[postj]);
		}
			
		int leftlen=index-ini;
		node.left=buildTree(postorder,posti,posti+leftlen-1,hashmap,ini,index-1);
		node.right=buildTree(postorder,posti+leftlen,postj-1,hashmap,index+1,inj);
		return node;
	}
	public static void main(String[] args) {
//		BinaryTreeNode n1=new BinaryTreeNode('A');
//		BinaryTreeNode n2=new BinaryTreeNode('B');
//		BinaryTreeNode n3=new BinaryTreeNode('C');
//		BinaryTreeNode n4=new BinaryTreeNode('D');
//		BinaryTreeNode n5=new BinaryTreeNode('E');
//		BinaryTreeNode n6=new BinaryTreeNode('F');
//		BinaryTreeNode n7=new BinaryTreeNode('G');
//		n1.left=n2;
//		n1.right=n3;
//		n2.left=n4;
//		n2.right=n5;
//		n3.left=n6;
//		n5.right=n7;
//		preorder(n1);
//		System.out.println();
//		LinkedList<Character> l=new LinkedList<>();
//		l=postorder(n1);
//		for(int i=0;i<l.size();i++) {
//			System.out.println(l.get(i));
//		}
//		System.out.println();
//		inorder(n1);
//		System.out.println();
//		traversal(n1);
		char preorder[]= {'A','B','C','D','E'};
		char inorder[]= {'B','A','D','C','E'};
		char postorder[]= {'B','D','E','C','A'};
		//BinaryTreeNode node=buildTree(preorder,inorder);
		BinaryTreeNode node=buildTree(inorder,postorder);
		traversal(node);
		//inorder(node);
		//preorder(node);
//		LinkedList<Character> l=new LinkedList<>();
//		l=postorder(node);
//		for(int i=0;i<l.size();i++) {
//			System.out.println(l.get(i));
//		}
		
	}
}

前中序看前一篇