二叉树总结二

关注

原创最新推荐文章于 2026-02-17 16:33:15 发布 328 阅读 AI 写同款· GEO 优化 ›

左神算法：找到二叉树中的最大搜索二叉子树（树形dp套路，Java版）本题来自左神《程序员代码面试指南》“找到二叉树中的最大搜索二叉子树”题目。题目给定一棵二叉树的头节点 head，已知其中所有节点的值都不一样，找到含有节点最多的搜索二叉子树，并返回这棵子树的头节点。例如，二叉树如图 3-17 所示。这棵树中的最大搜索二叉子树如图 3-18 所示。要求：如果节点数为 N，则要求时间复杂度为 O(N)，额外空间复杂度为 O(h)，其中，h 为二叉树的高度。题解本题涉及二叉树面试题中一个很常见的套路，也是全书的一个重要内容。利用分析可能性求解在二叉树上做类似动. 阅读详情

复习下写递归的重要方法：

确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数，并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。
确定终止条件： 写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。
确定单层递归的逻辑： 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。

654.最大二叉树

力扣题目地址(opens new window)

给定一个不含重复元素的整数数组。一个以此数组构建的最大二叉树定义如下：

二叉树的根是数组中的最大元素。
左子树是通过数组中最大值左边部分构造出的最大二叉树。
右子树是通过数组中最大值右边部分构造出的最大二叉树。

通过给定的数组构建最大二叉树，并且输出这个树的根节点。

方法是从数组中构建二叉树。

创建一个根节点，其值为 nums 中的最大值。
递归地在最大值左边的 子数组前缀上 构建左子树。
递归地在最大值右边的 子数组后缀上 构建右子树。

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func constructMaximumBinaryTree(nums []int) *TreeNode {
    if len(nums) < 1 {
        return nil
    }
    index:=findMax(nums)
    root := &TreeNode{
        Val:nums[index],
        Left:constructMaximumBinaryTree(nums[:index]),
        Right:constructMaximumBinaryTree(nums[index+1:]),
    }
    return root
}

func findMax(nums []int) (index int){
    for i:=0;i<len(nums);i++{
        if nums[i]>nums[index]{
            index=i
        }
    }
    return 
}

617.合并二叉树

力扣题目链接(opens new window)

给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。

你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。

示例 1:

617.合并二叉树

注意: 合并必须从两个树的根节点开始。

那么我们来按照递归三部曲来解决：

确定递归函数的参数和返回值：

首先那么要合入两个二叉树，那么参数至少是要传入两个二叉树的根节点，返回值就是合并之后二叉树的根节点。

代码如下：

TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {

确定终止条件：

因为是传入了两个树，那么就有两个树遍历的节点t1 和 t2，如果t1 == NULL 了，两个树合并就应该是 t2 了啊（如果t2也为NULL也无所谓，合并之后就是NULL）。

反过来如果t2 == NULL，那么两个数合并就是t1（如果t1也为NULL也无所谓，合并之后就是NULL）。

代码如下：

if (t1 == NULL) return t2; // 如果t1为空，合并之后就应该是t2
if (t2 == NULL) return t1; // 如果t2为空，合并之后就应该是t1

确定单层递归的逻辑：

单层递归的逻辑就比较好些了，这里我们用重复利用一下t1这个树，t1就是合并之后树的根节点（就是修改了原来树的结构）。

那么单层递归中，就要把两棵树的元素加到一起。

t1->val += t2->val;

接下来t1 的左子树是：合并 t1左子树 t2左子树之后的左子树。

t1 的右子树：是合并 t1右子树 t2右子树之后的右子树。

最终t1就是合并之后的根节点。

代码如下：

t1->left = mergeTrees(t1->left, t2->left);
t1->right = mergeTrees(t1->right, t2->right);
return t1;

得出一下代码：

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func mergeTrees(root1 *TreeNode, root2 *TreeNode) *TreeNode {
    if root1 == nil{
        return root2
    }
    if root2 == nil{
        return root1
    }

    root1.Val+=root2.Val
    root1.Left = mergeTrees(root1.Left,root2.Left)
    root1.Right = mergeTrees(root1.Right,root2.Right)
    return root1
}

700.二叉搜索树中的搜索

力扣题目地址(opens new window)

给定二叉搜索树（BST）的根节点和一个值。你需要在BST中找到节点值等于给定值的节点。返回以该节点为根的子树。如果节点不存在，则返回 NULL。

例如，

700.二叉搜索树中的搜索

在上述示例中，如果要找的值是 5，但因为没有节点值为 5，我们应该返回 NULL。

递归三部曲：

递归法

确定递归函数的参数和返回值

递归函数的参数传入的就是根节点和要搜索的数值，返回的就是以这个搜索数值所在的节点。

代码如下：

TreeNode* searchBST(TreeNode* root, int val)

确定终止条件

如果root为空，或者找到这个数值了，就返回root节点。

if (root == NULL || root->val == val) return root;

确定单层递归的逻辑

看看二叉搜索树的单层递归逻辑有何不同。

因为二叉搜索树的节点是有序的，所以可以有方向的去搜索。

如果root->val > val，搜索左子树，如果root->val < val，就搜索右子树，最后如果都没有搜索到，就返回NULL。

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func searchBST(root *TreeNode, val int) *TreeNode {
    if root == nil {
        return nil
    }
    if root.Val == val {
        return root
    }
    if root.Val > val {
        return searchBST(root.Left, val)
    } else {
        return searchBST(root.Right,val)
    }
}

98.验证二叉搜索树

力扣题目链接(opens new window)

给定一个二叉树，判断其是否是一个有效的二叉搜索树。

假设一个二叉搜索树具有如下特征：

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

98.验证二叉搜索树

#视频讲解

《代码随想录》算法视频公开课：你对二叉搜索树了解的还不够！ | LeetCode：98.验证二叉搜索树 (opens new window)，相信结合视频在看本篇题解，更有助于大家对本题的理解。

#思路

要知道中序遍历下，输出的二叉搜索树节点的数值是有序序列。

有了这个特性，验证二叉搜索树，就相当于变成了判断一个序列是不是递增的了。

复习下二叉搜索树

二叉查找树（Binary Search Tree）二叉查找树是二叉树中最常用的一种类型，也叫二叉搜索树。顾名思义，二叉查找树是为了实现快速查找而生的。

二叉查找树要求，在树中的任意一个节点，其左子树中的每个节点的值，都要小于这个节点的值，而右子树节点的值都大于这个节点的值

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func isValidBST(root *TreeNode) bool {
    if root == nil {
        return true
    }

    return helper(root,math.MinInt64,math.MaxInt64)
}

func helper(node *TreeNode, min,max int64) bool{
    if node == nil {
        return true
    }

    if min >= int64(node.Val) || max <= int64(node.Val) {
        return false
    }

    // 分别对左子树和右子树递归判断，如果左子树和右子树都符合则返回true
    return helper(node.Right,int64(node.Val),max) && helper(node.Left,min,int64(node.Val))
}

530.二叉搜索树的最小绝对差

力扣题目链接(opens new window)

给你一棵所有节点为非负值的二叉搜索树，请你计算树中任意两节点的差的绝对值的最小值。

示例：

530二叉搜索树的最小绝对差

提示：树中至少有 2 个节点。

中序遍历，左，中，右，二叉搜索树。左结点小于根结点，右结点大于根节点，可以得出有序数组。从小到大排序。然后求相邻的元素差即可

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */

func getMinimumDifference(root *TreeNode) int {
    var nums []int
    var inorder func(node *TreeNode)
    inorder = func(node *TreeNode){
        if node == nil {
            return
        }
        inorder(node.Left)
        nums=append(nums,node.Val)
        inorder(node.Right)
    }
    inorder(root)
    fmt.Println(nums)
    min:=nums[len(nums)-1]
    for i:=1;i<len(nums);i++{
        if nums[i]-nums[i-1] < min {
            min = nums[i]-nums[i-1]
        }
    }
    return min
}

501.二叉搜索树中的众数

力扣题目链接(opens new window)

给定一个有相同值的二叉搜索树（BST），找出 BST 中的所有众数（出现频率最高的元素）。

假定 BST 有如下定义：

结点左子树中所含结点的值小于等于当前结点的值
结点右子树中所含结点的值大于等于当前结点的值
左子树和右子树都是二叉搜索树

例如：

给定 BST [1,null,2,2],

501. 二叉搜索树中的众数

返回[2].

提示：如果众数超过1个，不需考虑输出顺序

进阶：你可以不使用额外的空间吗？（假设由递归产生的隐式调用栈的开销不被计算在内）

简单方法：使用map统计

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func findMode(root *TreeNode) []int {
    var res = make(map[int]int,0)
    var inorder func(node *TreeNode)
    max:=0
    
    inorder = func(node *TreeNode){
        if node == nil {
            return
        }
        inorder(node.Left)
        res[node.Val]++
        inorder(node.Right)
    }
    inorder(root)
    index:=[]int{}
    fmt.Println(res)
    for _,v := range res {
        if v > max {
            max = v
        }
    }
    for k,v := range res {
        if v == max {
            index=append(index,k)
        }
    }
    return index
}

不需要建立这么多额外空间的做法：

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func findMode(root *TreeNode) []int {
    res := make([]int,0)
    if root == nil {
        return res
    }
    max:=1
    count:=1
    var prev *TreeNode
    var traversal func(node *TreeNode)
    traversal = func(node *TreeNode){
        if node == nil {
            return
        }
        traversal(node.Left)
        //递归单层逻辑
        if prev != nil && prev.Val == node.Val {
            count += 1
        } else {
            count = 1
        }
        if count >= max {
            if count > max && len(res) > 0 {
                res = []int{node.Val}
            } else {
                res = append(res,node.Val)
            }
            max = count
        }
        prev = node
        traversal(node.Right)
    }
    traversal(root)
    return res
}

236. 二叉树的最近公共祖先

力扣题目链接(opens new window)

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4]

