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

LeetCode 513.找树左下角的值

题目链接：LeetCode 513.找树左下角的值

前序遍历：

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

思路：递归三部曲：首先参数值为根节点与当前根节点的深度，递归的终止条件为找到叶子节点，单层逻辑为：当前根节点深度大于之前记录的最大深度时，更新最大深度与保存的节点值。

小结：

1.因为要经历二叉树的所有节点，故需要进行回溯操作。

2.在给最大深度赋初值时赋给无穷小。

3.找左下角值，是找到二叉树最深层第一个值。故在递归时利用深度这一参数对值进行更新。

---

LeetCode 112. 路径总和

题目链接：LeetCode 112. 路径总和

class Solution {
public:
    bool traversal(TreeNode*root,int count)
    {
        if(!root->left && !root->right && count == 0)
        return true;
        if(!root->left && !root->right)
        return false;
        if(root -> left)
        {
            count -= root -> left -> val;
            if(traversal(root -> left,count))
            return true;
            count += root -> left -> val;
        }
        if(root -> right)
        {
            count -= root -> right -> val;
            if(traversal(root -> right,count))
            return true;
            count += root -> right -> val;
        }
        return false;
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
        if (root == NULL) 
        return false;
        return traversal(root,targetSum - root->val);//除根节点之外的值进行遍历
    }
};

思路：递归三部曲：首先参数值为根节点与和结果值比较的计数器，递归的终止条件为找到叶子节点（找到叶子节点时总和为目标值，找到叶子节点时综合不为目标值），单层逻辑为：将节点值相加的思路转化为用目标值减去各节点值的思路，看结果最后是否为0，为0返回true，非0返回false。

小结：

1.需要对多条根节点到叶子节点进行遍历，故须进行回溯操作。

2.将节点值相加的思路转化为用目标值减去各节点值的思路比较巧妙。

---

LeetCode 113.路径总和II

题目链接：LeetCode 113. 路径总和 II

class Solution {
public:
    vector<int>path;
    vector<vector<int>>res;
    void traversal(TreeNode* root,int count)
    {
        if(!root->left && !root->right && count == 0)
        {
            res.push_back(path);
            return;
        }
        if(!root->left && !root->right)
        return;
        if(root -> left)
        {
            path.push_back(root -> left -> val);
            count -= root -> left -> val;
            traversal(root -> left,count);
            count += root -> left -> val;
            path.pop_back();
        }
        if(root -> right)
        { 
            path.push_back(root -> right -> val);
            count -= root -> right -> val;
            traversal(root -> right,count);
            count += root -> right -> val;
            path.pop_back();
        }
        return;
    }
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        res.clear();
        path.clear();
        if(root == NULL)
        {
            return res;
        }
        path.push_back(root -> val);
        traversal(root,targetSum - root -> val);
        return res;
    }
};

思路：思路与上一题大致相同，需要进行遍历与回溯，不同的是寻找路径时不需要对返回值进行处理，故不需要返回值。

---

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

题目链接：LeetCode 106. 从中序与后序遍历序列构造二叉树

class Solution {
private:
    TreeNode* traversal(vector<int>& inorder,vector<int>& postorder)
    {
        if(postorder.size() == 0)
        return NULL;//后序数组为0返回空
        int rootval = postorder[postorder.size() - 1];
        TreeNode* treeroot = new TreeNode(rootval);//通过后序数组找到根节点
        int i;
        for(i = 0;i < inorder.size();i++)
        {
            if(inorder[i] == rootval)
            break;
        }//找到根节点在中序数组的位置
        vector<int> leftinorder(inorder.begin(),inorder.begin() + i);
        vector<int> rightinorder(inorder.begin() + i + 1,inorder.end());
        //切开左中序和右中序
        postorder.resize(postorder.size() - 1);//去掉后序数组中的根节点
        vector<int> leftposter(postorder.begin(),postorder.begin() + leftinorder.size());//通过左中序来找到左后序
        vector<int> rightposter(postorder.begin() + leftinorder.size(),postorder.end());
        //切开左后序和右后序
        treeroot->left = traversal(leftinorder,leftposter);
        treeroot->right =traversal(rightinorder,rightposter);
        //前序遍历
        return treeroot;
    }
public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if(inorder.size() == 0 || postorder.size() == 0)
        return NULL;
        return traversal(inorder,postorder);
    }
};

思路：首先通过后序数组找到根节点（后序数组的最后一个节点值），用该值将中序数组做切分，左中序和右中序；之后因切出来的左中序在左后序中大小相同（可以理解为都是左子树），再将后序数组切分为左中序与右后序。最后进行前序遍历即可。

小结：

1.因根节点只有一个，所以能在后序数组或前序数组中唯一确定；再之后的递归中也是先通过前序/后序数组找到根节点，之后进行切分，再递归。

2.需要注意切分区间开闭的一致性。

---

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

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

class Solution {
private:
    TreeNode* traversal(vector<int>& preorder,vector<int>& inorder)
    {
        if(preorder.size() == 0)
        return NULL;
        int rootval = preorder[0];
        TreeNode* root = new TreeNode(rootval);
        int i = 0;
        for(i = 0;i < inorder.size();i++)
        {
            if(inorder[i] == rootval)
            break;
        }
        vector<int> leftinorder(inorder.begin(),inorder.begin() + i);
        vector<int> rightinorder(inorder.begin() + i + 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 = traversal(leftpreorder,leftinorder);
        root -> right = traversal(rightpreorder,rightinorder);
        return root;
    }
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if(preorder.size() == 0 || inorder.size() == 0)
        return NULL;
        return traversal(preorder,inorder);
    }
};

 思路： 与上一题思路基本一致。

小结：因在切分中需要通过中序数组来切分出左右子树大小，故必须含有中序数组才能进行二叉树的构造。