Leetcode刷题DAY4

系列文章目录

提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加
例如：第一章 Python 机器学习入门之pandas的使用

---

提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

提示：这里可以添加本文要记录的大概内容：

例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、从上到下打印二叉树

示例：从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。

1.解题

• 对于层次搜索的题目，二叉树的 从上至下 打印（即按层打印），又称为二叉树的 广度优先搜索（BFS）
• BFS 通常借助 队列 的先入先出特性来实现

算法流程

1. 特例处理： 当树的根节点为空，则直接返回空列表 [] ；

2. 初始化： 打印结果列表 res = [] ，包含根节点的队列 queue = [root] ；

3. BFS 循环： 当队列 queue 为空时跳出；

   出队： 队首元素出队，记为 node；
   打印： 将 node.val 添加至列表 tmp 尾部；
   添加子节点： 若 node 的左（右）子节点不为空，则将左（右）子节点加入队列 queue ；
   

4. 返回值： 返回打印结果列表 res 即可。

class Solution {
    public int[] levelOrder(TreeNode root) {
        Queue<TreeNode> queue=new LinkedList<TreeNode>();
        ArrayList<Integer> al=new ArrayList<Integer>();
        if(root==null){return new int[0];}
        queue.add(root);
        while(!queue.isEmpty()){
            TreeNode node=queue.poll();
            al.add(node.val);
            if(node.left!=null){queue.add(node.left);}
            if(node.right!=null){queue.add(node.right);}      
        }
        int[] ans=new int[al.size()];
        for(int i=0;i<al.size();i++){
            ans[i]=al.get(i);
        }
        return ans;
    }
}

队列操作

add 增加一个元索 如果队列已满，则抛出一个IIIegaISlabEepeplian异常

remove 移除并返回队列头部的元素 如果队列为空，则抛出一个NoSuchElementException异常

element 返回队列头部的元素 如果队列为空，则抛出一个NoSuchElementException异常

offer 添加一个元素并返回true 如果队列已满，则返回false

poll 移除并返问队列头部的元素 如果队列为空，则返回null

peek 返回队列头部的元素 如果队列为空，则返回null

put 添加一个元素 如果队列满，则阻塞

take 移除并返回队列头部的元素 如果队列为空，则阻塞

值得注意的写法

new LinkedList<>(){{ add(root); }}; 

二、从上到下打印二叉树 II

示例：从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。

1.解题

• 每层打印到一行： 将本层全部节点打印到一行，并将下一层全部节点加入队列，以此类推，即可分为多行打印。

算法流程

1. 特例处理： 当根节点为空，则返回空列表 [] ；

2. 初始化： 打印结果列表 res = [] ，包含根节点的队列 queue = [root] ；

3. BFS 循环： 当队列 queue 为空时跳出；

   • 新建一个临时列表 tmp ，用于存储当前层打印结果；
   • 当前层打印循环： 循环次数为当前层节点数（即队列 queue 长度）；
     • 出队： 队首元素出队，记为 node；
     • 打印： 将 node.val 添加至 tmp 尾部；
     • 添加子节点： 若 node 的左（右）子节点不为空，则将左（右）子节点加入队列 queue ；
   • 将当前层结果 tmp 添加入 res

4. 返回值： 返回打印结果列表 res 即可。

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        List<List<Integer>> res = new ArrayList<>();
        if(root != null) queue.add(root);
        while(!queue.isEmpty()) {
            List<Integer> tmp = new ArrayList<>();
            for(int i = queue.size(); i > 0; i--) {
                TreeNode node = queue.poll();
                tmp.add(node.val);
                if(node.left != null) queue.add(node.left);
                if(node.right != null) queue.add(node.right);
            }
            res.add(tmp);
        }
        return res;
    }
}

leetcode

2.踩的坑

