Leetcode 树专题题型总结

最新推荐文章于 2022-04-12 19:45:07 发布
最新推荐文章于 2022-04-12 19:45:07 发布
阅读量326 收藏 1
点赞数
文章标签： leetcode 树结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kother/article/details/120810261
版权
本文总结了LeetCode中涉及二叉树的算法题目，包括中序遍历、对称二叉树、层序遍历、最大深度、构造二叉树、展开为链表、直径计算等。涵盖了递归、迭代、深度优先搜索（DFS）、广度优先搜索（BFS）等解题方法，并探讨了二叉搜索树的特性和相关操作。
摘要由CSDN通过智能技术生成

目录


刷了一段时间的树的题型了，写一篇博文总结一下做过的题（已分类）

二叉树

普通题型：

LeetCode 94. 二叉树的中序遍历

解题思路：递归 / 迭代

1.递归

class Solution {
private:
    vector<int>ans;
public:
    void Traversal(TreeNode* root){
        if(root==nullptr)
            return;
        Traversal(root->left);
        ans.push_back(root->val);
        Traversal(root->right);
    } 
    vector<int> inorderTraversal(TreeNode* root) {
        //递归终止条件
        if(root==nullptr)
            return ans;
        Traversal(root);
        return ans;
    }
};

2.迭代【速度比递归慢】

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> stk;
        while (root != nullptr || !stk.empty()) {
            while (root != nullptr) {
                stk.push(root);
                root = root->left;
            }
            root = stk.top();
            stk.pop();
            res.push_back(root->val);
            root = root->right;
        }
        return res;
    }
};
101. 对称二叉树

解题思路：递归

class Solution {
public:
    bool check(TreeNode* right,TreeNode* left)
    {
        if(right==nullptr && left==nullptr) return true;
        if(right==nullptr || left==nullptr) return false;
        return right->val==left->val && check(right->left,left->right) && check(right->right,left->left);
    }
    bool isSymmetric(TreeNode* root) {
        return check(root,root);
    }
};
102. 二叉树的层序遍历

解题思路：广度优先搜索（利用队列）

1.广度优先搜索即可，比较简单，很常规的解法。

//广度优先搜索
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>>ans;
        if(root==nullptr)
            return ans;
        queue<TreeNode*>q;
        q.push(root);//先把根节点放进去
        while(!q.empty())
        {
            int size=q.size();//当前要返回答案的大小
            vector<int>tempans;
            for(int i=0;i<size;i++)//踢出一个节点并往里面塞它的儿子们
            {
                TreeNode *temproot=q.front();
                if(temproot->left!=nullptr)
                    q.push(temproot->left);
                if(temproot->right!=nullptr)
                    q.push(temproot->right);
                tempans.push_back(temproot->val);
                q.pop();
            }
            ans.push_back(tempans);
        }
        return ans;
    }
};

vector二维数组的插入元素方法

若想定义A = [[0,1,2],[3,4]]，有两种方法。

（1）定义vector B分别为[0,1,2]和[3,4]，然后放入vector A。

vector A;

vector B;
B.push_back(0);
B.push_back(1);
B.push_back(2);

A.push_back(B);

B.clear();
B.push_back(3);
B.push_back(4);

A.push_back(B);

（2）
vector A;
for(int i = 0; i < 2; ++i) A.push_back(vector());
A[0].push_back(0);
A[0].push_back(1);
A[0].push_back(2);
A[1].push_back(3);
A[1].push_back(4);

LeetCode 104. 二叉树的最大深度

解题思路：深度优先搜索（递归）

class Solution {
public:
    int maxDepth(TreeNode* root) {
        //递归终止条件
        if(root==nullptr)
            return 0;
        return max(maxDepth(root->left),maxDepth(root->right))+1;
    }
};
LeetCode 105. 从前序与中序遍历序列构造二叉树

解题思路：递归

前序遍历的第一个结点一定是根节点.

递归：每一次递归其实都是找一个根节点，往里面输入前序中序的各自长度就可以，根节点靠递归函数自己找。

pindex是通过哈希表来找到的（更快）（也可以使用遍历）

class Solution {
    unordered_map<int,int>index;
public:

