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

djykkkkkk

已于 2023-09-30 12:13:48 修改

阅读量831

点赞数

分类专栏： # 代码随想录算法训练营（19）文章标签：算法 leetcode 数据结构

于 2023-08-11 23:07:27 首次发布

本文链接：https://blog.csdn.net/Ricardo_XIAOHAO/article/details/132240853

版权

代码随想录算法训练营（19）专栏收录该内容

61 篇文章 0 订阅

订阅专栏

513.找树左下角的值

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

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

    }
};

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

class Solution {
public:
    vector<vector<int>> 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;i<ans.size();i++)
        {
            if(ans[i][0]>mid){
                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是值传递，只有父节点的改变影响子节点的值；同为子节点是相互不影响的，所以相当于回溯了。

二刷：对比深度，先遍历左子节点

思路三：递归

1.递归遍历
2.中序遍历
3.遍历到叶子节点：更大深度时更新节点值（必然先更新最左边）

class Solution {
public:
    int res=0;
    int minDeep=INT_MIN;
    void judge(TreeNode*root,int deep){
        if(root->left==nullptr && root->right==nullptr){//找到叶子节点
            if(deep>minDeep){//最深的一层
                minDeep=deep;
                res=root->val;
            }
            return;
        }
        if(root->left) judge(root->left,deep+1);//同一层先遍历左节点
        if(root->right) judge(root->right,deep+1);
    }
    int findBottomLeftValue(TreeNode* root) {
        judge(root,1);
        return res;
    }
};

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<<sum;
        }
        sum+=root->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;
    }
};

二刷路过：布尔变量判断

class Solution {
public:
    bool flag=false;//判断是否找到
    void judge(TreeNode*root,int targetSum,int sum){
        if(flag) return;//剪枝
        if(root->left==nullptr && root->right==nullptr){//叶子节点
            sum+=root->val;
            if(sum==targetSum) flag=true;//找到路径
            return;
        }
        sum+=root->val;
        if(root->left) judge(root->left,targetSum,sum);
        if(root->right) judge(root->right,targetSum,sum);
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
        if(root==nullptr) return false;
        judge(root,targetSum,0);
        return flag;
    }
};

113.路径总和||

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

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

class Solution {
public:
    vector<vector<int>>res;
    vector<int>mids;
    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<vector<int>> pathSum(TreeNode* root, int targetSum) {
        //思路一：直接递归，在叶子节点处判断
        if(root==nullptr)
            return vector<vector<int>>();
        judge(root,targetSum,0);
        return res;
    }
};

二刷路过：判断叶子节点的总和

class Solution {
public:
    vector<vector<int>>res;
    vector<int>mid;
    void judge(TreeNode*root,int targetSum,int sum){
        if(root->left==nullptr && root->right==nullptr){//叶子节点
            mid.push_back(root->val);
            sum+=root->val;
            if(sum==targetSum) res.push_back(mid);
            return;
        }
        sum+=root->val;
        mid.push_back(root->val);
        if(root->left){
            judge(root->left,targetSum,sum);
            mid.pop_back();//回溯
        }
        if(root->right){
            judge(root->right,targetSum,sum);
            mid.pop_back();//回溯
        }
    }
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        if(root==nullptr) return res;//节点为0
        judge(root,targetSum,0);
        return res;
    }
};

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

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


class Solution {
private:
    TreeNode*judge(vector<int>&inorder,vector<int>&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<inorder.size();midLastIndex++){
            if(inorder[midLastIndex]==rootValue) break;
        }

