Leetcode刷题记录-图论BFS、DFS&二叉树Ⅰ

最新推荐文章于 2024-07-04 10:15:20 发布
最新推荐文章于 2024-07-04 10:15:20 发布
阅读量194 收藏 1
点赞数
文章标签： leetcode 深度优先 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46570364/article/details/129592533
版权

Leetcode刷题记录-图论BFS、DFS&二叉树-基础

一、二叉树节点定义代码实现：

class TreeNode:
    def __init__(self, value， left = None, right = None):
        self.value = value
        self.left = left
        self.right = right

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

二、种类：

满二叉树: 节点数 2^k - 1
完全二叉树：除了底层以外其他层都是满的，底层从左到右必须连续，共h层，则第h层包含1~2^(h - 1)个节点
在这里插入图片描述

二叉搜索树：有序树，左小右大，便于搜索，O（logn）
平衡二叉搜索树：空树或左右子树高度绝对值差不超过1，O（logn）

三、存储方式：

链式：链表
线式：数组，左右孩子：2i+1，2i+2

四、遍历及代码实现：

(同图论)
步骤：
① 确定递归函数的参数和返回值
② 确定终止条件
③ 确定单层递归的逻辑

⭐⭐二叉树代码完整实现：构建、传入

class TreeNode:
    def __init__(self, val = 0, left = None, right = None):
        self.val = val
        self.left = left
        self.right = right


# 根据数组构建二叉树

def construct_binary_tree(nums: []) -> TreeNode:
    if not nums: 
        return None
    # 用于存放构建好的节点
    root = TreeNode(-1)
    Tree = []
    # 将数组元素全部转化为树节点
    for i in range(len(nums)):
        if nums[i]!= -1:
            node = TreeNode(nums[i])
        else:
            node = None
        Tree.append(node)
        if i == 0:
            root = node
    # 直接判断2*i+2<len(Tree)会漏掉2*i+1=len(Tree)-1的情况
    for i in range(len(Tree)):
        if Tree[i] and 2 * i + 1 < len(Tree):
            Tree[i].left = Tree[2 * i + 1]
            if 2 * i + 2 < len(Tree):
                Tree[i].right = Tree[2 * i + 2]
    return root



# 算法:中序遍历二叉树

class Solution:
    def __init__(self):
        self.T = []
    def inorder(self, root: TreeNode) -> []:
        if not root:
            return 
        self.inorder(root.left)
        self.T.append(root.val)
        self.inorder(root.right)
        return self.T



# 验证创建二叉树的有效性,二叉排序树的中序遍历应为顺序排列

test_tree = [3, 1, 5, -1, 2, 4 ,6]
root = construct_binary_tree(test_tree)
A = Solution()
print(A.inorder(root))

⭐深度优先搜索DFS（BreadthFirstSearch）：

前中后序遍历(栈：递归、迭代)：

在这里插入图片描述
步骤：
① 确定递归函数的参数和返回值 ：存放遍历过的节点
② 确定终止条件：为空就返回
③ 确定单层递归的逻辑：取节点的顺序，根据遍历顺序确定

1.前序遍历（144. 二叉树的前序遍历）：
# 递归：
class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        ans = []

        def traversal(root):
            if root == None: return
            ans.append(root.val)
            traversal(root.left)
            traversal(root.right)

        traversal(root)
        return ans

# 迭代：进栈先放右孩子后放左孩子
class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        if root == None: return []
        stack = [root]
        ans = []
        while stack:
            node = stack.pop()
            ans.append(node.val)
            if node.right: stack.append(node.right)
            if node.left: stack.append(node.left)
        return ans
2.中序遍历（94.二叉树的中序遍历）：
#  递归：
class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        ans = []

        def traversal(root):
            if root == None: return
            traversal(root.left)
            ans.append(root.val)
            traversal(root.right)
        
        traversal(root)
        return ans

⭐访问顺序和处理顺序不一致，借助一个指针来访问节点，栈用于处理

#  迭代：
class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        if root == None: return []
        stack, ans = [], []
        cur = root
        while cur or stack:
            # 先迭代访问最底层的左子树节点
            if cur:
                stack.append(cur)
                cur = cur.left
            # 到达最底左节点后，开始处理，入数组
            else:
                cur = stack.pop()
                ans.append(cur.val)
                cur = cur.right
        return ans
