【刷题笔记】二叉树3

之前已经介绍过了二叉树的前中后序遍历及层序遍历,这是解决所有二叉树问题的手段。上一期也提到过,很多题既可以用前中后序遍历去做也可以用层序遍历去做。本期就介绍一下例题,分别展示两种做法。

1. 二叉树的右视图

199. 二叉树的右视图

给定一个二叉树的 根节点 root,想象自己站在它的右侧,按照从顶部到底部的顺序,返回从右侧所能看到的节点值。

1.1 方法1:前序遍历

因为右视图的节点可能分布在各个位置,即处于某一层最右侧的节点有可能在左子树,也有可能在右子树,有可能在左子树的左子树,也有可能在右子树的左子树......因此,采用前序遍历的方式也需要遍历整棵树,时间复杂度为O(n)。

所以,前序遍历的想法就是,用一个高度值curHeight记录你当前所在层的高度,用一个List去收集每一层的最右侧的值。遍历的时候先把List填满,后序如果有更深的深度再往List中放值。后面遍历的时候再在相同高度发现List中有值,说明List中存的已经不是最右侧的了,就更新这个值。

图解如下:

java 复制代码
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        dfs(res, root, 0);
        return res;
    }

    private void dfs(List<Integer> res, TreeNode root, int curHeight) {
        if (res.size() == curHeight) {
            res.add(root.val);
        } else {
            res.set(curHeight, root.val);
        }
        if (root.left != null) {
            dfs(res, root.left, curHeight + 1);
        }
        if (root.right != null) {
            dfs(res, root.right, curHeight + 1);
        }
    }

1.2 方法2:层序遍历

层序遍历与上一期代码类似,自行理解。

java 复制代码
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        Deque<TreeNode> deque = new LinkedList<>();
        deque.push(root);
        while (!deque.isEmpty()) {
            int size = deque.size();
            while (size-- > 0) {
                TreeNode pop = deque.pop();
                if(size == 0) {
                    res.add(pop.val);
                }
                if (pop.left != null) {
                    deque.addLast(pop.left);
                }
                if (pop.right != null) {
                    deque.addLast(pop.right);
                }
            }
        }
        return res;
    }

2. 二叉树的层平均值

637. 二叉树的层平均值

给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受

2.1 方法1:前序遍历

解法思路同右视图,即在遍历二叉树的每一条路径的时候用一个List记录对应位置的值,只不过右视图是每当发现新值就更新,本题是每当在对应深度发现新值就在List对应位置给做加和,同时再用一个List在对应深度记录当前深度的节点数。最后获取两个List,每个相同位置元素做除法,就得到了层平均值。

java 复制代码
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> sums = new ArrayList<>();
        if (root == null) {
            return sums;
        }
        List<Integer> nums = new ArrayList<>();
        dfs(sums, root, nums, 0);
        List<Double> res = new ArrayList<>();
        for (int i = 0; i < nums.size(); i++) {
            res.add(i, sums.get(i) / nums.get(i));
        }
        return res;
    }

    private void dfs(List<Double> sums, TreeNode root, List<Integer> nums, int curHeight) {
        if (sums.size() == curHeight) {
            sums.add(root.val * 1.0);
            nums.add(1);
        } else {
            sums.set(curHeight, sums.get(curHeight) + root.val);
            nums.set(curHeight, nums.get(curHeight) + 1);
        }
        if (root.left != null) {
            dfs(sums, root.left, nums, curHeight + 1);
        }
        if (root.right != null) {
            dfs(sums, root.right, nums, curHeight + 1);
        }
    }

2.2 方法2:层序遍历

java 复制代码
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> res = new ArrayList<>();
        Deque<TreeNode> deque = new LinkedList();
        deque.push(root);
        while (!deque.isEmpty()) {
            int size = deque.size();
            Double sum = 0d;
            int nums = size;
            while (size-- > 0) {
                TreeNode pop = deque.pop();
                sum += pop.val;
                if (pop.left != null) {
                    deque.addLast(pop.left);
                }
                if (pop.right != null) {
                    deque.addLast(pop.right);
                }
            }
            res.add(sum / nums);
        }
        return res;
    }

3. 二叉树层最大值

