二叉树非递归算法

/** 二叉树节点 */ 
public class BTNode { 
　　private char key; 
　　private BTNode left, right; 
　　public BTNode(char key) { 
　　　　this(key, null, null); 
　　} 
　　public BTNode(char key, BTNode left, BTNode right) { 
　　　　this.key = key; 
　　　　this.left = left; 
　　　　this.right = right; 
　　} 
　　public char getKey() { 
　　　　return key; 
　　} 
　　public void setKey(char key) { 
　　　　this.key = key; 
　　} 
　　public BTNode getLeft() { 
　　　　return left; 
　　} 
　　public void setLeft(BTNode left) { 
　　　　this.left = left; 
　　} 
　　public BTNode getRight() { 
　　　　return right; 
　　} 
　　public void setRight(BTNode right) { 
　　　　this.right = right; 
　　} 
} 



/** 二叉树遍历 */ 
public class BinTree { 
　　protected BTNode root; 
　　public BinTree(BTNode root) { 
　　　　this.root = root; 
　　} 
　　public BTNode getRoot() { 
　　　　return root; 
　　} 
　　/** 构造树 */ 
　　public static BTNode init() { 
　　　　BTNode a = new BTNode('A'); 
　　　　BTNode b = new BTNode('B', null, a); 
　　　　BTNode c = new BTNode('C'); 
　　　　BTNode d = new BTNode('D', b, c); 
　　　　BTNode e = new BTNode('E'); 
　　　　BTNode f = new BTNode('F', e, null); 
　　　　BTNode g = new BTNode('G', null, f); 
　　　　BTNode h = new BTNode('H', d, g); 
　　　　return h;// root 
　　} 
　　/** 访问节点 */ 
　　public static void visit(BTNode p) { 
　　　　System.out.print(p.getKey() + " "); 
　　} 
　　/** 递归实现前序遍历 */ 
　　protected static void preorder(BTNode p) { 
　　　　if (p != null) { 
　　　　　　visit(p); 
　　　　　　preorder(p.getLeft()); 
　　　　　　preorder(p.getRight()); 
　　　　} 
　　} 
　　/** 递归实现中序遍历 */ 
　　protected static void inorder(BTNode p) { 
　　　　if (p != null) { 
　　　　　　inorder(p.getLeft()); 
　　　　　　visit(p); 
　　　　　　inorder(p.getRight()); 
　　　　} 
　　} 
　　/** 递归实现后序遍历 */ 
　　protected static void postorder(BTNode p) { 
　　　　if (p != null) { 
　　　　　　postorder(p.getLeft()); 
　　　　　　postorder(p.getRight()); 
　　　　　　visit(p); 
　　　　} 
　　} 
　　/** 非递归实现前序遍历 */ 
　　protected static void iterativePreorder(BTNode p) { 
　　　　Stack<BTNode> stack = new Stack<BTNode>(); 
　　　　if (p != null) { 
　　　　　　stack.push(p); 
　　　　　　while (!stack.empty()) { 
　　　　　　　　p = stack.pop(); 
　　　　　　　　visit(p); 
　　　　　　　　if (p.getRight() != null) 
　　　　　　　　　　stack.push(p.getRight()); 
　　　　　　　　if (p.getLeft() != null) 
　　　　　　　　　　stack.push(p.getLeft()); 
　　　　　　} 
　　　　} 
　　} 
　　/** 非递归实现后序遍历 */ 
　　protected static void iterativePostorder(BTNode p) { 
　　　　BTNode q = p; 
　　　　Stack<BTNode> stack = new Stack<BTNode>(); 
　　　　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.empty()) 
　　　　　　　　　　return; 
　　　　　　　　p = stack.pop(); 
　　　　　　} 
　　　　　　// 处理右子 
　　　　　　stack.push(p); 
　　　　　　p = p.getRight(); 
　　　　} 
　　} 
　　/** 非递归实现中序遍历 */ 
　　protected static void iterativeInorder(BTNode p) { 
　　　　Stack<BTNode> stack = new Stack<BTNode>(); 
　　　　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.empty() && p.getRight() == null) { 
　　　　　　　　visit(p); 
　　　　　　　　p = stack.pop(); 
　　　　　　} 
　　　　　　visit(p); 
　　　　　　if (!stack.empty()) 
　　　　　　　　p = stack.pop(); 
　　　　　　else 
　　　　　　　　p = null; 
　　　　} 
　　} 
　　public static void main(String[] args) { 
　　　　BinTree tree = new BinTree(init()); 
　　　　System.out.print(" Pre-Order:"); 
　　　　preorder(tree.getRoot()); 
　　　　System.out.println(); 
　　　　System.out.print("　In-Order:"); 
　　　　inorder(tree.getRoot()); 
　　　　System.out.println(); 
　　　　System.out.print("Post-Order:"); 
　　　　postorder(tree.getRoot()); 
　　　　System.out.println(); 
　　　　System.out.print(" Pre-Order:"); 
　　　　iterativePreorder(tree.getRoot()); 
　　　　System.out.println(); 
　　　　System.out.print("　In-Order:"); 
　　　　iterativeInorder(tree.getRoot()); 
　　　　System.out.println(); 
　　　　System.out.print("Post-Order:"); 
　　　　iterativePostorder(tree.getRoot()); 
　　　　System.out.println(); 
　　} 
}