二叉树递归和非递归遍历

1、递归遍历

// 先序遍历（递归实现）-------------------------------------------------------------
 	  /*
	  1. Visit the node.
	  1. Call itself to traverse the node’s left subtree.
      3. Call itself to traverse the node’s right subtree.
	  4. base case: there is no node
	  */
   private void preOrder(Node localRoot){
      if(localRoot != null)
         {
         visit(localRoot);       // System.out.print(localRoot.iData + " ");
         preOrder(localRoot.leftChild);
         preOrder(localRoot.rightChild);
         }
      }
// 中序遍历（递归实现）-------------------------------------------------------------
   private void inOrder(Node localRoot){
      if(localRoot != null)
         {
         inOrder(localRoot.leftChild);
         visit(localRoot);       //System.out.print(localRoot.iData + " ");
         inOrder(localRoot.rightChild);
         }
      }
// 后序遍历（递归实现）-------------------------------------------------------------
   private void postOrder(Node localRoot){
      if(localRoot != null)
         {
         postOrder(localRoot.leftChild);
         postOrder(localRoot.rightChild);
         visit(localRoot);       //System.out.print(localRoot.iData + " ");
         }
      }
// -------------------------------------------------------------

2、非递归遍历

/*
总体思想是：因为递归的本质是用栈实现的，所以写出非递归的形式要用到栈。入栈的顺序与访问的顺序相反，如中序遍历访问顺序是left,current,right,所以入栈的顺序相反是right,current,left
steo0:初始化当前节点current
step1:初始化栈
step3:出栈,并访问
Note：中序遍历和后序遍历需要先判断bPushed为true时访问）
step2:入栈
循环结束条件是：栈为空
*/

//算法框架 pushNode是入栈的方式
public void templet(Node root){
  //special case
  if(root==null)
   return;
   
  //inital current node
  Node current=root;
  
  //initial stack
  Stack s=new Stack();
  pushNode(current,s);
  
  //loop: base case is stack is empty
  while( !s.empty() ){
     //pop
	 current=s.pop();
	 
	 //visit or push
  }//end while  
}//end templet()

// 先序遍历-深度优先搜索（递归实现）-------------------------------------------------------------
//current left right  
  //step1:pop current node
	//step2:visit current node
	//step3:push current's right child
	//step4:push current's left child
	//step5: loop step1-step5

privete void pushPreOrderNode(Node current, Stack s){
   if(current==null)
      return ;
   	if(!s.empty()){
	   leftChild=current.leftChild;
	   rightChild=curret.rightChild;
	     
	   if(rightChild!=null)    //push rightChild
	      s.push(rightChild);
	   if(leftChild!=null)     //push leftChild
	      s.push(leftChild):
	   visit(current);        //current always first visit in preOrder  
	}//end if 
}//end pushPreOrderNode()

public void preOrder(Node root){
    //special case
	if(root==null)
	  return ;
	
	//inintial current node
	Node current=root;
	//inintial stack
	Stack s=new Stack();
	pushPreOrderNode(current,s);
	
	//base case:stack is empty
	while( !s.empty() ){
	  //pop
	  current=s.pop();
	  //push
	  pushPreOrderNode(current,s);
	}//end while
}//end preOrder()
	
// 中序遍历（非递归实现）-------------------------------------------------------------
/*
left current right
*/

public void inOrder( Node root){
   //special case
   if(root==null)
       return;
	   
	Node current=root;
	//initial stack
	Stack s=new Stack();
	pushInOrderNode(current,s);
	
	//pop and visit
	while( !s.empty() ){
	     current=s.pop();
		 if(current.bPushed)
		    visit(current);
		 else
		    pushInOrderNode(current,s);
	}//end while
}//end postOrder()

private void pushInOrderNode(Node current,Stack s){
    if(current==null)
	  return;
	if(!s.empty()){
	   leftChild=current.leftChild;
	   rightChild=curret.rightChild;
	   
	   if(rightChild!=null){   //push rightChild
		  s.push(rightChild);
		  rightChild.bPushed=false;
	   }//end if
	   
	   s.push(current);        //push current
	   
	   
	   
	   if(leftChild!=null){    //push leftChild
	   	  s.push(leftChild);
	      rightChild.bPushed=false;
	   }//end if
		  
	   //set flag, ture present current's left and right has both pushed
	   current.bPushed=true;
	   }//end if
	}//end if
}//end pushInOrderNode()
// -------------------------------------------------------------


// 后序遍历（递归实现）-------------------------------------------------------------
/*
left right current
step1:初始化栈
按照step2初始化栈
step2:入栈
入栈顺序：current,right,left
如果current的中左右节点都入栈了，将current标识为true；
将入栈的左右节点标识初始化为false
step3:出栈
出栈节点设置为current,
如果current标识为ture,访问之；如果为false，做step2步骤
step4:重复step2&step3
*/

public void postOrder( Node root){
   //special case
   if(root==null)
       return;
	   
	Node current=root;
	
	//initial stack
	Stack s=new Stack();
	pushPostOrderNode(current,s);
	
	//pop and visit
	while( !s.empty() ){
	     current=s.pop();
		 if(current.bPushed)
		    visit(current);
		 else
		    pushPostOrderNode(current,s);
	}//end while
}//end postOrder()

// 左右子树尚未入栈，则依次将 根节点,右节点,左节点 入栈
private void  pushPostOrderNode(Node current, Stack s){
    if(current==null)
	  return;
	if(!s.empty()){
	   leftChild=current.leftChild;
	   rightChild=curret.rightChild;
	   
	   s.push(current);        //push current
	   if(rightChild!=null){   //push rightChild
		  s.push(rightChild);
		  rightChild.bPushed=false;
	   }//end if
	   if(leftChild!=null){    //push leftChild
	   	  s.push(leftChild);
	      rightChild.bPushed=false;
	   }//end if
		  
	   //set flag, ture present current's left and right has both pushed
	   current.bPushed=true;
	   }//end if
	}//end if
	
}//end pushPostOrderNode()

3 深度优先搜索和层次遍历（广度优先搜索）

// -------------------------------------------------------------
/*
二叉树的广度深度优先搜索即先序遍历，用栈实现（非递归实现）
*/

// -------------------------------------------------------------
/*
层次搜索，即广度优先搜索
step1:specail case
root==null;
step2:initial current
current=root;
step3:initial queue
step4:remove node in queue, and visit the current node
step5:add node in queue
step6:loop step4 and step5
base case: queue is empty
*/

public void gfs(Noode root){
  //step1:specail case
  if(root==null)
    return ;
  
  //step2:initial current
  Node current=root;
  
  //step3:initial queue
  Queue q=new Queue();
  q.add(current);
  
  //step6:loop step4 and step5
  //base case: queue is empty
  while( !q.empty() ){
    //step4:remove node in queue
	current=q.remove();
	visit(current);
	
	Node leftChild=current.leftChild;
	Node rightChild=curret.rightChild;
	
	//step5:add node in queue
	if(leftChild!=null)
	   q.add(leftChild);
	if(rightChild!=null)
	   q.add(rightChild);
  }//end while 
}//gfs()