二叉树的遍历（前序、中序、后序、层序）递归+迭代

前序、中序和后序遍历分别使用递归和迭代的方式实现了一遍。递归转迭代的主要思路是通过栈来模拟递归调用过程，代码如下：

import java.util.*;

/**
 * @author RuL
 */
public class Traverse {

    /**
     * 先序遍历（根-左-右）-递归方式
     *
     * @param root   根节点
     * @param result 遍历结果
     */
    public void preOrder(TreeNode root, List<Integer> result) {
        if (root != null) {
            result.add(root.value);
            preOrder(root.left, result);
            preOrder(root.right, result);
        }
    }

    /**
     * 先序遍历（根-左-右）-迭代方式
     *
     * @param root 根节点
     * @return 遍历结果
     */
    public List<Integer> preOrder(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        Stack<TreeNode> stk = new Stack<>();

        while (root != null || !stk.isEmpty()) {
            while (root != null) {
                result.add(root.value);
                stk.push(root);
                root = root.left;
            }

            TreeNode node = stk.pop();
            root = node.right;
        }

        return result;
    }

    /**
     * 中序遍历（左-根-右）-递归方式
     *
     * @param root   根节点
     * @param result 遍历结果
     */
    public void inOrder(TreeNode root, List<Integer> result) {
        if (root != null) {
            inOrder(root.left, result);
            result.add(root.value);
            inOrder(root.right, result);
        }
    }

    /**
     * 中序遍历（左-根-右）-迭代方式
     *
     * @param root 根节点
     * @return 遍历结果
     */
    public List<Integer> inOrder(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        Stack<TreeNode> stk = new Stack<>();

        while (root != null || !stk.isEmpty()) {
            while (root != null) {
                stk.push(root);
                root = root.left;
            }

            root = stk.pop();
            result.add(root.value);
            root = root.right;
        }

        return result;
    }

    /**
     * 后序遍历（左-右-根）-递归方式
     *
     * @param root   根节点
     * @param result 遍历结果
     */
    public void postOrder(TreeNode root, List<Integer> result) {
        if (root != null) {
            postOrder(root.left, result);
            postOrder(root.right, result);
            result.add(root.value);
        }
    }

    /**
     * 后序遍历（左-右-根）-迭代方式
     * 根-右-左 然后反转遍历结果
     *
     * @param root 根节点
     * @return 遍历结果
     */
    public List<Integer> postOrder(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        Stack<TreeNode> stk = new Stack<>();

        while (root != null || !stk.isEmpty()) {
            while (root != null) {
                result.add(root.value);
                stk.push(root);
                root = root.right;
            }

            TreeNode node = stk.pop();
            root = node.left;
        }

        Collections.reverse(result);
        return result;
    }

    /**
     * 层序遍历
     *
     * @param root 根节点
     * @return 遍历结果
     */
    public List<Integer> levelOrder(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        Queue<TreeNode> que = new LinkedList<>();

        if (root != null) {
            que.offer(root);
        }

        while (!que.isEmpty()) {
            TreeNode node = que.poll();
            result.add(node.value);
            if (node.left != null) {
                que.offer(node.left);
            }
            if (node.right != null) {
                que.offer(node.right);
            }
        }

        return result;
    }

    /**
     * 层序遍历按层分组
     *
     * @param root 根节点
     * @return 遍历结果
     */
    public List<List<Integer>> levelGroupOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        Queue<TreeNode> que = new LinkedList<>();

        if (root != null) {
            que.offer(root);
        }

        while (!que.isEmpty()) {
            ArrayList<Integer> level = new ArrayList<>();
            int size = que.size();

            //每层节点数刚好为队列当前大小
            for (int i = 0; i < size; i++) {
                TreeNode node = que.poll();
                level.add(node.value);
                if (node.left != null) {
                    que.offer(node.left);
                }
                if (node.right != null) {
                    que.offer(node.right);
                }
            }
            result.add(level);
        }
        return result;
    }


    static class TreeNode {
        int value;
        TreeNode left;
        TreeNode right;

        TreeNode() {
        }

        TreeNode(int value) {
            this.value = value;
        }

        TreeNode(int value, TreeNode left, TreeNode right) {
            this.value = value;
            this.left = left;
            this.right = right;
        }
    }
}