Java实现二叉树的遍历（多种方式实现前中后序的遍历）

二叉树的Node节点：

public class Node {

	private char key ;
	private Node left ;
	private Node right ;
	
	public Node() {
	}
	
	public Node(char key){
		this(key,null,null);
	}
	
	public Node(char key,Node left,Node right){
		this.key = key ;
		this.left = left ;
		this.right = right;
	}

	public char getKey() {
		return key;
	}

	public void setKey(char key) {
		this.key = key;
	}

	public Node getLeft() {
		return left;
	}

	public void setLeft(Node left) {
		this.left = left;
	}

	public Node getRight() {
		return right;
	}

	public void setRight(Node right) {
		this.right = right;
	}
	
}

二叉树的遍历操作：

import java.util.Stack;

public class BinaryTree {

	private Node root ;
	
	public BinaryTree(Node root) {
		this.root = root;
	}
	
	public Node getRoot(){
		return root ;
	}
	
	/*构造树*/
	public static Node init(){
		Node a = new Node('A');    
        Node b = new Node('B', null, a);    
        Node c = new Node('C');    
        Node d = new Node('D', b, c);    
        Node e = new Node('E');    
        Node f = new Node('F', e, null);    
        Node g = new Node('G', null, f);    
        Node h = new Node('H', d, g);    
        return h; // root
	} 
	
	/*访问节点*/
	public static void visit(Node p){
		System.out.print(p.getKey()+" ");
	} 
	/****************递归遍历二叉树**************************/
	/*前序递归遍历*/
	public static void preOrder(Node root){
		if(root!=null){
			visit(root);
			preOrder(root.getLeft());
			preOrder(root.getRight());
		}
	}
	
	/*中序递归遍历*/
	public static void InOrder(Node root){
		if(root!=null){
			InOrder(root.getLeft());
			visit(root);
			InOrder(root.getRight());
		}
	}
	/*后序递归遍历*/
	public static void PostOrder(Node root){
		if(root!=null){
			PostOrder(root.getLeft());
			PostOrder(root.getRight());
			visit(root);
		}
	}
	
	/*************非递归遍历*******************/
	
	/*前序非递归遍历*/
	public static void iterativePreorder(Node p){
		Stack<Node> stack = new Stack<Node>();
		if(p!=null){
			stack.push(p);
			while(!stack.isEmpty()){
				p = stack.pop();
				visit(p);
				if(p.getRight()!=null){
					stack.push(p.getRight());
				}
				if(p.getLeft()!=null){
					stack.push(p.getLeft());
				}
			}
		}
	}
	
	public static void iterativePreorder2(Node p){
		Stack<Node> stack = new Stack<Node>();
		while(p!=null || !stack.empty()){
			if(p!=null){//while(p!=null)
				visit(p);
				stack.push(p);
				p=p.getLeft();
			}else{
				p=stack.pop();
				p=p.getRight();
			}
		}
	}
	
	public static void iterativePreorder3(Node p){
		Stack<Node> stack = new Stack<Node>();
		while(p!=null || stack.size()>0){
			while(p!=null){//if(p!=null)
				visit(p);
				stack.push(p);
				p=p.getLeft();
			}
			if(stack.size()>0){
				p=stack.pop();
				p=p.getRight();
			}
		}
	}
	
	/*中序非递归遍历*/
	
	public static void iterativeInorder(Node p){
		Stack<Node> stack = new Stack<Node>();
		while(p!=null){
			
			while(p!=null){
				if(p.getRight()!=null)
					stack.push(p.getRight());
				stack.push(p);
				p=p.getLeft();
			}
			p=stack.pop();
			
			while(!stack.isEmpty() && p.getRight()==null){
				visit(p);
				p=stack.pop();
			}
			visit(p);
			if(!stack.isEmpty())
				p=stack.pop();
			else
				p=null;
		}
		
	}
	
	public static void iterativeInorder2(Node p){
		Stack<Node> stack = new Stack<Node>();
		while(p!=null||!stack.isEmpty()){
			if(p!=null){//while(p!=null)
				stack.push(p);
				p=p.getLeft();
			}else{
				p=stack.pop();
				visit(p);
				p=p.getRight();
			}
		}
	}
	
	/*后序非递归遍历*/
	public static void iterativePostorder(Node p){
		Node q = p ;//记录被访问过的节点
		Stack<Node> stack = new Stack<Node>();
		while(p!=null){
			//左子树入栈 
			for(;p.getLeft()!=null;p=p.getLeft()){
				stack.push(p);
			}
			//当左子树全部入栈结束，判断当前节点是否有右子树或者右子树没有被访问时输出当前节点
			while(p!=null &&(p.getRight()==null || p.getRight()==q)){
				visit(p);
				q=p;//记录被访问的节点
				if(stack.isEmpty())
					return ;
				p=stack.pop();
			}
			//右子树入栈
			stack.push(p);
			p=p.getRight();
		}
	}
	//双栈实现树的后序非递归遍历
	public static void iterativePostorder2(Node p){
		Stack<Node> stack1 = new Stack<Node>();
		Stack<Node> stack2 = new Stack<Node>();
		
		stack1.push(p);
		
		while(!stack1.isEmpty()){
			p = stack1.pop();
			stack2.push(p);
			
			if(p.getLeft()!=null)
				stack1.push(p.getLeft());
			
			if(p.getRight()!=null)
				stack1.push(p.getRight());
			
		}
		
		while(!stack2.isEmpty()){
			System.out.print(stack2.pop().getKey()+" ");
		}
	}
	
	public static void main(String[] args) {
		Node root = init();
		System.out.println("*****前序递归遍历*******");
		preOrder(root);
		System.out.println();
		iterativePreorder(root);
		System.out.println();
		iterativePreorder2(root);
		iterativePreorder3(root);
		System.out.println();
		System.out.println("*****中序递归遍历******");
		InOrder(root);
		System.out.println();
		iterativeInorder(root);
		System.out.println();
		iterativeInorder2(root);
		System.out.println();
		System.out.println("*****后序递归遍历*******");
		PostOrder(root);
		System.out.println();
		iterativePostorder(root);
		System.out.println();
		iterativePostorder2(root);
	}
}