3.后序遍历（145.二叉树的后序遍历）：
# 递归：
class Solution:
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        ans = []
        def traversal(root):
            if root == None : return
            traversal(root.left)
            traversal(root.right)
            ans.append(root.val)

        traversal(root)
        return ans

# 迭代：出栈顺序：中右左，然后将数组翻转，得到左右中
class Solution:
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        if root == None : return []
        stack = [root]
        ans = []
        while stack:
            node = stack.pop()
            ans.append(node.val)
            if node.left: stack.append(node.left)
            if node.right: stack.append(node.right)

        return ans[::-1]
4.前中后序统一迭代法：

入栈顺序完全按照遍历顺序的逆序

将需要处理的节点直接加入到栈中，中节点后面放入一个空节点， 只有空节点弹出的时候，才将下一个节点放进结果集
视频讲的很清楚：https://www.bilibili.com/video/BV1Zf4y1a77g/?spm_id_from=pageDriver&vd_source=0a8fa6e199761d9bcbc5d45a71832fed

中序遍历：
先访问所有节点并入栈，在中节点后添加一个None作为标记，只有遇到None才将节点放入结果

class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        ans, stack = [], []
        if root: stack.append(root)
        while stack:
            node = stack.pop()
            # 先进右孩子后进左孩子
            if node != None:
                if node.right:     # 空节点不入栈
                    stack.append(node.right)
                
                stack.append(node)
                stack.append(None) # 访问了中节点，存入栈后添加一个空为标记

                if node.left:      # 空节点不入栈
                    stack.append(node.left)
            
            else:
                node = stack.pop()
                ans.append(node.val)
        return ans

前序遍历：

class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        ans, stack = [], []
        if root: stack.append(root)
        while stack:
            node = stack.pop()
            # 先进右孩子后进左孩子
            if node:
                if node.right:     # 空节点不入栈
                    stack.append(node.right)
                if node.left:      # 空节点不入栈
                    stack.append(node.left)
                
                stack.append(node)
                stack.append(None) # 访问了中节点，存入栈后添加一个空为标记
            
            else:
                node = stack.pop()
                ans.append(node.val)
        return ans

后序遍历：

class Solution:
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        ans, stack = [], []
        if root: stack.append(root)
        while stack:
            node = stack.pop()
            if node:
                stack.append(node)
                stack.append(None)

                if node.right:
                    stack.append(node.right)
                if node.left:
                    stack.append(node.left)

            else:
                node = stack.pop()
                ans.append(node.val)
 
        return ans

⭐广度优先搜索BFS（BreadthFirstSearch）：

队列，迭代，

层序遍历及变形x10道：

102.层序遍历Ⅰ

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。
在这里插入图片描述

# deque来自collections模块，不在力扣平台时，需要手动写入
# deque相比list的好处是，list的pop(0)是O(n)复杂度，deque的popleft()是O(1)复杂度
from collections import deque
class Solution:
    def levelOrderBottom(self, root: Optional[TreeNode]) -> List[List[int]]:
        # 结果集
        res = []
        if not root:return res
        que = deque([root])
        while que:
            # 每一层的遍历结果
            ans = []
            for i in range(len(que)):
                cur = que.popleft()
                ans.append(cur.val)
                if cur.left: que.append(cur.left)
                if cur.right: que.append(cur.right)
            res.append(ans)
        res.reverse()
        return res
107.层序遍历Ⅱ

给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）
在这里插入图片描述

相对于上一道，把结果集反转就可以了

from collections import deque
class Solution:
    def levelOrderBottom(self, root: Optional[TreeNode]) -> List[List[int]]:
        res = []
        if not root:return res
        que = deque([root])
        while que:
            ans = []
            for i in range(len(que)):
                cur = que.popleft()
                ans.append(cur.val)
                if cur.left: que.append(cur.left)
                if cur.right: que.append(cur.right)
            res.append(ans)
        res.reverse()
        return res
199. 二叉树的右视图

给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
在这里插入图片描述

from collections import deque
class Solution:
    def rightSideView(self, root: Optional[TreeNode]) -> List[int]:
        if not root : return []
        que = deque([root])
        ans = []
        while que:
        	# 每次只取最后一个
            cur = que[-1]
            ans.append(cur.val)
            for i in range(len(que)):
                cur = que.popleft()
                if cur.left: que.append(cur.left)
                if cur.right: que.append(cur.right)
        return ans
