编程之美——3.9重建二叉树和3.10分层遍历二叉树(Java and C++)

编程之美——3.9、重建二叉树   and   3.10、分层遍历二叉树

(Java and C++)

给定一个前序和中序变量的结果，写一个算法重建这棵树：如：

1、根据前序遍历结果和中序遍历结果重建二叉树：
前序： a b d c e f
中序:  d b a e c f

前序遍历的每一个节点，都是当前子树的根节点，同时，以对应的节点
为边界，就会把前序遍历的结果分为左子树和右子树。

a是前序中第一个节点，以a为中界，把中序的结果分成：
左：db
右:ecf

对于db，由于在前序中b在d前面，所以，b是d的父亲。

对于ecf，前序中c在前面，c为父亲，c把e和f分开。

2、从上之下按层遍历二叉树：

Java代码：

import java.util.LinkedList;
import java.util.Queue;
import java.util.Vector;


public class Main {
	static Main  instance =new Main();
	
	public static void main(String[] arg){
		char[] preOrder={'a','b','d','c','e','f'};
		char[] inOrder ={'d','b','a','e','c','f'};
		Node root = buildTree(preOrder,inOrder,0,0,preOrder.length,null);
		preOrderTraversal(root);
		System.out.println("\n===============================");
		inOrderTraversal(root);
		System.out.println("\n===============================");
		traversalAtLevel(root, 2);
		System.out.println("\n===============================");
		TraversalByLevel(root, 3);
		System.out.println("\n===============================");
		TraversalByLevelUnknowDeep(root);
		System.out.println("\n===============================");
		TraversalByLevel_2(root);
		System.out.println("\n===============================");
		System.out.println("BFS_000");
		BFS_000(root);
		System.out.println("BFS_1");
		BFS_1(root);
		System.out.println("BFS_2");
		BFS_2(root);
	}
	
	public static Node  buildTree(char[] preOrder,char[] inOrder
			                     ,int pPreOrder       ,int pInOrder
			                     ,int treeLen    ,Node root){
		
		if(root ==null){
           root = instance.new Node(preOrder[pPreOrder]);//前序遍历的第一个节点作为Root     			
		}
        
		//！ 如果当前的树长度为1，那么已经是最后一个节点了
		if(treeLen==1){
			return root;
		}
		
		int pInOrder_bak =pInOrder;
		while(inOrder[pInOrder]!= preOrder[pPreOrder]){
			 pInOrder++;
			 if(pInOrder-pInOrder_bak>treeLen){
				 break;
			 }
		}
		int leftLength  =pInOrder-pInOrder_bak;
        int rightlength	=treeLen- leftLength -1;	
		if(leftLength>0){
			root.left =buildTree(preOrder,inOrder,pPreOrder+1,pInOrder_bak,leftLength,root.left);
		}
		if(rightlength>0){
			root.right=buildTree(preOrder,inOrder,pPreOrder+leftLength+1,pInOrder_bak+leftLength+1,rightlength,root.right);
		}
		return root;
	}
	//前序遍历
	public static void preOrderTraversal(Node node){
	    if(node!=null){
	        System.out.print(node.getVal()+" ");   	
		    if(node.left!=null){
		    	preOrderTraversal(node.left);
		    }
		    if(node.right != null){
		    	preOrderTraversal(node.right);
		    }
	    }
	}
	//中序遍历
	public static void inOrderTraversal(Node node){
        if(node!=null){
        	if(node.left != null){
        		inOrderTraversal(node.left);
        	}
        	System.out.print(node.getVal()+" ");
        	if(node.right !=null){
        		inOrderTraversal(node.right);
        	}
        }		
	}
	//特定层输出
	public static int traversalAtLevel(Node root,int level){
        //节点为空 或者 层数已经小于0，直接返回
		if(root == null || level <0){
        	return 0;
        }
		
		//Level==0，说明已经减了，减了level次到达想要输出的层，输出。
		//指定层才输出的判断条件
		if(level == 0){
			System.out.print(root.val+" ");
			return 1;
		}
		return traversalAtLevel(root.left , level-1) //去下一层的左孩子
			  +traversalAtLevel(root.right, level-1);//去下一层的右孩子
	}
	//已经深度的层遍历
	public static void TraversalByLevel(Node root ,int deep){
	    for(int level=0;level<deep;level++){
	    	traversalAtLevel(root, level);
	    	if(level!=deep-1)
	    		System.out.println();
	    }
	}
	//未知深度的层遍历
	//前提是traversalAtLevel(root, level)有返回值，以判断是否成功遍历了特定一行（行非空）
	public static void TraversalByLevelUnknowDeep(Node root){
         boolean b=false; 
		for(int level=0; ;level++){
        	 if(traversalAtLevel(root, level) == 0){
        		 b =true;
        		 break;
        	 }      
        	if(!b){
        	 System.out.println();
        	}
         }		
	}

	
	//不使用递归，提升效率的的层遍历
    //使用vector容器来储存n个节点信息，并用一个游标变量last记录前一层的访问结束条
	public static void TraversalByLevel_2(Node root){
		if(root == null){
			return ;
		}
        Vector<Node> vc =new Vector<Node>();
        
        vc.add(root);
        int last =vc.size();
        int cur  =0;
        while(cur<vc.size()){
        	last =vc.size();

        	while(cur < last){
	        	 System.out.print(vc.get(cur).val+" ");
	        	 
	        	 if(vc.get(cur).left  != null){
	                vc.add(vc.get(cur).left);	 
	             }
	        	 if(vc.get(cur).right != null){
	        		 vc.add(vc.get(cur).right);
	        	 }
	        	 cur++;
	        }
        	System.out.println();
        }
	}
    //使用Queue将二叉树按层顺序加入到队列中，再出队，这里没有换行，关键是如何换行输出
	public static void BFS_000(Node root){
		queue1.clear();
		if(root == null){
			return ;
		}
		queue1.add(root);
			while (!queue1.isEmpty()){
				  if(queue1.peek().left !=null){
	            	  queue1.add(queue1.peek().left);
	              }	
	              if(queue1.peek().right != null){
	            	  queue1.add(queue1.peek().right);
	              }
	              System.out.print(queue1.poll().val+" ");
			}
	}
	
