二叉搜索树基础概念与经典题目（Leetcode题解-Python语言）

二叉搜索树，首先上定义：

  • 节点的左子树只包含小于当前节点的数。
  • 节点的右子树只包含大于当前节点的数。
  • 所有左子树和右子树自身必须也是二叉搜索树。

而二叉搜索树最有用的性质就是，对其中序遍历可以得到一个递增的有序序列。更多的内容，可以到这个Leetbook当中学习。

700. 二叉搜索树中的搜索

递归法：

class Solution:def searchBST(self, root: TreeNode, val: int) -> TreeNode:while root and root.val != val:root = root.left if root.val > val else root.rightreturn root

迭代法：

class Solution:def searchBST(self, root: TreeNode, val: int) -> TreeNode:node = rootwhile node:if val < node.val:node = node.leftelif val > node.val:node = node.rightelse:return nodereturn None

简单题，目标数值大于当前节点值的话去右子树，小于当前节点值的话去左子树，直到目标数值等于当前节点值。

701. 二叉搜索树中的插入操作

递归法：

class Solution:def insertIntoBST(self, root: TreeNode, val: int) -> TreeNode:if not root:return TreeNode(val)if val < root.val:root.left = self.insertIntoBST(root.left, val)else:root.right = self.insertIntoBST(root.right, val)return root

迭代法：

class Solution:def insertIntoBST(self, root: TreeNode, val: int) -> TreeNode:if not root:return TreeNode(val)node = rootwhile node:if val < node.val:if node.left:node = node.leftelse:node.left = TreeNode(val)breakelse:if node.right:node = node.rightelse:node.right = TreeNode(val)breakreturn root

同样的，由于二叉搜索树自带大小关系，所以一个元素只要根据大小关系迭代进入左右子树，找到的空节点即为要插入的节点位置。

450. 删除二叉搜索树中的节点

class Solution:def deleteNode(self, root: Optional[TreeNode], key: int) -> Optional[TreeNode]:if not root:return root# 要删除的节点在左子树if key < root.val:root.left = self.deleteNode(root.left, key)return root# 要删除的节点在右子树elif key > root.val:root.right = self.deleteNode(root.right, key)return root# 找到了要删除的节点else:# 1、如果节点的左子树为空，就用右子树替代它自己if not root.left:return root.right# 2、如果节点的右子树为空，就用左子树替代它自己elif not root.right:return root.left# 3、节点的左右子树都不为空，则用它的后继节点替代它自己else:cur = root.rightwhile cur.left:cur = cur.left# 将待删除节点的左子树接到其后继节点的左边，然后返回其右子树cur.left = root.leftreturn root.right

这里有个知识点，在中序遍历里面，一个节点的前驱节点（仅小于待删除节点的节点）是其左节点的最右节点（右到底），一个节点的后继节点（仅大于待删除节点的节点）是其右节点的最左节点（左到底）。删除节点分三类情况讨论。

98. 验证二叉搜索树（面试题 04.05. 合法二叉搜索树）

验证二叉搜索树，第一种方法是从定义出发：

class Solution:def isValidBST(self, root: TreeNode) -> bool:def bounder(lower, node: TreeNode, upper) -> bool:if not node:return True        val = node.valif val <= lower or val >= upper:return Falsereturn bounder(lower, node.left, val) and bounder(val, node.right, upper)return bounder(float('-inf'), root, float('inf'))

使用递归函数判断二叉搜素树是否符合定义，同时传入边界作为参数。

第二种方法是根据二叉搜索树的性质，即中序遍历得到递增序列：

class Solution:def isValidBST(self, root: TreeNode) -> bool:self.temp = float('-inf')self.isValid = Truedef inorder(root: TreeNode):if not root:returninorder(root.left)  # 左根右if root.val <= self.temp:self.isValid = Falseself.temp = root.valinorder(root.right)inorder(root)return self.isValid

递归写法要使用到全局变量，比较麻烦，建议用统一的迭代写法：

class Solution:def isValidBST(self, root: TreeNode) -> bool:stack = []stack.append(root)pre = None while stack:node = stack.pop()if node:if node.right:stack.append(node.right)stack.append(node)stack.append(None)if node.left:stack.append(node.left)else:node = stack.pop()if pre and pre.val >= node.val:return Falsepre = nodereturn True

剑指 Offer 54. 二叉搜索树的第k大节点

