BFS-104-559-剑指offer 32-II-剑指offer 32-I -933-101-1379-面试04.03-513-116

最新推荐文章于 2024-08-23 01:05:03 发布
最新推荐文章于 2024-08-23 01:05:03 发布
阅读量101 收藏
点赞数
分类专栏： BFS 文章标签： leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45692660/article/details/117673880
版权

在这里插入图片描述

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if root is None:
            return 0
        queue=[]
        queue.append(root)
        depth=0
        while len(queue)!=0:
            size=len(queue)
            while size>=1:
                cur_head=queue.pop(0)
                if cur_head.left:
                    queue.append(cur_head.left)
                if cur_head.right:
                    queue.append(cur_head.right)
                size-=1
            depth+=1
        return depth

在这里插入图片描述

"""
# Definition for a Node.
class Node(object):
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children
"""

class Solution(object):
    def maxDepth(self, root):
        """
        :type root: Node
        :rtype: int
        """
        if root is None:
            return 0
        queue=[]
        queue.append(root)

        depth=0
        while len(queue)!=0:
            size=len(queue)
            while size>=1:
                cur_head=queue.pop(0)
                for c in cur_head.children:
                    queue.append(c)
                size-=1
            depth+=1
        return depth

同二叉树基本一致，但要注意，多叉树children是列表

在这里插入图片描述

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if root is None:
            return []
        res=[]
        queue=[]
        queue.append(root)
        while len(queue)!=0:
            size=len(queue)
            cur_res=[]
            while size>=1:
                cur_head=queue.pop(0)
                cur_res.append(cur_head.val)
                if cur_head.left:
                    queue.append(cur_head.left)
                if cur_head.right:
                    queue.append(cur_head.right)
                size-=1
            res.append(cur_res)
        return res

在这里插入图片描述

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if root is None:
            return []
        queue=[]
        queue.append(root)
        res=[]
        while len(queue)!=0:
            cur_head=queue.pop(0)
            res.append(cur_head.val)
            if cur_head.left:
                queue.append(cur_head.left)
            if cur_head.right:
                queue.append(cur_head.right)
        return res

在这里插入图片描述

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def isCousins(self, root, x, y):
        """
        :type root: TreeNode
        :type x: int
        :type y: int
        :rtype: bool
        """
        if root is None:
            return False
        queue=[]
        queue.append(root)
        while len(queue)!=0:
            size=len(queue)
            fx=False
            fy=False
            while size>=1:
                cur_head=queue.pop(0)
                if cur_head.val==x:
                    fx=True
                if cur_head.val==y:
                    fy=True
                if cur_head.left:
                    queue.append(cur_head.left)
                if cur_head.right:
                    queue.append(cur_head.right)
                size-=1
            if fx and fy:
                return True
        return False

代码暂时不通，还需要加一个条件判断这两个值是否为同一个父节点才行

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def isCousins(self, root, x, y):
        """
        :type root: TreeNode
        :type x: int
        :type y: int
        :rtype: bool
        """
        if root is None:
            return False
        queue=[]
        queue.append(root)
        par=[None]
        while len(queue)!=0:
            size=len(queue)
            fx=False
            fy=False
            while size>=1:
                cur_head=queue.pop(0)
                cur_par=par.pop(0)
                if cur_head.val==x:
                    fx=True
                    fxp=cur_par
                if cur_head.val==y:
                    fy=True
                    fyp=cur_par
                if cur_head.left:
                    queue.append(cur_head.left)
                    par.append(cur_head)
                if cur_head.right:
                    queue.append(cur_head.right)
                    par.append(cur_head)
                size-=1
            if (fx and fy) and fxp!=fyp:
                return True
        return False

改进版，定义了同一个父节点的条件

在这里插入图片描述

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if root is None:
            return False
        queue=[]
        queue.append(root)
        while len(queue)!=0:
            res=[]
            size=len(queue)
            while size>=1:
                cur_head=queue.pop(0)
                if cur_head:
                    res.append(cur_head.val)
                    queue.append(cur_head.left)
                    queue.append(cur_head.right)
                else:
                    res.append(None)
                size-=1
            if len(res)>=2:
                for i in range(len(res)):
                    if res[i]!=res[len(res)-1-i]:
                        return False
        return True

不管左右子树是否存在，都将其放入队列中

在这里插入图片描述

class Solution(object):
    def minDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if root is None:
            return 0
        
        queue=[]
        queue.append(root)
        depth=0
        while len(queue)!=0:
            size=len(queue)
            while size>=1:
                cur_head=queue.pop(0)
                if cur_head.left is None and cur_head.right is None:
                    return depth+1
                if cur_head.left:
                    queue.append(cur_head.left)
                if cur_head.right:
                    queue.append(cur_head.right)
                size-=1
            depth+=1

