day-18 代码随想录算法训练营（19）二叉树 part05

513.找树左下角的值

思路一：层序遍历，每一层判断是不是最后一层，是的话直接返回第一个;
              如何判断是不是最后一层呢，首先队列头部，其次记录左右子节点都没有的节点数是不是等于que.size()；或者直接判断队列是否为空。其实也不用判断，因为最后一次记录的队列头就是最左下角节点

class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        queueque;
        que.push(root);
        int res=0;
        while(!que.empty()){
            int n=que.size();
            int mid=que.front()->val;
            for(int i=0;ileft)
                    que.push(node->left);
                if(node->right)
                    que.push(node->right);
            }
            if(que.empty())
                res=mid;
        }
        return res;

    }
};

思路二：递归，每次遍历到叶子节点时记录节点值和深度，使用数组，找到深度最深的第一个

class Solution {
public:
    vector> ans;
    void judge(TreeNode*root,int deepth)
    {
        if(root==nullptr)
            return;
        if(root->left==nullptr && root->right==nullptr)
            ans.push_back({deepth,root->val});
        judge(root->left,deepth+1);
        judge(root->right,deepth+1);
    }
    int findBottomLeftValue(TreeNode* root) {
        judge(root,0);
        int  mid=0,res=0;
        for(int i=0;imid){
                mid=ans[i][0];
                res=i;
            }
                
        }
        return ans[res][1];

    }
};

思路三：递归，不使用额外空间，每次遍历到叶子节点是进行深度判断

class Solution {
public:
    int maxDeepth=-1;
    int res=0;
    void judge(TreeNode*root,int deepth)
    {
        if(root==nullptr)
            return;
        if(root->left==nullptr && root->right==nullptr)//遍历到叶子节点时
        {
            if(deepth>maxDeepth){
                maxDeepth=deepth;
                res=root->val;
            }
        }
        judge(root->left,deepth+1);
        judge(root->right,deepth+1);
    }
    int findBottomLeftValue(TreeNode* root) {
        judge(root,0);
        return res;
    }
};

注意：deepth是值传递，只有父节点的改变影响子节点的值；同为子节点是相互不影响的，所以相当于回溯了。

112.路径总和

思路：递归前序遍历二叉树，在叶子节点处进行判断

class Solution {
public:
    bool res=false;
    void judge(TreeNode*root,int targetSum,int sum)
    {
        if(root==nullptr)
            return;
        if(root->left==nullptr && root->right==nullptr){
            if(sum+root->val==targetSum)
                res=true;
            //cout<val;
        // if(sum>targetSum)
        //     return;
        judge(root->left,targetSum,sum);
        judge(root->right,targetSum,sum);
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
        judge(root,targetSum,0);
        return res;
    }
};

113.路径总和||

思路一：还是直接递归，然后在叶子节点处判断

注意：每次当前节点判断完之后需要删除路径的最后一个节点，即回溯到另一个节点

class Solution {
public:
    vector>res;
    vectormids;
    void judge(TreeNode*root,int targetSum,int sum){
        if(root==nullptr)
            return;
        if(root->left==nullptr && root->right==nullptr){
            if(sum+root->val==targetSum){
                mids.push_back(root->val);
                res.push_back(mids);
                mids.erase(mids.end()-1);
                return;
            }
        }
        sum+=root->val;
        mids.push_back(root->val);
        judge(root->left,targetSum,sum);
        judge(root->right,targetSum,sum);
        mids.erase(mids.end()-1);
    }
    vector> pathSum(TreeNode* root, int targetSum) {
        //思路一：直接递归，在叶子节点处判断
        if(root==nullptr)
            return vector>();
        judge(root,targetSum,0);
        return res;
    }
};

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

分析：这个递归切割的想法很精妙

class Solution {
private:
    TreeNode*judge(vector&inorder,vector&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 midLastIndex;
        for(midLastIndex=0;midLastIndex leftInorder(inorder.begin(),inorder.begin()+midLastIndex);

        vector rightInorder(inorder.begin()+midLastIndex+1,inorder.end());

        //删除后序数组的末尾元素
        postorder.resize(postorder.size()-1);

        //切割后序数组
        //依然左闭右开，注意这里使用了左中序数组大小作为切割点
        vector leftPostorder(postorder.begin(),postorder.begin()+leftInorder.size());

        vector rightPostorder(postorder.begin()+leftInorder.size(),postorder.end());

        root->left=judge(leftInorder,leftPostorder);
        root->right=judge(rightInorder,rightPostorder);

        return root;
    }
public:
    TreeNode* buildTree(vector& inorder, vector& postorder) {
        if(inorder.empty() || postorder.empty()) return nullptr;
        return judge(inorder,postorder);
    }
};

今日问题：43.字符串相乘

849. 到最近的人的最大距离