class Solution:def kthLargest(self, root: TreeNode, k: int) -> int:ans = []if not root:return Nonestack = []stack.append(root)while stack:node = stack.pop()if node: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[-k]

中序遍历得到递增序列，然后取倒数第k个即为第k大的节点值。

230. 二叉搜索树中第K小的元素

class Solution:def kthSmallest(self, root: Optional[TreeNode], k: int) -> int:ans = []if not root:return Nonestack = []stack.append(root)while stack:node = stack.pop()if node: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[k-1]

还是中序遍历，由于是取第 k 小，所有也可以遍历 k 个节点后直接跳出循环。

530. 二叉搜索树的最小绝对差（783. 二叉搜索树节点最小距离）

class Solution:def getMinimumDifference(self, root: TreeNode) -> int:if not root:return Noneans = 100001pre = Nonestack = []stack.append(root)while stack:node = stack.pop()if node:if node.right:stack.append(node.right)stack.append(node)stack.append(None)if node.left:stack.append(node.left)else:node = stack.pop()if pre and abs(pre.val - node.val) < ans:ans = abs(pre.val - node.val)pre = nodereturn ans

还是中序遍历，用 pre 记录前面的节点，用 ans 记录最小的相邻数字之差绝对值。

501. 二叉搜索树中的众数

class Solution:def findMode(self, root: TreeNode) -> List[int]:if not root:return Noneans = []maxCount = 0count = 0pre = Nonestack = []stack.append(root)while stack:node = stack.pop()if node:if node.right:stack.append(node.right)stack.append(node)stack.append(None)if node.left:stack.append(node.left)else:node = stack.pop()# 如果前面有节点且两者的值相同，就 count + 1，否则就是一个新的数if pre and pre.val == node.val:count += 1else:count = 1# 如果当前的数出现次数恰好等于 maxCount，那就加到 ans 中if count == maxCount:ans.append(node.val)# 如果当前的数出现次数大于 maxCount，那就是新的众数elif count > maxCount:maxCount = countans = [node.val]pre = nodereturn ans

还是中序遍历，用 pre 记录前面的节点，用 count 记录当前数出现的次数，用 maxCount 记录出现最多的数字的出现次数，用 ans 记录出现最多的数字（可能有多个众数）。

235. 二叉搜索树的最近公共祖先（剑指 Offer 68 - I. 二叉搜索树的最近公共祖先）

class Solution:def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':node = rootwhile node:if p.val < node.val and q.val < node.val:node = node.leftelif p.val > node.val and q.val > node.val:node = node.rightelse:return nodereturn None

要找到两个节点的最近公共祖先，只需要从根节点开始，同时对两个节点进行搜索，让他们一起移动，直到第一次出现分歧点，即为最近公共祖先。

255. 验证前序遍历序列二叉搜索树

class Solution:def verifyPreorder(self, preorder: List[int]) -> bool:stack = []root = float('-inf')for i in range(len(preorder)):if preorder[i] <= root: # 下一个节点必须比root值大，否则返回Falsereturn Falsewhile stack and stack[-1] < preorder[i]:  # 找到右子树对应的根节点root值，下一个节点必须比这个值大root = stack.pop()stack.append(preorder[i])return True

前序遍历序列，就是根左右，会先一直遍历左子树到底，若是二叉搜索树，则必定是个递减序列；然后出现第一个比前面的数大的，肯定是遍历了右子树，本题关键就在此，这个右子树不仅要比前一个数（左子树）大，还要比其根节点（父节点）大。因此，用一个栈记录遍历过的前序序列，递减时正常记录，每当出现递增的时候，都要找到前面序列中仅次于右子树的值（根节点），再后一个值是必须大于这个值的，否则返回False。

剑指 Offer 33. 二叉搜索树的后序遍历序列

class Solution:def verifyPostorder(self, postorder: List[int]) -> bool:stack = []root = float('+inf')for i in range(len(postorder) - 1, -1, -1):if postorder[i] >= root:return Falsewhile stack and stack[-1] > postorder[i]: root = stack.pop()stack.append(postorder[i])return True

与上一题类似，后序遍历是左右根，序列是先递增再递减，还是在递增转折为递减的时候，判断转折节点与其根节点的关系。推荐题解看这篇。

1008. 前序遍历构造二叉搜索树

