算法：[递归/搜索/回溯]二叉树的深搜

目录

题目一：计算布尔二叉树的值

题目二：求根节点到叶节点数字之和

题目三：二叉树剪枝

题目四：验证二叉搜索树

题目五：二叉搜索树中第k小的元素

题目六：二叉树的所有路径

---

题目一：计算布尔二叉树的值

给你一棵 完整二叉树 的根，这棵树有以下特征：

• 叶子节点 要么值为 0 要么值为 1 ，其中 0 表示 False ，1 表示 True 。
• 非叶子节点 要么值为 2 要么值为 3 ，其中 2 表示逻辑或 OR ，3 表示逻辑与 AND 。

计算 一个节点的值方式如下：

• 如果节点是个叶子节点，那么节点的 值 为它本身，即 True 或者 False 。
• 否则，计算 两个孩子的节点值，然后将该节点的运算符对两个孩子值进行 运算 。

返回根节点 root 的布尔运算值。

完整二叉树 是每个节点有 0 个或者 2 个孩子的二叉树。

叶子节点 是没有孩子的节点。

示例 1：

输入：root = [2,1,3,null,null,0,1]
输出：true
解释：上图展示了计算过程。
AND 与运算节点的值为 False AND True = False 。
OR 运算节点的值为 True OR False = True 。
根节点的值为 True ，所以我们返回 true 。

示例 2：

输入：root = [0]
输出：false
解释：根节点是叶子节点，且值为 false，所以我们返回 false 。

---

既然是二叉树相关的题目，就考虑使用递归来解决，dfs

题目告诉我们是完整二叉树，也就是每个结点如果有孩子，那就必然有两个孩子，并且叶子结点是true或false，非叶子结点是 | 或 &，通过非叶子的运算符，计算两个叶子结点的值

所以可以宏观看待：

想要得到整棵树的结果，就需要知道根节点左子树和右子树的结果，知道结果后，就可以根据根节点的运算符来计算最终的结果

而子问题同样也是这样，想知道左子树的结果，同样进行上述操作

1、重复子问题(函数头的设计)

bool dfs(root)

2、只关心某个子问题在做什么(函数体的设计)

bool left = dfs(root->left);
bool right= dfs(root->right);
计算最终结果

3、递归的出口(边界情况)

到叶子结点时就不需要计算结果了，因为叶子结点存储的本身就是 true 或 false

代码如下：

class Solution 
{
public:
    bool evaluateTree(TreeNode* root) 
    {
        // 叶子结点时就return，不用判断右孩子，因为左右孩子的状态一样
        if(root->left == nullptr) return root->val == 0 ? false : true;
        // 计算左右子树的结果
        bool left = evaluateTree(root->left);
        bool right = evaluateTree(root->right);
        // 通过root的值和左右子树的结果做计算
        return root->val == 2 ? left | right : left & right;
    }
};

---

题目二：求根节点到叶节点数字之和

给你一个二叉树的根节点 root ，树中每个节点都存放有一个 0 到 9 之间的数字。

每条从根节点到叶节点的路径都代表一个数字：

• 例如，从根节点到叶节点的路径 1 -> 2 -> 3 表示数字 123 。

计算从根节点到叶节点生成的 所有数字之和 。

叶节点 是指没有子节点的节点。

示例 1：

输入：root = [1,2,3]
输出：25
解释：
从根到叶子节点路径 1->2 代表数字 12
从根到叶子节点路径 1->3 代表数字 13
因此，数字总和 = 12 + 13 = 25

示例 2：

输入：root = [4,9,0,5,1]
输出：1026
解释：
从根到叶子节点路径 4->9->5 代表数字 495
从根到叶子节点路径 4->9->1 代表数字 491
从根到叶子节点路径 4->0 代表数字 40
因此，数字总和 = 495 + 491 + 40 = 1026

---

这道题同样使用递归解决，那么递归就需要找到相同的子问题，依旧是下面几步得到解法：

1、重复子问题(函数头的设计)

因为每一个结点都需要返回，到当前结点时代表的数字是多少，所以需要有一个int的返回值，而函数参数不光需要有结点的指针，还需要有之前节点算出来的数字，所以函数头应该为：

int dfs(Node* root, int prevnum);

2、只关心某个子问题在做什么(函数体的设计)

需要找到相同的子问题：