236. 二叉树的最近公共祖先

示例 1: 输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 输出: 3 解释: 节点 5 和节点 1 的最近公共祖先是节点 3。

示例 2: 输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 输出: 5 解释: 节点 5 和节点 4 的最近公共祖先是节点 5。因为根据定义最近公共祖先节点可以为节点本身。

说明:

所有节点的值都是唯一的。
p、q 为不同节点且均存在于给定的二叉树中。

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
 func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {

     if root == nil {
         return root
     }

     //p 或者 q 本身就是公共祖先
     if root == p || root == q {
         return root
     }

     left := lowestCommonAncestor(root.Left, p , q)
     right := lowestCommonAncestor(root.Right, p , q)

    // Conquer
    // 左右两边都不为空，则根节点为祖先
     if left != nil && right != nil {
        return root
     }

     if left != nil {
         return left
     }

     if right != nil {
         return right
     }
     
     return nil
}

235. 二叉搜索树的最近公共祖先

力扣题目链接(opens new window)

给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。

例如，给定如下二叉搜索树: root = [6,2,8,0,4,7,9,null,null,3,5]

235. 二叉搜索树的最近公共祖先

示例 1:

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
输出: 6
解释: 节点 2 和节点 8 的最近公共祖先是 6。

示例 2:

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
输出: 2
解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。

说明:

所有节点的值都是唯一的。
p、q 为不同节点且均存在于给定的二叉搜索树中。

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val   int
 *     Left  *TreeNode
 *     Right *TreeNode
 * }
 */

func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
	if root == nil {
        return root
    }

    if root.Val > p.Val && root.Val > q.Val {
        left:=lowestCommonAncestor(root.Left , p, q)
        if left != nil {
            return left
        }
    }

    if root.Val < p.Val && root.Val < q.Val {
        right:=lowestCommonAncestor(root.Right, p, q)
        if right != nil {
            return right
        }
    }
    
    return root
    
}

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