    TreeNode* CreateTree(vector<int>& preorder, vector<int>& inorder,int preleft,int        preright,int inleft,int inright)
    {
        if(preleft > preright || inleft > inright)
            return nullptr;
        int pindex = index[preorder[preleft]];//找到pindex
        TreeNode* root = new TreeNode(preorder[preleft]);
        root->left = CreateTree(preorder,inorder,preleft+1,preleft-inleft+pindex,inleft,pindex-1);
        root->right = CreateTree(preorder,inorder,preleft-inleft+pindex+1,preright,pindex+1,inright);
        return root;
    }

    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        int preleft = 0;
        int preright = preorder.size()-1;
        int inleft = 0;
        int inright = inorder.size()-1;
        for(int i=0;i<inorder.size();i++)
            index[inorder[i]]=i;//下标和值对应 方便以后找中序遍历的根节点
        return CreateTree(preorder,inorder,preleft,preright,inleft,inright);
    }
   
};
LeetCode 114. 二叉树展开为链表

解题思路：前序遍历

因为链表的顺序和前序遍历的顺序是一样的，所以用前序遍历把每个节点储存下来，再放到单链表中即可

class Solution {
private:
    vector<TreeNode*>pre;
public:
    //前序遍历
    void preTraversal(TreeNode* root){
        if(root==nullptr)
        {
            pre.push_back(root);
            return;
        }    
        pre.push_back(root);
        preTraversal(root->left);
        preTraversal(root->right);
    }
    
    void flatten(TreeNode* root) {
        preTraversal(root);
        root=pre[0];
        for(int i=1;i<pre.size();i++)
        {
            if(pre[i]!=nullptr)
            {
                root->right=pre[i];
                root->left=nullptr;
                root=root->right; 
            }  
        }    
    }
};
LeetCode 543. 二叉树的直径

解题思路：递归

class Solution {
    int ans=1;
public:
    int maxLength(TreeNode* root)
    {
        if(root==nullptr)
            return 0;
        int Lleft = maxLength(root->left);//左子树的最大深度
        int Lright = maxLength(root->right);//右子树最大深度
        ans = max(Lleft+Lright+1,ans);//更新答案

        return max(Lleft,Lright)+1;//返回的是两子树中取最大深度
    }

    int diameterOfBinaryTree(TreeNode* root) {
        //要记录每个结点延伸下去的左右子树的最大长度
        maxLength(root);
        return ans-1;
    }
};

二叉搜索树

LeetCode 96. 不同的二叉搜索树

解题思路：二叉搜索树序列的个数与其值无关，只与区间长度有关

抄的leetcode

class Solution {
public:
    int numTrees(int n) {
        vector<int> G(n + 1, 0);
        G[0] = 1;
        G[1] = 1;

        for (int i = 2; i <= n; ++i) {
            for (int j = 1; j <= i; ++j) {
                G[i] += G[j - 1] * G[i - j];
            }
        }
        return G[n];
    }
};
LeetCode 98. 验证二叉搜索树
class Solution {
public:
    bool helper(TreeNode* root, long long lower, long long upper) {
        if (root == nullptr) {
            return true;
        }
        //判断根节点是否在(lower,upper)的范围内
        //如果不在
        if (root -> val <= lower || root -> val >= upper) {
            return false;
        }
        //继续判断左节点，同时更新(lower,root->val)   // 继续判断右节点，同时更新(root->val,upper)
        return helper(root -> left, lower, root -> val) && helper(root -> right, root -> val, upper);
    }
    bool isValidBST(TreeNode* root) {
        return helper(root, LONG_MIN, LONG_MAX);
    }
};
基于树的DFS
LeetCode 236. 二叉树的最近公共祖先

解题思路：记录每个结点的父节点，然后一直p回溯往上走到根节点，期间用哈希表来标记走过的结点，之后q也一直往上走，当走到第一个p之前已经走过的结点时，这个结点就是最近公共祖先。

class Solution {
    unordered_map<TreeNode*,TreeNode*>parent;
    unordered_map<TreeNode*,int>visit;
public:

    TreeNode* Traversal(TreeNode* root)
    {
        if(root==NULL)
            return NULL;
        if(root->left!=NULL)
        {
            parent[root->left]=root;
            Traversal(root->left);
        }
        if(root->right!=NULL)
        {
            parent[root->right]=root;
            Traversal(root->right);
        }
        return NULL;
    }
    
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        Traversal(root);
        parent[root]=NULL;
        if(p==q)
            return p;
        TreeNode *pparent=p;
        TreeNode *qparent=q;

        while(pparent!=NULL)
        {
            visit[pparent]=1;//标记为访问过
            pparent=parent[pparent];
        }
        while(qparent!=NULL&&visit[qparent]!=1)
        {
            qparent=parent[qparent];
        }
        return qparent;
    }
};
226. 翻转二叉树

