leetcode-二叉树专题

已于 2023-05-15 16:43:23 修改
阅读量259 收藏
点赞数
分类专栏： 算法 文章标签： leetcode 算法 数据结构
于 2023-05-14 21:44:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/apple_53406386/article/details/130673629
版权

1. 判断相同

100. 相同的树

class Solution {
public:

    bool isSameTree(TreeNode* p, TreeNode* q) {
        if(!p&&!q) return true;
        if(!p||!q) return false;
        if(p->val!=q->val) return false;
        return isSameTree(p->left,q->left)&&isSameTree(p->right,q->right);
    }
};

101. 对称二叉树

class Solution {
public:
    bool isSame(TreeNode* p,TreeNode* q){
        if(!p&&!q) return true;
        if(!p||!q) return false;
        if(p->val!=q->val) return false;
        return isSame(p->left,q->right)&&isSame(p->right,q->left);
    }

    bool isSymmetric(TreeNode* root) {
        return isSame(root,root);
    }
};

2. 翻转

226. 翻转二叉树

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(!root) return NULL;
        TreeNode* left=invertTree(root->left);
        TreeNode* right=invertTree(root->right);
        root->left=right;
        root->right=left;
        return root;
    }
};

3. 深度

 111. 二叉树的最小深度

class Solution {
public:
    int minDepth(TreeNode* root) {
        if(!root) return 0;
        int left_minDepth=minDepth(root->left);
        int right_minDepth=minDepth(root->right);
        if(!left_minDepth&&!right_minDepth) return 1;
        else if(!left_minDepth&&right_minDepth) return right_minDepth+1;
        else if(left_minDepth&&!right_minDepth) return left_minDepth+1;
        return min(left_minDepth,right_minDepth)+1;
    }
};

104. 二叉树的最大深度

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(!root) return 0;
        return max(maxDepth(root->left),maxDepth(root->right))+1;
    }
};

 543. 二叉树的直径

class Solution {
public:
    int res=0;
    int maxHeight(TreeNode* root){ //返回树的高度
        if(!root) return 0;
        int left_height=maxHeight(root->left);
        int right_height=maxHeight(root->right);
        res=max(res,left_height+right_height);
        return max(left_height,right_height)+1;
    }

    int diameterOfBinaryTree(TreeNode* root) {
        maxHeight(root);
        return res;
    }
};

4. 遍历

 144. 二叉树的前序遍历

class Solution {
public:
    void travel(TreeNode* root,vector<int>& res){
        if(!root) return;
        res.push_back(root->val);
        travel(root->left,res);
        travel(root->right,res);
    }

    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        travel(root,res);
        return res;
    }
};
class Solution {
public:
    vector<int> travel(TreeNode* root){
        vector<int> res;
        stack<TreeNode*> stk;
        while(root||!stk.empty()){
            while(root){
                res.push_back(root->val);
                stk.push(root);
                root=root->left;
            }
            root=stk.top();
            stk.pop();
            root=root->right;
        }
        return res;
    }

    vector<int> preorderTraversal(TreeNode* root) {
        return travel(root);
    }
};

 145. 二叉树的后序遍历
 

class Solution {
public:
    vector<int> res;
    void travel(TreeNode* root){
        if(!root) return;
        travel(root->left);
        travel(root->right);
        res.push_back(root->val);
    }

    vector<int> postorderTraversal(TreeNode* root) {
        travel(root);
        return res;
    }
};

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> stk;
        TreeNode* prev;
        while(root||!stk.empty()){
            while(root){ //先把最左的节点一路入栈
                stk.push(root);
                root=root->left;
            }
            root=stk.top();
            stk.pop();
            if(!root->right||prev==root->right){
                prev=root;
                res.push_back(root->val);
                root=NULL;
            }else{
                stk.push(root);
                root=root->right;
            }
        }

        return res;
    }
};

 94. 二叉树的中序遍历

class Solution {
public:
    void travel(TreeNode* root,vector<int>& res){
        if(!root) return;
        travel(root->left,res);
        res.push_back(root->val);
        travel(root->right,res);
    }

    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        travel(root,res);
        return res;
    }
};
class Solution {
public:
    vector<int> travel(TreeNode* root){
        vector<int> res;
        stack<TreeNode*> stk;
        while(root||!stk.empty()){
            while(root!=NULL){
                stk.push(root);
                root=root->left;
            }
            root=stk.top();
            stk.pop();
            res.push_back(root->val);
            root=root->right;
        }
        return res;
    }

    vector<int> inorderTraversal(TreeNode* root) {
        return travel(root);
    }
};

102. 二叉树的层序遍历

class Solution {
public:
    vector<vector<int>> res;