力扣题目链接(opens new window)

给定二叉搜索树（BST）的根节点和要插入树中的值，将值插入二叉搜索树。返回插入后二叉搜索树的根节点。输入数据保证，新值和原始二叉搜索树中的任意节点值都不同。

注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。你可以返回任意有效的结果。

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

提示：

给定的树上的节点数介于 0 和 10^4 之间
每个节点都有一个唯一整数值，取值范围从 0 到 10^8
-10^8 <= val <= 10^8
新值和原始二叉搜索树中的任意节点值都不同

func insertIntoBST(root *TreeNode, val int) *TreeNode {
    if root == nil {
        root = &TreeNode{Val: val}
        return root
    }
    if root.Val > val {
        root.Left = insertIntoBST(root.Left, val)
    } else {
        root.Right = insertIntoBST(root.Right, val)
    }
    return root
}

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

力扣题目链接(opens new window)

给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的 key 对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。

一般来说，删除节点可分为两个步骤：

首先找到需要删除的节点；如果找到了，删除它。说明：要求算法时间复杂度为 $O(h)$，h 为树的高度。

示例:

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

#思路

搜索树的节点删除要比节点增加复杂的多，有很多情况需要考虑，做好心里准备。

第一种情况是，如果要删除的节点没有子节点，我们只需要直接将父节点中，指向要删除节点的指针置为 null。

第二种情况是，如果要删除的节点只有一个子节点（只有左子节点或者右子节点），我们只需要更新父节点中，指向要删除节点的指针，让它指向要删除节点的子节点就可以了。

第三种情况是，如果要删除的节点有两个子节点，这就比较复杂了。我们需要找到这个节点的右子树中的最小节点，把它替换到要删除的节点上。然后再删除掉这个最小节点，因为最小节点肯定没有左子节点（如果有左子结点，那就不是最小节点了），所以，我们可以应用上面两条规则来删除这个最小节点。

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */

 /*
    第一种情况是，如果要删除的节点没有子节点，我们只需要直接将父节点中，指向要删除节点的指针置为 null。
    第二种情况是，如果要删除的节点只有一个子节点（只有左子节点或者右子节点），我们只需要更新父节点中，指向要删除节点的指针，让它指向要删除节点的子节点就可以了。
    第三种情况是，如果要删除的节点有两个子节点，这就比较复杂了。我们需要找到这个节点的右子树中的最小节点，把它替换到要删除的节点上。然后再删除掉这个最小节点，因为最小节点肯定没有左子节点（如果有左子结点，那就不是最小节点了），所以，我们可以应用上面两条规则来删除这个最小节点。
 */
func deleteNode(root *TreeNode, key int) *TreeNode {
    p := root // p指向要删除的节点，初始化指向根节点
    var pp *TreeNode = nil // pp记录的是p的父节点

    for p != nil && p.Val != key {
        pp = p //这个时候p就是要删除的节点，pp就是要删除节点的父节点
        if key > p.Val {
            p=p.Right
        } else {
            p=p.Left
        }
    }

    if p == nil { // 没有找到
        return root
    }

    // 要删除的节点有两个子节点
    if p.Left != nil && p.Right != nil { // 查找右子树中最小节点

        var minP *TreeNode = nil
        var minPP *TreeNode = nil

        minP = p.Right
        minPP = p

        for minP.Left != nil {
            minPP = minP
            minP  = minP.Left
        }

        p.Val = minP.Val // 将minP的数据替换到p中

        p = minP 
        pp = minPP // 下面就变成了删除minP了
    }

    // 删除节点是叶子节点或者仅有一个子节点
    var child *TreeNode = nil

    if p.Left != nil {
        child = p.Left
    } else if p.Right != nil {
        child = p.Right
    } else {
        child = nil
    }
    
    if pp == nil {
        root = child
    } else if pp.Left == p {
        pp.Left = child
    } else {
        pp.Right = child
    }
    
    return root
}