mysql 实现非递归树_二叉树的递归和非递归实现

importjava.util.Stack;classNode {private charkey;privateNode left, right;public Node(charkey) {this(key, null, null);

}public Node(charkey, Node left, Node right) {this.key =key;this.left =left;this.right =right;

}public chargetKey() {returnkey;

}public void setKey(charkey) {this.key =key;

}publicNode getLeft() {returnleft;

}public voidsetLeft(Node left) {this.left =left;

}publicNode getRight() {returnright;

}public voidsetRight(Node right) {this.right =right;

}

}public classBinaryTree {protectedNode root;publicBinaryTree(Node root) {this.root =root;

}publicNode getRoot() {returnroot;

}/**构造树*/

public staticNode init() {

Node a= new Node('A');

Node b= new Node('B', null, a);

Node c= new Node('C');

Node d= new Node('D', b, c);

Node e= new Node('E');

Node f= new Node('F', e, null);

Node g= new Node('G', null, f);

Node h= new Node('H', d, g);return h;//root

}/**访问节点*/

public static voidvisit(Node p) {

System.out.print(p.getKey()+ " ");

}/**递归实现前序遍历*/

protected static voidpreorder(Node p) {if (p != null) {

visit(p);

preorder(p.getLeft());

preorder(p.getRight());

}

}/**递归实现中序遍历*/

protected static voidinorder(Node p) {if (p != null) {

inorder(p.getLeft());

visit(p);

inorder(p.getRight());

}

}/**递归实现后序遍历*/

protected static voidpostorder(Node p) {if (p != null) {

postorder(p.getLeft());

postorder(p.getRight());

visit(p);

}

}//前序非递归实现

protected static voiditerativePreorder(Node p) {

Stack stack = new Stack();

Node node=p;while (node != null || stack.size() > 0) {while (node != null) {//压入所有的左节点，压入前访问它。左节点压入完后pop访问右节点。像这样算法时思考规律性的东西在哪。不管哪个节点都要压所节点判断右节点。

visit(node);

stack.push(node);

node=node.getLeft();

}if (stack.size() > 0) {//

node =stack.pop();

node=node.getRight();

}

}

}//中序非递归实现

protected static voiditerativeInorder(Node p) {

Stack stack = new Stack();

Node node=p;while(node != null || stack.size() > 0) {while (node != null) {

stack.push(node);

node=node.getLeft();

}if (stack.size() > 0) {

node=stack.pop();

visit(node);

node=node.getRight();

}

}

}//后序非递归实现

protected static voiditerativePostorder(Node p) {

Node 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();

}

}public static voidmain(String[] args) {

BinaryTree tree= newBinaryTree(init());

System.out.print(" 递归前序遍历 \n");

preorder(tree.getRoot());

System.out.println();

System.out.print(" 递归中序遍历 \n");

inorder(tree.getRoot());

System.out.println();

System.out.print(" 递归后序遍历 \n");

postorder(tree.getRoot());

System.out.println();

System.out.print(" 非递归前序遍历 \n");

iterativePreorder(tree.getRoot());

System.out.println();

System.out.print(" 非递归中序遍历 \n");

iterativeInorder(tree.getRoot());

System.out.println();

System.out.print(" 非递归后序遍历 \n");

iterativePostorder(tree.getRoot());

}

}