    void search(TreeNode* root){
        queue<TreeNode*> q;
        queue<int> idx;
        q.push(root);
        idx.push(1);
        while(!q.empty()){
            TreeNode* p=q.front();
            q.pop();
            int i=idx.front();
            idx.pop();
            if(res.size()<i) res.push_back({});
            res[i-1].push_back(p->val);
            cout<<i<<":"<<p->val<<endl;
            if(p->left){
                q.push(p->left);
                idx.push(i+1);
            }
            if(p->right){
                q.push(p->right);
                idx.push(i+1);
            } 
        }
    }

    vector<vector<int>> levelOrder(TreeNode* root) {
        if(!root) return res;
        search(root);
        return res;
    }
};

199. 二叉树的右视图

class Solution {
public:
    vector<vector<int>> res;

    void search(TreeNode* root){
        queue<TreeNode*> q;
        queue<int> idx;
        q.push(root);
        idx.push(1);
        while(!q.empty()){
            TreeNode* p=q.front();
            q.pop();
            int i=idx.front();
            idx.pop();
            if(res.size()<i) res.push_back({});
            res[i-1].push_back(p->val);
            cout<<i<<":"<<p->val<<endl;
            if(p->left){
                q.push(p->left);
                idx.push(i+1);
            }
            if(p->right){
                q.push(p->right);
                idx.push(i+1);
            } 
        }
    }
    vector<int> rightSideView(TreeNode* root) {
        vector<int> final_res;
        if(!root) return final_res;
        search(root);
        for(int i=0;i<res.size();i++){
            final_res.push_back(res[i][res[i].size()-1]);
        }
        return final_res;
    }
};

 5. 恢复二叉树

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

class Solution {
public:

    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if(preorder.size()==0) return NULL;
        int idx=-1;
        for(int i=0;i<inorder.size();i++){
            if(inorder[i]==preorder[0]){
                idx=i; //找到左右子树的分叉点(即根节点)
                break;
            }
        }
        TreeNode* p=new TreeNode(inorder[idx]);
        cout<<inorder[idx];
        vector<int> pre_left(preorder.begin()+1,preorder.begin()+idx+1); //preleft=preorder[1,idx] 要排除掉第0个(即根节点)
        vector<int> pre_right(preorder.begin()+idx+1,preorder.end());
        vector<int> in_left(inorder.begin(),inorder.begin()+idx); //不用排除掉第0个, 但要排除掉idx
        vector<int> in_right(inorder.begin()+idx+1,inorder.end());
        p->left=buildTree(pre_left,in_left);
        p->right=buildTree(pre_right,in_right);
        return p;
    }
};

889. 根据前序和后序遍历构造二叉树

class Solution {
public:
    TreeNode* constructFromPrePost(vector<int>& preorder, vector<int>& postorder) {
        if(preorder.size()==0) return NULL;
        if(preorder.size()==1){
            TreeNode* p=new TreeNode(preorder[0]);
            return p;
        }
        int idx=-1; //后序遍历序列中, idx及其左边为左子树, 右边为右子树
        for(int i=0;i<postorder.size();i++){
            if(postorder[i]==preorder[1]){ 
                idx=i;
                break;
            }
        }
        TreeNode* p=new TreeNode(preorder[0]);
        vector<int> left_pre(preorder.begin()+1,preorder.begin()+idx+2);
        vector<int> right_pre(preorder.begin()+idx+2,preorder.end());
        vector<int> left_post(postorder.begin(),postorder.begin()+idx+1);
        vector<int> right_post(postorder.begin()+idx+1,postorder.end()-1);
        p->left=constructFromPrePost(left_pre,left_post);
        p->right=constructFromPrePost(right_pre,right_post);
        return p;
    }
};

108. 将有序数组转换为二叉搜索树

class Solution {
public:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        if(nums.size()==0) return NULL;
        int l=0,r=nums.size()-1,mid=(l+r)/2;
        TreeNode* p=new TreeNode(nums[mid]);
        vector<int> left_nums(nums.begin(),nums.begin()+mid);
        vector<int> right_nums(nums.begin()+mid+1,nums.end());
        p->left=sortedArrayToBST(left_nums);
        p->right=sortedArrayToBST(right_nums);
        return p;
    }
};

6. 路径总和

112. 路径总和

class Solution {
public:
    vector<int> res;
    bool helper(TreeNode* root,int sum,int targetSum){
        if(!root) return false;
        if(!root->left&&!root->right){
            sum+=root->val;
            return sum==targetSum;
        }
        sum+=root->val;
        return helper(root->left,sum,targetSum)||helper(root->right,sum,targetSum);
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
        return helper(root,0,targetSum);
    }
};

 113. 路径总和 II

class Solution {
public:
    vector<int> path;
    vector<vector<int>> res;

