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

1.找到左下角的值

 513. 找树左下角的值 - 力扣（LeetCode）
代码随想录 (programmercarl.com)

代码： 

class Solution {
public:
    int maxDepth = INT_MIN;
    int result;
    // 深度最大，确保是最后一行 先遍历左孩子再遍历右孩子 确保是左下角
    void traversal(TreeNode* node,int Depth){
        if(node->left == NULL && node->right == NULL){
            if(Depth > maxDepth){
                maxDepth = Depth;
                result = node->val;
            }
        }
        if(node->left){
            Depth++;
            traversal(node->left,Depth);
            Depth--;
        }            
        if(node->right){
            Depth++;                
            traversal(node->right,Depth);
            Depth--;
        }
    }
    int findBottomLeftValue(TreeNode* root) {
        traversal(root,0);
        return result;
    }
};

note：深度最大，确保是最后一行 先遍历左孩子再遍历右孩子 确保是左下角

2.路径总和

 112. 路径总和 - 力扣（LeetCode）
代码随想录 (programmercarl.com)

代码：（递归法） 

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

note:这里需要注意的点是，要自己确定好自己的递归函数里的参数sum变量是减了当前节点val值呢，还是没有减要在本次函数里操作的。这个就决定了你的终止条件怎么写。

以及，这里的判断是，左右孩子只要有一个满足题意的叶子结点，就算true了！！

代码：（迭代法）

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

 note：这里用一个二元组来记录每个结点，以及其对应的路径总和

相关题目练习 

 113. 路径总和 II - 力扣（LeetCode）

代码：递归法 

class Solution {
public:
    vector<vector<int>> result;
    void traversal(TreeNode* node,int sum,vector<int> &path){
        if(node == NULL) return;
        if(!node->left && !node->right && node->val == sum){
            path.push_back(node->val);
            result.push_back(path);
            path.pop_back();
            return;
        }
        if(node->left){
            path.push_back(node->val);
            traversal(node->left,sum - node->val,path);
            path.pop_back();
        }
        if(node->right){
            path.push_back(node->val);
            traversal(node->right,sum - node->val,path);
            path.pop_back();
        }
    }
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        vector<int> path;
        traversal(root,targetSum,path);
        return result;
    }
};

note：要遍历整颗树的时候 不需要返回值；不需要遍历整颗树的，需要返回值及时退出递归 

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

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

题目链接/文章讲解/视频讲解：代码随想录

代码： 

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution { // 左闭右开
public:
    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;
        }
        // 切割中序数组，得到中序左数组和中序右数组
        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 = traversal(leftInorder,leftPostorder);
        root->right = traversal(rightInorder,rightPostorder);
        return root;
    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if(inorder.size() == 0 || postorder.size() == 0) return NULL;
        return traversal(inorder,postorder);
    }
};

 note：

相关题目练习 

 105. 从前序与中序遍历序列构造二叉树 - 力扣（LeetCode）

代码： 

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public: // 左闭右开
    TreeNode* traversal(vector<int>& preorder,vector<int>& inorder){
        if(preorder.size() == 0) return NULL;
        // 找到根结点
        int rootValue = preorder[0];
        TreeNode* root = new TreeNode(rootValue);
        // 叶子结点
        if(preorder.size() == 1){
            return root;
        }
        // 找到切割点
        int delimitIndex;
        for(delimitIndex = 0; delimitIndex < inorder.size(); delimitIndex++){
            if(inorder[delimitIndex] == rootValue){
                break;
            }
        }
        // 切割中序遍历数组
        vector<int> leftInoreder(inorder.begin(),inorder.begin() + delimitIndex);
        vector<int> rightInorder(inorder.begin() + delimitIndex + 1,inorder.end());
        // 切割前序遍历数组
        vector<int> leftPreorder(preorder.begin() + 1,preorder.begin() + 1 + leftInoreder.size());
        vector<int> rightPreorder(preorder.begin() + 1 + leftInoreder.size(),preorder.end());
        //
        root->left = traversal(leftPreorder,leftInoreder);
        root->right = traversal(rightPreorder,rightInorder);
        return root;
    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if(preorder.size() == 0 || inorder.size() == 0){
            return NULL;
        }
        return traversal(preorder,inorder);
    }
};