代码随想录打卡Day16

今天有点忙，先写一题，剩下的明天再补。

找树左下角的值

这个题目我直接用迭代法做的，主要就是遍历二叉树，用一个二维向量v将所有节点保存起来，然后v中最后一个向量的第一个值就是树左下角的值了。再去看视频以后感觉用递归做确实会很难，我也没有完全搞懂，先这样吧。
这是我的代码。

class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode*> My_Queue;
        vector<vector<int>> v;
        if(root) My_Queue.push(root);
        while(!My_Queue.empty()){
            int size = My_Queue.size();
            vector<int> temp;
            while(size > 0){
                TreeNode* node = My_Queue.front();
                My_Queue.pop();
                temp.push_back(node -> val);
                if(node -> left) My_Queue.push(node -> left);
                if(node -> right) My_Queue.push(node -> right);
                size--;
            }
            v.push_back(temp);
        }
        return v[v.size() - 1][0];
    }
};

剩下的明天再说。

---

今天是8月30日，把昨天欠的两道题补上。

112. 路径总和

这个没思路，直接看视频的。这道题目我感觉以我的能力不能直接用一个函数解决，于是我重新写了个函数。这道题需要在主函数中对根节点为空的特殊情况进行单独处理，如果主函数不为空的话，说明二叉树中至少有一个节点，然后再调用自己写的函数。思路还是参考卡尔的思路。

class Solution {
public:
    bool hasPathSum(TreeNode* root, int targetSum) {
        if(root == NULL) return false; 
        targetSum -= root -> val;
        return Traversal(root, targetSum);
    }
    bool Traversal(TreeNode* root, int targetSum){ //调用该函数时默认传入指针不为空
        TreeNode* node = root;
        if(node -> left == NULL && node -> right == NULL && targetSum == 0)
            return true;
        if(node -> left == NULL && node -> right == NULL && targetSum != 0)
            return false;
        
        if(node -> left){
            targetSum -= node -> left -> val;
            if(Traversal(node -> left, targetSum)) return true;
            targetSum += node -> left -> val;
        }
        if(node -> right){
            targetSum -= node -> right -> val;
            if(Traversal(node -> right, targetSum)) return true;
            targetSum += node -> right -> val;
        }
        return false;
    }
};

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

这道题目确实很难，在两个数组不断分割迭代那里有点费解，看完视频以后写了挺久的，写完了以后提交代码，还在201个测试用例那里超时了，无语。。。。原因是我在分割后序遍历的向量时，是通过不断查找传入后序遍历向量中的值是否在传入的left_in中，每一次查找都耗费了时间，所以最后超时了，后面想到可以直接用left_in的大小直接定位到左右子树的分界点，然后可以直接一步到位，节约了很多时间。

class Solution {
public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if(postorder.size() == 0) return NULL;
        TreeNode* node = new TreeNode(postorder[postorder.size() - 1]);  //取出根节点
        vector<vector<int>> son_intree = split_inorder(inorder, node -> val);  //左中序，右中序
        vector<vector<int>> son_postree = split_postorder(postorder, son_intree[0]);  //左后序，右后序
        node -> left = buildTree(son_intree[0], son_postree[0]);
        node -> right = buildTree(son_intree[1], son_postree[1]);
        return node;
    }
    vector<vector<int>> split_inorder(vector<int> inorder, int root_val){
        int index;
        for(index = 0; index < inorder.size(); index++){
            if(inorder[index] == root_val)
                break;
        }
        vector<int> left_in(inorder.begin(), inorder.begin() + index);
        vector<int> right_in(inorder.begin() + index + 1, inorder.end());
        return {left_in, right_in};
    }
    vector<vector<int>> split_postorder(vector<int> postorder, vector<int> left_in){
        int index = left_in.size();
        vector<int> left_post(postorder.begin(), postorder.begin() + index);
        vector<int> right_post(postorder.begin() + index, postorder.end() - 1);
        return {left_post, right_post};
    }
};

最后AC了，但是时间复杂度和空间复杂度还是很大。。无语。。。。