其中二叉树节点类

　　/** 二叉树节点 */

　　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;

　　}

　　填写下面表单即可预约申请免费试听java课程!害怕学不会?助教陪读，随时解惑!担心就业?一地学习，可全国推荐就业!

　　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 stack = new Stack();

　　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 stack = new Stack();

　　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 stack = new Stack();

　　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

　　如果你现在想学习Java，赢取高薪工作机会，非常简单，填写下面信息，学好Java技术高薪工作机会唾手可得。