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

• 今日学习的文章链接，或者视频链接

腾讯文档

• 自己看到题目的第一想法

• 看完代码随想录之后的想法

513:

递归：

class Solution {
    // 记录二叉树的最大深度
    int maxDepth = 0;
    // 记录 traverse 递归遍历到的深度
    int depth = 0;
    TreeNode* res = nullptr;
public:
    void traverse(TreeNode* root) {
        if (root == nullptr) {
            return;
        }
        // 前序遍历位置
        depth++;
        if (depth > maxDepth) {
            // 到最大深度时第一次遇到的节点就是左下角的节点
            maxDepth = depth;
            res = root;
        }
        traverse(root->left);
        traverse(root->right);
        // 后序遍历位置
        depth--;
    }
    int findBottomLeftValue(TreeNode* root) {
        traverse(root);
        return res->val;
    }
};

迭代法（层序遍历）

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

112

遍历的思想：

class Solution {
    int cur_sum = 0;
    bool found = false;
public:
    // 二叉树遍历函数
    void traverse(TreeNode* root,int target) {
        if (root == nullptr) {
            return;
        }
        // 前序遍历位置
        cur_sum += root->val;
        if (root->left == nullptr && root->right == nullptr) {
            if (cur_sum == target) {
                found = true;
            }
        }
        traverse(root->left,target);
        traverse(root->right,target);
        // 后序遍历位置
        cur_sum -= root->val;
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
        if (root == nullptr){
            return false;
        }
        traverse(root,targetSum);
        return found;
    }
};

分解问题的思想：

    bool hasPathSum(TreeNode* root, int targetSum) {
        // base case
        if (root == nullptr) {
            return false;
        }
        if (root->left == nullptr && root->right == nullptr && root->val == targetSum) {
            return true;
        }

        return hasPathSum(root->left, targetSum - root->val)
                || hasPathSum(root->right, targetSum - root->val);
    }

106:

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;
        }

        // 第四步：切割中序数组，得到 中序左数组和中序右数组
        // 左闭右开区间：[0, delimiterIndex)
        vector<int> leftInorder(inorder.begin(), inorder.begin() + delimiterIndex);
        // [delimiterIndex + 1, end)
        vector<int> rightInorder(inorder.begin() + delimiterIndex + 1, inorder.end() );
        // 第五步：切割后序数组，得到 后序左数组和后序右数组
        // postorder 舍弃末尾元素，因为这个元素就是中间节点，已经用过了
        postorder.resize(postorder.size() - 1);
        // 左闭右开，注意这里使用了左中序数组大小作为切割点：[0, leftInorder.size)
        vector<int> leftPostorder(postorder.begin(), postorder.begin() + leftInorder.size());
        // [leftInorder.size(), end)
        vector<int> rightPostorder(postorder.begin() + leftInorder.size(), postorder.end());
        // 第六步
        root->left = buildTree(leftInorder, leftPostorder);
        root->right = buildTree(rightInorder, rightPostorder);

        return root;
    }
};

105:

class Solution {
public:
        TreeNode* traversal (vector<int>& inorder, int inorderBegin, int inorderEnd, vector<int>& preorder, int preorderBegin, int preorderEnd) {
            if (preorderBegin == preorderEnd) return NULL;

            int rootValue = preorder[preorderBegin]; // 注意用preorderBegin 不要用0
            TreeNode* root = new TreeNode(rootValue);

            if (preorderEnd - preorderBegin == 1) return root;

            int delimiterIndex;
            for (delimiterIndex = inorderBegin; delimiterIndex < inorderEnd; delimiterIndex++) {
                if (inorder[delimiterIndex] == rootValue) break;
            }
            // 切割中序数组
            // 中序左区间，左闭右开[leftInorderBegin, leftInorderEnd)
            int leftInorderBegin = inorderBegin;
            int leftInorderEnd = delimiterIndex;
            // 中序右区间，左闭右开[rightInorderBegin, rightInorderEnd)
            int rightInorderBegin = delimiterIndex + 1;
            int rightInorderEnd = inorderEnd;

            // 切割前序数组
            // 前序左区间，左闭右开[leftPreorderBegin, leftPreorderEnd)
            int leftPreorderBegin =  preorderBegin + 1;
            int leftPreorderEnd = preorderBegin + 1 + delimiterIndex - inorderBegin; // 终止位置是起始位置加上中序左区间的大小size
            // 前序右区间, 左闭右开[rightPreorderBegin, rightPreorderEnd)
            int rightPreorderBegin = preorderBegin + 1 + (delimiterIndex - inorderBegin);
            int rightPreorderEnd = preorderEnd;

            root->left = traversal(inorder, leftInorderBegin, leftInorderEnd,  preorder, leftPreorderBegin, leftPreorderEnd);
            root->right = traversal(inorder, rightInorderBegin, rightInorderEnd, preorder, rightPreorderBegin, rightPreorderEnd);

            return root;
    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        return traversal(inorder,0,inorder.size(),preorder,0,preorder.size());

    }
};

• 自己实现过程中遇到哪些困难

• 今日收获，记录一下自己的学习时长