①计算出之前的数字结合当前结点的数字后，最终的数字是多少
②将该结点最后得到的数字给左孩子
③将该结点最后得到的数字给右孩子
④将该结点的孩子节点返回来的值拿到，并相加返回给上一层

3、递归的出口(边界情况)

递归的出口就是到叶子结点时，就退出

不同的是：这里到了叶子结点，也需要先将这个结点的数字与之前的数字结合，再退出

代码如下：

class Solution 
{
public:
    // prevnum表示前驱和
    int dfs(TreeNode* root, int prevnum)
    {
        // 第一步，先将prevnum与前面得到的 前驱和 组合
        prevnum = prevnum * 10 + root->val;
        // 到叶子结点返回即可，递归出口
        if(root->left == nullptr && root->right == nullptr)
            return prevnum;
        int ret = 0;
        // 第二、三步，进入当前结点的左右字树中
        if(root->left) ret += dfs(root->left, prevnum);
        if(root->right) ret += dfs(root->right, prevnum);
        // 第四步，返回当前节点左右字树构成数字的和
        return ret;
    }

    int sumNumbers(TreeNode* root) 
    {
        // 初始的前驱和为0
        return dfs(root, 0);
    }
};

---

题目三：二叉树剪枝

给你二叉树的根结点 root ，此外树的每个结点的值要么是 0 ，要么是 1 。

返回移除了所有不包含 1 的子树的原二叉树。

节点 node 的子树为 node 本身加上所有 node 的后代。

示例 1：

输入：root = [1,null,0,0,1]
输出：[1,null,0,null,1]
解释：
只有红色节点满足条件“所有不包含 1 的子树”。 右图为返回的答案。

示例 2：

输入：root = [1,0,1,0,0,0,1]
输出：[1,null,1,null,1]

示例 3：

输入：root = [1,1,0,1,1,0,1,0]
输出：[1,1,0,1,1,null,1]

---

这里的剪枝，指的是子树中全部是0时，才会剪枝

又因为判断该节点是否剪枝，需要看该节点的左右孩子的值是否全部为0，所以是后序遍历的过程

1、重复子问题(函数头的设计)

因为每次子树剪枝或不剪枝，都需要返回给上一层，所以需要返回值，且只需要传入节点指针即可

Node* dfs(Node* root)

2、只关心某个子问题在做什么(函数体的设计)

只研究一个结点，得到子问题在做的事情

①处理当前节点的左子树
②处理当前结点的右子树
③根据左右字树的结果，以及自身的值，判断是否剪枝

3、递归的出口(边界情况)

边界情况也比较简单，当运行到nullptr时，就return

root == nullptr

代码如下：

class Solution 
{
public:
    TreeNode* pruneTree(TreeNode* root) 
    {
        // 边界条件
        if(root == nullptr) return nullptr;
        // 判断左右字树是否为空，以及自身的val是否为0
        root->left = pruneTree(root->left);
        root->right = pruneTree(root->right);
        if(root->left == nullptr && root->right == nullptr && root->val == 0)
            root = nullptr;
        // 返回给上一层
        return root;
    }
};

---

题目四：验证二叉搜索树

给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

有效 二叉搜索树定义如下：

• 节点的左

  子树

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

示例 1：

输入：root = [2,1,3]
输出：true

示例 2：

输入：root = [5,1,4,null,null,3,6]
输出：false
解释：根节点的值是 5 ，但是右子节点的值是 4 。

---

二叉搜索树也就是你的左子树必须要全部小于根节点，右子树必须全部大于根节点，并且左右字树也是符合上述的要求，此时这棵树就称之为二叉搜索树

我们知道二叉搜索树中序遍历的结果，是一个有序的序列

非常容易想到的一种方式就是将这个树中序遍历一遍，再将遍历后的结果存入一个数组中，再判断该数组是否是有序的，这种方式可行，但是消耗空间太多了，空间复杂度是O(N)了

那么换一种思路，既然中序遍历是有序的，那么我每次遍历到一个节点时，可以肯定的是：该结点是比上一个结点大的，所以就根据这个思路，不需要将整个树中序遍历一遍再判断遍历的结果，而是每次遍历到一个结点时就判断是否大于上一个结点的val

所以这里只需要创建一个全局变量prev，这样就不需要dfs的时候还需要传入一个变量prev了

当发现一个结点不符合上述规定时，就直接返回false，不需要再中序遍历其他没有遍历到的子树了

代码如下：

