LeetCode(94,145,144)-二叉树的遍历方式-二叉树

 一、题目

94. 二叉树的中序遍历https://leetcode.cn/problems/binary-tree-inorder-traversal/

144. 二叉树的前序遍历https://leetcode.cn/problems/binary-tree-preorder-traversal/

145. 二叉树的后序遍历https://leetcode.cn/problems/binary-tree-postorder-traversal/

二、题解

方式一：递归

    /**
     * 二叉树前序遍历
     * 方式一：递归之前序遍历
     *
     * @param root
     * @return
     */
    public List<Integer> preorderTraversal(TreeNode root) {
        ArrayList<Integer> res = new ArrayList<>();
        preorder(root, res);
        return res;
    }

    public void preorder(TreeNode curr, List<Integer> list) {
        if (curr == null) {
            return;
        }

        list.add(curr.val);

        preorder(curr.left, list);
        preorder(curr.right, list);
    }


    /**
     * 二叉树遍历方式
     * 方式一：递归之中序
     *
     * @param root
     * @return
     */
    public List<Integer> inorderTraversal(TreeNode root) {
        LinkedList<Integer> res = new LinkedList<>();
        inorder(root, res);

        return res;
    }

    public void inorder(TreeNode curr, List<Integer> list) {
        if (curr == null) {
            return;
        }


        inorder(curr.left, list);
        list.add(curr.val);
        inorder(curr.right, list);
    }


    /**
     * 二叉树得遍历方式
     * 方式一：递归之后续遍历
     *
     * @param root
     * @return
     */
    public List<Integer> postorderTraversal(TreeNode root) {
        LinkedList<Integer> res = new LinkedList<>();
        postorder(root, res);

        return res;
    }

    public void postorder(TreeNode curr, List<Integer> list) {
        if (curr == null) {
            return;
        }

        postorder(curr.left, list);
        postorder(curr.right, list);
        list.add(curr.val);
    }

方式二：迭代

这俩天期末考试，有点忙，所以这俩天可能会偷会懒（其实我主要是想偷懒~放假肯定不啦，相信我~哈哈）

然后今天在更新一下二叉树的遍历的迭代法；

前序遍历中左右，看懂前序遍历后，你会发现后续遍历就是把前序遍历稍微改了一下，有朋友到这可能看不懂了，为什么后续遍历只是在前序遍历的代码上，把左右节点加入栈的顺序换了一下，最后反转了一下结果集，就成为后续遍历了呢？哈哈哈，这里我当时想通的时候，也不得不大喊一声，妙！那么为什么秒呢？我解释一下

前序遍历的顺序是中左右嘛，后续遍历的顺序是左右中嘛；我们把前序遍历的左右顺序换一下，是不是就变成了中右左了？这个时候，我们再把整体结果反转一下，是不是就是左右中了？看到这，你忽然茅塞顿开，哇，左右中？？！！可不就是后续遍历嘛哈哈哈，所以说算法真的是好奇妙，只有每天刷算法的人，才能在看到一个好的思路时，感到惊奇惊奇，发出赞叹，那种感觉真的是妙不可言呢~

只有中序遍历嘛，也没什么好讲的啦，实在看不懂，就debug一下，然后再在纸上画一下，相信你马上就懂了，不是什么难点~

