二叉树刷题总结

最新推荐文章于 2024-08-29 16:23:51 发布
最新推荐文章于 2024-08-29 16:23:51 发布
阅读量57 收藏
点赞数
分类专栏： 算法刷题 文章标签： leetcode 算法 贪心算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74041368/article/details/129900483
版权
这篇文章介绍了多种二叉树的遍历方法，包括前序遍历、中序遍历、后序遍历的迭代实现，以及层次遍历、树的翻转、判断对称性、求最大深度、最小深度、节点计数、平衡二叉树检测等操作。所有方法都基于C++实现，利用栈和队列进行非递归遍历。
摘要由CSDN通过智能技术生成

前序遍历，中序遍历与后序遍历（迭代法）

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> result;
        if (root == NULL) return result;
        st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();                       // 中
            st.pop();
            result.push_back(node->val);
            if (node->right) st.push(node->right);           // 右（空节点不入栈）
            if (node->left) st.push(node->left);             // 左（空节点不入栈）
        }
        return result;
    }
};

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        TreeNode* cur = root;
        while (cur != NULL || !st.empty()) {
            if (cur != NULL) { // 指针来访问节点，访问到最底层
                st.push(cur); // 将访问的节点放进栈
                cur = cur->left;                // 左
            } else {
                cur = st.top(); // 从栈里弹出的数据，就是要处理的数据（放进result数组里的数据）
                st.pop();
                result.push_back(cur->val);     // 中
                cur = cur->right;               // 右
            }
        }
        return result;
    }
};

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> result;
        if (root == NULL) return result;
        st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            st.pop();
            result.push_back(node->val);
            if (node->left) st.push(node->left); // 相对于前序遍历，这更改一下入栈顺序 （空节点不入栈）
            if (node->right) st.push(node->right); // 空节点不入栈
        }
        reverse(result.begin(), result.end()); // 将结果反转之后就是左右中的顺序了
        return result;
    }
};

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        //广度优先搜索
        queue<TreeNode*> que;//辅助队列
        if (root != NULL)//根节点入队列 
        que.push(root);
        vector<vector<int>> result;
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();//记录根节点
                que.pop();//出栈
                vec.push_back(node->val);//记录出栈的值
                if (node->left) que.push(node->left);//注意这里必须是node而不能是root，不然死循环
                if (node->right) que.push(node->right);
            }
            result.push_back(vec);
        }
        return result;
    }
};

 

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        //递归可以看作先执行后面的
        //需要用到返回的指针
        if(!root)return nullptr;
        TreeNode*treeleft=invertTree(root->left);//记录左
        TreeNode*treeright=invertTree(root->right);//记录右
        root->left=treeright;//交换
        root->right=treeleft;
        return root;
    }
};

 

class Solution {
public:
    bool judge(TreeNode*root1,TreeNode*root2){
        //如果两边有一方为空一方不为空
        if((!root1&&root2)||(root1&&!root2)){
            return false;
        }
        else if(root1==nullptr&&root2==nullptr){
            return true;
        }
        //相等的话递归判断后续节点，相当于从后往前传递信息
        if(root1->val==root2->val){
            return judge(root1->left,root2->right)&&judge(root1->right,root2->left);
        }
        return false;

    }
    bool isSymmetric(TreeNode* root) {
        if(!root){
            return true;
        }
        else{
            return judge(root->left,root->right);
        }
    }
};

 

 

class solution {
public:
    int maxdepth(treenode* root) {
        if (root == null) return 0;
        return 1 + max(maxdepth(root->left), maxdepth(root->right));
    }
};

class Solution {
public:
    int maxDepth(TreeNode* root) {
        //广度优先队列
        if(!root)return 0;
        int res=0;
        queue<TreeNode*>que;
        que.push(root);
        while(!que.empty()){
            res++;//res在这里++，一层一层加
            int size=que.size();
            for(int i=0;i<size;i++){
            TreeNode*point=que.front();
            que.pop();
            if(point->left)que.push(point->left);
            if(point->right)que.push(point->right);
        }
        }
        return res;
    }
};

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

class Solution {
public:
    int minDepth(TreeNode* root) {
        if(!root)return 0;
        queue<TreeNode*>que;
        //导入根节点
        que.push(root);
        int res=0;
        while(que.size()!=0){
            res++;
            int size=que.size();
            for(int i=0;i<size;i++){
                TreeNode*point=que.front();
                que.pop();
                if(point->left)que.push(point->left);
                if(point->right)que.push(point->right);
                //如果左右节点都不存在了
                if(!point->left&&!point->right)return res;
            }
        }
        return res;
    }
};

 

