2022.2.18 LeetCode —— 二叉树

最新推荐文章于 2024-07-22 16:27:42 发布

LGoGoGo！

最新推荐文章于 2024-07-22 16:27:42 发布

阅读量3.4k

点赞数 1

文章标签： leetcode 算法职场和发展

本文链接：https://blog.csdn.net/alyzajlm/article/details/123010089

版权

本文主要介绍了LeetCode中关于二叉树的五道题目，包括102. 二叉树的层序遍历、107. 二叉树的层序遍历 II、199. 二叉树的右视图、637. 二叉树的层平均值和429. N 叉树的层序遍历。通过队列进行层序遍历，结合不同的处理方式得到不同结果，如右视图、层平均值等。

摘要由CSDN通过智能技术生成

一、今日刷题

1. 第七部分：二叉树 – 102. 二叉树的层序遍历

跳转LeetCode

在这里插入图片描述

答案代码：

维护一个队列用于存储树的节点，一个集合用于存储每层遍历到的节点，对队列的操作很巧妙：
一层一层的遍历，
①先加入第一层的 root 节点到队列中，poll 到集合中，再将集合加入 ans
②将 root 的左右子节点（如果不为 null ）加入队列，分别再 poll 到集合中，再将集合加入 ans
③再陆续将上一层所有节点的左右子节点加入队列，分别再 poll 到集合中，再将集合加入 ans
…
直到队列中没有元素，树的节点也就遍历完了。

package BinaryTree;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

/**
 * @author: LYZ
 * @date: 2022/2/18 19:49
 * @description: 105.
 */
public class LevelOrder {
    public static void main(String[] args) {
        TreeNode root = new TreeNode(1, new TreeNode(2), new TreeNode(3));
        LevelOrder levelOrder = new LevelOrder();
        List<List<Integer>> ans = levelOrder.levelOrder(root);
        System.out.println(ans);
    }

    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> ans = new ArrayList<>();
        if (root == null) {
            return ans;
        }

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            List<Integer> level = new ArrayList<>();
            int levelSize = queue.size(); //做题时差了这个语句，结果就不对了
            for (int i = 1; i <= levelSize; i++) {
                TreeNode node = queue.poll();
                level.add(node.val);
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            ans.add(level);
        }
        return ans;
    }
}

2. 第七部分：二叉树 – 107. 二叉树的层序遍历 II

跳转LeetCode

在这里插入图片描述

答案代码：

方法一：
自底向上的层序遍历，我的思路是：整体代码按照自顶向下编写，但引入一个栈，将每一层遍历的节点所存储的集合 level 存入栈，最后利用栈先入后出的原则将元素依次 pop 存入 ans 中。

方法二：
在105题代码最终 return 语句前写

Collections.reverse(ans);

package BinaryTree;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

/**
 * @author: LYZ
 * @date: 2022/2/18 19:49
 * @description: 105.
 */
public class LevelOrder {
    public static void main(String[] args) {
        TreeNode root = new TreeNode(1, new TreeNode(2), new TreeNode(3));
        LevelOrder levelOrder = new LevelOrder();
        List<List<Integer>> ans = levelOrder.levelOrder(root);
        System.out.println(ans);
    }

    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> ans = new ArrayList<>();
        if (root == null) {
            return ans;
        }

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            List<Integer> level = new ArrayList<>();
            int levelSize = queue.size(); //做题时差了这个语句，结果就不对了
            for (int i = 1; i <= levelSize; i++) {
                TreeNode node = queue.poll();
                level.add(node.val);
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            ans.add(level);
        }
        return ans;
    }
}

3. 第七部分：二叉树 – 199. 二叉树的右视图

跳转LeetCode

在这里插入图片描述

答案代码：

依旧是以105的代码思想为基础，我们依然把每层的节点都加入队列，并以此 poll 出来，但我们只需要将每一层的最后一个节点加入 ans，这样ans中存的就是右视图看到的节点。
(在做题时，最开始的思路是在向队列中加入节点时，只取每个节点的右侧子节点，但这样不能解决输入为 [1, 2, null] 的情况)

package BinaryTree;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

/**
 * @author: LYZ
 * @date: 2022/2/18 20:56
 * @description: 199.给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
 */
public class RightSideView {
    public static void main(String[] args) {
        TreeNode root = new TreeNode(1, new TreeNode(2), new TreeNode(3));
        RightSideView rightSideView = new RightSideView();
        List<Integer> ans = rightSideView.rightSideView(root);
        System.out.println(ans);
    }

    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> ans = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        if (root == null) {
            return ans;
        }

        queue.offer(root);
        while (!queue.isEmpty()) {
            int levelSize = queue.size();
            for (int i = 0; i < levelSize; i++) {
                TreeNode node = queue.poll();
                if (i == (levelSize - 1)) {
                    ans.add(node.val);
                }
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }

            }
        }
        return ans;
    }
}