解题思路：很简单的遍历

class Solution {
public:
    void Traversal(TreeNode *root)
    {
        if(root==nullptr)
            return;
        if(root->left!=nullptr&&root->right!=nullptr)
        {
            TreeNode *temp=root->left;
            root->left=root->right;
            root->right=temp;
        }
        else if(root->left==nullptr)
        {
            root->left=root->right;
            root->right=nullptr;
            
        }
        else if(root->right==nullptr)
        {
            root->right=root->left;
            root->left=nullptr;
        }
        Traversal(root->left);
        Traversal(root->right);

    }
    TreeNode* invertTree(TreeNode* root) {
        //对于每个根节点都交换左右结点
        Traversal(root);
        return root;
    }
};
951. 翻转等价二叉树
class Solution {
public:
//对任意结点，root1和root2有  1左=2左且1右=2右   或    1左=1右且1右=1左 就满足了
//
    bool flipEquiv(TreeNode* root1, TreeNode* root2) {
        if(!root1&&!root2)//如果都是空的
            return true;
        else if((!root1&&root2)||(root1&&!root2)||(root1->val!=root2->val))//只有一个是空的或则值不相同
            return false;
        return (flipEquiv(root1->left,root2->left)&&flipEquiv(root1->right,root2->right))||(flipEquiv(root1->left,root2->right)&&flipEquiv(root1->right,root2->left));
        
    }
};
987. 二叉树的垂序遍历
class Solution {
    //往左走是 x+1 y-1  往右走是 x+1 y+1
    //列指的是y  
    //要判断有没有同行同列的
                //列对应的vector
    unordered_map<int,vector<int>>hash;
    unordered_map<int,int>X;
    vector<vector<int>>ans;
    int maxy=0,miny=0;
public:
//自己设置一个vector sort的函数
//sort: 如果这2个结点的x和y值都相同
//那么比较这两个结点的大小，把小的放到前面
//那就需要记录结点的x值和y值了
    void Traversal(TreeNode* Node,int x,int y){
        if(Node==nullptr)
            return;

        if(y>maxy)
            maxy=y;
        if(y<miny)
            miny=y;

        hash[y].push_back(Node->val);
        //记录下结点的x坐标
        X[Node->val]=x;

        if(Node->left!=nullptr)
            Traversal(Node->left,x+1,y-1);
        if(Node->right!=nullptr)
            Traversal(Node->right,x+1,y+1);
    }

    vector<int> Sort(vector<int> num){
        for(int i=0;i<num.size();i++){
            for(int j=i+1;j<num.size();j++){
                if(X[num[i]]==X[num[j]] && num[i]>num[j] || X[num[i]]>X[num[j]]){
                    int temp;
                    temp=num[i];
                    num[i]=num[j];
                    num[j]=temp;
                }

            }
        }   
        return num;
    }
    
    vector<vector<int>> verticalTraversal(TreeNode* root) {
        Traversal(root,0,0);
        for(int i=miny;i<=maxy;i++){
            if(hash.count(i)){
                hash[i]=Sort(hash[i]);
                ans.push_back(hash[i]);
            }    
        }
        return ans;
    }
};
572. 另一棵树的子树
    bool isSameTree(TreeNode* root1,TreeNode* root2)
    {
        //都是空的
        if(!root1&&!root2)
            return true;
        else if((root1&&!root2)||(!root1&&root2)||(root1->val!=root2->val))
            return false;
        return isSameTree(root1->left,root2->left)&&isSameTree(root1->right,root2->right);
    }

    bool isSubtree(TreeNode* root1, TreeNode* root2) {
    if (!root1 || !root2)
        return false;
    if (isSameTree(root1, root2))
        return true;
    return isSubtree(root1->left, root2) || isSubtree(root1->right, root2);
    }
};
863. 二叉树中所有距离为 K 的结点
class Solution {
    vector<int>ans;
    unordered_map<int,TreeNode*>parents;

public:
    void findParents(TreeNode* node) 
    {
        if (node->left != nullptr) 
        {
            parents[node->left->val] = node;
            findParents(node->left);
        }
        if (node->right != nullptr) 
        {
            parents[node->right->val] = node;
            findParents(node->right);
        }
    }