class Solution:def bstFromPreorder(self, preorder: List[int]) -> TreeNode:if preorder:leftTree = []rightTree = []root = TreeNode(preorder.pop(0))for val in preorder:if val > root.val:rightTree.append(val)else:leftTree.append(val)root.left = self.bstFromPreorder(leftTree)root.right = self.bstFromPreorder(rightTree)return root

从前序遍历序列构造二叉搜索树，思路就是递归，利用二叉搜索树的特点，将小于当前节点的作为左子树，大于当前节点的作为右子树即可。

95. 不同的二叉搜索树 II

class Solution:def generateTrees(self, n: int) -> List[TreeNode]:def helper(start, end):if start > end:return [None]allTrees = []for i in range(start, end+1):leftTrees = helper(start, i-1)rightTrees = helper(i+1, end)for l in leftTrees:for r in rightTrees:curTree = TreeNode(i)curTree.left = lcurTree.right = rallTrees.append(curTree)return allTreesreturn helper(1, n) if n else []

我们定义 helper(start, end) 函数表示当前值的集合为 [start,end]，返回序列 [start,end] 生成的所有可行的二叉搜索树。在每次递归中，我们枚举 [start,end] 中的值 i 为当前二叉搜索树的根，那么序列划分为了 [start,i−1] 和 [i+1,end] 两部分。我们递归调用这两部分，即 helper(start, i - 1) 和 helper(i + 1, end)，获得所有可行的左子树和可行的右子树，那么最后一步我们只要从可行左子树集合中选一棵，再从可行右子树集合中选一棵拼接到根节点上，并将生成的二叉搜索树放入答案数组即可。

递归的入口即为 helper(1, n)，出口为当 start > end 的时候，当前二叉搜索树为空，返回空节点即可。

173. 二叉搜索树迭代器

这题最简单的思路是在__init__的时候进行一次中序遍历，把二叉搜索树的递增序列用队列记录下来，然后在next的时候返回队列首部的元素 popleft 即可。

class BSTIterator(object):def __init__(self, root):self.queue = collections.deque()self.inOrder(root)def inOrder(self, root):if not root: returnself.inOrder(root.left)self.queue.append(root.val)self.inOrder(root.right)def next(self):return self.queue.popleft()def hasNext(self):return len(self.queue) > 0

更好的思路是迭代法：

class BSTIterator:def __init__(self, root: TreeNode):self.stack = []while root:self.stack.append(root)root = root.leftdef next(self) -> int:cur = self.stack.pop()node = cur.rightwhile node:self.stack.append(node)node = node.leftreturn cur.valdef hasNext(self) -> bool:return len(self.stack) > 0

对比中序遍历的迭代写法，可以发现迭代器实际上是把中序遍历拆开分别执行了

    # 中序遍历def inorderTraversal(self, root: TreeNode) -> List[int]:ans = list()if not root:return ans     stack = list()node = rootwhile stack or node:while node: # 当node的左子节点为空时停止stack.append(node)node = node.left
###########################################################node = stack.pop()	# 回溯ans.append(node.val)node = node.right	# 访问右子节点        return ans

在__init__的时候，执行到了上半部分；之后每次next，都会执行本次循环的下半部分和下一次循环的上半部分，即相当于用手动的next代替了while stack or node。

二叉搜索树主要支持三个操作：搜索、插入和删除。二叉搜索树的优点是，即便在最坏的情况下，也允许你在O(h)的时间复杂度内执行所有的搜索、插入、删除操作。通常来说，如果你想有序地存储数据或者需要同时执行搜索、插入、删除等多步操作，二叉搜索树这个数据结构是一个很好的选择。

938. 二叉搜索树的范围和

class Solution:def rangeSumBST(self, root: TreeNode, low: int, high: int) -> int:def inorder(node: TreeNode):if not node:returnif node.val > low:inorder(node.left)if node.val <= high and node.val >= low:self.counter += node.valif node.val < high:inorder(node.right)self.counter = 0inorder(root)return self.counter

中序遍历二叉搜索树，只要节点值在范围内即累计到答案中，优化了的地方是当前节点值大于左边界才去遍历左子树（否则左子树都是比左边界小，越界），小于右边界才去遍历右子树（否则右子树都是比右边界大，越界）。

669. 修剪二叉搜索树

