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

Leetcode513.找树左下角的值

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

思路：两种，用层序迭代直接记录每一层的第一个节点即可，或者用递归求最大深度，记录最大深度的第一个节点（左节点）。
层序迭代：

/**
 * 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:
    int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode*> que;
        que.push(root);
        int result;
        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; 
    }
};

递归法：

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

Leetcode112. 路径总和

文章链接：代码随想录
题目链接：112. 路径总和

思路：递归回溯，需要处理递归返回值，递归函数设成有返回类型。

/**
 * 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:
    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;
    }

    bool hasPathSum(TreeNode* root, int targetSum) {
        if (root == NULL) return false;
        return traversal(root, targetSum - root->val);
    }
};

Leetcode113. 路径总和ii

文章链接：代码随想录i
题目链接：113. 路径总和ii

思路：递归回溯，不需要处理返回值，递归函数设成void

/**
 * 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:
    vector<vector<int>> result;
    vector<int> path;
    
    void traversal(TreeNode* node, int count){
        if (!node->left && !node->right && count == 0){
            result.push_back(path);
            return ;
        }
        if (!node->left && !node->right){
            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 ;
    }
    
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        if (root == NULL) return result;
        path.push_back(root->val);
        traversal(root, targetSum - root->val);
        return result;
    }
};

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

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

思路：通过后序确定中间节点，然后分割中序数组，再通过长度分割后序数组，递归。改不出bug时写日志调试真的很重要。

/**
 * 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 midValue = postorder[postorder.size() - 1];
        TreeNode* node = new TreeNode(midValue);
        
        if (postorder.size() == 1) return node;

        int i;
        for (i = 0; i < inorder.size(); i++){
            if (inorder[i] == midValue) break;
        }
        vector<int> linorder(inorder.begin() , inorder.begin() + i);
        vector<int> rinorder(inorder.begin() + i + 1, inorder.end());

        vector<int> lpostorder(postorder.begin(), postorder.begin() + linorder.size());
        vector<int> rpostorder(postorder.begin() + linorder.size(), postorder.end() - 1);
/*
        cout << "----------" << endl;

        cout << "linorder :";
        for (int j : linorder) {
            cout << j << " ";
        }
        cout << endl;

        cout << "rinorder :";
        for (int j : rinorder) {
            cout << j << " ";
        }
        cout << endl;

        cout << "lpostorder :";
        for (int j : lpostorder) {
            cout << j << " ";
        }
        cout << endl;
         cout << "rpostorder :";
        for (int j : rpostorder) {
            cout << j << " ";
        }
        cout << endl;
*/

        node->left = traversal(linorder, lpostorder);
        node->right = traversal(rinorder, rpostorder);

        return node;
    }

    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        return traversal(inorder, postorder);
    }
};

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

文章链接：代码随想录
题目链接：105.从前序与中序遍历序列构造二叉树

思路：和前一道题思路一样；再次强调，改不出bug时，写日志调试真的很重要很快看出问题所在！！！

/**
 * 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 midValue = preorder[0];
        TreeNode* node = new TreeNode(midValue);
        
        if (preorder.size() == 1) return node;

        int i;
        for (i = 0; i < inorder.size(); i++){
            if (inorder[i] == midValue) break;
        }

        vector<int> linorder(inorder.begin(), inorder.begin() + i);
        vector<int> rinorder(inorder.begin() + i + 1, inorder.end());

        vector<int> lpreorder(preorder.begin() + 1, preorder.begin() + 1 + linorder.size());
        vector<int> rpreorder(preorder.begin() + 1 + linorder.size(), preorder.end());
/*
        cout << "----------" << endl;

        cout << "linorder :";
        for (int j : linorder) {
            cout << j << " ";
        }
        cout << endl;

        cout << "rinorder :";
        for (int j : rinorder) {
            cout << j << " ";
        }
        cout << endl;

        cout << "lpreorder :";
        for (int j : lpreorder) {
            cout << j << " ";
        }
        cout << endl;
         cout << "rpreorder :";
        for (int j : rpreorder) {
            cout << j << " ";
        }
        cout << endl;
*/
        node->left = traversal(lpreorder, linorder);
        node->right = traversal(rpreorder, rinorder);

        return node;
    }
    
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        return traversal(preorder, inorder);
    }
};

第十八天打卡，分两天做的题，改不出bug写日志真的很重要！！！
加油！！！