2022.2.18 LeetCode —— 二叉树

文章目录

  • 一、今日刷题
    • 1. 第七部分:二叉树 -- 102. 二叉树的层序遍历
    • 2. 第七部分:二叉树 -- 107. 二叉树的层序遍历 II
    • 3. 第七部分:二叉树 -- 199. 二叉树的右视图
    • 4. 第七部分:二叉树 -- 637. 二叉树的层平均值
    • 5. 第七部分:二叉树 -- 429. N 叉树的层序遍历
  • 二、知识积累
    • 1.队列Queue的一些方法:


一、今日刷题

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

跳转LeetCode

2022.2.18 LeetCode —— 二叉树_第1张图片


答案代码

维护一个队列用于存储树的节点,一个集合用于存储每层遍历到的节点,对队列的操作很巧妙:
一层一层的遍历,
①先加入第一层的 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

2022.2.18 LeetCode —— 二叉树_第2张图片


答案代码

方法一:
自底向上的层序遍历,我的思路是:整体代码按照自顶向下编写,但引入一个栈,将每一层遍历的节点所存储的集合 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

2022.2.18 LeetCode —— 二叉树_第3张图片


答案代码

依旧是以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 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);
        }
    }
}

2022.2.18 LeetCode —— 二叉树_第4张图片

你可能感兴趣的:(leetcode,算法,职场和发展)