碰到的第一个左右子树都不存在的节点时，该节点的深度就是最小深度

在这里插入图片描述

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def getTargetCopy(self, original, cloned, target):
        """
        :type original: TreeNode
        :type cloned: TreeNode
        :type target: TreeNode
        :rtype: TreeNode
        """
        if original.val==target:
            return cloned
        
        queue1=[original]
        queue2=[cloned]
        
        while len(queue1)!=0:
            cur_org=queue1.pop(0)
            cur_clo=queue2.pop(0)
            
            if cur_org==target:
                return cur_clo
            if cur_org.left:
                queue1.append(cur_org.left)
                queue2.append(cur_clo.left)
            if cur_org.right:
                queue1.append(cur_org.right)
                queue2.append(cur_clo.right)

target是一个节点，而不是一个数值

在这里插入图片描述

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def listOfDepth(self, tree):
        """
        :type tree: TreeNode
        :rtype: List[ListNode]
        """
        if tree is None:
            return []
        queue=[tree]
        res=[]
        while len(queue)!=0:
            size=len(queue)
            head_node=ListNode(0)
            cur_node=head_node
            while size>=1:
                cur_head=queue.pop(0)
                cur_node.next=ListNode(cur_head.val)
                cur_node=cur_node.next
                if cur_head.left:
                    queue.append(cur_head.left)
                if cur_head.right:
                    queue.append(cur_head.right)
                size-=1
            res.append(head_node.next)
        return res

在这里插入图片描述

# Definition for a
# binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def findBottomLeftValue(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if root is None:
            return
        queue=[]
        queue.append(root)
        res=[]
        while len(queue)!=0:
            size=len(queue)
            cur_res=[]
            while size>=1:
                cur_head=queue.pop(0)
                cur_res.append(cur_head.val)
                if cur_head.left:
                    queue.append(cur_head.left)
                if cur_head.right:
                    queue.append(cur_head.right)
                size-=1
            res.append(cur_res)
        return res[-1][0]

在这里插入图片描述

"""
# Definition for a Node.
class Node(object):
    def __init__(self, val=0, left=None, right=None, next=None):
        self.val = val
        self.left = left
        self.right = right
        self.next = next
"""

class Solution(object):
    def connect(self, root):
        """
        :type root: Node
        :rtype: Node
        """
        if root is None:
            return None
        queue=[]
        queue.append(root)
        
        while len(queue)!=0:
            size=len(queue)
            while size>=1:
                cur_head=queue.pop(0)
                if cur_head.left:
                    queue.append(cur_head.left)
                if cur_head.right:
                    queue.append(cur_head.right)
                if size!=1:
                    cur_head.next=queue[0]
                size-=1
        return root

同一个深度中，最后一个节点的next为NULL，否则横向指，其指向就在队列中的第一个节点