        //切割中序数组
        //左闭右开区间[0,midLastIndex]
        vector<int> leftInorder(inorder.begin(),inorder.begin()+midLastIndex);

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

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

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

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

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

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

二刷：拆分数组

class Solution {
public:
    TreeNode*containTree(vector<int>&inorder,vector<int>&postorder){
        if(postorder.size()==0) return nullptr;
        int midValue=postorder.back();//找到中间节点
        int midIndex=0;
        while(inorder[midIndex]!=midValue) midIndex++;//找到下标

        TreeNode*midNode=new TreeNode(midValue);//创建中间节点
        //拆分中序数组
        vector<int>leftInorder(inorder.begin(),inorder.begin()+midIndex);
        vector<int>rightInorder(inorder.begin()+midIndex+1,inorder.end());
        //拆分后序数组
        postorder.pop_back();//删除中间节点
        vector<int>leftPostorder(postorder.begin(),postorder.begin()+leftInorder.size());
        vector<int>rightPostorder(postorder.begin()+leftInorder.size(),postorder.end());

        midNode->left=containTree(leftInorder,leftPostorder);
        midNode->right=containTree(rightInorder,rightPostorder);
        return midNode;
    
    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        return containTree(inorder,postorder);
    }
};

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

分析：和中序和后序遍历序列构造二叉树几乎一摸一样

思路：每次构建中间节点，把前序和中序遍历序列进行分割，再递归到下一层，把分割后的序列传入下一层，最后依次把创建出来的中间节点返回给上一层连接（回溯）

class Solution {
public:
    TreeNode* judge(vector<int>&preorder,vector<int>&inorder){
        if(preorder.size()==0) return nullptr;

        int rootValue=preorder[0];
        TreeNode*root=new TreeNode(rootValue);

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

        //在中序序列中找到切割点
        int mid;
        for(mid=0;mid<inorder.size();mid++){
            if(inorder[mid]==rootValue) break;
        }

        //对中序遍历序列进行切割
        vector<int>leftInorder(inorder.begin(),inorder.begin()+mid);
        vector<int>rightInorder(inorder.begin()+mid+1,inorder.end());

        //删除中间节点
        preorder.erase(preorder.begin());

        //对前序遍历序列进行切割  注意，中间节点已经删除，所以第一个元素也为左边前序
        vector<int>leftPreorder(preorder.begin(),preorder.begin()+leftInorder.size());
        vector<int>rightPreorder(preorder.begin()+leftInorder.size(),preorder.end());

        //把切割后的序列传入下一层
        root->left=judge(leftPreorder,leftInorder);
        root->right=judge(rightPreorder,rightInorder);
        //把创建出来的中间节点传入上一层
        return root;

    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if(preorder.empty() || inorder.empty())  return nullptr;
        return judge(preorder,inorder);
    }
};

二刷路过：

注意：不需要删除前序数组中第一个元素，所以后面前序截取的起点都是第二个元素

class Solution {
public:
    TreeNode*containTree(vector<int>&preorder,vector<int>&inorder){
        if(preorder.size()==0) return nullptr;
        int midValue=preorder[0];
        int midIndex=0;
        while(inorder[midIndex]!=midValue) midIndex++;

        TreeNode*root=new TreeNode(midValue);
        if(preorder.size()==1) return root;

        //拆分中序数组
        vector<int>leftInorder(inorder.begin(),inorder.begin()+midIndex);
        vector<int>rightInorder(inorder.begin()+midIndex+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=containTree(leftPreorder,leftInorder);
        root->right=containTree(rightPreorder,rightInorder);
        return root;

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

107.二叉树的层序遍历II

思路一：简单的层序遍历，加入栈然后取出

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        //思路：层序遍历，然后把每一层的数据加入栈中，最后再从栈中取出
        vector<vector<int>>res;
        if(root==nullptr) return res;
        queue<TreeNode*>que;
        stack<vector<int>>midSt;
        que.push(root);
        
        while(!que.empty()){
            int n=que.size();
            vector<int>mids;
            for(int i=0;i<n;i++){
                TreeNode*cur=que.front();
                mids.push_back(cur->val);
                que.pop();
                if(cur->left) que.push(cur->left);
                if(cur->right) que.push(cur->right);
            }
            midSt.push(mids);
        }
        cout<<midSt.size();
        int len=midSt.size();
        for(int i=0;i<len;i++){
            res.push_back(midSt.top());
            midSt.pop();
        }
        return res;
    }
};

二刷：

思路二：层序遍历后，直接翻转

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>>res;
        if(root==nullptr) return res;
        queue<TreeNode*>que;
        vector<int>mid;
        que.push(root);
        while(!que.empty()){//层序遍历
            int n=que.size();
            for(int i=0;i<n;i++){
                TreeNode*cur=que.front();
                que.pop();
                if(cur->left) que.push(cur->left);
                if(cur->right) que.push(cur->right);
                mid.push_back(cur->val);
            }
            res.push_back(mid);
            mid.clear();
        }
        reverse(res.begin(),res.end());//翻转
        return res;
    }
};

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

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

djykkkkkk

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
day-18 代码随想录算法训练营（19）二叉树 part05 已二刷

513.找树左下角的值 112.路径总和 113.路径总和|| 106.从中序与后序遍历序列构造二叉树 105.从前序和中序遍历序列构造二叉树 107.二叉树的层序遍历II
复制链接

扫一扫