那么今天就先更新前中后序的普通迭代，后面还有前中后序的通用迭代，以及层序遍历呢~拜拜

 /**
     * 二叉树前序遍历
     * 方式二：迭代遍历
     *
     *
     * 中，左，右
     * @param root
     * @return
     */
    public List<Integer> preorderTraversal(TreeNode root) {
        ArrayList<Integer> res = new ArrayList<>();
        if (root == null) {
            return res;
        }

        Stack<TreeNode> stack = new Stack<>();
        TreeNode curr = root;
        stack.push(curr);

        while (!stack.isEmpty()) {
            TreeNode node = stack.pop();
            res.add(node.val);                  //输出中间节点
            if (node.right != null) {           //右节点入栈
                stack.push(node.right);
            }

            if (node.left != null) {        //左节点入栈
                stack.push(node.left);
            }

        }

        return res;

    }




    /**
     * 二叉树遍历方式
     * 方式一：迭代中序遍历
     *
     * @param root
     * @return
     */
    public List<Integer> inorderTraversal(TreeNode root) {
        ArrayList<Integer> res = new ArrayList<>();
        if (root == null) {
            return res;
        }

        Stack<TreeNode> stack = new Stack<>();
        TreeNode curr = root;


        while (!stack.isEmpty() || curr != null) {

            if (curr != null) {
                //如果当前节点不等于空，那么一直向左走
                stack.push(curr);
                curr = curr.left;
            } else {
                //如果当前节点为空
                //输出当前节点
                curr = stack.pop();
                res.add(curr.val);
                //然后将当前节点移动到当前节点的右节点
                curr = curr.right;

            }
         }


        return res;
    }






    /**
     * 二叉树得遍历方式
     * 方式一：迭代后续遍历
     *
     * @param root
     * @return
     */
    public List<Integer> postorderTraversal(TreeNode root) {
        ArrayList<Integer> res = new ArrayList<>();
        if (root == null) {
            return res;
        }

        Stack<TreeNode> stack = new Stack<>();
        TreeNode curr = root;
        stack.push(curr);

        while (!stack.isEmpty()) {
            TreeNode node = stack.pop();
            res.add(node.val);                  //输出中间节点

            if (node.left != null) {        //左节点入栈
                stack.push(node.left);
            }

            if (node.right != null) {           //右节点入栈
                stack.push(node.right);
            }

        }
        Collections.reverse(res);
        return res;
    }

方式三：通用迭代

/**
     *
     * 二叉树得遍历方式：通用迭代遍历
     *
     * @param root
     * @return
     */
    public List<Integer> traversal(TreeNode root) {
        ArrayList<Integer> res = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        if (root == null) {
            return res;
        }

        stack.push(root);

        while (!stack.isEmpty()) {
            TreeNode top = stack.peek();
            //前序遍历，中，左右
            if (top != null) {
                TreeNode temp = stack.pop();
                //放入中间节点
                stack.push(temp);
                stack.push(null);

                //先放入右节点
                if (temp.right != null) {
                    stack.push(temp.right);
                }

                //放入左节点
                if (temp.left != null) {
                    stack.push(temp.left);
                }
            } else {            //等于空得情况下，说明要弹出那个被标记得节点
                stack.pop();        //弹出空
                res.add(stack.pop().val);
            }
        }


        return res;
    }

以上是二叉树前中后得通用迭代方式，只需要不断变换中间节点得位置就行，前序遍历，中左右，那么就先放入右节点，在放入左节点，最后放入中间节点并加入空做标记；中序遍历，左中右，那么就先放入右节点，再放入中间节点并加入标记，最后放入左节点；后续遍历，左右中，先放入中间节点并加入标记，然后放入右节点，最后放入左节点。（标记就是加入空，当我们弹出节点得时候，遇到null，那么就表明下一个节点就是我们要弹出得节点）；如果时间充足得话，希望大家可以用debug得方式将前中后方式分别就运行一遍，我相信马上会了然于胸得；

方式四：层序遍历（从左到右）

    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        LinkedList<TreeNode> list = new LinkedList<>();

        if (root == null) {
            return res;
        }

        list.addLast(root);

        while (!list.isEmpty()) {
            int len = list.size();
            ArrayList<Integer> temp = new ArrayList<>();
            while (len > 0) {
               len--;
                TreeNode first = list.getFirst();
                temp.add(first.val);

                if (first.left != null) {
                    list.addLast(first.left);
                }

                if (first.right != null) {
                    list.addLast(first.right);
                }

                list.removeFirst();
            }
            res.add(temp);
        }

        return res;
    }