qq_45692660
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
cpp-剑指Offer算法面试题目总结CC实现
08-16
《C++剑指Offer算法面试题目总结：CC++实现》 在编程面试中，C++与C语言常常是考察的重点，因为它们提供了底层控制和高效性能。本资料集以"剑指Offer"系列为基础，结合C++语言特性，对一系列经典的算法面试题目进行...
《剑指Offer》刷题笔记——面试题32-II. 从上到下打印二叉树II
12-22
《剑指Offer》是许多程序员在准备面试时的重要参考资料，其中包含了各种经典的编程问题，旨在提升面试者在算法和数据结构方面的技能。本题“面试题32-II. 从上到下打印二叉树II”是一道关于二叉树层次遍历的问题，...
LeetCode102 二叉树的层序遍历 & 剑指Offer 32 - II 从上到下打印二叉树 II
10-04 127
LeetCode102 二叉树的层序遍历题目解题解题一：深度优先搜索 DFS解题二：广度优先搜索 BFS 题目 解题 参考：LeetCode《程序员面试金典》面试题 04.03. 特定深度节点链表，区别是这题是用 array of array 存储，而前者是用 array of linkedlist 存储。 解题一：深度优先搜索 DFS // javascript var levelOrder = function(root) { const res = new Array(); find
【LeetCode 程序员面试金典（第 6 版）】第1-4章题目 01.01 ~ 04.10
lzs_lazy
12-18 2945
剑指 offer 面试题 01.01. 判定字符是否唯一 实现一个算法，确定一个字符串 s 的所有字符是否全都不同。 思路 因为题目并没有明确说明是否为 ‘a’-‘z’，所以这里直接暴力枚举进行判断。 如果能够知道输入的字符串大小，则可以使用位运算来进行标记是否出现过。 //1. 暴力枚举判定 class Solution { public: bool isUnique(string astr) { for(int i = 0; i < astr.size(); ++i).
leetcode -- 树 --编程
认真学代码的shell
11-17 154
110. 平衡二叉树
LeetCode-树(解题技巧总结一)
qq_41605114的博客
04-27 809
递归，但是有细节，就是vector的使用，前闭后开。细节非常重要 面试题07. 重建二叉树https://leetcode-cn.com/problems/zhong-jian-er-cha-shu-lcof/ class Solution { public: TreeNode* buildTree(vector<int>& preorder, vector&...
LeetCode-题目详解（四）：二叉树（Tree）【遍历方式（前序、中序、后序、层序）、属性（对称、深度、平衡、路径）、修改与构造（翻转、合并）、公共祖先问题、二叉树之间的关系（相同、子树）】
u013250861的博客
05-13 1462
给你二叉树的根节点 root ，返回它节点值的 前序 遍历。示例 1： 示例 2： 示例 3： 示例 4： 示例 5： 提示：进阶：递归算法很简单，你可以通过迭代算法完成吗？递归方法： 94-二叉树的中序遍历 给定一个二叉树的根节点 root ，返回它的 中序 遍历。示例 1： 示例 2： 示例 3： 示例 4： 示例 5： 提示：进阶: 递归算法很简单，你可以通过迭代算法完成吗？ 145-二叉树的后序遍历 给定一个二叉树，返回它的 后序 遍历。示例: 进阶: 递归算法很简单，你可以通过迭代算
二叉树DFS、BFS
nameofcsdn的博客
01-30 1091
。。
《程序员面试金典》解题目录（更新完毕）
Michael是个半路程序员
02-14 5570
题目来源于LeetCode上的《程序员面试金典》，这里做一个目录方便大家查找。另外有本人的LeetCode解题目录、《剑指Offer》解题目录可点击链接查看。
LeetCode专题 ——《程序员面试金典》
aift的专栏
02-14 1337
文章目录 下面只给出答案，具体题目请参考：LeetCode专题 ——《程序员面试金典》
【笔试】算法题目+数据结构 总结【每日更新..】
7zwang的博客
09-15 329
算法大汇总 -- ROOT根目录
剑指Offer-V1.pdf
12-12
《剑指Offer》是一本专注于算法和数据结构的书籍，特别针对面试和编程竞赛中的常见问题进行了深入解析。V1版本仅提供了Java语言的解决方案。书中涵盖了大量编程面试中经常遇到的问题，旨在提升读者在算法设计、实现...
剑指offer（java版）----牛客.zip
09-20
《剑指Offer》是经典的一本面试准备书籍，主要针对计算机科学与技术领域的求职者，尤其是对Java开发者具有很高的参考价值。这本书源自牛客网，一个专注于编程技能测试和在线编程竞赛的平台，旨在帮助求职者提升编程...
15-puzzle-solver:Java接口和基于BFS的树求解器
05-21
标题中的“15-puzzle-solver”指的是一个Java程序，专门设计用来解决15拼图游戏。15拼图是一个经典的智力游戏，通常由15个数字和一个空位组成，玩家需要通过滑动数字方块，使得它们按照1到15的顺序排列。这个程序...
力扣220题详解：存在重复元素 III 的多种解法与复杂度分析
10年数据\经营分析经验，现任大厂数据分析负责人
08-21 649
本文详细解读了力扣第220题“存在重复元素 III”，通过使用滑动窗口 + 桶排序和滑动窗口 + 有序集合两种方法高效地解决了这一问题，并提供了详细的解释和模拟面试问答。希望读者通过本文的学习，能够在力扣刷题的过程中更加得心应手。
leetcode242:有效的字母异位词
最新发布
qq_55630615的博客
08-23 150
hashmap法,正常应该用数组实现即可。中每个字符出现的次数都相同，则称。，编写一个函数来判断。
一起学习LeetCode热题100道（48/100）
weixin_53224223的博客
08-20 515
7.注意：虽然代码中包含了回溯部分（即减少当前路径和的计数并从prefixSums中删除它），但在本问题中，由于树是无环的，并且我们不需要精确跟踪每条路径，因此这部分是多余的。输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22。输入：root = [10,5,-3,3,2,null,11,3,-2,null,1], targetSum = 8。1.这是主函数，接收根节点和目标和作为参数，并返回满足条件的路径数量。
Leetcode 219. 存在重复元素 II⭐️
铁马冰河入梦来
08-20 374
哈希表解决存在重复元素二问题
微软数据结构与算法面试题第21-40题答案解析
"微软等公司的数据结构和算法面试100题系列，提供了第21-40题的答案，旨在帮助求职者准备面试。作者强调了尊重原作者和思考的重要性，并提供了其他题目的链接和资源下载地址。" 这部分内容主要涉及的是在微软等顶级...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值