    void Go(TreeNode* target,TreeNode* from,int depth,int k)//DFS
    {
        if(target==nullptr)
            return;
        if(depth==k)
        {
            ans.push_back(target->val);
            return;
        }
        //from是防止走回头路
        if(target->left!=from) //往左走
            Go(target->left,target,depth+1,k);
        if(target->right!=from)//往右走
            Go(target->right,target,depth+1,k);
        if(parents[target->val]!=from)//往上走
            Go(parents[target->val],target,depth+1,k);
    }

    vector<int> distanceK(TreeNode* root, TreeNode* target, int k) {
        findParents(root);
        Go(target,nullptr,0,k);
        return ans;
    }
};
230. 二叉搜索树中第K小的元素
class Solution {
    vector<int>ans;
public:
    void Traversal(TreeNode* root)
    {
        if(root==nullptr)
            return;
        Traversal(root->left);
        ans.push_back(root->val);
        Traversal(root->right);
    }
    
    int kthSmallest(TreeNode* root, int k) {
        Traversal(root);
        return ans[k-1];
        
    }
};
235. 二叉搜索树的最近公共祖先
class Solution {
    unordered_map<TreeNode*,TreeNode*>parents;
    unordered_set<TreeNode*>visited;
public:
    void FindParents(TreeNode* root){
        if(root==NULL)
            return;
        if(root->left!=NULL){
            parents[root->left]=root;
            FindParents(root->left);
        }
        if(root->right!=NULL){
            parents[root->right]=root;
            FindParents(root->right);
        }
    }

    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        FindParents(root);
        parents[root]=NULL;
        TreeNode* temp=p;
        while(parents[temp]!=NULL){   //没到根节点，就一直做这个循环
            visited.insert(temp);
            temp=parents[temp];
        }
        temp=q;
        while(parents[temp]!=NULL){
            if(visited.count(temp))
                return temp;
            temp=parents[temp];
        }
        return root;
    }
};
669. 修剪二叉搜索树
class Solution {
public:
    TreeNode* trimBST(TreeNode* root, int low, int high) {
        if(root==nullptr)
            return root;
        if(root->val>high) 
            return trimBST(root->left,low,high);
        if(root->val<low)
            return trimBST(root->right,low,high);
        root->left = trimBST(root->left,low,high);
        root->right = trimBST(root->right,low,high);
        return root;
    }  
};
700. 二叉搜索树中的搜索
class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        if(root==nullptr)
            return nullptr;
        if(root->val==val)
            return root;
        if(root->val>val)
            return searchBST(root->left,val);
        if(root->val<val)
            return searchBST(root->right,val);
        return nullptr;
    }
};
108. 将有序数组转换为二叉搜索树
class Solution {
public:
    TreeNode* CreateTree(vector<int>& nums,int left,int right){

        if(left>=right)//终止条件
            return nullptr;
        int mid=(right+left)/2;
        TreeNode* root = new TreeNode(nums[mid]);
        root->left=CreateTree(nums,left,mid);       //左子树
        root->right=CreateTree(nums,mid+1,right);   //右子树
        return root;
    }

