二叉树遍历：递归 + 非递归 （Java）

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

public class Tree {
    class TreeNode {
        public TreeNode left;
        public TreeNode right;
        public int value;

        public TreeNode(int v) {
            value = v;
            left = null;
            right = null;
        }
    }


    private void preOrder(TreeNode root) {
        if (root == null) return;

        System.out.print(root.value + " ");
        preOrder(root.left);
        preOrder(root.right);
    }

    private void preOrderLoop(TreeNode root) {
        if (root == null) return;

        Stack<TreeNode> help = new Stack<TreeNode>();
        help.add(root);

        TreeNode current;
        while (!help.isEmpty()) {
            current = help.pop();
            System.out.print(current.value + " ");

            if (current.right != null) help.add(current.right);
            if (current.left != null) help.add(current.left);
        }
    }


    private void inOrder(TreeNode root) {
        if (root == null) return;

        inOrder(root.left);
        System.out.print(root.value + " ");
        inOrder(root.right);
    }

    private void inOrderLoop(TreeNode root) {
        if (root == null) return;
        Stack<TreeNode> help = new Stack<TreeNode>();

        TreeNode current = root;
        while (!help.isEmpty() || current != null) {
            while (current != null) {
                help.add(current);
                current = current.left;
            }

            current = help.pop();
            System.out.print(current.value + " ");

            current = current.right;
        }
    }


    private void postOrder(TreeNode root) {
        if (root == null) return;

        postOrder(root.left);
        postOrder(root.right);
        System.out.print(root.value + " ");
    }

    private void postOrderLoop(TreeNode root) {
        if (root == null) return;
        Stack<TreeNode> help = new Stack<TreeNode>();
        Stack<TreeNode> result = new Stack<TreeNode>();

        help.add(root);

        TreeNode current;
        while (!help.isEmpty()) {
            current = help.pop();
            result.add(current);
            if (current.left != null) help.add(current.left);
            if (current.right != null) help.add(current.right);
        }

        while (!result.isEmpty()) {
            System.out.print(result.pop().value + " ");
        }
    }


    private void levelOrderLoop(TreeNode root) {
        if (root == null) return;

        Queue<TreeNode> help = new LinkedList<TreeNode>();
        help.add(root);

        TreeNode current;
        while (!help.isEmpty()) {
            current = help.poll();
            System.out.print(current.value + " ");

            if (current.left != null) help.add(current.left);
            if (current.right != null) help.add(current.right);
        }
    }

    public void test() {
        TreeNode root = new TreeNode(1);
        TreeNode node1 = new TreeNode(2);
        TreeNode node2 = new TreeNode(3);
        TreeNode node3 = new TreeNode(4);
        TreeNode node4 = new TreeNode(5);
        TreeNode node5 = new TreeNode(6);

        root.left = node3;
        node3.left = node2;
        node3.right = node4;
        root.right = node1;
        node1.right = node5;

        System.out.print("preOrder: ");
        preOrder(root);
        System.out.println();
        System.out.print("preOrderLoop: ");
        preOrderLoop(root);
        System.out.println();
        System.out.print("inOrder: ");
        inOrder(root);
        System.out.println();
        System.out.print("inOrderLoop: ");
        inOrderLoop(root);
        System.out.println();
        System.out.print("postOrder: ");
        postOrder(root);
        System.out.println();
        System.out.print("postOrderLoop: ");
        postOrderLoop(root);
        System.out.println();
        System.out.print("levelOrderLoop: ");
        levelOrderLoop(root);
        System.out.println();
    }
}