class Solution:def trimBST(self, root: TreeNode, low: int, high: int) -> TreeNode:def trim(node):if not node:return Noneelif node.val > high:  # 若当前节点值大于high，则它的右子树必大于highreturn trim(node.left)elif node.val < low:   # 若当前节点值小于low，则它的左子树必小于lowreturn trim(node.right)else:node.left = trim(node.left)node.right = trim(node.right)return nodereturn trim(root)

修剪的方法就是，如果当前节点值大于high，则它的右子树必大于high，只能返回其左子树；如果当前节点值小于low，则它的左子树必小low，只能返回其右子树。注意增加return node是因为根节点可能改变，否则就 trim(root) 然后 return root 就行了。

285. 二叉搜索树中的中序后继（剑指 Offer II 053. 二叉搜索树中的中序后继）（面试题 04.06. 后继者）

class Solution:def inorderSuccessor(self, root: 'TreeNode', p: 'TreeNode') -> 'TreeNode':if p.right:p = p.rightwhile p.left:p = p.leftreturn pstack = []node = rootpre = float('-inf')while stack or node:while node:stack.append(node)node = node.leftnode = stack.pop()if pre == p.val: return nodepre = node.val     node = node.rightreturn None

对于有右子树的节点，它的后继节点（递增序列中右边的元素）是其右节点的最左节点（左到底）。如果没有右子树，则其后继节点是其作为左子树时的父节点。如果节点即没有右子树，其自身又是右子树，则没有后继节点。

510. 二叉搜索树中的中序后继 II

class Solution:def inorderSuccessor(self, node: 'Node') -> 'Node':if node.right:node = node.rightwhile node.left:node = node.leftreturn nodeelse:while node.parent and node == node.parent.right:node = node.parentreturn node.parent

本题的条件比上一题修改了一点，没有了根节点，但是多了父节点指针。思路还是一样，如果节点有右子树，其后继节点可以马上找到；如果没有，则寻找其父节点、父节点的父节点，一直到找到有父子关系是右子树的或者空节点为止。

653. 两数之和 IV - 输入 BST（剑指 Offer II 056. 二叉搜索树中两个节点之和）

class Solution:def findTarget(self, root: TreeNode, k: int) -> bool:def inorder(node: TreeNode):if not node:return inorder(node.left)nums.append(node.val)inorder(node.right)nums = []inorder(root)left = 0right = len(nums) - 1while left < right:if nums[left] + nums[right] == k:return Trueelif nums[left] + nums[right] > k:right -= 1else:left += 1return False

还是先用中序遍历记录数组，得到递增序列，然后用双指针即可。

1214. 查找两棵二叉搜索树之和

class Solution:def twoSumBSTs(self, root1: TreeNode, root2: TreeNode, target: int) -> bool:        def inorder(node: TreeNode, nums):if not node:return inorder(node.left, nums)nums.append(node.val)inorder(node.right, nums)nums1, nums2 = [], []inorder(root1, nums1)inorder(root2, nums2)     left = 0right = len(nums2) - 1while left < len(nums1) and 0 <= right:if nums1[left] + nums2[right] == target:return Trueelif nums1[left] + nums2[right] > target:right -= 1else:left += 1return False

与上一题类似，此题是要在两个二叉搜索树中找到两数之和，即做两次中序遍历，然后双指针分别遍历两个递增序列即可。

897. 递增顺序搜索树（剑指 Offer II 052. 展平二叉搜索树）（面试题 17.12. BiNode）

class Solution:def increasingBST(self, root: TreeNode) -> TreeNode:if not root:return Nonestack = []node = rootnewnode = 0while stack or node:while node:stack.append(node)node = node.leftnode = stack.pop()if newnode == 0:  # 第一个节点newnode = TreeNode(node.val)newroot = newnodeelse:newnode.right = TreeNode(node.val)newnode = newnode.rightnode = node.rightreturn newroot

在中序遍历二叉搜索树的同时，用一个新的节点构建二叉树即可。

99. 恢复二叉搜索树

class Solution:def recoverTree(self, root: Optional[TreeNode]) -> None:firstNode = NonesecondNode = Nonepre = TreeNode(float("-inf"))stack = []node = rootwhile node or stack:while node:stack.append(node)node = node.leftnode = stack.pop()if pre.val > node.val:if not firstNode:firstNode = preif firstNode:               secondNode = nodepre = nodenode = node.rightfirstNode.val, secondNode.val = secondNode.val, firstNode.val