    void helper(TreeNode* root, int sum,int targetSum){
        if(!root) return;
        if(!root->left&&!root->right){
            sum+=root->val;
            path.push_back(root->val);
            if(sum==targetSum) res.push_back(path);
            path.pop_back();
        }else{
            sum+=root->val;
            path.push_back(root->val);
            helper(root->left,sum,targetSum);
            helper(root->right,sum,targetSum);
            path.pop_back();
        }
    }

    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        helper(root,0,targetSum);
        return res;
    }
};

 437. 路径总和 III

class Solution {
public:
    unordered_map<long long,int> prefix; //存储根节点到每一个节点的路径长度, 后用前缀和就可以求出所有节点之间的路经长度
    int helper(TreeNode* root,long long sum,int targetSum){
        if(!root) return 0;
        int cnt=0; //满足条件的路径总数
        sum+=root->val;
        if(prefix.find(sum-targetSum)!=prefix.end()){
            cnt=prefix[sum-targetSum];
        }
        prefix[sum]++;
        cnt+=helper(root->left,sum,targetSum);
        cnt+=helper(root->right,sum,targetSum);
        prefix[sum]--;

        return cnt;
    }  

    int pathSum(TreeNode* root, int targetSum) {
        prefix[0]=1;
        return helper(root,0,targetSum);
    }
};

7.else

114. 二叉树展开为链表

class Solution {
public:
    void flatten(TreeNode* root) {
        if(!root) return;
        TreeNode* prev=NULL;
        TreeNode* head=root;
        while(head){
            if(head->left){ //左子树存在的话, 找到左子树中的最右节点
                prev=head->left;
                while(prev->right) prev=prev->right;
                prev->right=head->right;
                head->right=head->left;
                head->left=NULL;
            }
            head=head->right;
        }
    }
};

236. 二叉树的最近公共祖先

class Solution {
public:
    vector<TreeNode*> path2p;
    vector<TreeNode*> path2q;
    bool findPath(TreeNode* root,TreeNode* p,vector<TreeNode*>& path){
        if(!root) return false;
        path.push_back(root);
        if(root==p){
            return true;
        }
        bool isFind=false;
        if(!isFind){
            isFind=findPath(root->left,p,path);
        }
        if(!isFind){
            isFind=findPath(root->right,p,path);
        }
        if(!isFind) path.pop_back();
        return isFind;
    }   

    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        findPath(root,p,path2p);
        findPath(root,q,path2q);
        for(int i=path2p.size()-1;i>=0;i--){
            for(int j=path2q.size()-1;j>=0;j--){
                if(path2p[i]->val==path2q[j]->val) return path2p[i];
            }
        }
        return NULL;
    }
};