515. 在每个树行中找最大值

给定一棵二叉树的根节点 root ,请找出该二叉树中每一层的最大值。

3.1 方法一:前序遍历

还是熟悉的配方用一个curHeight记录当前高度,然后在遍历的时候一旦到了相同的高度,就对比List中存的值和现在的值哪个,如果比存的值大,就更新List对应位置的值。

java 复制代码
    public List<Integer> largestValues(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        dfs(res, root, 0);
        return res;
    }

    private void dfs(List<Integer> res, TreeNode root, int curHeight) {
        if (res.size() == curHeight) {
            res.add(root.val);
        } else {
            res.set(curHeight, Math.max(res.get(curHeight), root.val));
        }
        if (root.left != null) {
            dfs(res, root.left, curHeight + 1);
        }
        if (root.right != null) {
            dfs(res, root.right, curHeight + 1);
        }
    }

3.2 方法二:层序遍历

java 复制代码
    public List<Integer> largestValues(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        Deque<TreeNode> deque = new LinkedList<>();
        deque.push(root);
        while (!deque.isEmpty()) {
            int size = deque.size();
            int maxValue = deque.peek().val;
            while (size-- > 0) {
                TreeNode pop = deque.pop();
                maxValue = Math.max(maxValue, pop.val);
                if (pop.left != null) {
                    deque.addLast(pop.left);
                }
                if (pop.right != null) {
                    deque.addLast(pop.right);
                }
            }
            res.add(maxValue);
        }
        return res;
    }

4. 填充每个节点的下一个右侧节点指针

116. 填充每个节点的下一个右侧节点指针

给定一个 完美二叉树,其所有叶子节点都在同一层,每个父节点都有两个子节点。二叉树定义如下:

java 复制代码
struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针,让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点,则将 next 指针设置为 NULL。初始状态下,所有 next 指针都被设置为 NULL

117. 填充每个节点的下一个右侧节点指针 II

给定一个二叉树:

java 复制代码
struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针,让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点,则将 next 指针设置为 NULL 。初始状态下,所有 next 指针都被设置为 NULL

两道题解法几乎一样,在这里给出通用的代码(一套代码打两个)。

4.1 方法一:前序遍历

思路与之前相似,记录高度,每次遍历到曾经遍历过的高度,就让List中存的next指向当前节点,并把当前节点更新到List中以便下一次的引用指向。

java 复制代码
    public static Node connect(Node root) {
        if (root == null) {
            return root;
        }
        Node cur = root;
        List<Node> records = new ArrayList<>();
        dfs(records, cur, 0);
        return root;
    }

    private static void dfs(List<Node> records, Node root, int curHeight) {
        if(root == null) {
            return;
        }
        if (records.size() == curHeight) {
            records.add(root);
        } else {
            Node node = records.get(curHeight);
            node.next = root;
            records.set(curHeight, root);
        }
        dfs(records, root.left, curHeight + 1);
        dfs(records, root.right, curHeight + 1);
    }

4.2 方法二:层序遍历

java 复制代码
    public Node connect(Node root) {
        Deque<Node> deque = new LinkedList<>();
        if (root != null) {
            deque.push(root);
        }
        while (!deque.isEmpty()) {
            int size = deque.size();
            while (size-- > 0) {
                Node node = deque.pollFirst();
                if (size != 0) {
                    node.next = deque.peek();
                } else {
                    node.next = null;
                }
                if (node.left != null) {
                    deque.addLast(node.left);
                }
                if (node.right != null) {
                    deque.addLast(node.right);
                }
            }
        }
        return root;
    }

这个层序遍历,由于116题中,说了是完美二叉树,所以做116的时候可以不用写两个判断,写一个也是可以的。上面代码是一个通用的解法,怎么写都可以。

java 复制代码
                if (pop1.left != null) {
                    deque.addLast(pop1.right);
                    deque.addLast(pop1.left);
                }

5. 二叉树的最大深度

104. 二叉树的最大深度

给定一个二叉树 root ,返回其最大深度。二叉树的最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。

5.1 方法一:后序遍历

这道题用递归是最简单的,为什么用后序遍历呢?在这里说一下思路,最好的解决办法就是:

