代码随想录算法训练营day16

1.找到左下角的值

1.1 题目

. - 力扣（LeetCode）

1.2 题解

/**
 * 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*> q;
        q.push(root);
        int result;
        while(!q.empty())
        {
            int size=q.size();
            for(int i=0;i<size;i++)
            {
                auto tmp=q.front();
                q.pop();
                if(i==0)
                {
                    result=tmp->val;
                }
                if(tmp->left!=nullptr)q.push(tmp->left);
                if(tmp->right!=nullptr)q.push(tmp->right);
            }
        }
        return result;
    }
};

2.路径总和

2.1 题目

. - 力扣（LeetCode）

2.2 题解

/**
 * Definition for a binary tree root.
 * 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 hasPathSum(TreeNode* root, int targetSum) 
    {
        if(root==nullptr)return false;
        return reversal(root,targetSum-root->val);
        
    }
    bool reversal(TreeNode* root, int targetSum)
    {
        if(root->left==nullptr&&root->right==nullptr&&targetSum==0)return true;
        if(root->left==nullptr&&root->right==nullptr&&targetSum!=0)return false;
        if(root->left)
        {
            targetSum-=root->left->val;
            if(reversal(root->left,targetSum))return true;
            targetSum+=root->left->val;
        }
        if(root->right)
        {
            targetSum-=root->right->val;
            if(reversal(root->right,targetSum))return true;
            targetSum+=root->right->val;
        }
        return false;
    }
};

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

3.1 题目

. - 力扣（LeetCode）

3.2 题解

/**
 * 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* buildTree (vector<int>& inorder, vector<int>& postorder)
    {
        if(inorder.size()==0||postorder.size()==0)
        {
            return nullptr;
        }
        return traversal(inorder,postorder);
    }
    TreeNode* traversal (vector<int>& inorder, vector<int>& postorder) 
    {
        //后序数组为0，为空节点
        if(postorder.size()==0)return nullptr;
        //根据后续数组可以确定根节点
        int rootValue=postorder[postorder.size()-1];
        //构建根节点
        TreeNode* root=new TreeNode(rootValue);

        //当前遍历到叶子节点，直接返回
        if(postorder.size()==1)return root;

        //开始切割
        //找切割点
        int delimiterIndex=0;
        //在中序数组中找切割点
        for(;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.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=traversal(leftInorder,leftPostorder);
        root->right=traversal(rightInorder,rightPostorder);

        return root;
    }
};