二叉树的深搜与回溯

1. 计算布尔二叉树的值

解法：DFS

class Solution {
public:
    bool evaluateTree(TreeNode* root) {
        // 遇到叶子结点返回叶子结点
        if(root->left == nullptr && root->right == nullptr)
            return root->val == 0 ? false : true;
        // 处理递归之后的结果
        bool left = evaluateTree(root->left);
        bool right = evaluateTree(root->right);
        return root->val == 2 ? (left || right) : (left && right);
    }
};

2. 求根节点到叶结点数字之和

解法：DFS
如图：在递归的过程中，每次递归传入上一次的前缀和与下一个要进入递归的节点，该递归的返回值是当前节点的左右两边返回来的数字之和。

总的代码描述如下：

class Solution {
public:
    // presum: 代表前驱和
    int dfs(TreeNode* root, int presum)
    {
        // 递归结束条件: 遇到叶子结点就返回根节点到叶节点的路径表示的数字
        if(!root->left && !root->right) return 10 * presum + root->val;

        // 递归的过程(注意：空节点的处理)
        int ret = 0;
        if(root->left) ret += dfs(root->left, 10 * presum + root->val);
        if(root->right) ret += dfs(root->right, 10 * presum + root->val);

        // 根节点接受左右递归的返回值
        return ret;
    }
    int sumNumbers(TreeNode* root) {
        return dfs(root, 0);
    }
};

3. 二叉树剪枝

解法：DFS
遇到叶子结点，并且节点值为0就可以删除了，删除很简单，就直接将上一个节点连接到nullptr即可。

总的代码描述如下：

class Solution {
public:
    TreeNode* pruneTree(TreeNode* root) {
        // 递归结束条件
        if(root == nullptr) return nullptr;
        
        // 递归处理左右子树: 如果该节点要删除, 则返回nullptr给上一个节点
        // 如果该节点不需要删除, 则返回该节点本身给上一个节点
        root->left = pruneTree(root->left);
        root->right = pruneTree(root->right);

        // 返回nullptr还是节点本身的判断条件
        if(!root->left && !root->right && root->val == 0)
        {
            //delete root; // 防止内存泄漏(注意如果这个节点不是new出来的, delete则会报错)
            root = nullptr;
        }
        return root;
    }
};

4. 验证二叉搜索树

算法原理：二叉搜索树的中序遍历的结果，最终是一个有序的序列。
用变量prev保存cur前面的节点的值，cur负责中序遍历，类似于用双指针判断有序数组。

（一）递归法
策略一： 判断左子树是不是二叉搜索树，再让前驱结点和根节点去比较判断是否是二叉搜索树，最后判断右子树是不是二叉搜索树。

class Solution {
    long prev = LONG_MIN;
public:
    bool isValidBST(TreeNode* root) {
        if(root == nullptr) return true;

        // 递归处理中序遍历
        // 1. 左子树
        bool left = isValidBST(root->left);
        // 2. 判断中节点的值是否比它的前一个节点要大
        bool cur = false;
        if(root->val > prev)
            cur = true;
        prev = root->val; // 更新前驱节点
        // 3. 右子树
        bool right = isValidBST(root->right);

        return left && cur && right;
    }
};

策略二： 剪枝，如果遇到前驱结点大于了当前节点，这就已经不构成二叉搜索树了，那么右子树就无需再进行深度优先遍历了。
写法一：

class Solution {
    long prev = LONG_MIN;
public:
    bool isValidBST(TreeNode* root) {
        if(root == nullptr) return true;

        // 递归处理中序遍历
        // 1. 左子树
        bool left = isValidBST(root->left);
        // 2. 判断中节点的值是否比它的前一个节点要大 
        if(left == false) return false; // 左子树不满足搜索二叉树, 剪枝

        bool cur = false;
        if(root->val > prev)
            cur = true;
        if(root->val <= prev) return false; // 当前节点不满足搜索二叉树, 剪枝
        prev = root->val; // 更新前驱节点
        
        // 3. 右子树
        bool right = isValidBST(root->right);

        return left && cur && right;
    }
};

（二）迭代法
用栈模拟后序遍历

class Solution {
public:
    bool isValidBST(TreeNode* root) {
        if(!root) return true; // 空节点也是二叉搜索树
        stack<TreeNode*> st;
        TreeNode* cur = root, *prev = nullptr;
        while(cur || !st.empty())
        {
            // 将左路节点依次全部入栈
            while(cur)
            {
                st.push(cur);
                cur = cur->left;
            }

            cur = st.top(); st.pop();
            if(prev != nullptr && prev->val >= cur->val) return false;
            prev = cur; // 记录前一个节点
						
			// 转化为右子树的子问题
            cur = cur->right;
        }
        return true;
    }
};

5. 二叉搜索树的第k小的元素

（一）递归法：
算法原理：中序遍历+全局变量计数
注意剪枝策略的优化，剪枝一般用在递归函数调用前进行，防止进行无用的递归。

class Solution {
    int count = 0; // 计数
    int val = 0; // 存放结果
public:
    void dfs(TreeNode* root)
    {
        if(root == nullptr || count == 0) return; // count == 0就返回包含剪枝策略

        dfs(root->left);
        count--;
        if(count == 0) {
            val = root->val;
            return; // count == 0就返回包含剪枝策略
        }
        dfs(root->right);
    }
    int kthSmallest(TreeNode* root, int k) {
        count = k;
        dfs(root);
        return val;
    }
};

（二）迭代法：
用栈模拟二叉搜索树的中序遍历：

class Solution {
    int count = 0; // 计数
    int val = 0; // 存放结果
public:
    int kthSmallest(TreeNode* root, int k) {
        count = k;
        stack<TreeNode*> st;
        TreeNode* cur = root;
        while(cur || st.size())
        {
            // 左路节点入栈
            while(cur)
            {
                st.push(cur);
                cur = cur->left;
            }
            // 取栈顶元素
            cur = st.top(); st.pop();
            count--;
            if(count == 0) val = cur->val;

            // 转化为右子树的子问题
            cur = cur->right;
        } 
        return val;
    }
};

6. 二叉树的所有路径

这题就是经典的回溯思想的题目，弄清楚回溯的过程以及回溯要还原为原来的状态，这样我们以后碰到了回溯会发现并不难。
首先来理解什么是恢复原来的状态，我们遍历二叉树的时候会用一个变量string path来记录路径。
当path为全局变量时，或者是函数形参传递的是引用，我们在回溯的时候都需要手动去修改变量：

当path为局部变量时，且函数形参为值传递，由于当前栈帧的path和下一层栈帧的path是拷贝的关系，互不影响，那么下一层栈帧结束返回后就回到了原来状态的path。

参考答案如下：

class Solution {
    vector<string> ret; // 记录结果
public:
    void dfs(TreeNode* root, string path)
    {
        path += to_string(root->val);
        // 将路过的节点添加到path中
        if(!root->left && !root->right) // 如果是叶子结点则插入"数字"
        {
            ret.push_back(path);
            return;
        }
        // 如果不是叶子结点插入"数字->"
        path += "->";

        // 递归遍历(注意:下面的两个if都是剪枝操作)
        if(root->left) dfs(root->left, path);
        if(root->right) dfs(root->right, path);
    }
    vector<string> binaryTreePaths(TreeNode* root) {
        string path;
        if(root == nullptr) return ret;
        dfs(root, path);
        return ret;
    }
};