代码如下（示例）：

  for(int i=0;i<queue.size();i++){for(int i=0;i<queue.size();i++){
                TreeNode node=queue.poll();
                tmp.add(node.val);               
                if(node.left!=null){queue.add(node.left);}
                if(node.right!=null){queue.add(node.right);}
            }

该处使用的i从0到queue.size()，queue.size()在变，所以得用从queue.size()到0。

三、从上到下打印二叉树 III

示例：请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。

1.解题一：层序遍历 + 双端队列

• 利用双端队列的两端皆可添加元素的特性，设打印列表（双端队列） tmp ，并规定：

  • 奇数层 则添加至 tmp 尾部 ，
  • 偶数层 则添加至 tmp 头部 。

算法流程

1. 特例处理： 当根节点为空，则返回空列表 [] ；

2. 初始化： 打印结果空列表 res ，包含根节点的双端队列 deque ；

3. BFS 循环：当 deque 为空时跳出；

   • 新建列表 tmp ，用于临时存储当前层打印结果；
   • 当前层打印循环： 循环次数为当前层节点数（即队列 deque 长度）；
     • 出队： 队首元素出队，记为 node；
     • 打印： 若为奇数层，将 node.val 添加至 tmp 尾部；否则，添加至 tmp 头部；
     • 添加子节点： 若 node 的左（右）子节点不为空，则加入 deque
   • 将当前层结果 tmp 转化为 list 并添加入 res ；

4. 返回值： 返回打印结果列表 res 即可。

}class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        List<List<Integer>> res = new ArrayList<>();
        if(root != null) queue.add(root);
        while(!queue.isEmpty()) {
            LinkedList<Integer> tmp = new LinkedList<>();
            for(int i = queue.size(); i > 0; i--) {
                TreeNode node = queue.poll();
                if(res.size() % 2 == 0) tmp.addLast(node.val); // 偶数层 -> 队列头部
                else tmp.addFirst(node.val); // 奇数层 -> 队列尾部
                if(node.left != null) queue.add(node.left);
                if(node.right != null) queue.add(node.right);
            }
            res.add(tmp);
        }
        return res;
    }
}

Java 中将链表 LinkedList 作为双端队列使用。

2.解题二：层序遍历 + 双端队列（奇偶层逻辑分离）

• 方法一代码简短、容易实现；但需要判断每个节点的所在层奇偶性，即冗余了 NN 次判断。
• 通过将奇偶层逻辑拆分，可以消除冗余的判断。

算法流程

与方法一对比，仅 BFS 循环不同。

3. BFS 循环：循环打印奇 / 偶数层，当 deque 为空时跳出

   • 打印奇数层： 从左向右 打印，先左后右 加入下层节点；
   • 若 deque 为空，说明向下无偶数层，则跳出；
   • 打印偶数层： 从右向左 打印，先右后左 加入下层节点；

4. 返回值： 返回打印结果列表 res 即可。

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        Deque<TreeNode> deque = new LinkedList<>();
        List<List<Integer>> res = new ArrayList<>();
        if(root != null) deque.add(root);
        while(!deque.isEmpty()) {
            // 打印奇数层
            List<Integer> tmp = new ArrayList<>();
            for(int i = deque.size(); i > 0; i--) {
                // 从左向右打印
                TreeNode node = deque.removeFirst();
                tmp.add(node.val);
                // 先左后右加入下层节点
                if(node.left != null) deque.addLast(node.left);
                if(node.right != null) deque.addLast(node.right);
            }
            res.add(tmp);
            if(deque.isEmpty()) break; // 若为空则提前跳出
            // 打印偶数层
            tmp = new ArrayList<>();
            for(int i = deque.size(); i > 0; i--) {
                // 从右向左打印
                TreeNode node = deque.removeLast();
                tmp.add(node.val);
                // 先右后左加入下层节点
                if(node.right != null) deque.addFirst(node.right);
                if(node.left != null) deque.addFirst(node.left);
            }
            res.add(tmp);
        }
        return res;
    }
}

3.解题三：层序遍历 + 倒序

• 此方法的优点是只用列表即可，无需其他数据结构。
• 偶数层倒序： 若 res 的长度为 奇数 ，说明当前是偶数层，则对 tmp 执行 倒序 操作。

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        List<List<Integer>> res = new ArrayList<>();
        if(root != null) queue.add(root);
        while(!queue.isEmpty()) {
            List<Integer> tmp = new ArrayList<>();
            for(int i = queue.size(); i > 0; i--) {
                TreeNode node = queue.poll();
                tmp.add(node.val);
                if(node.left != null) queue.add(node.left);
                if(node.right != null) queue.add(node.right);
            }
            if(res.size() % 2 == 1) Collections.reverse(tmp);
            res.add(tmp);
        }
        return res;
    }
}

---

总结

提示：这里对文章进行总结：

例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。