class Solution {
public:
    int countNodes(TreeNode* root) {
        queue<TreeNode*>que;
        if(!root)return 0;
        que.push(root);
        int res=0;
        while(!que.empty()){
            res++;
            TreeNode*point=que.front();
            que.pop();
            if(point->left)que.push(point->left);
            if(point->right)que.push(point->right);
        }
        return res;
    }
};

 

class Solution {
public:
    int deep(TreeNode*root){
        if(!root)return 0;
        else return max(deep(root->left),deep(root->right))+1;
    }
    bool isBalanced(TreeNode* root) {
        if(root==nullptr)return true;
        if(abs(deep(root->left)-deep(root->right))<=1){
            return isBalanced(root->left)&&isBalanced(root->right);
        }
        return false;
    }
};

class Solution {
public:
    // 返回以该节点为根节点的二叉树的高度，如果不是平衡二叉树了则返回-1
    int getHeight(TreeNode* node) {
        if (node == NULL) {
            return 0;
        }
        int leftHeight = getHeight(node->left);
        if (leftHeight == -1) return -1;
        int rightHeight = getHeight(node->right);
        if (rightHeight == -1) return -1;
        return abs(leftHeight - rightHeight) > 1 ? -1 : 1 + max(leftHeight, rightHeight);
    }
    bool isBalanced(TreeNode* root) {
        return getHeight(root) == -1 ? false : true;
    }
};

 

class Solution {
public:
    vector<int>res;
    vector<vector<int>>result;
    void search(TreeNode*root){
        //回溯
        if(!root)return;//如果root为空，直接返回
        //不为空的话就导入
        res.push_back(root->val);
        //终止条件为到叶子节点
        if(!root->left&&!root->right){
            result.push_back(res);//传递
            res.pop_back();//回溯，因为这里就return了，不会进行下面的回溯
            return;
        }
        //正常深度优先搜索+回溯
        search(root->left);
        search(root->right);
        res.pop_back();
    }
    vector<string> binaryTreePaths(TreeNode* root) {
        search(root);
        string str;
        vector<string>strres;
        for(int i=0;i<result.size();i++){
            str.clear();
            str=to_string(result[i][0]);
            for(int j=1;j<result[i].size();j++){
                str+="->"+to_string(result[i][j]);
            }
            strres.push_back(str);
        }
    return strres;
    }
};

 

class Solution {
public:
    int sumOfLeftLeaves(TreeNode* root) {
        queue<TreeNode*>que;//广度优先遍历
        if(!root)return 0;
        que.push(root);
        int res=0;
        while(que.size()!=0){
            TreeNode*point=que.front();
            que.pop();
            if(point->left){//不能写在一起，不然左节点即使存在也有可能加不进来
            //如果这个节点的左节点是左叶子
            if(point->left->left==nullptr&&point->left->right==nullptr){
                que.push(point->left);
                res+=point->left->val;
            }
            else{
                que.push(point->left);
            }
            }
            if(point->right){
                que.push(point->right);
            }
        }
        return res;
    }
};

 

class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        //广度优先搜索
        if(!root)return 0;
        queue<TreeNode*>que;
        que.push(root);
        int result=0;
        while(que.size()!=0){
            int size=que.size();
            for(int i=0;i<size;i++){
                TreeNode*point=que.front();
                que.pop();
                if (i == 0) result = point->val; // 记录每一行第一个元素
                //当结束时就自然是最后一行的第一个元素
                if(point->left){
                    que.push(point->left);
                }
                if(point->right)que.push(point->right);
            }
        }
        return result;

    }
};

 

class Solution {
public:
    bool hasPathSum(TreeNode* root, int targetSum) {
        if(!root)return false;
        //一个条件返回上来
        if(targetSum-root->val==0&&root->left==nullptr&&root->right==nullptr){
            return true;
        }
        else{
            return hasPathSum(root->left,targetSum-root->val)||hasPathSum(root->right,targetSum-root->val);
        }
    }
};

 

