Day18|leetcode 513.找树左下角的值、112.路径总和、106.从中序与后序遍历序列构造二叉树

leetcode 513.找树左下角的值

题目链接：513. 找树左下角的值 - 力扣（LeetCode）

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

题目概述：

给定一个二叉树的 根节点 root，请找出该二叉树的 最底层 最左边 节点的值。

假设二叉树中至少有一个节点。

示例 1:

输入: root = [2,1,3]
输出: 1

示例 2:

输入: [1,2,3,4,null,5,6,null,null,7]
输出: 7

思路

这道题需要注意的是：并不是一直往左边遍历，就能找到最左边节点的值，要先找到最底层然后再找最左边的值才可以。所以说，这道题用前中后序都可以，只要强调先左后右就行，中有没有都可以，而最后一层就是最大深度。

代码实现

class Solution {
public:
    int maxDepth = INT_MIN;
    int result;
    void traversal(TreeNode* root, int depth) {
        if (root->left == NULL && root->right == NULL) {
            if (depth > maxDepth) {
                maxDepth = depth;
                result = root->val;
            }
            return;
        }
        if (root->left) {
            depth++;
            traversal(root->left, depth);
            depth--; 
        }
        if (root->right) {
            depth++;
            traversal(root->right, depth);
            depth--; 
        }
        return;
    }
    int findBottomLeftValue(TreeNode* root) {
        traversal(root, 0);
        return result;
    }
};

代码里的depth--其实就是回溯，就相当于遍历到了最底下然后原路返回。

leetcode 112.路径总和

题目链接：112. 路径总和 - 力扣（LeetCode）

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

题目概述：

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。

示例 1：

输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
输出：true
解释：等于目标和的根节点到叶节点路径如上图所示。

 
示例 2：

输入：root = [1,2,3], targetSum = 5
输出：false
解释：树中存在两条根节点到叶子节点的路径：
(1 --> 2): 和为 3
(1 --> 3): 和为 4
不存在 sum = 5 的根节点到叶子节点的路径。

思路

本题说判断该树中是否存在一条从根节点到叶子节点的路径，且这条路径上所有节点值相加等于目标值，所以说本题并不用把所有节点都遍历一遍，只用找出其中一条符合要求的路径返回true就行了。

正常来说比较顺的思路就是遍历节点，然后把节点值相加，最后判断是否等于目标值，思路没毛病，但是代码写起来比较麻烦。其实也可以使用递减法，让count等于目标值，然后遍历一条路径中的节点时让count做减法，如果count==0，就返回true。

这道题用前中后序遍历哪个都可以，因为中可有可无，不用去管中，只要把左和右写明白就行。

代码实现

class Solution {
private:
    bool traversal(TreeNode* cur,int count) {
        if(!cur->left && !cur->right && count==0) return true;
        if(!cur->left && !cur->right && count!=0) 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);

    }
};

递归回溯是一家，而count减完再加回来，加回来的过程就体现了回溯，因为你从根节点一直往下遍历，当你遍历到最后一个结点的时候，要是不重新回到根节点，那如何在找下一条路径呢？所以需要加回来。

（写完112，可以再试一下113）

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

题目链接：106. 从中序与后序遍历序列构造二叉树 - 力扣（LeetCode）

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

题目概述：

给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗 二叉树 。

示例 1:

输入：inorder = [9,3,15,20,7], postorder = [9,15,7,20,3]
输出：[3,9,20,null,null,15,7]

思路

本题说要构造一个二叉树，那么就想二叉树是如何构建的，要先知道根节点，然后再有左子树，然后再有右子树，然后左子树父节点，左孩子、右孩子，右子树父节点，左孩子、右孩子......这道题说用中序和后序构建二叉树，中序是：左中右、后序是：左右中，由此不难找出根节点是后序的中，因为中序已经用中把左右树都分割开了，就不难找出左右树了。

说白了就是用后序最后一个数作为切割点，先切割中序，再切割后序，这样就能构建出一个二叉树了。如图所示：

· 需要注意的是：用后序最后一个元素作为切割点，一定要先切割中序，再切割后序，顺序千万别错了！！还有就是要注意区间，不要一会左闭右开，一会左闭右闭的！

代码实现（左闭右开）

class Solution {
private:
    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;
        }

        // 切割中序数组
        // 左闭右开区间：[0, delimiterIndex)
        vector<int> leftInorder(inorder.begin(), inorder.begin() + delimiterIndex);
        // [delimiterIndex + 1, end)
        vector<int> rightInorder(inorder.begin() + delimiterIndex + 1, inorder.end() );

        // postorder 舍弃末尾元素
        postorder.resize(postorder.size() - 1);

        // 切割后序数组
        // 依然左闭右开，注意这里使用了左中序数组大小作为切割点
        // [0, leftInorder.size)
        vector<int> leftPostorder(postorder.begin(), postorder.begin() + leftInorder.size());
        // [leftInorder.size(), end)
        vector<int> rightPostorder(postorder.begin() + leftInorder.size(), postorder.end());

        root->left = traversal(leftInorder, leftPostorder);
        root->right = traversal(rightInorder, rightPostorder);

        return root;
    }
public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if (inorder.size() == 0 || postorder.size() == 0) return NULL;
        return traversal(inorder, postorder);
    }
};