637. 二叉树的层平均值

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

from collections import deque
class Solution:
    def averageOfLevels(self, root: Optional[TreeNode]) -> List[float]:
        res = []
        if not root:return root
        que = deque([root])
        while que:
            size = len(que)
            sum = 0
            for i in range(size):
                cur = que.popleft()
                sum += cur.val
                if cur.left:que.append(cur.left)
                if cur.right:que.append(cur.right)
            res.append(sum / size)
        return res
429.N叉树的层序遍历

给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。
在这里插入图片描述

"""
# Definition for a Node.
class Node:
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children
"""
from collections import deque
class Solution:
    def levelOrder(self, root: 'Node') -> List[List[int]]:
        if not root : return root
        res = []
        que = deque([root])
        while que:
            ans = []
            for i in range(len(que)):
                cur = que.popleft()
                ans.append(cur.val)
                if cur.children:
                    que.extend(cur.children)
            res.append(ans)
        return res
515. 在每个树行中找最大值

给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。
给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。

from collections import deque
class Solution:
    def largestValues(self, root: Optional[TreeNode]) -> List[int]:
        res = []
        if not root:return res
        
        que = deque([root])
        while que:
            ans = []
            for i in range(len(que)):
                cur = que.popleft()
                ans.append(cur.val)
                if cur.left:que.append(cur.left)
                if cur.right:que.append(cur.right)
            res.append(max(ans))
        return res
116. 填充每个节点的下一个右侧节点指针

**给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。**二叉树定义如下：
在这里插入图片描述
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。初始状态下，所有 next 指针都被设置为 NULL。
在这里插入图片描述

# 层序遍历
class Solution:
    def connect(self, root: 'Optional[Node]') -> 'Optional[Node]':
        if not root: return None
        que = [root]
        while que:
            n = len(que)
            for i in range(n):
                # 记录每层第一个节点
                cur = que.pop(0)
                if cur.left: que.append(cur.left)
                if cur.right: que.append(cur.right)
                if i == n - 1:
                    break
                cur.next = que[0]
        return root

# 链表
class Solution:
    def connect(self, root: 'Optional[Node]') -> 'Optional[Node]':
        # 用first遍历每一层
        first = root
        while first:
            cur = first
            # cur 遍历每一层的节点
            while cur:
                if cur.left:cur.left.next = cur.right
                if cur.right and cur.next :cur.right.next = cur.next.left
                cur = cur.next
            # 移动到下一层
            first = first.left
        return root
117. 填充每个节点的下一个右侧节点指针 II

给定一个二叉树，填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL 。初始状态下，所有 next 指针都被设置为 NULL 。
在这里插入图片描述

class Solution:
    def connect(self, root: 'Node') -> 'Node':
        if not root : return None
        que = [root]
        while que:
            n = len(que)
            tail = None
            for i in range(n):
                cur = que.pop(0)
                # 让尾节点指向当前节点
                if tail:tail.next = cur
                # 让当前节点成为尾节点
                tail = cur
                if cur.left:que.append(cur.left)
                if cur.right:que.append(cur.right)
        return root
104. 二叉树的最大深度

给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。说明: 叶子节点是指没有子节点的节点。
在这里插入图片描述

class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        if not root:return 0
        que = [root]
        depth = 0
        while que:
            ans = []
            for i in range(len(que)):
                cur = que.pop(0)
                ans.append(cur.val)
                if cur.left:que.append(cur.left)
                if cur.right:que.append(cur.right)
            depth += 1
        return depth
111. 二叉树的最小深度

给定一个二叉树，找出其最小深度。最小深度是从根节点到最近叶子节点的最短路径上的节点数量。说明：叶子节点是指没有子节点的节点。

在这里插入图片描述

class Solution:
    def minDepth(self, root: Optional[TreeNode]) -> int:
        if not root: return 0
        que = [(root,1)]
        while que:
            cur,depth = que.pop(0)
            # 左右节点都为空则返回答案
            if cur.left == None and cur.right == None:return depth
            if cur.left : que.append((cur.left,depth + 1))
            if cur.right : que.append((cur.right,depth + 1))
        return 0