	static Queue<Node> queue1 =new LinkedList<Node>();
	static Queue<Node> queue2 =new LinkedList<Node>();
	//两个Queue来实现换行，queue1存放当前输出行，queue2存放下一行
	public static void BFS_1(Node root){
		queue1.clear();
		queue2.clear();
		if(root == null){
			return ;
		}
		queue1.add(root);
			while (!queue1.isEmpty()){
				  if(queue1.peek().left !=null){
	            	  queue2.add(queue1.peek().left);
	              }	
	              if(queue1.peek().right != null){
	            	  queue2.add(queue1.peek().right);
	              }
	              System.out.print(queue1.poll().val+" ");
	              if(queue1.isEmpty()){
	            	  System.out.println();
	            	  while(!queue2.isEmpty()){
	            		  queue1.add(queue2.poll());
	            	  }
	              }
			}
	}
	//类比使用cur,在每行结束的时候加一个标记节点‘@’
	public static void BFS_2(Node root){
		if(root == null){
            return ;		
		}
		queue1.clear();
		queue1.add(root);
		Node changLine =instance.new Node('@');
		queue1.add(changLine);
		while(queue1.peek()!= changLine){
			if( queue1.peek().left!= null){
				queue1.add(queue1.peek().left);
			}
			if( queue1.peek().right !=null){
				queue1.add(queue1.peek().right);
			}
			System.out.print(queue1.poll().val+" ");
			if(queue1.peek() ==changLine){
				queue1.poll();
				System.out.println();
				queue1.add(changLine);
			}
		}
	}
	
	class Node{
		char val;
		Node left;
		Node right;
		public Node(char c){
			val =c;
			left =null;
			right=null;
		}
		public char getVal() {
			return val;
		}
		public void setVal(char val) {
			this.val = val;
		}
	}
}

C++：

分层遍历的另两个实现：http://www.cnblogs.com/miloyip/archive/2010/05/12/binary_tree_traversal.html

http://blog.csdn.net/luyafei_89430/article/details/12967411

http://www.cnblogs.com/youxin/p/3288261.html