class Solution 
{
public:
    // 因为题目中最小的就是INT_MIN，所以这里使用long类型的最小值
    long prev = LONG_MIN;
    bool isValidBST(TreeNode* root) 
    {
        // 根节点是nullptr，就返回true
        if(root == nullptr) return true;
        // 先拿到左子树的结果
        bool left = isValidBST(root->left);
        // 剪枝，如果一个节点是false，就不需要遍历其他的了  
        if(left == false) return false;
        // 判断当前节点
        if(root->val > prev) prev = root->val;
        else return false; // 同样是剪枝操作
        // 再拿到右子树的结果
        bool right = isValidBST(root->right);
        return left && right;
    }
};

---

题目五：二叉搜索树中第k小的元素

给定一个二叉搜索树的根节点 root ，和一个整数 k ，请你设计一个算法查找其中第 k 小的元素（从 1 开始计数）。

示例 1：

输入：root = [3,1,4,null,2], k = 1
输出：1

示例 2：

输入：root = [5,3,6,2,4,null,null,1], k = 3
输出：3

---

这道题其实在我们知道中序遍历的结果是有序的这个概念后，就非常简单了，也就是中序遍历的过程中，遍历一次计数一次，直到第k次就是题目所求的元素

同样，这里遍历时可以使用全局遍历，这样就不需要都传参数了

几乎每一个递归题都会体现回溯的特性，就按中序遍历的题看，每当走到空节点时，就不会继续往下递归了，而会返回上一级的结点，这就叫做回溯

也就是设定两个全局遍历，一个用来计数，一个用来当找到第k小个元素时记录该元素，并且在代码中也可以加上剪枝的操作，也就是当找到第k小个元素后，就不需要继续遍历了

代码如下：

class Solution 
{
public:
    int count;   // count是用来计数的
    int ret = 0; // ret是最终结果
    int kthSmallest(TreeNode* root, int k) 
    {
        count = k;
        dfs(root);
        return ret;
    }

    void dfs(TreeNode* root)
    {
        // if中加上count == 0，进行剪枝操作
        if(root == nullptr || count == 0) return;
        dfs(root->left);
        count--;
        if(count == 0) 
        {
            ret = root->val;
            return;
        }
        dfs(root->right);
    }
};

---

题目六：二叉树的所有路径

给你一个二叉树的根节点 root ，按 任意顺序 ，返回所有从根节点到叶子节点的路径。

叶子节点 是指没有子节点的节点。

示例 1：

输入：root = [1,2,3,null,5]
输出：["1->2->5","1->3"]

示例 2：

输入：root = [1]
输出：["1"]

---

这道题比较简单，为了说明 回溯 -> 恢复现场 这个情况

前面说到了只要有深度优先dfs，必然会出现回溯，而只要回溯，就必然会有恢复现场

所以总结一下：只要有深度优先变量，就必然会有恢复现场的操作

下面说说这道题的思路，其实很简单，就是从根节点开始，每次都记录路径，到叶子节点后就存储当前的路径，直到循环完这棵树为止

这时解题中，会定义一个全局变量ret，ret是string类型的数组用于存储所有的路径

而string类型的path存储每次的路径，在该题中不适合设置为全局变量，因为每次回溯时都需要pop，甚至需要pop好几个字符，比较麻烦，所以该题中将path当做参数传入是比较方便的

如果没有将path设置为局部变量，而是设置为了全局变量，这时就会引出恢复现场这个动作，因为当执行到一个叶子结点处，将叶子结点的路径path存入ret后，path会回溯到上一层，这时如果不恢复现场，path中就会多一个叶子结点，不符合题意，所以需要恢复现场

代码如下：

class Solution 
{
public:
    vector<string> ret; // 最终结果
    vector<string> binaryTreePaths(TreeNode* root) 
    {
        string path;
        dfs(root, path);
        return ret;
    }

    void dfs(TreeNode* root, string path)
    {
        path += to_string(root->val);
        // 这里直接剪枝，如果判断出是叶子结点，直接return，不需要进入
        if(root->left == nullptr && root->right == nullptr)
        {
            ret.push_back(path);
            return;
        }
        path += "->";
        // 这里的if判断其实就是剪枝的操作，如果为空就不进入了
        if(root->left) dfs(root->left, path);
        if(root->right) dfs(root->right, path);
    }
};

---

二叉树的深搜题目到此结束