《LeetCode力扣练习》代码随想录——二叉树（二叉树的层序遍历---Java）

最新推荐文章于 2024-09-15 15:29:37 发布
最新推荐文章于 2024-09-15 15:29:37 发布
阅读量782 收藏 27
点赞数 22
分类专栏： # LeetCode 文章标签： leetcode java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XRT_knives/article/details/136457091
版权

《LeetCode力扣练习》代码随想录——二叉树（二叉树的层序遍历—Java）

刷题思路来源于 代码随想录
102. 二叉树的层序遍历
  • 二叉树
    /**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {

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

        List<List<Integer>> result=new ArrayList<>();
        Deque<TreeNode> queue =new ArrayDeque<>();

        queue.offer(root);

        while(queue.size()!=0){

            int num=queue.size();
            List<Integer> list=new ArrayList<>();

            while(num>0){

                TreeNode temp=queue.poll();
                list.add(temp.val);

                if(temp.left!=null){
                    queue.offer(temp.left);
                }

                if(temp.right!=null){
                    queue.offer(temp.right);
                }

                num--;

            }

            result.add(list);

        }

        return result;

    }
}
107. 二叉树的层序遍历 II
  • 二叉树
    /**
 * Definition for a binary tree node.
 * public class TreeNode {
 * int val;
 * TreeNode left;
 * TreeNode right;
 * TreeNode() {}
 * TreeNode(int val) { this.val = val; }
 * TreeNode(int val, TreeNode left, TreeNode right) {
 * this.val = val;
 * this.left = left;
 * this.right = right;
 * }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {

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

        List<List<Integer>> result = new ArrayList<>();
        Deque<TreeNode> queue = new ArrayDeque<>();

        queue.offer(root);

        while (queue.size() != 0) {

            int num = queue.size();
            List<Integer> list = new ArrayList<>();

            while (num > 0) {

                TreeNode temp = queue.poll();
                list.add(temp.val);

                if (temp.left != null) {
                    queue.offer(temp.left);
                }

                if (temp.right != null) {
                    queue.offer(temp.right);
                }

                num--;

            }

            result.add(list);

        }

        Collections.reverse(result);

        return result;

    }
}
199. 二叉树的右视图
  • 二叉树
    /**
 * Definition for a binary tree node.
 * public class TreeNode {
 * int val;
 * TreeNode left;
 * TreeNode right;
 * TreeNode() {}
 * TreeNode(int val) { this.val = val; }
 * TreeNode(int val, TreeNode left, TreeNode right) {
 * this.val = val;
 * this.left = left;
 * this.right = right;
 * }
 * }
 */
class Solution {
    public List<Integer> rightSideView(TreeNode root) {

        if (root == null) {
            return new ArrayList<Integer>();
        }

        List<Integer> result = new ArrayList<>();
        Deque<TreeNode> queue = new ArrayDeque<>();

        queue.offer(root);

        while (queue.size() != 0) {

            int num = queue.size();

            while (num > 0) {

                TreeNode temp = queue.poll();

                if (num == 1) {
                    result.add(temp.val);
                }

                if (temp.left != null) {
                    queue.offer(temp.left);
                }

                if (temp.right != null) {
                    queue.offer(temp.right);
                }

                num--;

            }

        }

        return result;

    }
}
637. 二叉树的层平均值
  • 二叉树
    /**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Double> averageOfLevels(TreeNode root) {

        if(root==null){
            return new ArrayList<Double>();
        }

        List<Double> result=new ArrayList<>();
        Deque<TreeNode> queue=new ArrayDeque<>();
        
        queue.offer(root);

        while(queue.size()!=0){

            int num=queue.size();
            int size=num;
            double sum=0.0;

            while(num>0){

                TreeNode temp=queue.poll();
                sum=sum+temp.val;

                if(temp.left!=null){
                    queue.offer(temp.left);
                }

                if(temp.right!=null){
                    queue.offer(temp.right);
                }

                num--;

            }

            result.add(sum/size);

        }

        return result;

    }
}
429. N 叉树的层序遍历
  • 二叉树
    /*
// Definition for a Node.
class Node {
    public int val;
    public List<Node> children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
    public List<List<Integer>> levelOrder(Node root) {

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

        List<List<Integer>> result = new ArrayList<>();
        Deque<Node> queue = new ArrayDeque<>();

        queue.offer(root);

        while (queue.size() != 0) {

            int num = queue.size();
            List<Integer> list = new ArrayList<>();

            while (num > 0) {

                Node temp = queue.poll();
                list.add(temp.val);

                for (Node node : temp.children) {

                    if (node != null) {
                        queue.offer(node);
                    }

                }

                num--;

            }

            result.add(list);

        }

        return result;

    }
}
515. 在每个树行中找最大值
  • 二叉树
    /**
 * Definition for a binary tree node.
 * public class TreeNode {
 * int val;
 * TreeNode left;
 * TreeNode right;
 * TreeNode() {}
 * TreeNode(int val) { this.val = val; }
 * TreeNode(int val, TreeNode left, TreeNode right) {
 * this.val = val;
 * this.left = left;
 * this.right = right;
 * }
 * }
 */