樱桃小完犊⁡⁡子
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
谷歌师兄的leetcode刷题笔记-shorthand3:速记3
06-30
【谷歌师兄的LeetCode刷题笔记 - shorthand3:速记3】是一份针对程序员提升算法能力和准备面试的重要资源。这份笔记由一位在谷歌工作的资深工程师编写，旨在帮助读者快速掌握LeetCode上的经典算法问题，从而提升编程...
leetcode-DFS-2:DFS-2
06-29
标题 "leetcode-DFS-2:DFS-2" 暗示了这个压缩包可能包含了关于LeetCode中的深度优先搜索（DFS）算法的第二部分题目和解决方案。DFS是一种常用的图论和树形结构遍历方法，它按照“深入优先”的原则访问节点。在编程...
leetcode刷题之BFS专题
Daisy_Wang777的博客
11-17 1507
参考资料： 广度优先算法 BFS（即广度优先搜索）是图论中一种常见的算法，常用于二叉树数据结构，能够实现对树或图中每个节点的遍历。本文将从leetcode的一些例题中详尽介绍这种算法的实现原理和在实际问题中的应用方式。 一、概念 原理：如其名字，BFS是从根节点开始，沿着树的宽度遍历树的节点。如果所有节点均被访问，则算法终止。 结束条件：树或图中的所有节点都已被遍历。 如果还存在未被遍历的节点，则选择其中一个作为源节点并重复以上过程，整个过程反复进行知道所有节点都被遍历为止。 二、实现方法（利用栈） B
leetcode刷题笔记： 图论 · 从入门到精通---刷通图论（2）bfs
weixin_43897646的博客
10-25 74
一个简单的想法就是把target数组当作根节点，随后搜索所有的深度为K的字节点，观察原树与把target数组的区别，关键在于需要把从原来root的到target 的路径全部逆折， 那么可以想到，从target节点开始，dfs k 次。每个单词都是一个节点， 可以转换表明这两个节点之间存在路径， 开始结束单词以及过度单词之间构成了一张图， 从开始节点bfs， 访问到结束单词说明得到路径。只有两座岛就太简单了， 先随便遍历到一个岛， 然后所有节点呈轮次向外扩张，在遍历到陆地时说明连接到水了。
leetcode刷题记录：hot100强化训练2：二叉树+图论
weixin_39548654的博客
06-15 599
递归就不写了，写一下迭代法顺便再写一下前序和后序的迭代法。
leetcode刷题周记-2021.11.14~2021.11.20
zombotany的博客
11-20 247
leetcode刷题周记-2021.11.14~2021.11.202021.11.14-键值映射题面文字分析代码2021.11.15-灯泡开关题面文字分析代码2021.11.16-完美矩形题面文字分析代码2021.11.17-最大单词长度乘积题面文字分析代码2021.11.18-二叉树的坡度题面文字分析代码2021.11.19-整数替换题面文字分析代码2021.11.20-最长和谐子序列题面文字分析代码自我总结 2021.11.14-键值映射 题面 实现一个 MapSum 类，支持两个方法，insert
leetcode(8) | BFS && DFS
向着星辰大海
03-09 420
广度优先搜索（BFS） 总结： 适用场景 代码模板 具体题目 Word Ladder（mid） Word Ladder II（hard） Surrounded Regions 深度优先算法 总结 适用场景 思考的步骤 代码模板 深搜与回溯法的区别 深搜与递归的区别 具体题目 Additive Number（hard) Palindrome Partition...
leetcode刷题（javaScript）——BFS广度优先遍历相关场景题总结
涵盖了计算机专业基础知识、数学建模相关实践、复杂网络论文研究、LeetCode算法刷题经验、C语言开发经验、前端Vue、React框架开发实战相关知识
03-21 709
广度优先搜索（BFS）在JavaScript编程中有许多实际应用场景，特别是在解决图、树等数据结构相关问题时非常常见。在JavaScript中，可以使用队列来实现广度优先搜索算法。通过将起始节点加入队列，然后迭代地将节点的邻居节点加入队列，直到队列为空为止。这样可以逐层地遍历图或树结构，找到目标节点或满足条件的节点。在实际编程中，需要注意避免重复访问节点、处理环路等问题，确保算法的正确性和效率。上题：可以按照博主的列的题目顺序依次练习，二叉树的简单，图论的难，但是做题技巧比较固定。
【leetcode】BFS DFS （图论）
myaijarvis notebook
12-21 319
总结 套路：图论算法基础（修订版）_ labuladong DFS 应用：二叉树搜索，图搜索 回溯法=DFS+剪枝 DFS：每一条路径走完再回溯 BFS … //938.二叉搜索树的范围和 public int rangeSumBST(TreeNode root, int low, int high) { if(root==null) return 0; int result=0; Queue<TreeNode> queue=new Lin
leetcode2389--感染二叉树需要的总时间
bdn_nbd的博客
04-25 228
leetcode2389--感染二叉树需要的总时间
leetcode刷题之DFS专题
Daisy_Wang777的博客
11-15 676
参考资料： 深度优先搜索—wikipedia 210课程表II—leetcode官方解答 DFS深度优先搜索算法 DFS（即深度优先搜索）是图论中一种常见的算法，常用于二叉树数据结构，能够实现对树或图中每个节点的遍历。本文将从leetcode的一些例题中详尽介绍这种算法的实现原理和在实际问题中的应用方式。 一、概念 原理：如其名字，DFS会尽可能深地搜索树的分支。当节点v所在边都已被探寻过，搜索将回溯到发现节点v的那条边的起始节点。 结束条件：树或图中的所有节点都已被遍历。 如果还存在未被遍历的节点，则选
谷歌师兄的leetcode刷题笔记-pw2163:Web编程工作文件夹2016年8月至12月
06-30
《谷歌师兄的LeetCode刷题笔记——pw2163:Web编程工作文件夹2016年8月至12月》是一份珍贵的学习资源，它由一位在谷歌工作的师兄整理，涵盖了他在LeetCode上刷题的过程和心得，旨在帮助学习者提升编程技能，特别是...
leetcode跳跃-leetcode:记录Leetcode刷题思路
06-30
平台上的题目按照难度分为简单、中等和困难三个级别，涵盖字符串处理、数组操作、链表、二叉树、图论等多个领域。每道题目都有完善的测试用例，用户提交代码后可以立即得到运行结果和时间复杂度分析。 二、“跳跃”...
leetcode题库-sky-leetcode:leetcode刷题
06-29
2. **搜索算法**：深度优先搜索（DFS）、广度优先搜索（BFS）、二分查找、回溯法、贪心算法等。 3. **数据结构**：数组、链表、栈、队列、哈希表、树（二叉树、平衡树、红黑树等）、图等。 4. **动态规划**：经典...
【CT】LeetCode手撕—94. 二叉树的中序遍历
weixin_44382896的博客
07-02 342
思路1：使用递归的方式中序遍历。
LeetCode热题100刷题5：189. 轮转数组、238. 除自身以外数组的乘积、41. 缺失的第一个正数
cir_sky的博客
07-03 210
数组篇，今天的三道题略简单
力扣（2024.07.01）
m0_52507142的博客
07-01 690
随机决定是要「交换两个子字符串」还是要「保持这两个子字符串的顺序不变」。即，在执行这一步骤之后，个非负整数，用来表示柱状图中各个柱子的高度。在一个随机下标处将字符串分割成两个非空的子字符串。返回的解集中，子集可以按任意顺序排列。注意：最终，合并后数组不应由函数返回，而是存储在数组。，其中可能包含重复元素，请你返回该数组所有可能的。求在该柱状图中，能够勾勒出来的矩形的最大面积。栈，数组，动态规划，矩阵，单调栈（目前不会）中，使合并后的数组同样按非递减顺序排列。如果字符串的长度为 1 ，算法停止。
刷leetcode中常用且有效的方法总结
最新发布
路有瑶台的博客
07-04 239
刷题的时候经常会因为不知道一个方法多写很多行代码，既然有trick为何不用！你问我眼中为何常含泪水，因为我忘记方法忘的深沉。join（）是 Python 中的一个字符串方法，它用于将序列（如列表、元组、集合等，但集合需要首先转换为列表或其他有序序列，因为集合是无序的）中的元素以指定的字符连接生成一个新的字符串。方法来更新计数器中的计数。可以传递另一个可迭代对象或者另一个。提供了一个快速简单的方式来统计哈希对象在集合中出现的次数。
AcWing_Tree题解1
08-04
"AcWing夏季LeetCode刷题活动介绍及树相关题目解析" 在AcWing的暑期LeetCode刷题活动中，参与者将面临一系列精选的高频率算法题目，总计80道，涵盖了各种数据结构和算法主题。活动分为8周进行，每周会有10道题目，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值