【代码随想录算法训练营第37期 】day18 | LeetCode513.找树左下角的值、112. 路径总和、113.路径总和ii、106.从中序与后序遍历序列构造二叉树

112. 路径总和

这题需要注意的是对于回溯的关注，正常写法如下：

count -= cur->left->val; // 递归，处理节点;
if (traversal(cur->left, count)) return true;
count += cur->left->val; // 回溯，撤销处理结果

这里将回溯的逻辑详细的写出来了，但由于在传参数的时候可以传 count - cur->left->val，这样的写法不会改变当前层（节点） 的count值，所以回溯到当前节点进行另一子树的递归时，可以保证当前回溯到该节点的count的正确性。这样写就隐藏了回溯的逻辑，以前写都没有注意这点，以后写之前需要思考一下回溯的问题。

class Solution {
private:
    bool traversal(TreeNode* cur, int count) {
        if (!cur->left && !cur->right && count == 0) return true; // 遇到叶子节点，并且计数为0
        if (!cur->left && !cur->right) return false; // 遇到叶子节点直接返回

        if (cur->left) { // 左
            count -= cur->left->val; // 递归，处理节点;
            if (traversal(cur->left, count)) return true;
            count += cur->left->val; // 回溯，撤销处理结果
        }
        if (cur->right) { // 右
            count -= cur->right->val; // 递归，处理节点;
            if (traversal(cur->right, count)) return true;
            count += cur->right->val; // 回溯，撤销处理结果
        }
        return false;
    }

public:
    bool hasPathSum(TreeNode* root, int sum) {
        if (root == NULL) return false;
        return traversal(root, sum - root->val);
    }
};

113.路径总和ii

递归函数什么时候需要返回值？什么时候不需要返回值？这里总结如下三点：

• 如果需要搜索整棵二叉树且不用处理递归返回值，递归函数就不要返回值。（这种情况就是本文下半部分介绍的113.路径总和ii）
• 如果需要搜索整棵二叉树且需要处理递归返回值，递归函数就需要返回值。 （这种情况我们在236. 二叉树的最近公共祖先 (opens new window)中介绍）
• 如果要搜索其中一条符合条件的路径，那么递归一定需要返回值，因为遇到符合条件的路径了就要及时返回。（本题的情况）

这题就是递归函数不需要返回值的题型。

这题的要求是找所有符合条件的路径，所以不能碰到符合条件的就直接返回，还需要继续搜索。

class Solution {
public:
    vector<vector<int>> ans;
    vector<int> path;

    void traversal(TreeNode* cur, int targetSum) {
        // 当到达叶子节点时，检查是否满足路径和条件
        if (!cur->left && !cur->right) {
            if(targetSum == cur->val){
                path.push_back(cur->val);
                ans.push_back(path);
                path.pop_back();
            }
            return;
        }
        
        // 递归检查左右子树
        if (cur->left) {
            path.push_back(cur->val);
            traversal(cur->left, targetSum - cur->val);
            path.pop_back();
        }
        if (cur->right) {
            path.push_back(cur->val);
            traversal(cur->right, targetSum - cur->val);
            path.pop_back();
        }
        return;
    }
    
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        ans.clear();
        path.clear();
        if (root == NULL) return ans;
        traversal(root, targetSum);
        return ans;
    }
};

这里可以发现在递归函数中，在所有的条件分支中，都有push和pop的操作，我们可以把这个操作提出来。写成以下形式

class Solution {
public:
    vector<vector<int>> ans;
    vector<int> path;

    void traversal(TreeNode* cur, int targetSum) {
        path.push_back(cur->val);
        // 当到达叶子节点时，检查是否满足路径和条件
        if (!cur->left && !cur->right) {
            if(targetSum == cur->val){
                ans.push_back(path);
            }
        }
        else{
            // 递归检查左右子树
            if (cur->left) {
                traversal(cur->left, targetSum - cur->val);
            }
            if (cur->right) {
                traversal(cur->right, targetSum - cur->val);
            }
        }
        path.pop_back();
    }
    
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        ans.clear();
        path.clear();
        if (root == NULL) return ans;
        //path.push_back(root->val); // 把根节点放进路径
        traversal(root, targetSum);
        return ans;
    }
};

106.从中序与后序遍历序列构造二叉树

. - 力扣（LeetCode）

这题重点有两个：