class Solution {
    public List<Integer> largestValues(TreeNode root) {

        if (root == null) {
            return new ArrayList<Integer>();
        }

        List<Integer> result = new ArrayList<>();
        Deque<TreeNode> queue = new ArrayDeque<>();
        queue.offer(root);

        while (queue.size() != 0) {

            int num = queue.size();
            int max = Integer.MIN_VALUE;

            while (num > 0) {

                TreeNode temp = queue.poll();
                max = max > temp.val ? max : temp.val;

                if (temp.left != null) {
                    queue.offer(temp.left);
                }

                if (temp.right != null) {
                    queue.offer(temp.right);
                }

                num--;

            }

            result.add(max);

        }

        return result;

    }
}
116. 填充每个节点的下一个右侧节点指针
  • 二叉树
    /*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;
    public Node next;

    public Node() {}
    
    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, Node _left, Node _right, Node _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};
*/

class Solution {
    public Node connect(Node root) {

        if (root == null) {
            return null;
        }

        Deque<Node> queue = new ArrayDeque<>();

        root.next = null;
        queue.offer(root);

        while (queue.size() != 0) {

            int num = queue.size() - 1;
            Node temp = queue.poll();

            if (temp.left != null) {
                queue.offer(temp.left);
            }

            if (temp.right != null) {
                queue.offer(temp.right);
            }

            while (num > 0) {

                temp.next = queue.poll();
                temp = temp.next;

                if (temp.left != null) {
                    queue.offer(temp.left);
                }

                if (temp.right != null) {
                    queue.offer(temp.right);
                }

                num--;

            }

            temp.next = null;

        }

        return root;

    }
}
117. 填充每个节点的下一个右侧节点指针 II
  • 二叉树
    /*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;
    public Node next;

    public Node() {}
    
    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, Node _left, Node _right, Node _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};
*/

class Solution {
    public Node connect(Node root) {

        if (root == null) {
            return null;
        }

        Deque<Node> queue = new ArrayDeque<>();
        queue.offer(root);

        while (queue.size() != 0) {

            int num = queue.size() - 1;
            Node temp = queue.poll();

            if (temp.left != null) {
                queue.offer(temp.left);
            }

            if (temp.right != null) {
                queue.offer(temp.right);
            }

            while (num > 0) {

                temp.next = queue.poll();
                temp = temp.next;

                if (temp.left != null) {
                    queue.offer(temp.left);
                }

                if (temp.right != null) {
                    queue.offer(temp.right);
                }

                num--;

            }

            temp.next=null;

        }

        return root;

    }
}
104. 二叉树的最大深度
  • 二叉树
    /**
 * Definition for a binary tree node.
 * public class TreeNode {
 * int val;
 * TreeNode left;
 * TreeNode right;
 * TreeNode() {}
 * TreeNode(int val) { this.val = val; }
 * TreeNode(int val, TreeNode left, TreeNode right) {
 * this.val = val;
 * this.left = left;
 * this.right = right;
 * }
 * }
 */