4. 第七部分：二叉树 – 637. 二叉树的层平均值

跳转LeetCode

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

答案代码：

依旧是以105的代码思想为基础，但为了对每层取平均值，我们把每一层遍历出来的节点的 val 不再存入集合，而是将 val 加入 sum，将每层的 sum 与 size 做除法运算作为平均值。

package BinaryTree;

import java.util.*;

/**
 * @author: LYZ
 * @date: 2022/2/18 21:21
 * @description: 637.给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。
 */
public class AverageOfLevels {
    public static void main(String[] args) {
        TreeNode root = new TreeNode(1, new TreeNode(2), new TreeNode(3));
        AverageOfLevels averageOfLevels = new AverageOfLevels();
        List<Double> ans = averageOfLevels.averageOfLevels(root);
        System.out.println(ans);
    }

    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> ans = new ArrayList<>();
        if (root == null) {
            return ans;
        }

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            //List<Integer> level = new ArrayList<>();
            long sum = 0; //注意这里，如果sum为int型，当输入为[2147483647,2147483647,2147483647]时会溢出，第二层的平均值不再是2147483647
            int levelSize = queue.size();
            for (int i = 1; i <= levelSize; i++) {
                TreeNode node = queue.poll();
                sum += node.val;
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            double ave = (double) sum / levelSize; //平均值的计算，前几天刚练过数型转换
            ans.add(ave);
        }
        return ans;
    }
}

5. 第七部分：二叉树 – 429. N 叉树的层序遍历

跳转LeetCode

给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。

树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。

答案代码：

依旧是以105的代码思想为基础，在 for 循环中不再只判断左右子节点，而是直接使用队列的 addAll 方法将所有子节点加入队列（小心空指针异常，记得在方法外套一层if判断语句）

package BinaryTree;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

/**
 * @author: LYZ
 * @date: 2022/2/18 21:43
 * @description: 429. N叉树的层序遍历
 */
public class LevelOrderN {
    public static void main(String[] args) {
        List<Node> children = new ArrayList<>();
        children.add(new Node(2));
        children.add(new Node(3));
        children.add(new Node(4));
        children.add(new Node(5));
        Node node = new Node(1, children);
        LevelOrderN levelOrderN = new LevelOrderN();
        List<List<Integer>> ans = levelOrderN.levelOrderN(node);
        System.out.println(ans);
    }

    public List<List<Integer>> levelOrderN(Node root) {
        List<List<Integer>> ans = new ArrayList<>();
        if (root == null) {
            return ans;
        }

        Queue<Node> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            List<Integer> level = new ArrayList<>();
            int levelSize = queue.size();
            for (int i = 1; i <= levelSize; i++) {
                Node node = queue.poll();
                level.add(node.val);
                if (node.children != null) {
                    queue.addAll(node.children);
                }
            }
            ans.add(level);
        }
        return ans;
    }
}

二、知识积累

1.队列Queue的一些方法：

add 增加一个元索如果队列已满，则抛出一个 IIIegaISlabEepeplian 异常
remove 移除并返回队列头部的元素如果队列为空，则抛出一个 NoSuchElementException 异常
element 返回队列头部的元素如果队列为空，则抛出一个 NoSuchElementException 异常
offer 添加一个元素并返回true 如果队列已满，则返回false
poll 移除并返问队列头部的元素如果队列为空，则返回null
peek 返回队列头部的元素如果队列为空，则返回null
put 添加一个元素如果队列满，则阻塞
take 移除并返回队列头部的元素如果队列为空，则阻塞

①声明队列：

Queue<String> queue = new LinkedList<String>();

②add()和remove()方法在失败的时候会抛出异常所以不推荐使用。

③操作实例：

import java.util.LinkedList;
import java.util.Queue;
 
public class Main {
    public static void main(String[] args) {
        //add()和remove()方法在失败的时候会抛出异常(不推荐)
        Queue<String> queue = new LinkedList<String>();
        //添加元素
        queue.offer("a");
        queue.offer("b");
        queue.offer("c");
        queue.offer("d");
        queue.offer("e");
        for(String q : queue){
            System.out.println(q);
        }
        System.out.println("===");
        System.out.println("poll="+queue.poll()); //返回第一个元素，并在队列中删除
        for(String q : queue){
            System.out.println(q);
        }
        System.out.println("===");
        System.out.println("element="+queue.element()); //返回第一个元素 
        for(String q : queue){
            System.out.println(q);
        }
        System.out.println("===");
        System.out.println("peek="+queue.peek()); //返回第一个元素 
        for(String q : queue){
            System.out.println(q);
        }
    }
}