代码随想录第十四天：左下角的值、路径总和、中序后序构造二叉树

1.左下角的值

题目链接：. - 力扣（LeetCode）

讲解链接：代码随想录 (programmercarl.com)

视频链接：怎么找二叉树的左下角？ 递归中又带回溯了，怎么办？| LeetCode：513.找二叉树左下角的值_哔哩哔哩_bilibili

寻找二叉树左下角的值，即最后一行左边的值。立刻想到使用层序遍历解决，只要遍历到最后一层，输出第一个结点即可。

代码如下：

int findBottomLeftValue(TreeNode* root) {
    queue<TreeNode*> que;
    que.push(root);
    while (!que.empty()){
        int size = que.size();
        bool isButtom = true;
        int temp = que.front()->val;
        for (int i = 0; i < size; ++i) {
            TreeNode* cur = que.front();
            que.pop();
            if (cur->left) {
                que.push(cur->left);
                isButtom = false;
            }
            if (cur->right) {
                que.push(cur->right);
                isButtom = false;
            }
        }
        if (isButtom)
            return temp;
    }
    return 0;
}

2.路径总和

题目链接：. - 力扣（LeetCode）

讲解链接：代码随想录 (programmercarl.com)

视频链接：拿不准的遍历顺序，搞不清的回溯过程，我太难了！ | LeetCode：112. 路径总和_哔哩哔哩_bilibili

递归法：

三要素

1.确定参数与返回值：本题需要判断路径是否满足要求，需要返回bool类型。传入树结点指针，和一个计数器，用来判断该条路径是否满足要求。且递归过程中不要将遍历的结点相加来，而要将目标值减去遍历结点的值，这样方便处理。

2.终止条件：如果遍历到叶子结点，且计数器此时减到0，就返回true，否则返回false。

3.单层逻辑：如果遍历到非叶子节点，就向它的左右孩子递归（如果有的话），并且将叶子结点的返回值一层层传递出来。

代码如下：

bool traversal(TreeNode* cur, int count){
    if (!cur->left && !cur->right && count == 0)
        return true;
    if (!cur->left && !cur->right)
        return false;
    if (cur->left){
        if (traversal(cur->left, count - cur->left->val))
            return true;
    }
    if (cur->right){
        if (traversal(cur->right, count - cur->right->val))
            return true;
    }
    return false;
}

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

3.根据中序和后序构建二叉树

题目链接：. - 力扣（LeetCode）

讲解链接：代码随想录 (programmercarl.com)

视频链接：坑很多！来看看你掉过几次坑 | LeetCode：106.从中序与后序遍历序列构造二叉树_哔哩哔哩_bilibili

构建的思路如下：

我们要实现的是用代码构建以上过程，通过递归实现。

三要素

1.参数与返回值：要返回当前递归处理序列构建的树结点指针，参数是中序和后序序列。注意到不同递归处理的序列不同，如果每次都是用新数组复制序列则会造成代码性能差，时间和空间复杂度都增加。所以可以使用下标代替新数组，因此参数需要多加上四个下标参数，表示处理的数据范围。而下标是开区间还是闭区间需要统一。

2.终止条件：以左闭右开为例，左边界为最左边的元素，右边界为最右边元素的下一位。当左右边界相等时，区间内没有元素，返回空指针。若区间内只有一个元素，说明它是叶子结点没有其他子结点了，可以直接返回新树结点指针，

3.单层逻辑：后序序列的最后一个元素就是根节点，而中序序列的根节点左边是左子树，右边是右子树，因此我们首先根据后序序列在中序序列中找到根节点，然后将中序和后序序列分别分成两个序列（不包括根节点），然后递归处理两个新的序列，将其作为根节点的左右子树。

代码如下：

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());
    }