class Solution {
    public int maxDepth(TreeNode root) {

        if (root == null) {
            return 0;
        }

        int result = 0;
        Deque<TreeNode> queue = new ArrayDeque<>();
        queue.offer(root);

        while (queue.size() != 0) {

            int num = queue.size();
            result++;

            while (num > 0) {

                TreeNode temp = queue.poll();

                if (temp.left != null) {
                    queue.offer(temp.left);
                }

                if (temp.right != null) {
                    queue.offer(temp.right);
                }

                num--;

            }

        }

        return result;

    }
}
111. 二叉树的最小深度
  • 二叉树
    /**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int minDepth(TreeNode root) {

        if(root==null){
            return 0;
        }

        int result=0;
        Deque<TreeNode> queue=new ArrayDeque<>();
        queue.offer(root);

        while(queue.size()!=0){

            int num=queue.size();
            result++;

            while(num>0){

                TreeNode temp=queue.poll();

                if(temp.left==null&&temp.right==null){
                    return result;
                }

                if(temp.left!=null){
                    queue.offer(temp.left);
                }

                if(temp.right!=null){
                    queue.offer(temp.right);
                }

                num--;

            }

        }

        return result;

    }
}
XRT_knives
关注
专栏目录
leetcode: 102. 二叉树的层序遍历
uncle_ll的博客
07-25 505
给你二叉树的根节点root，返回其节点值的层序遍历。（即逐层地，从左到右访问所有节点）。来源力扣（LeetCode）
力扣102 二叉树的层序遍历 Java版本
m0_47066863的博客
02-21 510
给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。
【LeetCode】-二叉树
银尘博客
03-15 7752
文章目录前言一、二叉树的层序遍历 前言 初识LeetCode与算法，将在此系列文章里面，记录自己的算法学习经历，前期主要是监督自己学习打卡，后期我会将自己对知识的理解，慢慢补充到文章当中，希望大家能在阅读我的文章中，有所收获。该系列文章的刷题顺序以代码随想录为线索。 一、二叉树的层序遍历 题目： 给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。 示例 1： 输入：root = [3,9,20,null,null,15,7] 输出：[[3],[9,20],[1
LeetCode刷题总结之二叉树的构建算法-一道题13种解法
weixin_47067712的博客
05-24 713
前言 最近开始刷到一些二叉树的构建的算法题，挺有意思的，打算总结一下。这里总结的都是确定二叉树的构造算法题，可能有多个构造结果的算法题就没考虑。 从构造目标上来看，这里讨论的算法题可以分为两种： 二叉树的构造 二叉搜索树（BST）的构造 从构造条件上来看，这里讨论的算法题也可以分为两种： 不含重复数值节点的二叉树的构造 含重复数值节点的二叉树的构造 1.从前序与中序遍历以及中序和后序遍历构造二叉树 这2个题目分别为： LeetCode.105 从前序与中序遍历序列构造二叉树，中等难度 LeetCo
leetcode刷题之构建二叉树
星的博客
11-19 1600
题目描述： 给出一棵树的中序遍历和后序遍历，请构造这颗二叉树。 给定的是中序遍历和后序遍历的数组，输出是树。 题目分析: 对于一颗二叉树的构建，现根据两个数组找到树的头结点，中序遍历顺序是：左中右，先遍历左子树再遍历中间节点最后遍历右子树，对于后序遍历顺序是：先遍历左子树，再遍历右子树，最后遍历中间的节点。后序数组的最后一个节点为树的根节点，根据根节点在中序遍历的位置index，index左边的节...
leetcode---层序遍历二叉树
啦~啦~啦~的博客
08-10 1054
层序遍历二叉树 Given a binary tree, return the level order traversal of its nodes’ values. (ie, from left to right, level by level). For example: Given binary tree [3,9,20,null,null,15,7], 3 / \...
leetcode算法练习：二叉树的层序遍历
silence_bug的博客
04-17 178
题目： 二叉树的层序遍历 给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。 示例： 二叉树：[3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 返回其层次遍历结果： [ [3], [9,20], [15,7] ] 思路： 定义递归函数三个值分别是：当前...
代码随想录-力扣刷题-总结笔记01
upward
02-27 1107
代码随想录-力扣刷题-总结笔记01
Python算法题源代码-LeetCode(力扣)-二叉树中的最大路径和
02-21
力扣热题Python源代码 题目：124. 二叉树中的最大路径和 二叉树中的 路径 被定义为一条节点序列，序列中每对相邻节点之间都存在一条边。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个 节点，且不...
LeetCode-094-二叉树的中序遍历-中等-Java实现
今天你敲代码了嘛
07-29 319
题目： 给定一个二叉树，返回它的中序 遍历。 示例: 输入: [1,null,2,3] 1 \ 2 / 3 输出: [1,3,2] 进阶: 递归算法很简单，你可以通过迭代算法完成吗？ 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/binary-tree-inorder-traversal 方法一 思路： 递归 代码如下： List<Integer> res = new ArrayList<&g
leetcode二叉树问题本地调试 java——Eclipse版
Reoz的博客
06-18 1275
最近一直在leetcode上刷题，每次在做比较复杂的二叉树问题时，都想先调试再提交，但是在线编辑器并不支持这个功能，于是就想到了在eclipse上自己弄一套二叉树的代码方便调试，这里把我的代码分享给大家，有需要的同学可以按照我的这套方法在自己的编辑器上还原出来。 首先看下项目的结构 这里我把构建二叉树的代码放在了Tree目录下，solutions用于存放我的题解，在题解中调用Tree中的二叉树就可以用来调试了。 OK，下面废话不多说，直接放上Tree中每个文件的代码： 首先是TreeNode：这里是用.
【Hot100】LeetCode—64. 最小路径和
weixin_44382896的博客
09-12 452
64. 最小路径和。
【JavaScript】LeetCode：707设计链表
weixin_45980065的博客
09-14 595
【代码】【JavaScript】LeetCode：707设计链表。
leetcode-647. 回文子串
曼巴的博客
09-12 413
3）遍历顺序：一定要从下到上，从左到右遍历，这样保证dp[i + 1][j - 1]都是经过计算的。当s[i]与s[j]不相等，那没啥好说的了，dp[i][j]一定是false。整体上是两种，就是s[i]与s[j]相等，s[i]与s[j]不相等这两种。6个回文子串: "a", "a", "a", "aa", "aa", "aaa"当s[i]与s[j]相等时，这就复杂一些了，有如下三种情况。三个回文子串: "a", "b", "c"是字符串中的由连续字符组成的一个序列。是正着读和倒过来读一样的字符串。
leetcode-617. 合并二叉树
曼巴的博客
09-11 247
想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；1）如果没有root1，return root2。2）如果没有root2，return root1。null 的节点将直接作为新二叉树的节点。合并过程必须从两个树的根节点开始。3）根结点处理：两节点值加和。4）遍历两棵树的左节点。5）遍历两棵树的右节点。返回合并后的二叉树。
408算法题leetcode--第一天
weixin_58073817的博客
09-11 415
【代码】408算法题leetcode--第一天。
力扣123-买卖股票的最佳时机 III（Java详细题解）
2302_79761426的博客
09-15 515
所以dp[4 ] [4]已经包含了dp[4] [2]的情况。也就是说第二次卖出手里所剩的钱一定是最多的。一定是选最大的，所以 dp[i] [1] = Math.max(dp[i-1] [0] - prices[i], dp[i - 1 ] [1]);由递推公式可以看出dp[i] [1] = Math.max(dp[i-1] [0] - prices[i], dp[i - 1 ] [1]);那么dp[i] [1]究竟选 dp[i-1] [0] - prices[i]，还是dp[i - 1] [1]呢？
Leetcode 验证回文串
最新发布
985小菜鸡
09-15 600
尽管外层的控制了总体循环，但内部的while循环在跳过无效字符时，左右指针可能会过多地移动，因此需要在内部的循环中再次检查，以防止指针越界或交错的情况发生。这是确保算法正确性和防止潜在错误的关键步骤。
【Hot100】LeetCode—1143. 最长公共子序列
weixin_44382896的博客
09-12 400
5. 最长回文子串。
推荐力扣的几道平衡二叉树题
05-31
以下是几道关于平衡二叉树的力扣题目： 1. 题目名称：验证二叉搜索树 题目描述：给定一个二叉树，判断其是否是一个有效的二叉搜索树。 题目难度：中等 相关知识点：平衡二叉树，二叉搜索树 题目链接：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值