    TreeNode* sortedArrayToBST(vector<int>& nums) {
        int n=nums.size();
        TreeNode* root;
        root=CreateTree(nums,0,n);
        return root;
    }
};
617. 合并二叉树
class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if(root1==nullptr)
            return root2;
        if(root2==nullptr)
            return root1;
        TreeNode *merged = new TreeNode(root1->val+root2->val);
        merged->left = mergeTrees(root1->left,root2->left);
        merged->right = mergeTrees(root1->right,root2->right);
        return merged;
    }
};
基于树的BFS
103. 二叉树的锯齿形层序遍历
class Solution {
    vector<vector<int>>ans;
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        if(root==nullptr)
            return ans;
        queue<TreeNode*>q;
        int flag=0;
        q.push(root);//根节点入队
        while(!q.empty()){//q是非空的
            int n=q.size();
            vector<int>tempans;
            for(int i=0;i<n;i++){
                TreeNode *temproot=q.front();
                q.pop();
                if(temproot->left!=nullptr)
                    q.push(temproot->left);
                if(temproot->right!=nullptr)
                    q.push(temproot->right);
                tempans.push_back(temproot->val);
            }
            if(flag==1){
                reverse(tempans.begin(),tempans.end());
                flag=0;
            }
            else{
                flag=1;
            }
            ans.push_back(tempans);
        }
        return ans;
    }
};
姚同学阿
关注
leetcode总结——树篇
weixin_45680007的博客
02-17 340
自上而下： 路径和sum 最短路径 镜像树 层次遍历 树化链表 完全二叉树的节点个数： 路径和sum： 给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。 说明: 叶子节点是指没有子节点的节点。 示例: 给定如下二叉树，以及目标和 sum = 22， 5 / \ 4 8 ...
leetcode刷题之树专题
hua111hua的博客
02-02 693
文章目录1. 关于层次遍历2. 非递归层次遍历3. 记录层次信息的递归遍历3.1 二叉树的锯齿形层次遍历3.2 二叉树的右视图3.3 找树左下角的值3.4 在每个树行中找最大值 1. 关于层次遍历 层次遍历在树的遍历中有着非常重要的地位，本篇博客提出两种遍历方式，一种是最基本的使用队列完成的非递归遍历，一种是遍历过程中统计遍历层数的递归遍历，这种统计层数的好处是可以记录下每层的节点信息，对于找特殊...
LeetCode总结 -- 树的构造篇
热门推荐
Code Ganker
11-12 2万+
这篇总结主要介绍树中比较常见的一类题型--树的构造。其实本质还是用递归的手法来实现，但是这类题目有一个特点，就是它是构建一棵树，而不是给定一棵树，然后进行遍历，所以实现起来思路上有点逆向，还是要练习一下。LeetCode中关于树的构造的题目有以下几道：Convert Sorted Array to Binary Search TreeConvert Sorted List to Binary Se
Leetcode树专题
Myblog
08-19 283
Leetcode098（验证二叉搜索树）-------中序遍历 地址： https://leetcode-cn.com/problems/validate-binary-search-tree/ 描述： 代码： /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(
【LeetCode】树专题
ysq96的博客
06-02 286
注意 主要和b站大雪菜一起刷题，宝藏up主（https://www.bilibili.com/video/BV19t411w7Ep/?spm_id_from=333.788.videocard.0） 98. 验证二叉搜索树 思路： 这个题只需要判断是否是BST即可 题目条件限制的也很清晰，不会出现节点相等的情况 考虑划分范围的做法，假如当前节点的值为x，则左子树的取值范围为[-∞，x-1]，右子树的取值范围为[x+1，∞] # Definition for a binary tree node
【LeetCode 总结】Leetcode 题型分类总结、索引与常用接口函数
只能说希望每日一更
08-07 3238
文章目录零. Java 常用接口函数集合类数学类字符串一. 动态规划知识点题目二. 链表知识点题目三. 哈希表知识点题目四. 滑动窗口知识点题目五. 字符串知识点题目六. DFS、BFS知识点题目七. 二分法知识点题目八. 偏数学、过目不忘 and 原地算法等知识点题目 前言： 是时候开一个对于我的 LeetCode 专栏的总结索引了= = 虽然说大概只刷了150道左右，不过应该也可以简单总结一下了呢～ 题型主要是 LeetCode hot100 + 剑指Offer，也有其他的一些高频题 零. Java
力扣树专题-4 用leetcode104求树的深度举例 总结递归秒杀树问题的套路！ java刷题笔记
一碗菜粥的博客
05-31 1132
递归秒杀树问题的小套路~使用leetcode104 求树的深度 来进行举例说明~
LeetCode 1~400题知识点与题型全面总结
资源摘要信息:"LeetCode 1~400题知识点与题型总结" LeetCode是全球著名的在线代码编程练习平台，它提供了大量的编程题目，覆盖了各种算法和数据结构的知识点。本文档标题中的“leetcode296-LeetCode_400:力扣_400”...
Leetcode 刷题指南-树（1）C++
God_Xuebi的博客
07-24 597
Leetcode树结构刷题总结
LeetCode刷题攻略
Redemption___的博客
06-13 7318
应届生面试算法就考个数组 链表 二叉树 矩阵 数组变着法子考你排序 查询 指针 位运算 链表变着法子考你指针 最多再考个哈希 二叉树变着法子考用递归和栈前中后遍历 最多加上回溯 矩阵的话就是知道起点的路径查询和不知道起点的路径查询 掌握了这些 面大厂就比较轻松了 其实和学历技术关系也不大 大部分人先死到想都不敢想上了。 据了解，LeetCode 是一个非常棒的 OJ（Online Judge）平台，收集了许多公司的面试题目。相对其他 OJ 平台而言，有着下面的几个优点： 题目全部来自业内大公司的真.
LeetCode刷题：树专题
学习 & 分享 ~
04-12 355
文章目录【1】面试题 04.04. 检查平衡性【2】530. 二叉搜索树的最小绝对差【3】538. 把二叉搜索树转换为累加树【4】1022. 从根到叶的二进制数之和【5】543. 二叉树的直径【6】563. 二叉树的坡度【7】572. 另一个树的子树【8】606. 根据二叉树创建字符串【9】617. 合并二叉树【10】100. 相同的树 【1】面试题 04.04. 检查平衡性 考点： 递归 思路1： 从顶向下，若根节点的左右子树高度相差小于等于1（即是平衡树），则递归向下检查每个子树是否也为平衡树。 思路2
树专题汇总（Leetcode+牛客）
秀秀的奇妙旅行
03-22 371
二叉搜索树（BST） 1 验证树为BST 2 BST树中的两数之和为给定值 3 修剪BST 使之值位于给定最大值最小值之间 4 把BST转化为累加树 5 BST最小绝对差 6 有序数组转化为平衡的BST 有序链表转化为平衡的BST 7 BST搜索节点 BST插入节点 BST删除节点 8 BST中两节点的最近公共祖先 剑指offer补充 二叉搜索树的后序遍历序列 二叉搜索树与双向链表 二叉搜索树的...
leetcode:树总结
qq_43808588的博客
09-06 203
1、涉及的题目考虑使用：递归，遍历（深度、广度）处理 2、递归： （1）结束条件 一般为node为空，或者Node为叶子节点； 考虑函数的返回值 （2）递归结构 考虑node.left，node.right的函数调用与node的函数实现的关系 考虑node.left空，node.right的函数调用与node的函数实现的关系 考虑node.left，node.right空的函数调用与node的函数实现的关系 看是否可以统一起来 特殊： 对于参数是两个树的，处理的时候考虑树1的根节点、树
Leetcode总结（树）
Aaron_Marvel的博客
05-24 676
Leetcode刷题中的Tree类型，解析比较经典的题目
leetcode---树专题
多多
04-12 286
  Leetcode——二叉树常考算法整理 BFS与DFS常考算法整理 Leetcode——回溯法常考算法整理 动态规划(Dynamic Programming)算法与LC实例的理解 决战Leetcode: easy part(1-50) 决战Leetcode: easy part(51-96)   题目1： 求一棵二叉树的最大深度    Given a binary tree...
