代码随想录算法训练营第18天| 513.找树左下角的值、112. 路径总和、106.从中序与后序遍历序列构造二叉树

513.找树左下角的值

题目链接：找树左下角的值

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

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

递归法：

可以使用前序遍历（当然中序，后序都可以，因为本题没有 中间节点的处理逻辑，只要左优先就行），保证优先左边搜索，然后记录深度最大的叶子节点，此时就是树的最后一行最左边的值。

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

迭代法：

使用层序遍历，使用每层的第一个值更新result。

class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode*> que;
        if (root) que.push(root);
        int result;
        while(!que.empty()){
            int size = que.size();
            for (int i = 0; i < size; i++){
                TreeNode* node = que.front();
                que.pop();
                if (i==0) result = node->val;
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return result;
    }
};

112. 路径总和

题目链接：二叉树的所有路径

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

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

递归法：

递归法分别遍历左右子树中是否有满足sum+node→val==targetSum 的子树，然后依次递归。

class Solution {
public:
    bool hasPathSum(TreeNode* root, int targetSum) {
        if(root)
            return traversal(root,sum,targetSum);
        else
            return false;
    }
private:
    int sum = 0;
    bool traversal(TreeNode*node, int sum, int targetSum){
        sum += node->val;
        if (node->left==NULL&&node->right==NULL){
            if (targetSum==sum){
                return true;
            }else{
                return false;
            }
        }
        bool left = false, right = false;
        if (node->left){
            left = traversal(node->left,sum,targetSum);
        }
        if (node->right){
            right = traversal(node->right,sum,targetSum);
        }
        return left || right;
    }
};

迭代法：

至于非递归的方式，我们可以依然可以使用前序遍历的迭代方式来模拟遍历路径的过程，这里除了模拟递归需要一个栈，同时还需要存放对应的遍历路径求和，这里可以使用pair<TreeNode*,int> 。

class Solution {
public:
    bool hasPathSum(TreeNode* root, int targetSum) {
        stack<pair<TreeNode*, int>> st;
        if (root) {
            st.push(pair<TreeNode*, int>(root, root->val));
        }
        while (!st.empty()) {
            auto node = st.top();
            st.pop();
            if (node.first->left == NULL && node.first->right == NULL) {
                if (node.second == targetSum)
                    return true;
            }
            if (node.first->left) {
                st.push(pair<TreeNode*, int>(
                    node.first->left, node.second + node.first->left->val));
            }
            if (node.first->right) {
                st.push(pair<TreeNode*, int>(
                    node.first->right, node.second + node.first->right->val));
            }
        }
        return false;
    }
};

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

题目链接：从中序与后序遍历序列构造二叉树

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

解题思路：

首先回忆一下如何根据两个顺序构造一个唯一的二叉树，相信理论知识大家应该都清楚，就是以 后序数组的最后一个元素为切割点，先切中序数组，根据中序数组，反过来再切后序数组。一层一层切下去，每次后序数组最后一个元素就是节点元素。

说到一层一层切割，就应该想到了递归。

来看一下一共分几步：

• 第一步：如果数组大小为零的话，说明是空节点了。
• 第二步：如果不为空，那么取后序数组最后一个元素作为节点元素。
• 第三步：找到后序数组最后一个元素在中序数组的位置，作为切割点
• 第四步：切割中序数组，切成中序左数组和中序右数组 （顺序别搞反了，一定是先切中序数组）
• 第五步：切割后序数组，切成后序左数组和后序右数组
• 第六步：递归处理左区间和右区间

class Solution {
public:
    TreeNode* buildTree(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;
            }
        }

        vector<int> leftInorder(inorder.begin(),
                                inorder.begin() + delimiterIndex);
        vector<int> rightInorder(inorder.begin() + delimiterIndex + 1,
                                 inorder.end());

        postorder.resize(postorder.size() - 1);

        vector<int> leftPostorder(postorder.begin(),
                                  postorder.begin() + leftInorder.size());
        vector<int> rightPostorder(postorder.begin() + leftInorder.size(),
                                   postorder.end());

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

        return root;
    }
};