中序遍历二叉搜索树，得到的一定是递增序列，如果有两个节点被错误交换，则反映在序列中一定是出现了递减的位置，找到这两个位置即可。

108. 将有序数组转换为二叉搜索树

class Solution:def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:n = len(nums)if n == 0:return Nonemid = n // 2root = TreeNode(nums[mid])root.left = self.sortedArrayToBST(nums[:mid])root.right = self.sortedArrayToBST(nums[mid+1:])return root

最直观的思路，每次取中间元素作为当前的根节点，两侧的元素作为左右子树递归建树，左侧区间 [:mid-1] 作为左子树，右侧区间 [mid+1:] 作为右子树。如果想节省点空间，那递归时用区间的指针代替区间也可以：

class Solution:def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:def helper(left, right):if left > right:return Nonemid = (left + right) // 2root = TreeNode(nums[mid])root.left = helper(left, mid - 1)root.right = helper(mid + 1, right)return rootreturn helper(0, len(nums) - 1)

538. 把二叉搜索树转换为累加树（1038. 把二叉搜索树转换为累加树）（剑指 Offer II 054. 所有大于等于节点的值之和）

递归法：

class Solution:def convertBST(self, root: Optional[TreeNode]) -> Optional[TreeNode]:total = 0def inorder(root: TreeNode):nonlocal totalif not root:returninorder(root.right)total += root.valroot.val = totalinorder(root.left)inorder(root)return root

迭代法：

class Solution:def convertBST(self, root: Optional[TreeNode]) -> Optional[TreeNode]:if not root:return Nonestack = []stack.append(root)total = 0while stack:node = stack.pop()if node:if node.left:stack.append(node.left)stack.append(node)stack.append(None)if node.right:stack.append(node.right)else:node = stack.pop()total += node.valnode.val = totalreturn root

本题要求我们将每个节点的值修改为原来的节点值加上所有大于它的节点值之和。我们只需要反序中序遍历该二叉搜索树（即右根左），记录过程中的节点值之和，并不断更新当前遍历到的节点的节点值，即可得到题目要求的累加树。

426. 将二叉搜索树转化为排序的双向链表（剑指 Offer 36. 二叉搜索树与双向链表）

class Solution:def treeToDoublyList(self, root: 'Node') -> 'Node':if not root:return Nonedef inorder(node):nonlocal first, lastif not node:returninorder(node.left)if not first:first = nodeelse:last.right = nodenode.left = lastlast = nodeinorder(node.right)first, last = None, Noneinorder(root)last.right = firstfirst.left = lastreturn first

使用两个指针，一个头指针一个尾指针，初始均为空。然后中序遍历二叉搜索树，如果头指针为空则把该节点设为头节点，否则就先建立当前节点与下一个节点的双向联系，然后移动到下一个节点。遍历完成后，再补上尾节点与头节点的联系即可。

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

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

相关文章

异方差 的 BP检验 方法及原理详解

异方差 的 BP检验 方法及原理详解

异方差 的 BP检验详解            文章目录 1. `BP`检验的步骤2. 场景示例步骤 ①步骤 ②BP检验，也称为Breusch-Pagan检验，是一种用于检验线性回归模型中异方差性（即误差项方差不恒定）的统计方法。该方法由Trevor S. Breusch和Adrian R. Pagan在1980年提出。 1.…
阅读更多...
leetcode309. 最佳买卖股票时机含冷冻期

leetcode309. 最佳买卖股票时机含冷冻期

一&#xff1a;题目 二:上码 class Solution { public:/**思路:1.分析题意那么我们会有四种状态0 买入股票(或者说是之前就买入了股票但是也一直没有操作)1 卖出股票的状态一 两天前就卖出了股票 但是一直没有操作 2 卖出股票状态二 今天卖出股票3 冷冻期 持续一天2.动态规…
阅读更多...
.NET Core 下使用 Exceptionless 记录日志

.NET Core 下使用 Exceptionless 记录日志

ExceptionLess是一套免费开源分布式系统日志收集框架&#xff0c;也是我无意中发现的&#xff0c;支持自己部署和平台托管的方式接入使用。ExceptionLess官网&#xff1a;https://exceptionless.comExceptionLess开源地址&#xff1a;https://github.com/exceptionless/Excepti…
阅读更多...
高度平衡的二叉搜索树基础概念与经典题目（Leetcode题解-Python语言）