1、怎么从中序，后序序列中找到根节点，并将中序，后续序列划分为左子树部分，右子树部分和根，再对左右子树部分的序列找子树的根和左右子树，这里体现了分治的思想。

2、怎么建立一颗二叉树，以下是建立二叉树的代码，之前写的都是遍历二叉树，还没创建过，导致不会处理建立二叉树的递归。

TreeNode* creatTreeNode(TreeNode* root, int val)
{
	if (root == nullptr)
	{
		root = new TreeNode();
		root->val = val;
		return root;
	}

	if (val < root->val)
	{
		root->left = creatTreeNode(root->left, val);
	}
	else if (val > root->val)
	{
		root->right = creatTreeNode(root->right,val);
	}

	return root;
}

以下是整体思路：

• 第一步：如果数组大小为零的话，说明是空节点了。

• 第二步：如果不为空，那么取后序数组最后一个元素作为节点元素。

• 第三步：找到后序数组最后一个元素在中序数组的位置，作为切割点

• 第四步：切割中序数组，切成中序左数组和中序右数组 （顺序别搞反了，一定是先切中序数组）

• 第五步：切割后序数组，切成后序左数组和后序右数组

• 第六步：递归处理左区间和右区间

整体框架可写成如下形式：

TreeNode* traversal (vector<int>& inorder, vector<int>& postorder) {

    // 第一步
    if (postorder.size() == 0) return NULL;

    // 第二步：后序遍历数组最后一个元素，就是当前的中间节点
    int rootValue = postorder[postorder.size() - 1];
    TreeNode* root = new TreeNode(rootValue);

    // 叶子节点
    if (postorder.size() == 1) return root;

    // 第三步：找切割点
    int delimiterIndex;
    for (delimiterIndex = 0; delimiterIndex < inorder.size(); delimiterIndex++) {
        if (inorder[delimiterIndex] == rootValue) break;
    }

    // 第四步：切割中序数组，得到 中序左数组和中序右数组
    // 第五步：切割后序数组，得到 后序左数组和后序右数组

    // 第六步
    root->left = traversal(中序左数组, 后序左数组);
    root->right = traversal(中序右数组, 后序右数组);

    return root;
}

完整代码如下：

class Solution {
private:
    // 中序区间：[inorderBegin, inorderEnd)，后序区间[postorderBegin, postorderEnd)
    TreeNode* traversal (vector<int>& inorder, int inorderBegin, int inorderEnd, vector<int>& postorder, int postorderBegin, int postorderEnd) {
        if (postorderBegin == postorderEnd) return NULL;

        int rootValue = postorder[postorderEnd - 1];
        TreeNode* root = new TreeNode(rootValue);

        if (postorderEnd - postorderBegin == 1) return root;

        int delimiterIndex;
        for (delimiterIndex = inorderBegin; delimiterIndex < inorderEnd; delimiterIndex++) {
            if (inorder[delimiterIndex] == rootValue) break;
        }
        // 切割中序数组
        // 左中序区间，左闭右开[leftInorderBegin, leftInorderEnd)
        int leftInorderBegin = inorderBegin;
        int leftInorderEnd = delimiterIndex;
        // 右中序区间，左闭右开[rightInorderBegin, rightInorderEnd)
        int rightInorderBegin = delimiterIndex + 1;
        int rightInorderEnd = inorderEnd;

        // 切割后序数组
        // 左后序区间，左闭右开[leftPostorderBegin, leftPostorderEnd)
        int leftPostorderBegin =  postorderBegin;
        int leftPostorderEnd = postorderBegin + delimiterIndex - inorderBegin; // 终止位置是 需要加上 中序区间的大小size
        // 右后序区间，左闭右开[rightPostorderBegin, rightPostorderEnd)
        int rightPostorderBegin = postorderBegin + (delimiterIndex - inorderBegin);
        int rightPostorderEnd = postorderEnd - 1; // 排除最后一个元素，已经作为节点了

        root->left = traversal(inorder, leftInorderBegin, leftInorderEnd,  postorder, leftPostorderBegin, leftPostorderEnd);
        root->right = traversal(inorder, rightInorderBegin, rightInorderEnd, postorder, rightPostorderBegin, rightPostorderEnd);

        return root;
    }
public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if (inorder.size() == 0 || postorder.size() == 0) return NULL;
        // 左闭右开的原则
        return traversal(inorder, 0, inorder.size(), postorder, 0, postorder.size());
    }
};