二叉树遍历方式，包括递归和非递归遍历

package algori.chapter06;

import java.util.Stack;

/**
 * Created by jiang on 2017/8/26.
 */
public class TreeOperator {

    public static void main(String[] args) {

        BinaryTreeNode root = new BinaryTreeNode();
        root.setData(1);

        BinaryTreeNode t2 = new BinaryTreeNode();
        t2.setData(2);

        BinaryTreeNode t3 = new BinaryTreeNode();
        t3.setData(3);

        root.setLeft(t2);
        root.setRight(t3);

        BinaryTreeNode t4 = new BinaryTreeNode();
        t4.setData(4);
        BinaryTreeNode t5 = new BinaryTreeNode();
        t5.setData(5);

        t2.setLeft(t4);
        t2.setRight(t5);

        BinaryTreeNode t6 = new BinaryTreeNode();
        t6.setData(6);
        BinaryTreeNode t7 = new BinaryTreeNode();
        t7.setData(7);

        t3.setLeft(t6);
        t3.setRight(t7);

//        afterOrder(root);

        afterOrderNonRecursive(root);

    }

    /**
     * 递归前序遍历
     * @param root
     */
    private static void preOrder(BinaryTreeNode root) {
        if(root != null) {
            System.out.println(root.getData());
            preOrder(root.getLeft());
            preOrder(root.getRight());
        }
    }

    /**
     * 非递归前序遍历
     * @param root
     */
    private static void preOrderNonRecursive(BinaryTreeNode root) {
        if(root != null) {
            Stack<BinaryTreeNode> stack = new Stack<BinaryTreeNode>();
            while(true) {
                while(root != null) {
                    System.out.println(root.getData());
                    stack.push(root);
                    root = root.getLeft();
                }
                if(stack.isEmpty()) {
                    break;
                }
                root = stack.pop();
                root = root.getRight();
            }
        }
    }

    /**
     * 递归中序遍历
     * @param root
     */
    private static void inOrder(BinaryTreeNode root) {
        if(root != null) {
            inOrder(root.getLeft());
            System.out.println(root.getData());
            inOrder(root.getRight());
        }
    }

    /**
     * 非递归中序遍历
     * @param root
     */
    private static void inOrderNonRecursive(BinaryTreeNode root) {
        if(root != null) {
            Stack<BinaryTreeNode> stack = new Stack<BinaryTreeNode>();
            while(true) {
                while(root != null) {
                    stack.push(root);
                    root = root.getLeft();
                }
                if(stack.isEmpty()) {
                    break;
                }
                root = stack.pop();
                System.out.println(root.getData());
                root = root.getRight();
            }
        }
    }

    /**
     * 递归后续遍历
     * @param root
     */
    private static void afterOrder(BinaryTreeNode root) {
        if(root != null) {
            afterOrder(root.getLeft());
            afterOrder(root.getRight());
            System.out.println(root.getData());
        }
    }

    /**
     * 非递归后序遍历
     * @param root
     */
    private static void afterOrderNonRecursive(BinaryTreeNode root) {
        BinaryTreeNode tmpRoot = root;
        if(root != null) {
            Stack<BinaryTreeNode> stack = new Stack<BinaryTreeNode>();
            boolean isLeft = true;
            while(true) {
                if(root != null) {
                    stack.push(root);
                    root = root.getLeft();
                } else {

                    if(stack.isEmpty()) {
                        break;
                    }
                    if(stack.peek().getRight() == null) {

                        root = stack.pop();
                        System.out.println(root.getData());
                        if(root == stack.peek().getRight()) {
                            System.out.println(stack.pop().getData());
                            if(stack.peek() == tmpRoot) {  //判断是否达到根节点（遍历完右子树之后）
                                if(!isLeft) {
                                    root = stack.pop();
                                    System.out.println(root.getData());
                                    root = null;
                                } else {
                                    isLeft = false;
                                }
                            }
                        }
                    }
                    if(!stack.isEmpty()) {
                        root = stack.peek();
                        root = root.getRight();
                    } else {
                        root = null;
                    }
                }
            }
        }
    }
}