高度平衡的二叉搜索树基础概念与经典题目（Leetcode题解-Python语言）

高度平衡的二叉搜索树&#xff08;平衡二叉树&#xff09;&#xff0c;定义见此Leetbook。简单来说&#xff0c;就是基于相同节点值构建出来的二叉搜索树中高度最小的&#xff0c;即为平衡二叉树&#xff08;不唯一&#xff09;。有 N 个节点的平衡二叉搜索树&#xff0c;它的高…
阅读更多...
spring boot 中@Mapper和@Repository的区别

spring boot 中@Mapper和@Repository的区别

一:前言 Mapper和Repository是常用的两个注解&#xff0c;两者都是用在dao上&#xff0c;两者功能差不多&#xff0c;容易混淆&#xff0c;有必要清楚其细微区别&#xff1b; 二:区别 Repository需要在Spring中配置扫描地址&#xff0c;然后生成Dao层的Bean才能被注入到Serv…
阅读更多...
你没有看错，爬网页数据，C# 也可以像 Jquery 那样

你没有看错，爬网页数据，C# 也可以像 Jquery 那样

一&#xff1a;背景 1. 讲故事前段时间搞了一个地方性民生资讯号&#xff0c;资讯嘛&#xff0c;都是我抄你的&#xff0c;你抄官媒的&#xff0c;小市民都喜欢奇闻异事&#xff0c;所以就存在一个需求&#xff0c;如何去定向抓取奇闻异事的地方号上的新闻&#xff0c;其实做起…
阅读更多...
leetcode300. 最长递增子序列

leetcode300. 最长递增子序列

