使用堆栈实现二叉树的非递归遍历

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;
import java.util.concurrent.BlockingDeque;

public class Tree {
    int data;
    Tree left;
    Tree right;

    Tree(int i) {
        data = i;
    }

    /**
     * 生成一个简单的完美二叉树
     */
    static void createTree(Tree t, int i) {
        if (i > 0) {
            t.setLeft(new Tree(2 * t.getData()));
            t.setRight(new Tree(2 * t.getData() + 1));
            createTree(t.getLeft(), i - 1);
            createTree(t.getRight(), i - 1);
        }
    }

    /**
     * 先序遍历
     *
     * @return
     */
    String preOrder() {
        String result = "";
        Stack s = new Stack();
        Tree t = this;
        while (t != null || !s.empty()) {
            while (t != null) {
                s.push(t);
                result += t.getData() + " ";
                t = t.getLeft();
            }
            if (!s.empty()) {
                t = (Tree) s.pop();
                t = t.getRight();
            }
        }
        return result;
    }

    /**
     * 中序遍历
     *
     * @return
     */
    String inOrder() {
        String result = "";
        Stack s = new Stack();
        Tree t = this;
        while (t != null || !s.empty()) {
            while (t != null) {
                s.push(t);
                t = t.getLeft();
            }
            if (!s.empty()) {
                while (t != null) {
                    s.push(t);
                    t = t.getLeft();
                }
                if (!s.empty()) {
                    t = (Tree) s.pop();
                    result += t.getData() + " ";
                    t = t.getRight();
                }
            }
        }
        return result;
    }

    /**
     * 后序遍历
     * 需要入栈两次，才能够对节点进行访问
     * 需要一个入栈次数标志
     *
     * @return
     */
    String postOrder() {
        String result = "";
        Stack s = new Stack();
        Tree t = this;
        while (t != null || !s.empty()) {
            while (t != null) {
                s.push(t);
                s.push(1);
                t = t.getLeft();
            }
            if (!s.empty()) {
                int i = (int) s.pop();
                t = (Tree) s.pop();
                if (i == 2) {
                    result += t.getData() + " ";
                    t = null;
                } else {
                    s.push(t);
                    s.push(2);
                    t = t.getRight();
                }

            }
        }
        return result;
    }

    /**
     * 层次遍历
     * @return
     */
    String levelOrder() {
        String result = "";
        Queue q = new LinkedList();
        Tree t = this;
        q.add(t);
        while (!q.isEmpty()) {
            t = (Tree) q.poll();
            result += t.getData() + " ";
            if (t.getLeft() != null) q.add(t.getLeft());
            if (t.getRight() != null) q.add(t.getRight());
        }
        return result;
    }


    public int getData() {
        return data;
    }

    public void setData(int data) {
        this.data = data;
    }

    public Tree getLeft() {
        return left;
    }

    public void setLeft(Tree left) {
        this.left = left;
    }

    public Tree getRight() {
        return right;
    }

    public void setRight(Tree right) {
        this.right = right;
    }
}

public class Test {
    public static void main(String[] args) {
        Tree t = new Tree(1);
        Tree.createTree(t, 2);
        System.out.println(t.preOrder());
        System.out.println(t.inOrder());
        System.out.println(t.postOrder());
        System.out.println(t.levelOrder());
    }
}