二叉树的遍历——递归+非递归

import java.util.*;
public class BinaryTree{
     // 创建结点内部类
     public static class Node{
	  public int value;
	  public Node left;
	  public Node right;
	  public Node(int data) {
	       this.value = data;
	  }
     }
     // 递归形式的先序遍历
     public static void preOrderRecur(Node head) {
	  if(head==null) {
	       return;
	  }
	  System.out.println(head.value+" ");
	  preOrderRecur(head.left);
	  preOrderRecur(head.right);
     }
     // 递归形式的中序遍历
     public static void inOrderRecur(Node head) {
	  if(head==null) {
	       return;
	  }
	  inOrderRecur(head.left);
	  System.out.println(head.value+" ");
	  inOrderRecur(head.right);
     }
     // 递归形式的后序遍历
     public static void posOrderRecur(Node head) {
	  if(head==null) {
	       return;
	  }
	  posOrderRecur(head.left);
	  posOrderRecur(head.right);
	  System.out.println(head.value+" ");
     }
     // 非递归形式的先序遍历
     public static void preOrderUnRecur(Node head) {
	  System.out.println("pre-order");
	  if(head != null) {
	       Stack<Node> stack = new Stack<Node>();
	       stack.add(head);
	       while(!stack.isEmpty()) {
	           head = stack.pop();
	           System.out.println(head.value+"  ");
	           if(head.right != null) {
	                stack.push(head.right);
	           }
	           if(head.left != null) {
	                stack.push(head.left);
	           }
	        }
	  }
	  System.out.println();
     }
     // 非递归形式的中序遍历
     public static void inOrderUnRecur(Node head) {
	  System.out.println("in-order");
	  if(head!=null) {
	   	Stack<Node> stack = new Stack<Node>();
	        while(!stack.isEmpty() || head != null) {
		    if(head != null) {
		     	stack.push(head);
		     	head=head.left;
		    }else {
		     	head = stack.pop();
		     	System.out.println(head.value+"  ");
		     	head = head.right;
		    }
	        }
	  }
	  System.out.println();
     }
     // 非递归形式的后序遍历--双栈法
     public static void posOrderUnRecur(Node head){
	  System.out.println("pos-order");
	  if(head != null) {
	   	Stack<Node> s1 = new Stack<Node>();
	   	Stack<Node> s2 = new Stack<Node>();
	   	s1.push(head);
	  	while(!s1.isEmpty()) {
		    head = s1.pop();
		    s2.push(head); //  存入s2顺序中右左，所以取出顺序 左右中
		    if(head.left != null) {
		        s1.push(head.left);
	   	    }
	   	    if(head.right != null) {
	    		s1.push(head.right);
	   	     }
	         }
	   	 while(!s2.isEmpty()) {
	   	     System.out.println(s2.pop().value+" ");
	   	 }
	   }
	   System.out.println();
     }
     // 非递归形式的后序遍历--单栈法
     public static void posOrderUnRecur2(Node head){
	  System.out.println("pos-oreder");
	  if(head != null) {
	   	Stack<Node> stack = new Stack<Node>();
	   	stack.push(head);
	   	Node c = null;
	   	while(!stack.isEmpty()) {
	    	    c = stack.peek();
	    	    if(c.left != null && head != c.left && head != c.right) {
	     		stack.push(c.left);
	    	    }else if(c.right != null && head != c.right) {
	    		stack.push(c.right);
	    	    }else {
	     		System.out.println(stack.pop().value+" ");
	     	        head = c;
	    	    }
	        }
  	   }
 	   System.out.println();
     }
}