java非递归遍历树_二叉树的递归与非递归遍历(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;

}

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

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技术高薪工作机会唾手可得。