二叉树中序遍历的三种方法（递归，用栈非递归，不用栈非递归）

/*************************************************************************
 *  Compilation:  javac BS.java
 *  Execution:    java BS
 *    Author:          xjzhou
 *  Date:          2013.07.26
 *
 *************************************************************************/
import java.util.Stack;
class Node {
    private int key;
    private Node left, right;
    public Node(int key) {
        this.key = key;
        left = null;
        right = null;
    }
    public Node(int key, Node left, Node right) {
        this.key = key;
        this.left = left;
        this.right = right;
    }
    public int getKey() {return key;}
    public Node getLeft() {return left;}
    public Node getRight() {return right;}
    public void setKey(int key) {this.key = key;}
    public void setLeft(Node left) {this.left = left;}
    public void setRight(Node right) {this.right = right;}
}

public class BT {
    private final Node root;
    public BT() {root = null;}
    public BT(Node root) {this.root = root;}
    private void visit(Node x) {System.out.print(x.getKey() + " ");}
    public void recursiveInOrder() {recursiveInOrder(root);}
    private void recursiveInOrder(Node x) {
        if (x == null) return;
        recursiveInOrder(x.getLeft());
        visit(x);
        recursiveInOrder(x.getRight());
    }
    public void stackInOrder() {
        if (root == null) return;
        Stack stack = new Stack<Node>();
        Node curr;
        stack.push(root);
        while (!stack.empty()) {
            curr = (Node)stack.pop();
            while (curr != null) {
                if (curr.getRight() != null) stack.push(curr.getRight());
                stack.push(curr);
                curr = curr.getLeft();
            }
            curr = (Node)stack.pop();
            while (!stack.empty() && curr.getRight() == null) {
                visit(curr);
                curr = (Node)stack.pop();
            }
            visit(curr);    
        }
    }
    public void inOrder() {//inOrder traverse without stack and without recursion
        Node curr = root;
        while (curr != null) {
            if (curr.getLeft() == null) {
                visit(curr);
                curr = curr.getRight();
            }
            else {
                Node pre = curr.getLeft();
                while (pre.getRight() != null && pre.getRight() != curr) pre = pre.getRight();
                if (pre.getRight() == null) {
                    pre.setRight(curr);
                    curr = curr.getLeft();
                }
                else {
                    visit(curr);
                    pre.setRight(null);
                    curr = curr.getRight();
                }
            }
        }

    }
    private static Node initial() {
        Node a = new Node(1);
        Node b = new Node(2, null, a);
        Node c = new Node(3);
        Node d = new Node(4, b, c);
        Node e = new Node(5);
        Node f = new Node(6, e, null);
        Node g = new Node(7, null, f);
        Node h = new Node(8, d, g);
        return h;
    }
    public static void main(String[] args) {
        BT bt = new BT(initial());
        bt.recursiveInOrder(); //Output: 2 1 4 3 8 7 6
        System.out.println();
        bt.stackInOrder();//Output: 2 1 4 3 8 7 6
        System.out.println();
        bt.inOrder();//Output: 2 1 4 3 8 7 6
    }
}