算法通过村第七关-树(递归/二叉树遍历)黄金笔记|迭代遍历

文章目录

  • 前言
  • 1. 迭代法实现前序遍历
  • 2. 迭代法实现中序遍历
  • 3. 迭代法实现后序遍历
  • 总结


前言


提示:在一个信息爆炸却多半无用的世界,清晰的见解就成了一种力量。 --尤瓦尔·赫拉利《今日简史》

你是不是觉得上一关特别简单,代码少,背下来就行了,但是如果你要真的理解透了,尝试一下这个一关的练习,用迭代的方式在展示一下,我们就看看非递归方式实现过程。

当然在面试的时候,如果你靠二叉树的前中后序遍历,面试官很可能不让你使用递归方式,因为太简单,可能会点名要你采用迭代的方式,所以这种方式也是必要掌握的。

理论上,递归可以解决的事情都可以通过迭代的方式解决,但是会很复杂,上面的几个递归遍历方法,背下来但是面试的时候不要求使用你就很难受的。

递归就是每次执行方法调用都会先把当前的局部变量、参数值和返回地址等压入栈中,后面再递归返回的时候,从栈顶弹出上一层的各项参数继续执行,这就是递归为什么自动返回并执行上一层方法的原因。我们这里采用迭代方法练习这三道题:

推荐题目⭐⭐⭐⭐:

144. 二叉树的前序遍历 - 力扣(LeetCode)

94. 二叉树的中序遍历 - 力扣(LeetCode)

145. 二叉树的后序遍历 - 力扣(LeetCode)

1. 迭代法实现前序遍历

前序遍历是中左右,如果还有子树就是一直向下找。完了之后再返回从最底层逐步向上向右找。不难写出代码,但是要主以空节点不如栈。


    /**
     * 二叉树的前序遍历
     * @param root
     * @return
     */
    public static List<Integer> preOrderTraversal(TreeNode root) {
        // 校验参数
        if (root == null){
            return new ArrayList<Integer>();
        }
        // 创建空间
        List<Integer> res = new ArrayList<Integer>();
        Deque<TreeNode> stack = new LinkedList<>();
        // 保留根节点
        TreeNode node = root;
        // 只要根节点不空或者栈不空 就循环遍历
        while(!stack.isEmpty() || node != null){
            // 中左右
            while(node != null){
                res.add(node.val);
                stack.push(node);
                node = node.left;
            }
            node = stack.pop();
            node = node.right;
        }
        return res;
    }

2. 迭代法实现中序遍历

再来看看中序遍历,中序遍历时左中右,先访问的时二叉树的左子树,然后再一层一层向下访问,知道达到树的最左底部,在处理节点(也就是把节点数值放入res列表)。在使用迭代法写中序遍历,就需要借助指针的遍历帮助访问节点,栈则用来处理节点上的元素。

看下代码实现:

    /**
     * 二叉树中序遍历
     * @param root
     * @return
     */
    public static List<Integer> inorderTraversal (TreeNode root) {
        // 参数检验
        if (root == null){
            return new ArrayList<Integer>();
        }
        // 创建空间
        List<Integer> res = new ArrayList<Integer>();
        // 栈存储引用
        Deque<TreeNode> stack = new LinkedList<>();
        // 根节点不为空或者栈不为空 一直向下遍历
        while (root != null ||!stack.isEmpty() ) {
            while(root != null){
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            res.add(root.val);
            root = root.right;
        }
        return res;
    }

3. 迭代法实现后序遍历

后续遍历的非递归方法有三种基本实现思路

  1. 反转法
  2. 访问标记法
  3. Morris法

说是话这三种方法理解起来都有些难度,如果你想挑战一下你的头发,我觉得你可以试一试。

个人觉得访问标记法时最难理解的方法,Morris法时国外的大佬发明的巧思:不是用栈,而使用树中大量的空闲指针完成的,但是实现起来也是很麻烦。感兴趣的同学可以参考这篇文章看下:

【递归+迭代详解】二叉树的morris遍历、层序遍历、前序遍历、中序遍历、后序遍历_morris 递归_威斯布鲁克.猩猩的博客-CSDN博客

这里你们估计已经猜到我们要使用那种方法了:反转发。

我们看下图:
算法通过村第七关-树(递归/二叉树遍历)黄金笔记|迭代遍历_第1张图片
我们可以看到后序遍历的结果是seq = {9 5 7 4 3 },我们将其反转后的结果是 new_seq = {3 4 7 5 9}.

你有没有发现有什么不一样的地方,看new_seq的序列是不是和前序的思路几乎一致,只不过是左右反了,前序是先中间然后再左右,这里变成了先中间然后再右左。我们完全可以改造一下前序遍历的思路,得到序列new_seq之后,然后再将结果反转过来就是我们想要的结果了。

这真是个天才:

 	/**
     * 反转法实现
     *
     * @param root
     * @return
     */
    public static List<Integer> postOrderTraversal(TreeNode root) {
        // 参数校验
        if (root == null) {
            return new ArrayList<Integer>();
        }
        // 创建空间
        List<Integer> res = new ArrayList<Integer>();
        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        // 保留根节点信息
        TreeNode node = root;
        // 根节点不为空或者栈不为空,不断遍历下去
        while (!stack.isEmpty() || node != null) {
            while (node != null) {
                res.add(node.val);
                stack.push(node);
                node = node.right;
            }
            node = stack.pop();
            node = node.left;
        }
        // 重新反转分到结果集
        Collections.reverse(res);
        return res;
    }

这个方法可以巧妙的避开后序遍历的坑,感兴趣的同学可以从后续慢慢写,研究下他的妙处。


总结

提示:二叉树的迭代遍历;栈的思想;反转法

你可能感兴趣的:(算法集训营,算法笔记,二叉树的迭代遍历,栈的思想,反转法,Java)