【算法刷题day18】Leetcode:513.找树左下角的值 112. 路径总和 113.路径总和ii 106.从中序与后序遍历序列构造二叉树 105.从前序与中序遍历序列构造二叉树

513.找树左下角的值

文档链接：[代码随想录]
题目链接：513.找树左下角的值
状态：ok

题目：
给定一个二叉树，在树的最后一行找到最左边的值。
注意：
1.递归法
2.迭代法

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

class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode*> que;
        if(root != NULL)que.push(root);
        int result = 0;
        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.路径总和

文档链接：[代码随想录]
题目链接：112.路径总和
状态：ok

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

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

113. 路径总和ii

文档链接：[代码随想录]
题目链接：[112.路径总和]
状态：ok

题目：
给定一个二叉树和一个目标和，找到所有从根节点到叶子节点路径总和等于给定目标和的路径。
说明: 叶子节点是指没有子节点的节点。

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

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

文档链接：[代码随想录]
题目链接：106.从中序与后序遍历序列构造二叉树
状态：Ok 这道题很有意思

题目：

根据一棵树的中序遍历与后序遍历构造二叉树。
注意: 你可以假设树中没有重复的元素。

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 index;
        for(index = 0; index < inorder.size(); index++){
            if(inorder[index] == rootValue)break;
        }

        vector<int>leftorder(inorder.begin(), inorder.begin() + index);
        vector<int>rightorder(inorder.begin() + index + 1, inorder.end());

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

        vector<int>leftPostOrder(postorder.begin(), postorder.begin() + leftorder.size());
        vector<int>rightPostOrder(postorder.begin() + leftorder.size(), postorder.end());

        root -> left = traversal(leftorder,leftPostOrder);
        root -> right = traversal(rightorder, 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);
    }
};