sqattt
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode双人赛-leetcode-exercises:leetcode-练习
06-30
刷完整个专题，再去做什么回溯动规分治专题，你就会发现只要涉及递归的问题，都是树的问题。 其实很多动态规划问题就是在遍历一棵树，你如果对树的遍历操作烂熟于心，起码知道怎么把思路转化成代码，也知道如何提取...
acwing和leetcode-Algorithm:acwinglabuladongleetcode
07-07
acwing和leetcode 算法小结 0、排序 快速排序 快速排序 第K个数 归并排序 归并排序 逆序对的数量 1、二分 整数二分 数的范围 小数二分 数的三次方根 2、前缀和 一维前缀和 前缀和数组 二维前缀和 子矩阵的和 3、差分...
leetcode小岛出水口-leetcode-pp:记录刷题，方便复习
06-30
二叉树中的最大路径和 哈希表 【day-21】36.有效的数独 【day-24】149.直线上最多的点数 双指针 【day-25】11.盛最多水的容器 进阶篇 高频面试题 前缀树 并查集 跳表 剪枝 专题篇 二分法 滑动窗口 位运算 搜索(BFS, ...
leetcode题库-LeetCode:leetcode练习集合（分专题练习）
06-29
如果你不熟悉数据结构，那么像二叉树，BST，AVL树这些看似简单的结构都会让你头疼很久；更不用说在图论中出现的DFS, BFS, 贪心算法，动态规划等。 未掌握好以上两点就刷Leetocde， 那么你可能每一题都需要两三个小时...
leetcode题库-LeetCode:刷题记录
06-29
data_structure_binary_tree包为二叉树专题记录。 introduction_to_data_structure_binary_search_tree包为二叉搜索树专题记录。 n_ary_tree包为N叉树专题记录。 trie包为前缀树专题记录。 算法 binary_search包为二...
LeetCode 2644.找出可整除性得分最大的整数：暴力模拟（两层循环）
<font color="Pink">Tisfy的博客</font>
05-18 856
LeetCode 2644.找出可整除性得分最大的整数：暴力模拟（两层循环） 给你两个下标从 0 开始的整数数组 nums 和 divisors 。 divisors[i] 的 可整除性得分 等于满足 nums[j] 能被 divisors[i] 整除的下标 j 的数量。 返回 可整除性得分 最大的整数 divisors[i] 。如果有多个整数具有最大得分，则返回数值最小的一个。
LeetCode 235. 二叉搜索树的最近公共祖先
2301_80211119的博客
05-16 686
给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。 百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”
贪心 -力扣860.柠檬水找零力扣2208.将数组和减半的最少操作次数力扣179.最大数力扣376.摆动序列
weixin_72953218的博客
05-14 456
贪心 -力扣860.柠檬水找零力扣2208.将数组和减半的最少操作次数力扣179.最大数力扣376.摆动序列
LeetCode 108.将有序数组转换为二叉搜索树
2301_80211119的博客
05-18 815
给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 平衡 二叉搜索树。
力扣204.计数质数（线性筛）
ouliten的博客
05-17 168
假设不中断，对于i*primes[j+1]这个合数，它被primes[j+1]这个质数标记.但实际上，它的最小质数因该是primes[j],因为当i' =(i/primes[j])*primes[j+1]时，i' *primes[j]==i*primes[j+1],可知它因该被primes[j]这个质数标记。线性筛我之前的题解已经涉及到，但是讲的实在太差了我自己回看都看不懂，于是通过这道题重新回顾线性筛。（p,q等都是质因数，n,m是指数），其中一定会有一个最小的质数，我们的目的是要标记一个合数。
Golang | Leetcode Golang题解之第91题解码方法
weixin_66442839的博客
05-16 278
Golang | Leetcode Golang题解之第91题解码方法
代码随想录Day40：Leetcode343、96
maybeyaluokenai的博客
05-15 449
Leetcode343、96
【缺失的第一个正数】leetcode,python
m0_73629042的博客
05-18 231
总结：我觉得一个关键点是将[1,n]外的点全部赋值为0，这样的话，我们就能将问题转换为[1,n]上，就能使用先前的哈希表方法了。直接上石山代码：（过不了一点）。真是越做越觉得自己所学尚浅，，
力扣-219. 存在重复元素 II
最新发布
ls3614140的博客
05-19 94
给你一个整数数组 nums 和一个整数 k ，判断数组中是否存在两个 不同的索引 i 和 j ，满足 nums[i] == nums[j] 且 abs(i - j) <= k。如果存在，返回 true；否则，返回 false。输入：nums = [1,2,3,1,2,3], k = 2。输入：nums = [1,2,3,1], k = 3。输入：nums = [1,0,1,1], k = 1。
LeetCode_LCR002做题总结（可变字符序列使用）
yavlgloss的博客
05-14 318
如果想要可变字符，使用StringBuilder（可变字符序列，效率高，线程不安全）、StringBuffer（可变字符序列，效率低，线程安全）String是使用char数组来存储数据，并且是使用final修饰的，所以String的值一经定义是不可变的。没考虑到一个大于0 一个小于零int tmp = (a[i]-‘0’) + (b[j]-‘0’)public StringBuffer append(String str)：可以把。的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身。
[力扣题解] 1049. 最后一块石头的重量 II
东皇太一在此的博客
05-16 277
难点在于转化为背包问题；
【算法刷题day57】Leetcode：739. 每日温度、496.下一个更大元素 I
qq_45022758的博客
05-18 231
暂无暂无739. 每日温度代码随想录解析496.下一个更大元素 I代码随想录解析。
每日5题Day5 - LeetCode 21 - 25
alimamaalala的博客
05-17 378
虽然递归也要使用空间，但至少空间消耗比原来低一些，代码则简单太多了。所以我们对于链表、树节点的处理，尽量要考虑递归。这道题不好处理，咱们直接考虑使用优先级队列来做，反正是升序，具体过程交给优先级队列来做，我们就负责把所有的值添加进去。否则两者都存在时，当前node的next的next其实应该是返回比较小的那个值（如果对于链表（树的节点同样如此）使用递归的话，专注于每一个具体节点的行为，我们可以发现。上面的代码用了太多的额外空间了，如果考虑使用递归呢？这样写清爽得多，在子递归中我们也表明了方向。
【代码随想录算法训练Day10】LeetCode 225. 用队列实现栈、LeetCode 232.用栈实现队列
qq_46121420的博客
05-17 311
栈和队列
idea leetcode-edito乱码
09-01
LeetCode-Editor是一种在线编码工具，它提供了一个用户友好的界面编写和运行代码。在使用LeetCode-Editor时，有时候会出现乱码的问题。 乱码的原因可能是由于编码格式不兼容或者编码错误导致的。在这种情况下，我们...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值