Day18 | 513. 找树左下角的值 |112. 路径总和 |106. 从中序与后序遍历序列构造二叉树 |105. 从前序与中序遍历序列构造二叉树

513. 找树左下角的值

注意点：

1.没有中，采用前中后都可，首先找到最高深度的值，然后先对左孩子进行递归，然后对右孩子进行递归

2.在终止条件中，会比较左孩子和右孩子的深度，如果右孩子的深度大于左孩子，左值才会是右孩子，如果在同一深度，左孩子会优先赋给result（因为判断条件是depth>maxDepth）

3.回溯是为了返回上一个节点，为下一步迭代右（左）做准备

/**
 * 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 result=0;
    int maxDepth = INT_MIN;
    int travelsal(TreeNode* node, int depth) {

        if(node ->left == nullptr && node ->right == nullptr) {
            if(depth > maxDepth) {
                maxDepth = depth;
                result = node->val;
            }
        }

        if(node->left) {
            depth++;
            travelsal(node->left,depth);
            depth--;//回溯，只是减一，回溯到父节点
        }
        if(node->right) {
            depth++;//父节点的右孩子开始
            travelsal(node->right, depth);
            depth--;
        }

        return result;
    }
    int findBottomLeftValue(TreeNode* root) {

        return travelsal(root, 0);
    }
};

112. 路径总和

注意点：
1.需要进行回溯

2.主函数中首先对根节点进行判断，如果为空，返回false，如果不为空，则进行下一步操作，首先将根节点和目标值-根节点的值代入递归函数中。

/**
 * 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 == nullptr && node->right == nullptr && count == 0) return true;
        if(node->left == nullptr && node->right == nullptr && count != 0) 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 == nullptr) return false;
       //需要将根节点减去
        return traversal(root, targetSum-root->val);
    }
};

113. 路径总和 II

注意点：

1.参考题目112，与112不同的是需要创建两个全局变量对最终的结果进行处理

2.如果最终结果和count不相等，则返回的是空，如果相等，则将其添加到result中

3.需要对path中的数据进行回溯，清空，以便对另一个孩子进行遍历

/**
 * 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 == nullptr && node->right == nullptr && count != 0) return ;
        if(node->left == nullptr && node->right == nullptr && count == 0) return result.push_back(path);

        if(node->left) {
            count -= node->left->val;
            path.push_back(node->left->val);
            traversal(node->left,count);
            count += node->left->val;
            path.pop_back();
        }

        if(node->right) {
            count -= node->right->val;
            path.push_back(node->right->val);
            traversal(node->right,count);
            count += node->right->val;//回溯
            path.pop_back();//回溯
        }

    }
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        // result.clear();加不加都可以
        // path.clear();加不加都可以
        if(root == nullptr) return result;
        path.push_back(root->val);
        traversal(root, targetSum-root->val);
        return result;
    }
};

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

注意点：

        1.如果数组大小为空的话，直接返回
        2.如果不为空，取后序最后一个为根节点，并对数组的大小做判断，如果为1的话直接是根节点,直接返回即可
        3.在前序中找根节点作为切割点
        4.切割中序数组，中左和中右--用中序的size去切后序的左部分
        5.切割后序数组，后左和后右
        6.递归处理

/**
 * 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) {}
 * };
        1.如果数组大小为空的话，直接返回
        2.如果不为空，取后序最后一个为根节点，并对数组的大小做判断，如果为1的话直接是根节点,直接返回即可
        3.在前序中找根节点作为切割点
        4.切割中序数组，中左和中右--用中序的size去切后序的左部分
        5.切割后序数组，后左和后右
        6.递归处理
 */
class Solution {
public:
    TreeNode* travelsal(vector<int>& inorder, vector<int>& postorder) {
        // 1.如果数组大小为空的话，直接返回
        if(inorder.size() == 0) return nullptr;
// 2.如果不为空，取后序最后一个为根节点，并对数组的大小做判断，如果为1的话直接是根节点,直接返回即可
        int rootVal = postorder[postorder.size() -1];
        TreeNode* root = new TreeNode(rootVal);

        if(postorder.size() == 1) return root;

// 3.在前序中找根节点作为切割点
        int index;
        for(index =0; index< inorder.size(); index++) {
            if(inorder[index] == rootVal) break;
        }
        // 4.切割中序数组，中左和中右
        vector<int> leftInorder(inorder.begin(), inorder.begin()+index);
        vector<int> rightInorder(inorder.begin()+index+1, inorder.end());
        // 5.切割后序数组，后左和后右
        postorder.resize(postorder.size()-1);//舍弃末尾
        // vector<int> leftPostorder(postorder.begin(), postorder.begin() + leftInorder.size());
        // vector<int> rightPosorder(postorder.begin()+leftInorder.size(), postorder.end());


        vector<int> leftPostorder(postorder.begin(), postorder.begin() + index);
        vector<int> rightPosorder(postorder.begin()+index, postorder.end());
        // 6.递归处理
        root->left = travelsal(leftInorder,leftPostorder);
        root->right = travelsal(rightInorder,rightPosorder);
        
        return root;

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

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

/**
 * 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* travesal(vector<int>& preorder, vector<int>& inorder) {
        if(preorder.size() == 0) return nullptr;

        int begin=0;
        int val = preorder[begin++];
        TreeNode* root = new TreeNode(val);
        if(preorder.size() == 1) return root;

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

        vector<int> leftInorder(inorder.begin(), inorder.begin()+index);
        vector<int> rightInorder(inorder.begin()+index + 1, inorder.end());

        vector<int> leftPreorder(preorder.begin()+1, preorder.begin()+1+leftInorder.size());
        vector<int> rightPreorder(preorder.begin()+1+leftInorder.size(), preorder.end());

        root->left = travesal(leftPreorder,leftInorder);
        root->right = travesal(rightPreorder, rightInorder);
        return root;        
    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        return travesal(preorder, inorder);
    }
};