class Solution {
public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if(inorder.size()==0||postorder.size()==0)return nullptr;
        int i=0;
        int temp=postorder[postorder.size()-1];
        for(i=0;i<postorder.size();i++){
            if(inorder[i]==temp){
                break;
            }
        }
        //分块在构建
        vector<int>inorder1(inorder.begin(),inorder.begin()+i);
        vector<int>inorder2(inorder.begin()+i+1,inorder.end());
        vector<int>postorder1(postorder.begin(),postorder.begin()+i);
        vector<int>postorder2(postorder.begin()+i,postorder.end()-1);
        TreeNode*point=new TreeNode(temp);//新建节点
        point->left=buildTree(inorder1,postorder1);//递归构建左子树
        point->right=buildTree(inorder2,postorder2);//递归构建右子树
        return point;//返回
    }
};

 

class Solution {
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if(inorder.size()==0||preorder.size()==0)return nullptr;
        int i=0;
        int temp=preorder[0];
        for(i=0;i<inorder.size();i++){
            if(inorder[i]==temp){
                break;
            }
        }
        //分块在构建
        vector<int>preorder1(preorder.begin()+1,preorder.begin()+i+1);
        vector<int>preorder2(preorder.begin()+i+1,preorder.end());
        vector<int>inorder1(inorder.begin(),inorder.begin()+i);
        vector<int>inorder2(inorder.begin()+i+1,inorder.end());
        TreeNode*point=new TreeNode(temp);
        point->left=buildTree(preorder1,inorder1);
        point->right=buildTree(preorder2,inorder2);
        return point;
    }
};

 

class Solution {
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        if(nums.empty())return nullptr;
        int i=0;
        int max=nums[0];int j=0;
        for(i=0;i<nums.size();i++){
            if(nums[i]>max){
                max=nums[i];
                j=i;
            }
        }
        vector<int>nums1(nums.begin(),nums.begin()+j);
        vector<int>nums2(nums.begin()+j+1,nums.end());
        TreeNode*point=new TreeNode(max);
        point->left=constructMaximumBinaryTree(nums1);
        point->right=constructMaximumBinaryTree(nums2);
        return point;

    }
};

 

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if(root1==nullptr&&root2==nullptr)return nullptr;
        int temp=0;
        if(root1)temp+=root1->val;
        if(root2)temp+=root2->val;
        TreeNode*point=new TreeNode(temp);
        //分情况
        if(root1==nullptr&&root2){
            point->left=mergeTrees(nullptr,root2->left);
        point->right=mergeTrees(nullptr,root2->right);
        }
        else if(root2==nullptr&&root1){
            point->left=mergeTrees(root1->left,nullptr);
        point->right=mergeTrees(root1->right,nullptr);
        }
        else{
        point->left=mergeTrees(root1->left,root2->left);
        point->right=mergeTrees(root1->right,root2->right);
        }
        return point;
    }
};

 

class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        if(root==nullptr)return nullptr;
        //小了，去右边找
        if(root->val<val){
            return searchBST(root->right,val);
        }
        //大了，去左边找
        else if(root->val>val){
            return searchBST(root->left,val);
        }
        //相等就返回
        else{
            return root;
        }
    }
};

 

class Solution {
public:
    vector<int>temp;
    void search(TreeNode*root){
        if(!root)return;
        search(root->left);
        temp.push_back(root->val);
        search(root->right);
    }
    bool isValidBST(TreeNode* root) {
        search(root);
        for(int i=0;i<temp.size()-1;i++){
            if(temp[i]>=temp[i+1]){
                return false;
            }
        }
        return true;
    }

};

 

class Solution {
public:
    vector<int>temp;
    void search(TreeNode*root){
        if(!root)return;
        search(root->left);
        temp.push_back(root->val);
        search(root->right);
    }
    int getMinimumDifference(TreeNode* root) {
        search(root);
        int res=temp[1]-temp[0];
        vector<int>dp(temp.size()-1,temp[1]-temp[0]);
        for(int i=0;i<temp.size()-1;i++){
            dp[i]=temp[i+1]-temp[i];
            res=min(res,dp[i]);
        }
        return res;
    }
};

 

class Solution {
public:
    vector<int>temp;
    void search(TreeNode*root){
        if(!root)return;
        search(root->left);
        temp.push_back(root->val);
        search(root->right);
    }
    vector<int> findMode(TreeNode* root) {
        search(root);
        unordered_map<int,int>hash;
        for(int i=0;i<temp.size();i++){
            hash[temp[i]]++;
        }
        vector<int>res;
        int max=0;
        for(auto it=hash.begin();it!=hash.end();it++){
            if(it->second>max){
                max=it->second;
                res.clear();
                res.push_back(it->first);
            }
            else if(it->second==max){
                res.push_back(it->first);
            }
        }
        return res;
    }
};

 

