【代码随想录第18天】二叉树5

513.找树左下角的值（中等）

题目链接：513.找树左下角的值
代码随想录：513.找树左下角的值

层序遍历很简单，记录最后一层队头的元素，循环结束返回即可

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

递归有点难想
终止条件：到达叶子，更新最大深度和结果

class Solution {
public:
    int maxDepth = INT_MIN;
    int res;
    void traversal(TreeNode * root, int depth){
        // 叶子
        if(!root->left && !root->right){
            if(depth > maxDepth){
                maxDepth = depth;
                res = root->val;
            }
            return;
        }
        if(root->left) traversal(root->left, depth + 1);
        if(root->right) traversal(root->right, depth + 1);
    }
    int findBottomLeftValue(TreeNode* root) {
        traversal(root, 1);
        return res;
    }
};

112. 路径总和（简单）

LeetCode题目：112. 路径总和
代码随想录：112. 路径总和

class Solution {
public:
    bool hasPathSum(TreeNode* root, int targetSum) {
        if(!root) return false;
        // 终止条件是判断叶子节点.到叶子节点且剩下的值与叶子结点值相等
        if(!root->left && !root->right && targetSum == root->val) return true;
        if(root->left) //向左寻找
           if( hasPathSum(root->left, targetSum - root->val)) return true;
        if(root->right) // 向右寻找
            if(hasPathSum(root->right, targetSum - root->val)) return true;
        return false;
    }
};

113.路径总和2（中）

给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。

113. 路径总和 II

回溯

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    void backtracking(TreeNode * cur, int target){
        //到叶子
        if(!cur->left && !cur->right){
            if(cur->val == target){
                res.push_back(path);
            }
            return;
        }
        if(cur->left) {
            path.push_back(cur->left->val);
            backtracking(cur->left, target - cur->val);
            path.pop_back();
        }
        if(cur->right) {
            path.push_back(cur->right->val);
            backtracking(cur->right, target - cur->val); 
            path.pop_back();       
        }
    }
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        if(!root) return res;
        path.push_back(root->val);
        backtracking(root, targetSum);
        return res;
    }
};

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

LeetCode题目：106.从中序与后序遍历序列构造二叉树
代码随想录：106.从中序与后序遍历序列构造二叉树

写的时候把数组大小为0判断给忘了

（懒得在画图了）

class Solution {
public:
    TreeNode * traversal(vector<int>& inorder, vector<int>& postorder){
        //第一步：如果数组大小为零的话，说明是空节点!
        if(postorder.size() == 0) return NULL;
        TreeNode * root = new TreeNode;
        root->val = postorder[postorder.size() - 1];
        // 叶子
        if(postorder.size() == 1) return root;
        // 分割中序数组
        int i = 0; // i是root
        for(; i<inorder.size(); i++)
            if(inorder[i] == root->val) break;
        vector<int> leftIn(inorder.begin(), inorder.begin() + i); // [0,i)
        vector<int> rightIn(inorder.begin() + i + 1, inorder.end()); //[i+1,size-1]
        
        // 分割后序数组
        vector<int> leftPo(postorder.begin(), postorder.begin() + i);
        vector<int> rightPo(postorder.begin() + i, postorder.begin() + postorder.size() - 1);
        root->left = traversal(leftIn, leftPo);
        root->right =  traversal(rightIn, rightPo);
        return root;
    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if (inorder.size() == 0 || postorder.size() == 0) return NULL;
        return traversal(inorder, postorder);
    }
};

105.从前序与中序遍历序列构造二叉树

LeetCode题目：105.从前序与中序遍历序列构造二叉树

class Solution {
public:
    TreeNode * traversal(vector<int>& pre, vector<int>& in){
        if(pre.size() == 0) return NULL;
        // root
        TreeNode * root = new TreeNode(pre[0]);
        // 到叶子了返回
        if(pre.size() == 1) return root;
        //分割中序 i是root
        int i = 0;
        for(; i < in.size(); i++)
            if(in[i] == pre[0]) break;
        vector<int> leftIn(in.begin(), in.begin() + i); // [0,i)
        vector<int> rightIn(in.begin() + i + 1, in.end());
        //分割前序
        vector<int> leftPre(pre.begin() + 1, pre.begin() + 1 + i); // [1,i]
        vector<int> rightPre(pre.begin() + 1 + i, pre.end());
        root->left = traversal(leftPre, leftIn);
        root->right = traversal(rightPre, rightIn);
        return root;
    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if(preorder.size() == 0 || inorder.size() == 0) return NULL;
        return traversal(preorder, inorder);
    }
};