leetcode系列之-树(tree)题型总结
weixin_39802680的博客
09-13 1042
文章目录树模板路径总和112未完待续 树模板 路径总和112 题目简介 解题思路：现在大部分树的题大多使用递归解决。对于该道题用一个变量记录递归到某一层时，root到其根叶子节点的路径和。递归结束意味着要返回上一层，要减去该层的值进行复原。类似于二叉树的先序遍历。 public int count=0; public boolean hasPathSum(TreeNode root, int targetSum) { if(root==null){ retu
LeetCode刷题——树（递归）
qq_39181839的博客
12-14 623
对于树，经常用的算法有递归，回溯，BFS，DFS等。下面是一些用递归算法来解的题： 104，二叉树的最大深度，easy 110，平衡二叉树，easy 543，二叉树的直径，easy 226，翻转二叉树，easy 617，合并二叉树，easy 112，路径总和，easy 113，路径总和Ⅱ，midium 572，另一个树的子树，easy 101，对称二叉树，easy 111，二叉树的最小深度，easy 404，左叶子之和，easy 687，最长同值路径，medium 671，二叉树中第二小的节点，easy 1
Leetcode——树专题（持续更新）
qq_42265220的博客
01-11 493
学习目标： 掌握树的常见leetcode题目 学习内容： ①二叉树前中后序遍历：递归与非递归都要掌握 94.二叉树的中序遍历 144.二叉树的前序遍历 145.二叉树的后序遍历 ②二叉树的层序遍历： 102. 二叉树的层序遍历 107. 二叉树的层序遍历 II LinkedList的api(addFirst) 翻转二叉树 二叉树周末总结 对称二叉树 二叉树的最大深度 二叉树的最小深度 完全二叉树的节点个数 平衡二叉树 二叉树的所有路径 二叉树周末总结 二叉树中递归带着回溯 左叶子之和 找树左下角的
Leetcode题型分类总结及练习指南
LeetCode中的栈与递归题目可能会要求实现栈的基本操作，或者解决使用递归算法的问题，如树的遍历、分治算法、回溯算法等。 练习建议: - 对于数组和字符串类型的题目，通常需要重点掌握基础操作和常见的算法模式，如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值