class Solution {
public:
    vector<vector<TreeNode*>>vec;//用二维容器存储
    vector<TreeNode*>temp;//回溯
    void search(TreeNode*root,TreeNode*point){
        if(!root)return;
        //不为空则导入
        temp.push_back(root);
        if(root==point){
            vec.push_back(temp);
            //这里如果加了return，则不会进行关于root节点的深度优先搜索了
            //因此加return的话，需要在这里pop——back，即回溯
        }
        search(root->left,point);
        search(root->right,point);
        temp.pop_back();
    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        search(root,p);
        search(root,q);
        int size=min(vec[0].size(),vec[1].size());
        int i=0;
        for(i=0;i<size;i++){//第一个不同的，或者走到一个数组没了
            if(vec[0][i]!=vec[1][i]){
                break;
            }
        }
        //返回前一个
        return vec[0][i-1];
    }
};

 

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if (root->val > p->val && root->val > q->val) {
            return lowestCommonAncestor(root->left, p, q);
        } else if (root->val < p->val && root->val < q->val) {
            return lowestCommonAncestor(root->right, p, q);
        } else return root;
    }
};

 

class Solution {
public:
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        //返回指针，用后面递归传来的指针进行操作
        //root为空，代表此时需要新增节点，并返回
        if(!root){
            TreeNode*point=new TreeNode(val);
            return point;
        }
        //大了的话，用左递归传来的节点接到左子树上，如果root->left为空的话
        //则会返回新节点
        if(root->val>val){
            root->left=insertIntoBST(root->left,val);
            return root;
        }
        else if(root->val<val){
            root->right=insertIntoBST(root->right,val);
            return root;
        }
        return root;
    }
};

class Solution {
private:
    TreeNode* parent;
    void traversal(TreeNode* cur, int val) {
        if (cur == NULL) {
            TreeNode* node = new TreeNode(val);
            if (val > parent->val) parent->right = node;
            else parent->left = node;
            return;
        }
        parent = cur;
        if (cur->val > val) traversal(cur->left, val);
        if (cur->val < val) traversal(cur->right, val);
        return;
    }

public:
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        parent = new TreeNode(0);
        if (root == NULL) {
            root = new TreeNode(val);
        }
        traversal(root, val);
        return root;
    }
};

 

class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
        //依旧返回指针，给上一步用
        if(!root)return nullptr;
        //大了的话，更新左子树
        if(root->val>key)root->left=deleteNode(root->left,key);
        else if(root->val<key)root->right=deleteNode(root->right,key);
        //相等的话，找到了删除节点，对其更正后返回更正了的节点
        else{
            if(root->left==nullptr&&root->right){
                return root->right;
            }
            else if(root->right==nullptr&&root->left){
                return root->left;
            }
            else if(root->right==nullptr&&root->left==nullptr){
                return nullptr;
            }
            else{
                TreeNode*cur=root->right;
                while(cur->left){
                    cur=cur->left;
                }
                cur->left = root->left;
                root = root->right;
                return root;
            }
        }
        return root;
    }
};

 

class Solution {
public:
    TreeNode* trimBST(TreeNode* root, int low, int high) {
        if(root==nullptr)return nullptr;
        //该修剪了
        if(root->val>high){
            //返回左边的修剪后的节点，递归的传上来
            TreeNode*point=trimBST(root->left,low,high);
            return point;
        }
        else if(root->val<low){
            TreeNode*point=trimBST(root->right,low,high);
            return point;
        }
        //重接
        root->left=trimBST(root->left,low,high);
        root->right=trimBST(root->right,low,high);
        return root;
    }
};

 

class Solution {
private:
    TreeNode* traversal(vector<int>& nums, int left, int right) {
        if (left > right) return nullptr;
        int mid = left + ((right - left) / 2);
        TreeNode* root = new TreeNode(nums[mid]);
        root->left = traversal(nums, left, mid - 1);
        root->right = traversal(nums, mid + 1, right);
        return root;
    }
public:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        TreeNode* root = traversal(nums, 0, nums.size() - 1);
        return root;
    }
};

 

