二叉树的三种遍历算法 源码

VisitBiTree.java

package biTree;

import java.util.Stack;

//二叉树的遍历类
public class VisitBiTree {

    /* 访问时机：遇到不为空的则访问它，右孩子入栈，转而去左孩子 */
    // 非递归先序遍历
    public void preOrder(BNode node) {
        if (node != null) {
            Stack<BNode> stack = new Stack<BNode>();
            for (BNode iter = node; !stack.empty() || iter != null;) {
                if (iter == null) {
                    iter = stack.pop();
                }
                iter.visit();
                if (iter.getRight() != null) {
                    stack.push(iter.getRight());
                }
                iter = iter.getLeft();
            }
        }
    }

    // 递归先序遍历
    public void preOrderRecur(BNode node) {
        if (node != null) {
            node.visit();
            preOrderRecur(node.getLeft());
            preOrderRecur(node.getRight());
        }
    }

    /* 访问时机：每当退栈时，即没有左子树的时候 */
    // 非递归中序遍历
    public void inOrder(BNode node) {
        if (node != null) {
            Stack<BNode> stack = new Stack<BNode>();
            for (BNode iter = node; !stack.empty() || iter != null;) {
                while (iter != null) {// 找最左子树
                    stack.push(iter);
                    iter = iter.getLeft();
                }
                if (!stack.empty()) {// 退栈，访问右子树
                    iter = stack.pop();
                    iter.visit();
                    iter = iter.getRight();
                }
            }
        }
    }

    // 递归中序遍历
    public void inOrderRecur(BNode node) {
        if (node != null) {
            inOrderRecur(node.getLeft());
            node.visit();
            inOrderRecur(node.getRight());
        }
    }

    /* 访问时机：当前被访问节点是栈顶的右孩子，则退栈访问栈顶 */
    // 非递归后序遍历
    public void postOrder(BNode node) {
        if (node != null) {
            Stack<BNode> stack = new Stack<BNode>();
            for (BNode iter = node; !stack.empty() || iter != null;) {
                while (iter != null) {
                    stack.push(iter);
                    iter = iter.getLeft();
                }
                while (!stack.empty() && iter == stack.peek().getRight()) {
                    iter = stack.pop();
                    iter.visit();
                }
                if (stack.empty()) {
                    return;
                } else {
                    iter = stack.peek().getRight();
                }
            }
        }

    }

    // 递归后序遍历
    public void postOrderRecur(BNode node) {
        if (node != null) {
            postOrderRecur(node.getLeft());
            postOrderRecur(node.getRight());
            node.visit();
        }
    }

    // 测试代码
    public static void main(String[] args) {
        BNode iter = new CharBNode('A');
        BNode root = iter;
        iter.setLeft(new CharBNode('B'));
        iter.setRight(new CharBNode('C'));
        iter = iter.getLeft();
        iter.setLeft(new CharBNode('D'));
        iter.setRight(new CharBNode('E'));
        new VisitBiTree().preOrder(root);
    }

}

CharBNode.java

package biTree;


public class CharBNode extends BNode {


	private char data;


	// 构造方法
	public CharBNode(BNode l, BNode r, char ch) {
		super(l, r);
		this.data = ch;
	}


	// 构造方法
	public CharBNode(char ch) {
		this.data = ch;
	}


	// 实现访问方法
	@Override
	public void visit() {
		System.out.println(this.data);
	}
}

BNode.java

package biTree;

abstract class BNode {

	private BNode left;// 左孩子
	private BNode right;// 右孩子

	// 构造方法
	protected BNode(BNode l, BNode r) {
		this.left = l;
		this.right = r;
	}

	// 默认构造方法
	protected BNode() {
	}

	// 设置左孩子节点
	public void setLeft(BNode l) {
		this.left = l;
	}

	// 获取左孩子节点
	public BNode getLeft() {
		return this.left;
	}

	// 设置右孩子节点
	public void setRight(BNode r) {
		this.right = r;
	}

	// 获取左孩子节点
	public BNode getRight() {
		return this.right;
	}

	// 访问接口方法
	abstract public void visit();
}