BinaryTree-Traverse

首先定义Node类

public class Node {
	Node lchild;
	Node rchild;
	char data;
	int status;
}

主函数：

public class BinaryTree {
	static int index = 0;
	public static void main(String[] args) {
		char[] str = {'a','b','c','#','#','d','e','#','g','#','#','f','#','#','h','i','#','#','j','#','#'};
		Node tree = null; 
		tree = CreateTree(str, tree);
		
		PreOrder(tree);
		System.out.println();
		UnrecursivePreOrder(tree);
		System.out.println();
		UnrecursivePreOrder2(tree);
		System.out.println();
		
		inOrder(tree);
		System.out.println();
		UnrecursiveInorder(tree);
		System.out.println();

		
		PostOrder(tree);
		System.out.println();
		UnrecursivePostorder(tree);
		System.out.println();
		UnrecursivePostorder2(tree);
		System.out.println();
		UnrecursivePostorder3(tree);
		System.out.println();
		UnrecursivePostorder4(tree);
		System.out.println();
	}
	
	public static Node CreateTree(char[] str, Node tree){
		if(str[index] == '#'){
			tree = null;
			index++;
		}
		else{
			tree = new Node();
			tree.data = str[index]; index++;
			tree.lchild = CreateTree(str, tree.lchild);
			tree.rchild = CreateTree(str, tree.rchild);
		}
		return tree;
	}
	
	public static void PreOrder(Node tree){
		if(tree != null){
			System.out.print(tree.data+" ");
			PreOrder(tree.lchild);
			PreOrder(tree.rchild);
		}
	}

	
	public static void PostOrder(Node tree){
		if(tree != null){
			PostOrder(tree.lchild);
			PostOrder(tree.rchild);
			System.out.print(tree.data+" ");
		}
	}
	
	public static void inOrder(Node tree){
		if(tree != null){
			inOrder(tree.lchild);
			System.out.print(tree.data+" ");
			inOrder(tree.rchild);
		}
	}
	
	public static void UnrecursivePreOrder(Node tree){
		Stack<Node> stack = new Stack<Node>();  
        if (tree != null) {  
            stack.push(tree);  
            while (!stack.empty()) {  
                tree = stack.pop();  
                System.out.print(tree.data+" ");  
                if (tree.rchild != null)  
                    stack.push(tree.rchild);  
                if (tree.lchild != null)  
                    stack.push(tree.lchild);  
            }  
        }  
	}

	public static void UnrecursivePreOrder2(Node tree) {  
        Stack<Node> stack = new Stack<Node>();  
        Node node = tree;  
        while (node != null || stack.size() > 0) {  
            while (node != null) {
                System.out.print(node.data+" ");  
                stack.push(node);  
                node = node.lchild;  
            }  
            if (stack.size() > 0) {
                node = stack.pop();  
                node = node.rchild;  
            }  
        }  
    }  
	
	public static void UnrecursiveInorder(Node tree) {  
        Stack<Node> stack = new Stack<Node>();  
        while (tree != null) {  
            while (tree != null) {  
                if (tree.rchild != null)  
                    stack.push(tree.rchild);
                stack.push(tree);  
                tree = tree.lchild;  
            }  
            tree = stack.pop();  
            while (!stack.empty() && tree.rchild == null) {  
                System.out.print(tree.data+" ");  
                tree = stack.pop();  
            }  
            System.out.print(tree.data+" ");  
            if (!stack.empty())  
                tree = stack.pop();  
            else  
                tree = null;  
        }  
    }  
    
    public static void UnrecursivePostorder(Node tree) {  
        Node q = tree;  
        Stack<Node> stack = new Stack<Node>();  
        while (tree != null) {  
            for (; tree.lchild != null; tree = tree.lchild)  
                stack.push(tree);  
            while (tree != null && (tree.rchild == null || tree.rchild == q)) {  
                System.out.print(tree.data+" ");  
                q = tree; 
                if (stack.empty())  
                    return;  
                tree = stack.pop();  
            }   
            stack.push(tree);  
            tree = tree.rchild;  
        }  
    }  
  
    public static void UnrecursivePostorder2(Node tree) {  
        Stack<Node> lstack = new Stack<Node>();  
        Stack<Node> rstack = new Stack<Node>();  
        Node node = tree, right;  
        do {  
            while (node != null) {  
                right = node.rchild;  
                lstack.push(node);  
                rstack.push(right);  
                node = node.lchild;  
            }  
            node = lstack.pop();  
            right = rstack.pop();  
            if (right == null) {  
                System.out.print(node.data+" ");  
            } else {  
                lstack.push(node);  
                rstack.push(null);  
            }  
            node = right;  
        } while (lstack.size() > 0 || rstack.size() > 0);  
    }  
  
    public static void UnrecursivePostorder3(Node tree) {  
        Stack<Node> stack = new Stack<Node>();  
        Node node = tree, prev = tree;  
        while (node != null || stack.size() > 0) {  
            while (node != null) {  
                stack.push(node);  
                node = node.lchild;  
            }  
            if (stack.size() > 0) {  
                Node temp = stack.peek().rchild;  
                if (temp == null || temp == prev) {  
                    node = stack.pop();  
                    System.out.print(node.data+" ");  
                    prev = node;  
                    node = null;  
                } else {  
                    node = temp;  
                }  
            }  
        }  
    }  
  
    public static void UnrecursivePostorder4(Node tree) {  
        Stack<Node> stack = new Stack<Node>();  
        Stack<Node> temp = new Stack<Node>();  
        Node node = tree;  
        while (node != null || stack.size() > 0) {  
            while (node != null) {  
                temp.push(node);  
                stack.push(node);  
                node = node.rchild;  
            }  
            if (stack.size() > 0) {  
                node = stack.pop();  
                node = node.lchild;  
            }  
        }  
        while (temp.size() > 0) {  
            node = temp.pop();  
            System.out.print(node.data+" ");  
        }  
    } 
}