一:题目 二:上码 class Solution { public:/**思路:1.分析题意:我们在求取答案的过程中;我们的结果是动态的; 如果从某个数有一个递增序列 但是在这个数的后面又有一个数又可以是递增的 而且可能还比起长 2.动态规划五步走1>:确定dp数组的含义以及下标的含义dp[i] 表示的是…
阅读更多...
链表基础概念与经典题目（Leetcode题解-Python语言）

链表基础概念与经典题目（Leetcode题解-Python语言）

所谓链表&#xff0c;就是由链节点元素组成的表&#xff0c;那什么是链节点呢&#xff1f;直接上定义&#xff1a; class ListNode:def __init__(self, val0, nextNone):self.val valself.next next很简单&#xff0c;链节点就是只记录自身的值 val&#xff0c;还有其指向的…
阅读更多...
leetcode674. 最长连续递增序列

leetcode674. 最长连续递增序列

一:题目 二:上码 1:方法一贪心 class Solution { public:/**思路:1.贪心**/int findLengthOfLCIS(vector<int>& nums) {int ans 1;int count 1;for (int i 1; i < nums.size(); i) {if(nums[i] > nums[i-1]) {count;}else{count 1;//出现不连续的状态}if…
阅读更多...
WPF 从 .net core 3.1 到 .net 5.0

WPF 从 .net core 3.1 到 .net 5.0

WPF 从 .net core 3.1 到 .net 5.0Intro昨天更新了一个简单的 asp.net core webapi 项目&#xff0c;从 3.1 更新到了 5.0&#xff0c;今天更新一个 WPF 应用到 net 5.0项目文件更新首先项目文件中的 SDK 发生了变化&#xff0c;原来是 Microsoft.NET.Sdk.WindowsDesktop 更新后…
阅读更多...
最小堆最大堆基础概念与经典题目（Leetcode题解-Python语言）

最小堆最大堆基础概念与经典题目（Leetcode题解-Python语言）

堆是一种特别的完全二叉树&#xff0c;符合以下两个定义即为堆&#xff1a; 1、完全二叉树&#xff1b; 2、每一个节点的值都必须大于等于或者小于等于其孩子节点的值。若是大于等于&#xff0c;即为最大堆&#xff0c;若是小于等于&#xff0c;即为最小堆。显然&#xff0c;…
阅读更多...
进击吧！ Blazor ！第三期 信息交互

进击吧！ Blazor ！第三期 信息交互

Blazor 是一个 Web UI 框架&#xff0c;可通过 WebAssembly 在任意浏览器中运行 .Net 。Blazor 旨在简化快速的单页面 .Net 浏览器应用的构建过程&#xff0c;它虽然使用了诸如 CSS 和 HTML 之类的 Web 技术&#xff0c;但它使用 C&#xff03;语言和 Razor 语法代替 JavaScrip…
阅读更多...
leetcode718. 最长重复子数组

leetcode718. 最长重复子数组

一:题目 二:上码 class Solution { public:/**思路:1.分析题意:1 2 3 6 7 41 2 6 7 4 3这里我们先遇到的1 2 但后来我们又遇见了6 7 4 那么我们的要的答案就是动态变化的2.动态规划五步走1>:确定dp数组以及下标的含义dp[i][j] 表示 以下标i-1结尾的A数组和以下标…
阅读更多...
二叉树序列化与反序列化相关题目（Leetcode题解-Python语言）

二叉树序列化与反序列化相关题目（Leetcode题解-Python语言）

297. 二叉树的序列化与反序列化&#xff08;剑指 Offer 37. 序列化二叉树&#xff09;&#xff08;剑指 Offer II 048. 序列化与反序列化二叉树&#xff09; class Codec:def serialize(self, root):"""Encodes a tree to a single string.:type root: TreeNod…
阅读更多...
.NET 5 的 Target Framework 详解[上篇]

.NET 5 的 Target Framework 详解[上篇]

❝作者&#xff1a;.NET Team翻译&#xff1a;精致码农-王亮原文&#xff1a;http://dwz.win/Q4v❞我们希望极大地简化开发人员必须在项目文件和 NuGet 包中使用的「TFM」 (Target Framework Name, 目标框架名称)。这包括合并 .NET 5 和 .NET Standard 的概念&#xff0c;同时仍…
阅读更多...
leetcode1143. 最长公共子序列

leetcode1143. 最长公共子序列

一&#xff1a;题目 二:上码 class Solution { public:/**思路:1.分析题意这个子序列就是我们是可以不连续的字符组成的2.动态规划五步走1>:确定dp数组的含义以及下标的含义dp[i][j] 表示的是text1中[0,i-1]字符范围,text2中[0,j-1]的字符范围 的最长公共子序列这里我们取i…
阅读更多...
爬楼梯与路径类题目记忆化递归与动态规划双解法（Leetcode题解-Python语言）

爬楼梯与路径类题目记忆化递归与动态规划双解法（Leetcode题解-Python语言）

70. 爬楼梯&#xff08;剑指 Offer 10- II. 青蛙跳台阶问题&#xff09; 递归&#xff08;英语&#xff1a;Recursion&#xff09;&#xff0c;是指在函数的定义中使用函数自身的方法。有意义的递归通常会把问题分解成规模缩小的同类子问题&#xff0c;当子问题缩写到寻常的时…
阅读更多...
JAVA 15发布，越来越像C# ？9月排名，C#增幅狠甩JAVA

JAVA 15发布，越来越像C# ？9月排名，C#增幅狠甩JAVA

2016年.NET Core首个正式版本问世&#xff0c;如今已发布到了.NET Core3.1&#xff0c;再有2个月.NET5也将如约而至&#xff0c;跨平台开发已经快5年。微软 .NET 程序管理总监 Scott 表示&#xff0c;.NET 5 是 .NET Framework 和 .NET Core 的未来&#xff0c;最终将成为一个统…
阅读更多...
买卖股票类问题动态规划解法（Leetcode题解-Python语言）

买卖股票类问题动态规划解法（Leetcode题解-Python语言）

在 Leetcode 中&#xff0c;关于买卖股票的问题共有6道&#xff0c;而这些题目是可以用相同的思维进行求解的&#xff0c;强烈推荐这篇总结&#xff0c;写得非常到位。 股票类问题的动态规划分三步走&#xff0c;1、首先明确方程的含义&#xff0c; T[i][k][0]&#xff1a;表…
阅读更多...
leetcode1035. 不相交的线

leetcode1035. 不相交的线

一:题目 二:上码 class Solution { public:/**思路:1.分析题意:这里的我们要求解的是最大值,那么我们的求解过程肯定是动态变化的,举个例子2 5 1 2 510 5 2 1 5 2 如果我们一开始就让nums1[1] 5何 nums2[4] 5 相连的话 那么我们肯定不会求解出最大值那么题目中的说的直线不…
阅读更多...
最新文章

Copyright @ 2022~2023