class Solution {
private:
    int pre = 0; // 记录前一个节点的数值
    void traversal(TreeNode* cur) { // 右中左遍历
        if (cur == NULL) return;
        traversal(cur->right);
        cur->val += pre;
        pre = cur->val;
        traversal(cur->left);
    }
public:
    TreeNode* convertBST(TreeNode* root) {
        pre = 0;
        traversal(root);
        return root;
    }
};

 

看到请叫我去学习
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树刷题总结：力扣刷题
gtjsjj的博客
12-21 289
这篇文章写的太好了！https://labuladong.gitbook.io/algo/shu-ju-jie-gou-xi-lie/2.3-shou-ba-shou-shua-er-cha-shu-xun-lian-di-gui-si-wei/er-cha-shu-xi-lie-1 一般二叉树的题离不开前序，中序，后序，层序遍历。（概念性的东西就不说了，很多博客都讲了，专注刷题） 前序遍历：中左右 中序遍历：左中右 后序遍历：左右中 层序遍历：类似于广度搜索，从左到右，从上到下顺着来。 一.二
leetcode之二叉树刷题总结（C++）
L_smartworld的博客
08-04 627
基础知识： 所有的题都是建立在二叉树的前序遍历，中序遍历，后序遍历（它们的递归版与非递归版），及层次遍历。搜索二叉树及平衡二叉树。搜索二叉树是指按照中序遍历，它是从小到大排序的(所以考搜索二叉树基本考中序遍历)。平衡二叉树是指根节点的左右子树总结点相差不能超过1。 参考代码：（上面的遍历方式标准版） #include <iostream> #include <vector> #include <string> #include <stack...
【leetcode】二叉树刷题总结（二）二叉树构造问题、最近公共祖先问题
zs16113的博客
07-24 328
先找到根节点，然后找到并递归构造左右子树即可：可以通过前序遍历结果找到根节点，然后根据中序遍历结果确定左右子树。通过前序后序遍历结果无法确定唯一的原始二叉树。前序遍历，迭代法实现。
二叉树刷题总结：二叉树的遍历方式
2401_83384536的博客
04-11 453
好了，关于二叉树遍历的总结到这里就结束了，回顾一下，在二叉树的遍历中分为深度优先遍历和广度优先遍历，其中深度优先遍历可以使用递归和迭代的方式去实现。广度优先遍历则可以用层序遍历的方式去实现。其中，我们还用到了栈和队列的数据结构。
二叉树刷题
weixin_39034379的博客
09-03 7410
二叉树刷题 二叉树相关的问题基本都可以用递归来解答，是我们拿来练习递归的好方法。 递归的阶梯关键两个步骤： 1.递归结束条件。（程序什么时候退出） 2.递推公式。 只要找到这两个 结果，递归相关的代码就可以写出来了。切忌不要平铺直叙的去想问题，因为递归相关的问题，人的大脑基本是想不明白的，我们只需要总结出来规律其他的交给计算机即可，这本身就是计算机喜欢做的事情。 例子： 就比如我们非常熟悉的 斐波那切数列。就是后边的值是前边两个数的和。 可以非常容易的写出公式 f(n) = f(n-1) + f(n-2);
Leetcode刷题总结-3.二叉树篇
weixin_44924725的博客
05-29 336
二叉树有两种主要的形式：满二叉树和完全二叉树，满二叉树上只有度为0和2的节点，完全二叉树的定义是在除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置（通俗点说就是没填满的都在最后一层，而且是从左向右，没填满的都是在右边）；
二叉树刷题第一部分总结
qq_44787943的博客
01-28 141
参考链接：https://labuladong.gitbook.io/algo/shu-ju-jie-gou-xi-lie/shou-ba-shou-shua-er-cha-shu-xun-lian-di-gui-si-wei/er-cha-shu-xi-lie-1 首先是递归算法的核心： 明确函数定义，相信这个定义，不要跳进递归细节 其次关于递归框架的选择： 首先要搞清楚，root节点它自己要做什么，或者说，在什么时候做，这点很关键，然后根据题目要求选择前，中，后序的递归框架 还有什么心得以后补充 ..
力扣 | 二叉树刷题笔记
zzzlueng的博客
09-28 412
今天两道题是找二叉树的公共祖先，不同点是二叉树一棵是普通二叉树，另外一棵是搜索二叉树。 先说搜索二叉树： 给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。 百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。” 解题思路： 搜索二叉树的的性质就是对于任意一个结点，它的左子树所有值都要比它小，右子树的所有结点值都要比它大。 既然是二叉搜索树，那么root结点的值
二叉树刷题，bfs刷题
小泽爱刷题的博客
08-06 1012
实例方法使用self来访问和修改实例属性和方法。类方法使用cls来访问类属性和方法。静态方法不需要self或cls参数，因为它们不访问类或实例的任何属性或方法。访问实例方法需要使用self，这并不是类方法的特性，而是实例方法的特性。类方法和静态方法不使用self，类方法使用cls，静态方法不使用任何特殊的类或实例引用实例方法： 实例方法可以访问实例属性和类属性。它们主要用于操作实例数据。python复制代码class MyClass:类方法： 类方法只能访问类属性，不能直接访问实例属性。
leetcode分类-leetcode:leetcode刷题总结
06-30
《LeetCode刷题总结与系统开源解析》 LeetCode，这个全球知名的在线编程挑战平台，是程序员提升技能、准备面试的必备工具。它涵盖了多种编程语言，提供了丰富的算法和数据结构题目，帮助开发者在实践中磨炼编程思维...
Leetcode刷题总结——二叉树
weixin_47883447的博客
04-06 445
二叉树节点的定义： 1、二叉树的遍历 前序遍历（中左右）、中序遍历（左中右）、后序遍历（左右中） 递归三要素： 1）确定递归函数的参数和返回值：确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。 2）确定终止条件：写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。 3）.
算法面试题-----二叉树完整刷题总结
爱喝舒化奶的博客
03-19 3360
题目：输入一颗二叉树，返回他的深度（包括最大深度，最小深度） 解题：可以通过DFS，BFS两种方式进行计算 【剑指offer】面试题55 二叉树的深度 leetcode 104. Maximum Depth of Binary Tree （求二叉树的最大深度,DFS,BFS） leetcode 111. Minimum Depth of Binary Tree(求二叉树的最小深度，DFS,BFS)...
力扣（无重叠区间）
yyssas的博客
08-29 1725
先按照左侧数字排序，然后对于i位置和i+1位置，如果i位置右侧数字大于i+1位置左侧数字，则说明这两个区间有重叠，则需要移除更可能和后面重叠的那一个，因为排序是按照左边从小到大排序的，所以左边一定是小的，此时要关注的就是右边，也就是选择i和i+1右侧更小的那个，即右侧大的那个删除。一直到右侧小于k的左侧停止，此时剩下的一定是不会重叠的那个。需要移除区间的最小数量，使剩余区间互不重叠。
57. 插入区间【 力扣(LeetCode) 】
yyh520025的博客
08-29 1757
给你一个 无重叠的 ，按照区间起始端点排序的区间列表 intervals，其中 intervals[i] = [starti, endi] 表示第 i 个区间的开始和结束，并且 intervals 按照 starti 升序排列。同样给定一个区间 newInterval = [start, end] 表示另一个区间的开始和结束。在 intervals 中插入区间 newInterval，使得 intervals 依然按照 starti 升序排列，且区间之间不重叠（如果有必要的话，可以合并区间）。
leetCode - - - 二叉树
weixin_67793092的博客
08-26 921
理解树的基本结构和操作是解决这些问题的关键。通过熟悉递归和迭代的实现方式，能够在不同问题中选择合适的解决方案。此外，注意边界条件和节点关系的处理，能够提高解题的准确性和效率。
leetcode_128_最长连续序列解析
最新发布
shulu的专栏
08-29 502
如何确定一个数是连续序列的起点？如何跟踪和更新最长序列的长度？如何高效地扩展连续序列？
leetcode763:划分字母区间
qq_55630615的博客
08-25 517
我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。注意，划分结果需要满足：将所有划分结果按顺序连接，得到的字符串仍然是。返回一个表示每个字符串片段的长度的列表。贪心+哈希表记录最远距离,只要满足就截断。(不是复杂度最优解)
leetcode509:斐波那契数
qq_55630615的博客
08-25 572
开始，后面的每一项数字都是前面两项数字的和。表示）形成的序列称为。
Labuladong二叉树递归课程与刷题资源
总结来说，labuladong的刷题笔记V5.0是一本实用的工具书，不仅适合正在学习数据结构的学生，也适合有经验的开发者巩固知识，通过大量实战练习提高算法设计和优化技巧。无论你是希望深入理解二叉树递归，还是寻求提高...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值