(1)求取当前节点左子树的深度;

(2)再求取当前节点右子树的深度;

(3)然后比较两科子树的深度,取最深的加1,就是当前节点为头节点所在子树的最大深度。

这不就是"左右中"------后序遍历吗。

java 复制代码
    public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int l = maxDepth(root.left);
        int r = maxDepth(root.right);
        return Math.max(l, r) + 1;
    }

5.2 方法二:层序遍历

层序的解决方法就简单粗暴了,我直接一层一层去遍历,直到下一层一个节点都没有了,每遍历一层就+1。

java 复制代码
    public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        Deque<TreeNode> deque = new LinkedList<>();
        deque.push(root);
        int height = 0;
        while (!deque.isEmpty()) {
            int size = deque.size();
            height++;
            while (size-- > 0) {
                TreeNode pop = deque.pop();
                if (pop.left != null) {
                    deque.addLast(pop.left);
                }
                if (pop.right != null) {
                    deque.addLast(pop.right);
                }
            }
        }
        return height;
    }

6. 二叉树的最小深度

111. 二叉树的最小深度

给定一个二叉树,找出其最小深度。最小深度是从根节点到最近叶子节点的最短路径上的节点数量

6.1 方法一:后序遍历

首先需要这段代码限制一下null为空的情况,root为null深度就为0,返回就好了。

java 复制代码
        if(root == null) {
            return 0;
        }

当前节点左节点为null,右节点也为null,此时这个节点的高度就是1,然后还是采用最大深度的思想,"中"用来收集左右子树最小的深度。

java 复制代码
    public int minDepth(TreeNode root) {
        if(root == null) {
            return 0;
        }
        if (root.left == null && root.right == null) {
            return 1;
        }
        int l = Integer.MAX_VALUE;
        if (root.left != null) {
            l = minDepth(root.left);
        }
        int r = Integer.MAX_VALUE;
        if (root.right != null) {
            r = minDepth(root.right);
        }
        return Math.min(l, r) + 1;
    }

6.2 方法二:层序遍历

在层序遍历的时候,一旦发现哪个节点的左节点为null,右节点也为null,就说明这个节点是叶子节点了。因为是一层一层的遍历,所以一旦第一次碰到叶子节点,这个深度一定就是最小的,直接返回此时记录的深度就好。

java 复制代码
    public int minDepth(TreeNode root) {
       if (root == null) {
            return 0;
        }
        Deque<TreeNode> deque = new LinkedList<>();
        deque.push(root);
        int height = 0;
        while (!deque.isEmpty()) {
            int size = deque.size();
            height++;
            while (size-- > 0) {
                TreeNode pop = deque.pop();
                if (pop.left == null && pop.right == null) {
                    return height;
                }
                if (pop.left != null) {
                    deque.addLast(pop.left);
                }
                if (pop.right != null) {
                    deque.addLast(pop.right);
                }
            }
        }
        return height;
    }
相关推荐
时光の尘5 分钟前
C语言菜鸟入门·关键字·void的用法
c语言·开发语言·c++·算法·c#·c·关键字
蚂蚁没问题s6 分钟前
图像处理 - 色彩空间转换
图像处理·人工智能·算法·机器学习·计算机视觉
戊子仲秋18 分钟前
【LeetCode】每日一题 2024_11_21 矩阵中的蛇(模拟)
算法·leetcode·矩阵
HP-Patience22 分钟前
【机器学习】- 模型复杂度vs模型误差
python·算法·机器学习
螺旋天光极锐斩空闪壹式!30 分钟前
第十三课 二维数组(2)方向数组
开发语言·c++·算法
peter801534 分钟前
算法项目推荐
算法
小小白白蛆35 分钟前
剑指offer JZ51 数组中的逆序对
数据结构·算法·排序算法
十五年专注C++开发40 分钟前
C++不完整类型(Incomplete Type)的检测与避免
开发语言·c++·算法·设计模式
eternal19951 小时前
优化算法|基于Deep-Q-Network(DQN)的邻域搜索算法求解分布式柔性作业车间调度问题
分布式·算法
心死翼未伤1 小时前
python从入门到精通:pyspark实战分析
开发语言·数据结构·python·spark·json