迭代——二叉树的前、中、后序遍历，顺序遍历

最新推荐文章于 2022-07-12 15:20:25 发布

原创最新推荐文章于 2022-07-12 15:20:25 发布 · 348 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#二叉树

二叉树专栏收录该内容

3 篇文章

订阅专栏

本文详细介绍了二叉树的前序、中序、后序及层次遍历的迭代算法实现，通过具体实例展示了每种遍历方式的节点访问顺序，并提供了完整的Java代码示例。

迭代------二叉树的前、中、后序遍历，顺序遍历

题目：
如下二叉树：

前序遍历：1 2 4 7 8 5 3 6
中序遍历：7 4 8 2 5 1 3 6
后序遍历：7 8 4 5 2 6 3 1
顺序遍历：1 2 3 4 5 6 7 8
迭代算法
java代码：

 /**
     * 前序遍历：根-左-右
     * 二叉树的前序遍历
     * * * ** 1
     * ****  / \
     * *****2  3
     * **** /\  \
     * ****4 5  6
     * *** /\
     * ***7 8
     * 前序遍历：1  2  4  7  8  5  3  6
     *
     * @param root
     * @return
     */
    public static List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        if (root == null) return null;
        stack.push(root);
        while (stack.size() != 0) {
            TreeNode treeNode = stack.pop();
            res.add(treeNode.value);
            if (treeNode.right != null) stack.push(treeNode.right);
            if (treeNode.left != null) stack.push(treeNode.left);
        }
        return res;
    }

 /**
     * 中序遍历:左-根-右
     * 中序遍历
     * * * * ** 1
     * * ****  / \
     * * *****2  3
     * * **** /\  \
     * * ****4 5  6
     * * *** /\
     * * ***7 8
     * * * 中序遍历：7 4 8 2 5 1 3 6
     *
     * @param root
     * @return
     */
    public static List<Integer> inorderTraversal(TreeNode root) {

        List<Integer> res = new ArrayList<>();
        Stack<TreeNode> stack = new Stack();

        while (stack.size() > 0 || root != null) {
            if (root != null) {
                stack.push(root);
                root = root.left;
            } else {
                TreeNode pop = stack.pop();
                res.add(pop.value);
                root = pop.right;
            }
        }
        return res;
    }

/**
     * 后序遍历:左-右-根
     * * * ** 1
     * ****  / \
     * *****2  3
     * **** /\  \
     * ****4 5  6
     * *** /\
     * ***7 8
     * 后序遍历：  7  8  4  5  2  6  3  1
     *
     * @param root
     * @return
     */
    public static List<Integer> PostOrderTraversal(TreeNode root) {

        List<Integer> res = new ArrayList<>();
        if (root == null) return null;
        Stack<TreeNode> stack1 = new Stack<>();
        //构造一个中间栈，存储逆后序遍历的结果
        Stack<TreeNode> stack2 = new Stack<>();
        while (stack1.size() != 0 || root != null) {
            if (root != null) {
                stack1.push(root);
                //保存节点，相当于前序遍历,根-右-左
                stack2.push(root);
                root = root.right;
            } else {
                root = stack1.pop();
                root = root.left;
            }
        }
        while (stack2.size() != 0) {
            TreeNode node = stack2.pop();
            res.add(node.value);
        }
        return res;
    }

 /**
     * 顺序遍历
     * 层次遍历
     * * * ** 1
     * ****  / \
     * *****2  3
     * **** /\  \
     * ****4 5  6
     * *** /\
     * ***7 8
     * 顺序遍历：1  2  3  4  5  6  7  8
     *
     * @param root
     * @return
     */
    public static List<Integer> readLevel(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();

        if (root == null) return null;
        queue.add(root);
        while (queue.size() != 0) {
            TreeNode treeNode = queue.remove();
            res.add(treeNode.value);
            if (treeNode.left != null) queue.add(treeNode.left);
            if (treeNode.right != null) queue.add(treeNode.right);
        }
        return res;
    }