【leetcode刷题之路】面试经典150题(5)——二叉树+二叉树层次遍历+二叉搜索树

文章目录

      • 9 二叉树
        • 9.1 【递归】二叉树的最大深度
        • 9.2 【递归】相同的树
        • 9.3 【递归】翻转二叉树
        • 9.4 【递归】对称二叉树
        • 9.5 【递归】从前序与中序遍历序列构造二叉树
        • 9.6 【递归】从中序与后序遍历序列构造二叉树
        • 9.7 【BFS】填充每个节点的下一个右侧节点指针 II
        • 9.8 【递归】二叉树展开为链表
        • 9.9 【DFS】路径总和
        • 9.10 【DFS】求根节点到叶节点数字之和
        • 9.11 【BFS】【动态规划】二叉树中的最大路径和
        • 9.12 【BFS】二叉搜索树迭代器
        • 9.13 【BFS】完全二叉树的节点个数
        • 9.14 【递归】二叉树的最近公共祖先
      • 10 二叉树层次遍历
        • 10.1 【DFS】二叉树的右视图
        • 10.2 【BFS】二叉树的层平均值
        • 10.3 【BFS】二叉树的层序遍历
        • 10.4 【BFS】二叉树的锯齿形层序遍历
      • 11 二叉搜索树
        • 11.1 【BFS】二叉搜索树的最小绝对差
        • 11.2 【BFS】二叉搜索树中第K小的元素
        • 11.3 【BFS】【递归】验证二叉搜索树

9 二叉树

9.1 【递归】二叉树的最大深度

题目地址:https://leetcode.cn/problems/maximum-depth-of-binary-tree/description/?envType=study-plan-v2&envId=top-interview-150

  递归找左子树和右子树的最大深度,就是二叉树的最大深度。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = rightclass Solution:def maxDepth(self, root: Optional[TreeNode]) -> int:if not root:return 0else:left_depth = self.maxDepth(root.left)right_depth = self.maxDepth(root.right)return max(left_depth, right_depth) + 1
9.2 【递归】相同的树

