leetcode地址：二叉搜索子树的最大键值和
给你一棵以 root 为根的 二叉树 ，请你返回 任意 二叉搜索子树的最大键值和。
二叉搜索树的定义如下：
任意节点的左子树中的键值都 小于 此节点的键值。
任意节点的右子树中的键值都 大于 此节点的键值。
任意节点的左子树和右子树都是二叉搜索树。
示例 1：
输入：root = [1,4,3,2,4,2,5,null,null,null,null,null,null,4,6]
输出：20
解释：键值为 3 的子树是和最大的二叉搜索树。
示例 2：
输入：root = [4,3,null,1,2]
输出：2
解释：键值为 2 的单节点子树是和最大的二叉搜索树。
示例 3：
输入：root = [-4,-2,-5]
输出：0
解释：所有节点键值都为负数，和最大的二叉搜索树为空。
示例 4：
输入：root = [2,1,3]
输出：6
示例 5：
输入：root = [5,4,8,3,null,6,3]
输出：7
提示：
每棵树有 1 到 40000 个节点。
每个节点的键值在 [-4 * 10^4 , 4 * 10^4] 之间。
实现思路
要解决这个问题，我们需要计算二叉树中每一个子树是否是二叉搜索树（BST），并计算所有BST子树的键值和，最终返回这些BST子树中的最大键值和。
我们可以使用递归的方法来解决这个问题。递归地遍历树中的每一个节点，同时计算子树的信息，包括：
- 是否是BST
- 子树的键值和
- 子树的最小键值
- 子树的最大键值
具体步骤如下：
- 定义一个辅助函数 dfs(node)，它返回四个值：
is_bst：当前子树是否为BST
subtree_sum：当前子树的键值和
min_val：当前子树的最小键值
max_val：当前子树的最大键值 递归计算左子树和右子树的信息。 - 根据左子树和右子树的信息，以及当前节点的值，判断当前子树是否为BST。
- 如果是BST，则计算当前子树的键值和、最小键值和最大键值。
- 更新最大BST键值和的结果。
- 返回当前子树的信息。
代码详解
假设有以下二叉树：1/ \4 3/ / \2 2 5
首先定义树节点类 TreeNode，用于构建二叉树：
class TreeNode:def __init__(self, val=0, left=None, right=None):self.val = valself.left = leftself.right = right
TreeNode 类有三个属性：
val：节点的值。
left：左子树。
right：右子树。
接下来是主函数 max_sum_BST，它计算二叉树中任意二叉搜索子树的最大键值和：
def max_sum_BST(root):def dfs(node):if not node:# 空节点被认为是BST，其和为0，最小值为正无穷大，最大值为负无穷大return True, 0, float('inf'), float('-inf')
dfs 辅助函数
dfs 函数接收一个节点 node 作为参数，返回四个值：
is_bst：布尔值，表示当前子树是否为BST。
subtree_sum：当前子树的键值和。
min_val：当前子树的最小键值。
max_val：当前子树的最大键值。
若 node 为 None，即为空节点，则返回：
True：空节点被认为是BST。
0：空节点的键值和为0。
float('inf')：空节点的最小键值为正无穷大。
float('-inf')：空节点的最大键值为负无穷大。
left_is_bst, left_sum, left_min, left_max = dfs(node.left)right_is_bst, right_sum, right_min, right_max = dfs(node.right)
递归计算左子树和右子树的信息，包括是否为BST、键值和、最小键值和最大键值。
# 检查当前节点为根的子树是否为BST
if left_is_bst and right_is_bst and left_max < node.val < right_min:subtree_sum = left_sum + node.val + right_summax_sum[0] = max(max_sum[0], subtree_sum)return True, subtree_sum, min(left_min, node.val), max(right_max, node.val)
else:# 当前子树不是BST，返回假return False, 0, float('-inf'), float('inf')
检查当前节点为根的子树是否为BST，条件是：
左子树是BST。
右子树是BST。
当前节点的值大于左子树的最大值且小于右子树的最小值。
若满足上述条件，则当前子树是BST：
计算当前子树的键值和 subtree_sum。
更新全局最大BST键值和 max_sum[0]。
返回 True、subtree_sum、当前子树的最小键值和最大键值。
否则，当前子树不是BST，返回 False、键值和0、最小键值为负无穷大、最大键值为正无穷大。
max_sum = [0]dfs(root)return max_sum[0]
在 max_sum_BST 函数中：
max_sum 是一个列表，存储最大BST键值和。使用列表是为了在 dfs 函数中能够修改其值。
调用 dfs(root)，开始递归遍历树。
返回 max_sum[0]，即最大BST键值和。
class TreeNode:def __init__(self, val=0, left=None, right=None):self.val = valself.left = leftself.right = rightdef max_sum_BST(root):def dfs(node):if not node:# 空节点被认为是BST，其和为0，最小值为正无穷大，最大值为负无穷大return True, 0, float('inf'), float('-inf')left_is_bst, left_sum, left_min, left_max = dfs(node.left)right_is_bst, right_sum, right_min, right_max = dfs(node.right)# 检查当前节点为根的子树是否为BSTif left_is_bst and right_is_bst and left_max < node.val < right_min:subtree_sum = left_sum + node.val + right_summax_sum[0] = max(max_sum[0], subtree_sum)return True, subtree_sum, min(left_min, node.val), max(right_max, node.val)else:# 当前子树不是BST，返回假return False, 0, float('-inf'), float('inf')max_sum = [0]dfs(root)return max_sum[0]# 测试示例
if __name__ == "__main__":# 创建测试二叉树# 1# / \# 4 3# / / \# 2 2 5root = TreeNode(1)root.left = TreeNode(4)root.right = TreeNode(3)root.left.left = TreeNode(2)root.right.left = TreeNode(2)root.right.right = TreeNode(5)result = max_sum_BST(root)print(f"最大BST子树的键值和: {result}") # 应该输出6GO语言实现
package mainimport ("fmt""math"
)// TreeNode 定义二叉树节点
type TreeNode struct {Val intLeft *TreeNodeRight *TreeNode
}// maxSumBST 函数返回二叉树中任意二叉搜索子树的最大键值和
func maxSumBST(root *TreeNode) int {maxSum := 0// dfs 辅助函数返回四个值：是否是BST、子树键值和、最小键值、最大键值var dfs func(node *TreeNode) (bool, int, int, int)dfs = func(node *TreeNode) (bool, int, int, int) {if node == nil {// 空节点被认为是BST，其和为0，最小值为正无穷大，最大值为负无穷大return true, 0, math.MaxInt64, math.MinInt64}leftIsBST, leftSum, leftMin, leftMax := dfs(node.Left)rightIsBST, rightSum, rightMin, rightMax := dfs(node.Right)// 检查当前节点为根的子树是否为BSTif leftIsBST && rightIsBST && leftMax < node.Val && node.Val < rightMin {subtreeSum := leftSum + node.Val + rightSumif subtreeSum > maxSum {maxSum = subtreeSum}return true, subtreeSum, min(leftMin, node.Val), max(rightMax, node.Val)}// 当前子树不是BST，返回假return false, 0, math.MinInt64, math.MaxInt64}dfs(root)return maxSum
}// 辅助函数：返回两个整数中的较小值
func min(a, b int) int {if a < b {return a}return b
}// 辅助函数：返回两个整数中的较大值
func max(a, b int) int {if a > b {return a}return b
}// 测试示例
func main() {// 创建测试二叉树// 1// / \// 4 3// / / \// 2 2 5root := &TreeNode{Val: 1}root.Left = &TreeNode{Val: 4}root.Right = &TreeNode{Val: 3}root.Left.Left = &TreeNode{Val: 2}root.Right.Left = &TreeNode{Val: 2}root.Right.Right = &TreeNode{Val: 5}result := maxSumBST(root)fmt.Printf("最大BST子树的键值和: %d\n", result) // 应该输出6
}kotlin实现
// 定义二叉树节点类
class TreeNode(var `val`: Int) {var left: TreeNode? = nullvar right: TreeNode? = null
}// maxSumBST 函数返回二叉树中任意二叉搜索子树的最大键值和
fun maxSumBST(root: TreeNode?): Int {var maxSum = 0// dfs 辅助函数返回四个值：是否是BST、子树键值和、最小键值、最大键值fun dfs(node: TreeNode?): Quad<Boolean, Int, Int, Int> {if (node == null) {// 空节点被认为是BST，其和为0，最小值为正无穷大，最大值为负无穷大return Quad(true, 0, Int.MAX_VALUE, Int.MIN_VALUE)}val (leftIsBST, leftSum, leftMin, leftMax) = dfs(node.left)val (rightIsBST, rightSum, rightMin, rightMax) = dfs(node.right)// 检查当前节点为根的子树是否为BSTif (leftIsBST && rightIsBST && leftMax < node.`val` && node.`val` < rightMin) {val subtreeSum = leftSum + node.`val` + rightSumif (subtreeSum > maxSum) {maxSum = subtreeSum}return Quad(true, subtreeSum, minOf(leftMin, node.`val`), maxOf(rightMax, node.`val`))}// 当前子树不是BST，返回假return Quad(false, 0, Int.MIN_VALUE, Int.MAX_VALUE)}dfs(root)return maxSum
}// Quad 数据类，用于返回四个值
data class Quad<A, B, C, D>(val first: A, val second: B, val third: C, val fourth: D)// 测试示例
fun main() {// 创建测试二叉树// 1// / \// 4 3// / / \// 2 2 5val root = TreeNode(1)root.left = TreeNode(4)root.right = TreeNode(3)root.left?.left = TreeNode(2)root.right?.left = TreeNode(2)root.right?.right = TreeNode(5)val result = maxSumBST(root)println("最大BST子树的键值和: $result") // 应该输出6
}
高可用集群)