Java实现二叉树的递归与非递归遍历

其中二叉树节点类

/** 二叉树节点 */
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();
　　 }
}

输出结果

Pre-Order:H D B A C G F E
　 In-Order:B A D C H G E F
Post-Order:A B C D E F G H
Pre-Order:H D B A C G F E
　 In-Order:B A D C H G E F
Post-Order:A B C D E F G H　

本文出自 “子 孑” 博客，请务必保留此出处 http://zhangjunhd.blog.51cto.com/113473/82616