题目地址:https://leetcode.cn/problems/same-tree/description/?envType=study-plan-v2&envId=top-interview-150

  左右子树相同的标志是左右子树都存在,且根节点的值相等,按照这一标准递归遍历树的左右子树。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = rightclass Solution:def isSameTree(self, p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:if (not p and q) or (p and not q):return Falseelif not p and not q:return Trueelif p.val != q.val:return Falseelse:return self.isSameTree(p.left,q.left) and self.isSameTree(p.right,q.right)
9.3 【递归】翻转二叉树

题目地址:https://leetcode.cn/problems/invert-binary-tree/description/?envType=study-plan-v2&envId=top-interview-150

  详见代码。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = rightclass Solution:def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:if not root:returnroot.left,root.right = self.invertTree(root.right),self.invertTree(root.left)return root
9.4 【递归】对称二叉树

题目地址:https://leetcode.cn/problems/symmetric-tree/description/?envType=study-plan-v2&envId=top-interview-150

  详见代码。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:def isSymmetric(self, root: Optional[TreeNode]) -> bool:if not root:return Truereturn self.is_symmetric(root.left, root.right)def is_symmetric(self, left: TreeNode, right: TreeNode):if not left and not right:return Trueelif (not left or not right) or (left.val != right.val):return Falseelse:return self.is_symmetric(left.left, right.right) and self.is_symmetric(left.right, right.left)
9.5 【递归】从前序与中序遍历序列构造二叉树

题目地址:https://leetcode.cn/problems/construct-binary-tree-from-preorder-and-inorder-traversal/description/?envType=study-plan-v2&envId=top-interview-150

  详见代码,找到根节点的位置进行递归。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = rightclass Solution:def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:if not preorder or not inorder:returnroot = TreeNode(preorder[0])idx = inorder.index(preorder[0])root.left = self.buildTree(preorder[1:1+idx],inorder[:idx])root.right = self.buildTree(preorder[1+idx:],inorder[idx+1:])return root
9.6 【递归】从中序与后序遍历序列构造二叉树

题目地址:https://leetcode.cn/problems/construct-binary-tree-from-inorder-and-postorder-traversal/description/?envType=study-plan-v2&envId=top-interview-150

  详见代码,找到根节点的位置进行递归。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:def buildTree(self, inorder: List[int], postorder: List[int]) -> Optional[TreeNode]:if not inorder or not postorder:returnroot = TreeNode(postorder[-1])idx = inorder.index(postorder[-1])root.left = self.buildTree(inorder[:idx],postorder[:idx])root.right = self.buildTree(inorder[1+idx:],postorder[idx:-1])return root
9.7 【BFS】填充每个节点的下一个右侧节点指针 II

题目地址:https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii/description/?envType=study-plan-v2&envId=top-interview-150

  其实就是找出每一层的所有结点就行了,而每一层的左右节点就是下一层的结点,按照这个规则进行BFS。

"""
# Definition for a Node.
class Node:def __init__(self, val: int = 0, left: 'Node' = None, right: 'Node' = None, next: 'Node' = None):self.val = valself.left = leftself.right = rightself.next = next
"""class Solution:def connect(self, root: 'Node') -> 'Node':if not root:return rootdef BFS(curLayer):nextLayer = []for node in curLayer:if node.left:nextLayer.append(node.left)if node.right:nextLayer.append(node.right)if len(nextLayer) > 1:for i in range(0,len(nextLayer)-1):nextLayer[i].next = nextLayer[i+1]if nextLayer:BFS(nextLayer)BFS([root])return root
9.8 【递归】二叉树展开为链表

题目地址:https://leetcode.cn/problems/flatten-binary-tree-to-linked-list/description/?envType=study-plan-v2&envId=top-interview-150

  二叉树的先序遍历的变形。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = rightclass Solution:def flatten(self, root: Optional[TreeNode]) -> None:"""Do not return anything, modify root in-place instead."""while root:if root.left:cur_left = root.leftwhile cur_left.right:cur_left = cur_left.rightcur_left.right = root.rightroot.right = root.leftroot.left = Noneroot = root.right
9.9 【DFS】路径总和

题目地址:https://leetcode.cn/problems/path-sum/description/?envType=study-plan-v2&envId=top-interview-150

  详见代码。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = rightclass Solution:def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:if not root:return Falseelif not root.left and not root.right and targetSum == root.val:return Trueelse:return self.hasPathSum(root.left,targetSum-root.val) or self.hasPathSum(root.right,targetSum-root.val)
9.10 【DFS】求根节点到叶节点数字之和

题目地址:https://leetcode.cn/problems/sum-root-to-leaf-numbers/description/?envType=study-plan-v2&envId=top-interview-150

  DFS,分别从根节点计算每一条路径的数字,然后求和,这里要注意判断条件,当一个节点没有左节点和右节点时,说明这条路径到底了,这是要把目前的数字加入到 a n s ans ans中。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = rightclass Solution:def sumNumbers(self, root: Optional[TreeNode]) -> int:ans = 0def sub_sum(root,cur_num):nonlocal ansif not root.left and not root.right:ans += cur_num*10 + root.valreturncur_num = cur_num*10 + root.valif root.left:sub_sum(root.left,cur_num)if root.right:sub_sum(root.right,cur_num)sub_sum(root,0)return ans
9.11 【BFS】【动态规划】二叉树中的最大路径和

题目地址:https://leetcode.cn/problems/binary-tree-maximum-path-sum/description/?envType=study-plan-v2&envId=top-interview-150

  先找到每个节点下的最大路径和,再一步步从上往下遍历所有节点,如果遍历到某个节点的左子树或者右子树的最大和小于零,则这个子树可以不要,只需考虑另一个子树即可。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = rightclass Solution:def maxPathSum(self, root: Optional[TreeNode]) -> int:self.maxSum = -1001def BFS(root):if not root:return 0left_max = BFS(root.left)right_max = BFS(root.right)self.maxSum = max(self.maxSum, left_max + right_max + root.val)return max(0,max(left_max,right_max) + root.val)BFS(root)return self.maxSum
9.12 【BFS】二叉搜索树迭代器

题目地址:https://leetcode.cn/problems/binary-search-tree-iterator/description/?envType=study-plan-v2&envId=top-interview-150

  先对二叉搜索树中的元素进行排序,然后按照题目要求构造函数即可。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = rightclass BSTIterator:def __init__(self, root: Optional[TreeNode]):self.root = rootself.num = []self.idx = 0self.len = 0def BFS(root):if not root:returnself.num.append(root.val)self.len += 1BFS(root.left)BFS(root.right)BFS(root)self.num.sort()def next(self) -> int:if self.idx < self.len:self.idx += 1return self.num[self.idx-1]else:return -1def hasNext(self) -> bool:if self.idx < self.len:return Trueelse:return False# Your BSTIterator object will be instantiated and called as such:
# obj = BSTIterator(root)
# param_1 = obj.next()
# param_2 = obj.hasNext()
9.13 【BFS】完全二叉树的节点个数

题目地址:https://leetcode.cn/problems/count-complete-tree-nodes/description/?envType=study-plan-v2&envId=top-interview-150

  详见代码。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = rightclass Solution:def countNodes(self, root: Optional[TreeNode]) -> int:self.ans = 0def BFS(root):if not root:returnself.ans += 1BFS(root.left)BFS(root.right)BFS(root)return self.ans
9.14 【递归】二叉树的最近公共祖先

题目地址:https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-tree/description/?envType=study-plan-v2&envId=top-interview-150

  如果 p p p q q q位于二叉树的同一侧,那么最近公共祖先要么是 p p p要么是 q q q,如果位于二叉树的两侧,那么最近公共祖先则是两者最深的那个 r o o t root root

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = Noneclass Solution:def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':if not root or root == p or root == q:return rootleft = self.lowestCommonAncestor(root.left,p,q)right = self.lowestCommonAncestor(root.right,p,q)if not left:return rightif not right:return leftreturn root

10 二叉树层次遍历

10.1 【DFS】二叉树的右视图

题目地址:https://leetcode.cn/problems/binary-tree-right-side-view/description/?envType=study-plan-v2&envId=top-interview-150

  深度优先遍历,每次都将二叉树每一层最右边的元素加入数组,同时设置 d e p t h depth depth来限制数组大小,保证数组中只有最右边的元素。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = rightclass Solution:def rightSideView(self, root: Optional[TreeNode]) -> List[int]:self.ans = []def DFS(root, depth):if not root:returnif len(self.ans) < depth:self.ans.append(root.val)DFS(root.right, depth+1)DFS(root.left, depth+1)DFS(root, 1)return self.ans
10.2 【BFS】二叉树的层平均值

题目地址:https://leetcode.cn/problems/average-of-levels-in-binary-tree/description/?envType=study-plan-v2&envId=top-interview-150

  详见代码。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = rightclass Solution:def averageOfLevels(self, root: Optional[TreeNode]) -> List[float]:ans = []node_list =  [root]if not root:return answhile node_list:cur_val = []nxt_list = []for node in node_list:cur_val.append(node.val)if node.left:nxt_list.append(node.left)if node.right:nxt_list.append(node.right)ans.append(sum(cur_val)/len(cur_val))node_list = nxt_listreturn ans
10.3 【BFS】二叉树的层序遍历

题目地址:https://leetcode.cn/problems/binary-tree-level-order-traversal/description/?envType=study-plan-v2&envId=top-interview-150

  详见代码。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = rightclass Solution:def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:ans = []cur_node = [root]if not root:return answhile cur_node:cur_val = []nxt_node = []for node in cur_node:cur_val.append(node.val)if node.left:nxt_node.append(node.left)if node.right:nxt_node.append(node.right)ans.append(cur_val)cur_node = nxt_nodereturn ans
10.4 【BFS】二叉树的锯齿形层序遍历

题目地址:https://leetcode.cn/problems/binary-tree-zigzag-level-order-traversal/description/?envType=study-plan-v2&envId=top-interview-150

  详见代码。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = rightclass Solution:def zigzagLevelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:ans = []cur_node = [root]flag = Trueif not root:return answhile cur_node:cur_val = []nxt_node = []for node in cur_node:cur_val.append(node.val)if node.left:nxt_node.append(node.left)if node.right:nxt_node.append(node.right)if flag:ans.append(cur_val)else:ans.append(cur_val[::-1])flag = not flagcur_node = nxt_nodereturn ans

11 二叉搜索树

11.1 【BFS】二叉搜索树的最小绝对差

题目地址:https://leetcode.cn/problems/minimum-absolute-difference-in-bst/description/?envType=study-plan-v2&envId=top-interview-150

  先遍历所有节点,然后排序,找出相邻元素差值最小的。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = rightclass Solution:def getMinimumDifference(self, root: Optional[TreeNode]) -> int:self.num = []def BFS(root):if not root:returnself.num.append(root.val)BFS(root.left)BFS(root.right)BFS(root)self.num.sort()ans = 100001for i in range(len(self.num)-1):ans = min(ans,self.num[i+1]-self.num[i])return ans
11.2 【BFS】二叉搜索树中第K小的元素

题目地址:https://leetcode.cn/problems/kth-smallest-element-in-a-bst/description/?envType=study-plan-v2&envId=top-interview-150

  对于二叉搜索树而言,中序遍历就是其从小到大的排序结果,记录访问到的第 k k k个元素即可。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = rightclass Solution:def kthSmallest(self, root: Optional[TreeNode], k: int) -> int:self.k = kself.ans = 0def BFS(root):if not root:returnBFS(root.left)self.k -= 1if self.k == 0:self.ans = root.valreturnBFS(root.right)BFS(root)return self.ans
11.3 【BFS】【递归】验证二叉搜索树

题目地址:https://leetcode.cn/problems/validate-binary-search-tree/description/?envType=study-plan-v2&envId=top-interview-150

  递归实现,首先要明白二叉搜索树的判定条件,一是左子树<root<右子树,二是下面的左子树的值要比当前结点小,而右子树的值要比当前结点大,也就是不能只在一个小的子树上满足这个条件,往上回溯几代之后这个条件要依然满足才行。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = rightclass Solution:def isValidBST(self, root: Optional[TreeNode]) -> bool:def is_Valid_BST(root, min_node, max_node):if not root:return Trueelse:if min_node and root.val <= min_node.val:return Falseif max_node and root.val >= max_node.val:return Falsereturn is_Valid_BST(root.left, min_node, root) and is_Valid_BST(root.right, root, max_node)return is_Valid_BST(root, None, None)

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/719736.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

代码随想录第二十七天 455.分发饼干 376.摆动序列 53.最大子序和 122.买卖股票的最佳时机II

LeetCode 455 分发饼干 题目描述 假设你是一位很棒的家长&#xff0c;想要给你的孩子们一些小饼干。但是&#xff0c;每个孩子最多只能给一块饼干。 对每个孩子 i&#xff0c;都有一个胃口值 g[i]&#xff0c;这是能让孩子们满足胃口的饼干的最小尺寸&#xff1b;并且每块饼…

2024全国护网行动HW行动招聘/收人!!!

2024全国护网行动HW行动招聘 溯蓉信创开始收人啦&#xff01;&#xff01;&#xff01;现在开始收录2024HW简历&#xff0c;感兴趣的小伙伴扫码二维码添加微信 我们签约后&#xff0c;入场即预付款3k&#xff0c;签约后我们会在HW之前对我们的人员进行HW培训&#xff0c;保证上…

Three.js--》探寻Cannon.js构建震撼的3D物理交互体验(一)

我们用three.js可以绘制出各种酷炫的画面&#xff0c;但是当我们想要一个更加真实的物理效果的话&#xff0c;这个时候我们就需要一个物理的库&#xff0c;接下来我们就讲解一下今天要学习的canon&#xff0c;它可以给我们提供一个更加真实的物理效果&#xff0c;像物体的张力、…

YOLOv8姿态估计实战:训练自己的数据集

课程链接&#xff1a;https://edu.csdn.net/course/detail/39355 YOLOv8 基于先前 YOLO 版本的成功&#xff0c;引入了新功能和改进&#xff0c;进一步提升性能和灵活性。YOLOv8 同时支持目标检测和姿态估计任务。 本课程以熊猫姿态估计为例&#xff0c;将手把手地教大家使用C…

Mysql实战(2)之MySQL执行流程

-- 查看mysql当前有多少连接 show global status like Thread%; /* Threads_cached&#xff1a;缓存中的线程连接数 Threads_connected&#xff1a;当前打开的连接数 Threads_created&#xff1a;为处理连接创建的线程数 Threads_running&#xff1a;非睡眠状态的连接数&…

windows部署mariadb-11.3

因为需要用到数据库来处理一些东西,所以决定在windows上安装一下MariaDB. 随着版本升级,安装已经不是那么复杂了.对应的.其实网上一大堆的检索结果,很多并不可用. 由于是开发环境,这里一切从简了. 下载安装包.并解压进入bin目录,使用mysql_install_db.exe程序来进行安装.执行 m…

MSCKF5讲:后端代码分析

MSCKF5讲&#xff1a;后端代码分析 文章目录 MSCKF5讲&#xff1a;后端代码分析1 初始化initialize()1.1 加载参数1.2 初始化IMU连续噪声协方差矩阵1.3 卡方检验1.4 接收与订阅话题createRosIO() 2 IMU静止初始化3 重置resetCallback()4 featureCallback4.1 IMU初始化判断4.2 I…

【文末送书】智能计算:原理与实践

欢迎关注博主 Mindtechnist 或加入【智能科技社区】一起学习和分享Linux、C、C、Python、Matlab&#xff0c;机器人运动控制、多机器人协作&#xff0c;智能优化算法&#xff0c;滤波估计、多传感器信息融合&#xff0c;机器学习&#xff0c;人工智能等相关领域的知识和技术。关…

Linux系统运维脚本:一键添加防火墙规则(开启服务和网络端口)

目 录 一、要求 二、解决方案 &#xff08;一&#xff09;解决思路 &#xff08;二&#xff09;方案 三、脚本程序实现 &#xff08;一&#xff09;脚本代码和解释 1、脚本代码 2、代码解释 &#xff08;二&#xff09;脚本验证 1、脚本编辑 2、给予执行权限…

NumPy数据处理详解的笔记2

NumPy数据处理详解的笔记2 第1章NumPy基础 NumPy是用于处理多维数组的数值运算库&#xff0c;不仅可用于 机器学习&#xff0c;还可以用于图像处理&#xff0c;语言处理等任务。 1.2 多维数据结构ndarray的基础 在学习NumPy的过程中&#xff0c;只要理解了ndarray的相关知识…

java 关于 Object 类中的 wait 和 notify 方法。(生产者和消费者模式!)

4、关于 Object 类中的 wait 和 notify 方法。&#xff08;生产者和消费者模式&#xff01;&#xff09; 第一&#xff1a;wait 和 notify 方法不是线程对象的方法&#xff0c;是 java 中任何一个 java 对象都有的方法&#xff0c;因为这两个方法是 Object 类中自带的。 wait 方…

基于YOLOv8/YOLOv7/YOLOv6/YOLOv5的停车位检测系统(Python+PySide6界面+训练代码)

摘要&#xff1a;开发停车位检测系统对于优化停车资源管理和提升用户体验至关重要。本篇博客详细介绍了如何利用深度学习构建一个停车位检测系统&#xff0c;并提供了完整的实现代码。该系统基于强大的YOLOv8算法&#xff0c;并结合了YOLOv7、YOLOv6、YOLOv5的性能对比&#xf…

HarmonyOS端云体化开发—创建端云一体化开发工程

云开发工程模板 DevEco Studio目前提供了两种云开发工程模板&#xff1a;通用云开发模板和商城模板。您可根据工程向导轻松创建端云一体化开发工程&#xff0c;并自动生成对应的代码和资源模板。在创建端云一体化开发工程前&#xff0c;请提前了解云开发工程模板的相关信息。 …

前端学习之HTML(第一天)

什么是HTML HTML是一种用来描述网页的一种语言&#xff0c;HTML不是一种编程语言&#xff0c;而是一种标记语言。 HTML标签 HTML 标签是由尖括号包围的关键词&#xff0c;比如 <html> HTML 标签通常是成对出现的&#xff0c;比如 <b> 和 </b> 标签对中的…

ROS 2基础概念#3:主题(Topic)| ROS 2学习笔记

在ROS&#xff08;Robot Operating System&#xff09;中&#xff0c;主题&#xff08;Topics&#xff09;是实现节点之间通信的主要机制之一。节点&#xff08;Node&#xff09;可以发布&#xff08;publish&#xff09;消息到话题&#xff0c;或者订阅&#xff08;subscribe&…

市场复盘总结 20240304

仅用于记录当天的市场情况&#xff0c;用于统计交易策略的适用情况&#xff0c;以便程序回测 短线核心&#xff1a;不参与任何级别的调整&#xff0c;采用龙空龙模式 一支股票 10%的时候可以操作&#xff0c; 90%的时间适合空仓等待 二进三&#xff1a; 进级率中 20% 最常用的…

格两例12345

osu/Lucky Roll gaming 周末osu有道题&#xff1a;lcg已知低位 def lcg(s, a, b, p):return (a * s b) % pp getPrime(floor(72.7)) a randrange(0, p) b randrange(0, p) seed randrange(0, p) print(f"{p }") print(f"{a }") print(f"{b …

幂等性设计

目录 前言 幂等性设计 幂等性设计处理流程 HTTP 幂等性 消息队列幂等性 基于kafka 前言 幂等性设计&#xff0c;就是说&#xff0c;一次和多次请求某一个资源应该具有同样的副作用。为什么我们要有幂等性操作&#xff1f;说白了&#xff0c;就两点&#xff1a;1、网络的…

LeetCode第125场双周赛个人题解

目录 100231. 超过阈值的最少操作数 I 原题链接 思路分析 AC代码 100232. 超过阈值的最少操作数 II 原题链接 思路分析 AC代码 100226. 在带权树网络中统计可连接服务器对数目 原题链接 思路分析 AC代码 100210. 最大节点价值之和 原题链接 思路分析 AC代码 10023…

大话C++之:对象内存模型

一般继承(无虚函数覆盖) 只有一个虚指针&#xff0c;指向一个虚表&#xff0c;虚函数按顺序从祖先节点开始插入到虚表上。字段按顺序从祖先节点开始插入到对象内存上 一般继承(有虚函数覆盖) 只有一个虚指针&#xff0c;指向一个虚表&#xff0c;虚函数按顺序从祖先节点开始&a…