二叉树常见oj题（持续更新中）

已于 2022-08-16 20:23:24 修改
阅读量515 收藏 18
点赞数 38
分类专栏： oj题 牛客网刷题系列 文章标签： leetcode 算法 深度优先
于 2022-05-09 22:51:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yin_ming_hui/article/details/124673787
版权

持续更新中的二叉树oj题

很多小伙伴为了刷题发愁
今天为大家推荐一款刷题神奇哦：刷题面试神器牛客
各大互联网大厂面试真题。从基础到入阶乃至原理刨析类面试题 应有尽有，赶快来装备自己吧！助你面试稳操胜券，solo全场面试官

一：根据二叉树创建字符串

class Solution {
public:
    string tree2str(TreeNode* root) {
         string ss;
         treecopy(root,ss);
         return ss;
    }
    void treecopy(TreeNode* root,string& str) //传引用减少构造
    {
        if(root == nullptr)
        return ;

        str+= to_string(root->val);

        if(root->left || root -> right)
        {
            str+="(";
           treecopy(root->left,str);
            str+=")";
        }

        if(root->right)
    {
        str+="(";
           treecopy(root->right,str);
            str+=")";
    }
    }
};
  • 思路：

利用的是前序遍历

  • 注意：
  1. 左子树和右子树的判断条件 ： 1. if(root->left || root -> right) （假如左子树或者右子树不为空，则执行左） 2. if(root->right) （只有当右子树不为空时，执行右分支）
  2. to_string的利用
  3. void treecopy(TreeNode* root,string& str) （传引用减少构造）

二：二叉树层序遍历

题目描述：（题目链接）
在这里插入图片描述

  • 方法一：
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> vv;
         if(root ==nullptr)
         return  vv;

         queue<TreeNode*> q;
         q.push(root);
         int numsize =1;
         while(!q.empty())
         {
             //一层一层的遍历
             vector<int> v;
           for(int i=0;i<numsize;i++)
           {
               TreeNode* cur = q.front();
               q.pop();
               v.push_back(cur->val);

               if(cur->left)
               q.push(cur->left);
               if(cur->right)
               q.push(cur->right);
           }
           vv.push_back(v);
           numsize = q.size();
           }
           return vv;
  • 思路：
  1. 记录当前层数的个数， 一层一层的遍历
  2. 利用了队列先进先出的特性
  • 注意事项：
  1. 注意队列函数的使用 ： q.front() 取出队头的数据
    q,back() 取队尾的数据
    （需要注意是的栈只能取队尾的数据，不能取对头的）
  2. 注意for循环的使用和numsize的更新，for(int i=0;i<numsize;i++)， numsize = q.size();
  • 方法二：
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> vv;
         if(root ==nullptr)
         return  vv;

         queue<TreeNode*> q;
         q.push(root);
         int numsize =1;
         while(!q.empty())
         {
           
             TreeNode* cur = q.front(); //取出队列的头
             v.push_back(cur->val);
             q.pop();
             numsize--;

             if(cur->left)
             q.push(cur->left);
             if(cur->right)
             q.push(cur->right);

             if(numsize==0)
             {
                 vector<int> tem =v;
                 v.clear();
                 vv.push_back(tem);
                 numsize = q.size();
             }
         }
         return vv;
    }
};

三：二叉树的层序遍历 II

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
         vector<vector<int>> vv;
         if(root ==nullptr)
         return  vv;

         queue<TreeNode*> q;
         q.push(root);
         int numsize =1;
         while(!q.empty())
         {
             //一层一层的遍历
             vector<int> v;
           for(int i=0;i<numsize;i++)
           {
               TreeNode* cur = q.front();
               q.pop();
               v.push_back(cur->val);

               if(cur->left)
               q.push(cur->left);
               if(cur->right)
               q.push(cur->right);
           }
           numsize =q.size();
           vv.push_back(v);
         }
         reverse(vv.begin(),vv.end());
         return vv;
    }
};
  • 思路：

reverse一下就得到了

四：二叉树的最近公共祖先

class Solution {
public:
bool find(TreeNode* root, TreeNode* p)
{
    if(root==nullptr)
    return false;

    if(root==p)
    return true;

     return find(root->right,p) ||  find(root->left,p);
}
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        //特殊情况
        if(root== p || root == q)
        return root;

        bool IsRightp=find(root->right,p);
        bool IsRightq=find(root->right,q);

        bool IsLeftp=!IsRightp;
         bool IsLeftq=!IsRightq;

         if(IsLeftp && IsLeftq)//全在左边
         {
            return  lowestCommonAncestor(root->left,p,q);
         }
         else if(IsRightp && IsRightq)//全在右边，就玩右边找
         {
             return lowestCommonAncestor(root->right,p,q);
         }
         else{
             return root;
         }
    }
};
  • 思路：
  1. 逻辑：找到第一个祖先， 有一个节点在祖先的左，有一个节点在祖先的右
  2. .时间复杂度：N*N 算最坏的情况（第一次findN,第二次find N-1…），因为find的时间复杂度是O（N）
  • 注意：

bool IsLeftp=!IsRightp;
bool IsLeftq=!IsRightq;
取反可以就不用再去递归左树了

  • 方法二：
bool findpath(TreeNode* root,stack<TreeNode*>& st,TreeNode* p)
{
      if(root==nullptr)
      return false;

      st.push(root); //先将root 入进栈
      if(root==p) //找到了
    { 
        return true;
    }

    //往左边找
    if(findpath(root->left,st,p)) 
    {
        return true; //左边找到了
    }

      //往右边找
    if(findpath(root->right,st,p)) 
    {
        return true; //右边找到了
    }

     //左右子树都没找到
     st.pop();
     return false;
}
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        stack<TreeNode*> stp,stq;
       findpath(root,stp,p);
       findpath(root,stq,q);
       int psize = stp.size();
       int qsize = stq.size();

       int max = psize >qsize? psize : qsize;
       int min = psize+qsize-max;

       stack<TreeNode*>* maxst =  max== psize? &stp : &stq;
       stack<TreeNode*>* minst =  max== psize? &stq : &stp; //找到长度大的和长度小的
       
       int  size = max - min;
       while(size--)
       {
           maxst->pop();
       }
       while(maxst->top()!=minst->top())
       {
           maxst->pop();
           minst->pop();
       }
       return maxst->top();
       }
       };
  • 思路：
    1. 找到p，q的路径
    2. 他们两个路径的交点就是共同祖先
    3. 两个栈交点的问题 可以理解为 链表交点问题来解决
    4. 时间复杂度为O（N）
  • 注意：
  1. 主要是findpath函数的实现，主要流程为：
    1. 先将root入进栈，再判断root是否为P,为p则找到了，return true
    2. 再判断左子树和右子树， if(findpath(root->left,st,p)) 假如左树找到了，则return true
    3. 假如左右子树都没找到，则pop出栈顶的元素

五：二叉树的前中后序遍历（非递归版）

前序

  • 方法一：

通用法，前后中序都基于此思路

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
       //先将左树全部入栈，再出，入右
       stack<TreeNode*> st;
       vector<int> v;
         //流程法
     TreeNode* cur =root; //要访问的树
     while(cur || !st.empty())
     {
         while(cur) //一直往左入
         {
             v.push_back(cur->val);
             st.push(cur);
             cur = cur->left;
         }
         //左边入完了
         TreeNode* tem= st.top();
         st.pop();
         cur = tem->right; //左数完了，再去入右树
         }
       return v;
    }
};
  • 思路：
  1. 先将左子树入栈，边入边push_back
  2. 左边入完了，再将本节点pop，入右树
  • 注意：
  1. 注意判断条件： while(cur || !st.empty()) ，当本节点不为空或者栈不为空的时候，进循环
  2. TreeNode* tem= st.top(); //先将栈顶节点pop掉，因为已经push_back了
    st.pop();
    cur = tem->right; //左数完了，再去入右树
  • 方法二：

简洁法

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
       //先将左树全部入栈，再出，入右
       stack<TreeNode*> st;
       vector<int> v;
       //简洁法
       if(root==nullptr)
       return v;
       st.push(root);
       while(!st.empty())
       {
           TreeNode* cur = st.top();
           st.pop();
           v.push_back(cur->val);

            if(cur->right)
                st.push(cur->right);
            if(cur->left)
            st.push(cur->left);
       }
    
       return v;
    }
};

中序

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
         stack<TreeNode*> st;
       vector<int> v;
     TreeNode* cur =root; //要访问的树
     while(cur || !st.empty())
     {
         while(cur) //一直往左入
         {
             
             st.push(cur);
             cur = cur->left;
         }
         //左边入完了
         TreeNode* tem= st.top();
         st.pop();
         v.push_back(tem->val); //左子树完了。访问根
         cur = tem->right;
     }
     return v;
    }
};

与前序不同的是 v.push_back(tem->val);的时机

后序

  • 方法一：

将前序的结果反转即可得到后序的结果

  • 方法二：
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {      
        vector<int> v;
        if(root == nullptr)
        return v;

        stack<TreeNode* > st;
        TreeNode* cur = root;
        TreeNode* prev = nullptr;
        while(cur || !st.empty())
        {
            //先去左边循环
            while(cur)
            {
                st.push(cur);
                cur = cur->left;
            }

             TreeNode* top = st.top(); //取栈顶的数据

             if(top->right == nullptr || top->right == prev)
             {
                 v.push_back(top->val);
                 st.pop();
                 prev =top;
             }
             else
             {
                cur = top->right;
             }
        }
        return v;
    }
};
  • 思路：
  1. 先入左数
  2. 再取栈顶元素
  3. 判断，假如（栈顶的右子树为空，或者 右子树为之前访问过的节点），就push_back，再pop，更新prev= 栈顶的元素
  4. 如果假如不成立，则再取栈顶的左树去找
  • 注意：
  1. 注意 if(top->right == nullptr || top->right == prev) 判断条件

六：二叉搜索树与双向链表

class Solution {
public:
    void Inoder(TreeNode* cur,TreeNode*& prev)
    { 
         if(cur==nullptr)
             return;
        
        Inoder(cur->left,prev);
        
        cur->left = prev;
        if(prev)
            prev->right = cur;
        
        prev =cur;
         Inoder(cur->right,prev);
     }
    TreeNode* Convert(TreeNode* pRootOfTree) {
        if(pRootOfTree == nullptr)
            return pRootOfTree;
         TreeNode* prev = nullptr;
        
        Inoder(pRootOfTree,prev);
        
        TreeNode* head = pRootOfTree;
        while(head->left)
            head = head->left;
        
        return head;
    }
};
  • 思路：
  1. 利用中序遍历链接整颗树
  2. 用一个prev指针指向前一个被访问的节点，然后当前节点的左子树指向 prev，假如prev不为空，prev的右子树指向当前节点，再更新pre。
  3. 最后递归右子树
  • 注意：
  1. 注意prev要传引用，因为prev是要实时变化的
  2. 链表的头不要格外的去记录，因为是双向链表，一直 往左就找到了

七：从前序与中序遍历序列构造二叉树

class Solution {
public:
     TreeNode* _buildTree(vector<int>& preorder,int& start,
     vector<int>& inorder,int left,int right)
     {
         if(left>right)
         return nullptr;

         //先由根构建节点
         TreeNode*  root = new TreeNode(preorder[start]);
         start++;
          
          //再利用中序去寻找左右子树的边界
          int preleft = left;
          int  i = root->val;
          while(left<=right)
          {
              if(i == inorder[left])
              {
                  break;
              }
              else
              left++;
          }
         root->left = _buildTree(preorder,start,inorder,preleft,left-1);
         root->right = _buildTree(preorder,start,inorder,left+1,right);

         return root;
     }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
              int start =0;
           return _buildTree(preorder,start,inorder,0,inorder.size()-1);
    }
};
  • 思路：

利用前序找到根节点，再通过中序找到左右子树，从而构造出了一整颗树

  • 注意：
  1. 递归结束的条件：left>right
  2. 注意start要传引用，因为要实时变化的。

八：后继者

class Solution {
public:
    TreeNode* inorderSuccessor(TreeNode* root, TreeNode* p) {
        if(root==nullptr)
        return root;
        
        TreeNode*  cur = inorderSuccessor(root->left,p);
        if(cur != nullptr)
        return cur;

        if(root->val > p->val) //找到第一个大于P的值
        return root;

        return inorderSuccessor(root->right,p);
    }
};
  • 思路：

中序找到第一个比p大的值就是后续

九：左子树之和

方法一：

  • 代码：
class Solution {
public:
      void _sumOfLeftLeaves(TreeNode* root,int& sum){
          if(root == nullptr)
              return ;

              if(root->left!=nullptr && root->left->right==nullptr && root->left->left ==nullptr)
            sum += root->left->val;
            
            _sumOfLeftLeaves(root->left,sum);
            _sumOfLeftLeaves(root->right,sum);
      }
    int sumOfLeftLeaves(TreeNode* root) {
          int sum=0;
            _sumOfLeftLeaves(root,sum);
            return sum;
    } 
};

方法二：

  • 代码：
class Solution {
public:
    int sumOfLeftLeaves(TreeNode* root) {
          int sum=0;
            _sumOfLeftLeaves(root,sum);
            return sum;

        if(root==nullptr)
        return 0;

        int leftsum = sumOfLeftLeaves(root->left);
        int rightsum = sumOfLeftLeaves(root->right);
        
        int tem =0;
        if(root->left!=nullptr && root->left->right==nullptr && root->left->left ==nullptr)
            tem = root->left->val;

            return leftsum+rightsum+tem;
    } 
};
  • 思路：

递归去找左树上和右树上的左叶子节点，相加即可

  • 注意：

特别要注意的是 左叶子节点的判断条件：root->left!=nullptr && root->left->right==nullptr && root->left->left ==nullptr

十：找树左下角的值

方法一：

层序遍历，找到最下面一层，最先从队列里出来的树

方法二：

  • 代码：
class Solution {
public:
             int high=0,ret=0;//high 来记录当前最左节点的高度，ret记录答案
             void _findBottomLeftValue(TreeNode* root,int deep)
             {
                    if(root==nullptr)
                    return;

                    if(root->left==nullptr && root->right ==nullptr) //因为是前序遍历，所以同一高度，左树优先
                    {
                        if(deep > high)
                           {
                               ret=root->val;
                               high =deep;
                           }
                    }
                    if(root->left)  _findBottomLeftValue(root->left,deep+1);
                    if(root->right)  _findBottomLeftValue(root->right,deep+1);
             }
    int findBottomLeftValue(TreeNode* root) {
        ret =root->val;
         _findBottomLeftValue(root,high);
         return ret;
    }
};
  • 思路：
  1. 记录当前最左节点的高度，如果找到叶子节点的高度大于之前的，则该叶子节点为当前树的左下角
  2. 因为是前序遍历，所以同一层的，左子树优先，所以可以求出左下角
  • 注意：

注意全局变量的使用

十一：路径总和

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool hasPathSum(TreeNode* root, int targetSum) {
        return _hasPathSum(root,0,targetSum);
    }
   bool  _hasPathSum(TreeNode* root, int curSum,int targetSum)
   {
       if(root==nullptr)
       {
         return false;
       }
       curSum+= root->val;
       if(root->left==nullptr && root->right==nullptr)
       {
           if(curSum == targetSum)
           return true;
           else
           return false;
       }
       if(_hasPathSum(root->left,curSum,targetSum))
       return true;

       if(_hasPathSum(root->right,curSum,targetSum))
       return true;

       return false;
   }
};

十二： 从前序与中序遍历序列构造二叉树

*代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
     TreeNode* _buildTree(vector<int>& preorder,int& start,
     vector<int>& inorder,int left,int right)
     {
         if(left>right)
         return nullptr;

         //先由根构建节点
         TreeNode*  root = new TreeNode(preorder[start]);
         start++;
          
          //再利用中序去寻找左右子树的边界
          int preleft = left;
          int  i = root->val;
          while(left<=right)
          {
              if(i == inorder[left])
              {
                  break;
              }
              else
              left++;
          }
         root->left = _buildTree(preorder,start,inorder,preleft,left-1);
         root->right = _buildTree(preorder,start,inorder,left+1,right);

         return root;
     }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
              int start =0;
           return _buildTree(preorder,start,inorder,0,inorder.size()-1);
    }
};

总结：

二叉树的oj题考察的主要是递归思想的运用和 非递归时，对整个递归流程的理解。
只有理解好递归的整个过程和思路，才能更好地学好二叉树

  • 多写，多思考，多复习，多总结！！
  • 持续更新中！！！
雪芙花
关注
专栏目录
2024华为OD机试真题最新题库 (B+C+D+E卷) +OJ在线刷题（C++、Java、Python合集）（目前已收录571道）
KJ.JK
06-17 5万+
本文是2024华为OD机试真题最新题库 (B+C+D卷) （C++、Java、Python合集）专栏的目录贴（持续更新中…）2024华为OD机试真题(Python语言) B+C+D卷2024华为OD机试真题(Java 语言) B+C+D卷2024华为OD机试真题(C++语言)B+C+D卷2024华为OD机试真题(JS 语言) B+C+D卷2024最全正版题库，全是原题什么是华为OD，什么是华为OD机试？ >**华为OD是Outsourcing Dispacth模式，是华为和外企德科联合招聘的简称**。目前
2024华为OD机试真题(Python 语言) B+C+D+E卷真题目录介绍，带你了解什么是华为OD，机试真题（570道）
热门推荐
KJ.JK
07-07 12万+
本文是华为OD机试真题（Python 语言）专栏的目录贴（持续更新中…）华为OD是Outsourcing Dispacth模式，是华为和外企德科联合招聘的简称。目前华为大多数是OD招聘。OD模式也是华为提出的一种新的用工形式，每年都会从OD项目挑优秀员工转为正编。所有OD和正式员工一样对待，没有差别，部门平时开会、评审等活动都是一起参加的，是同薪同酬，都是由华为的HR直接定的薪资，看的是我们技术能力。华为是大企业，能到华为上班也是有能力的，每个部门都有好多职位，是金子，在哪都会发光。
入门数据结构JAVADS——部分常见的二叉树OJ题目(1) 持续更新
cjejwe的博客
10-12 936
之前的博客中,笔者初步介绍了一下二叉树的性质,如何构建二叉树和二叉树的常见方法.这篇博客围绕着二叉树的常见方法,介绍一下常见的OJ题目,帮助读者们加深对于二叉树的理解.虽然本文介绍的是常见的OJ题,但其实还是介绍二叉树常见的构造,存储,遍历.只不过是把这些方法应用于实际的题目当中.
2024华为OD机试已正式切换E卷，E卷新题正在火热更新中，支持在线OJ练习题目，三种语言解答，每日持续更新 （已更新570道）
KJ.JK
09-09 1万+
华为od机试，华为od机试真题，华为od机试E卷，华为odE卷，华为od机试真题E卷，华为OD，华为OD机试，华为OD机试真题，华为od机考，华为od机试D卷，华为od机试真题D卷，华为od手撕代码，华为od，华为od机试C卷，华为od e卷，华为2024e卷，od机试，2024E卷，华为OD机试E卷，什么是华为od，华为od介绍，全面了解华为od，2024华为od，如何备战华为od，华为od算法，华为od手撕代码，华为OD机试2024年最新题库，一文带你读懂华为OD，华为机试e卷
ACM算法竞赛及OJ题面常用英文单词整理
流楚丶格念的博客
11-23 7760
文章目录 ABCDEFGHIJKLMNOPQRSTUVW A abbreviation [数学] 约分; activity on edge AOE网 activity on vertex AOV网 add, subtract, multiply and divide加减乘除 adjacency list 邻接表（adjacency multilist 邻接多重表） adjacency matrix 邻接矩阵 adjacent sequence elements相邻的元素串 adjacent v
【ACM】算法竞赛及OJ题面常用英文单词整理（更新ing）
Loi_Chairmanの博客
09-25 7026
好久不发博客啦又，偷懒可不行（笑），再次冒泡来与大家分享快乐！ 最近打多校和刷题时频频遇到一些高频词，特此整理一下，比赛的时候真的炒鸡有用，毕竟一个词卡掉一道题是真的伤呀！！ 小亓在这里整理的是已经过滤了大部分46级水平常见词汇，筛去了基础算法词汇，选出400多经典算法竞赛高频生词，如有错误欢迎各位大佬指出！此外本单词表仍在更新，欢迎米娜桑关注233333 本文涉及多为英文题面常见词汇总，具体见下： 文章目录ABCDEFGHIJKLMNOPQRSTUVW A abbreviation [数学] 约分; ac
【数据结构】二叉树面试题总结(持续更新中...)
weixin_44258092的博客
08-10 1513
总结了二叉树的相关习题。
JAVA(持续更新中...)
weixin_41742700的博客
02-20 285
Java基础 1、面向对象的概述 面向对象是模型化的，只需抽象出一个类，需要什么功能直接使用就可以了，不必去一步一步的实现，至于是如何实现的，不用去管。 面向过程是具体化的，流程化的，解决一个问题，你需要一步一步的分析，一步一步的实现。 2、 面向对象的特征有哪些方面? 1)抽象：将一类对象的共同特征总结出来构造类的过程 抽象包括两个方面，一是过程抽象,二是数据抽象。 2)继承：使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。 继
Ios中常见的问题
wangbao1991的博客
04-28 4983
__block和__weak修饰符的区别其实是挺明显的：  1.__block不管是ARC还是MRC模式下都可以使用，可以修饰对象，还可以修饰基本数据类型。  2.__weak只能在ARC模式下使用，也只能修饰对象（NSString），不能修饰基本数据类型（int）。  3.__block对象可以在block中被重新赋值，__weak不可以。     tableView 滑动卡的问题主要
二叉树与堆
纪宁的博客
09-16 654
树、二叉树、堆排序的内容，1.5w字超详细讲解，内附大量配图。初学者建议收藏
【数据结构Java版】树与二叉树的相关知识全解
m0_63372226的博客
12-27 810
a.树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，（根朝上，而叶朝下）它具有以下的特点：b.有一个特殊的结点，称为根结点，根结点没有前驱结点。除根结点外，其余结点被分成M(M > 0)个互不相交的集合T1、T2、......、Tm，其中每一个集合Ti (1
数据结构与算法(Python)——常见数据结构Part4(二叉树)
王定桥的专栏
12-21 2085
写在前面 在上一节part3我们熟悉队列结构，本节将熟悉应用广泛的树结构。我们的目的是快速了解他们，对于它们涉及到的复杂的数据结构和算法，在这里并不全部展开，留在后期详述。 1. 树 1.1 树的直观感受 树是一个广泛应用的数据结构，即使未开始学习这个数据结构，我们在生活或者计算机中已经和它打交道好久了。首先让我们看几个树形的应用例子(图片来自What is the real li...
华为OD机试真题目录汇总（C语言）2024 B+C+D+E卷 （484道）
KJ.JK
08-09 9万+
本文是华为OD机试真题（C语言）专栏的目录贴（持续更新中…）华为OD是Outsourcing Dispacth模式，是华为和外企德科联合招聘的简称。目前华为大多数是OD招聘。OD模式也是华为提出的一种新的用工形式，每年都会从OD项目挑优秀员工转为正编。所有OD和正式员工一样对待，没有差别，部门平时开会、评审等活动都是一起参加的，是同薪同酬，都是由华为的HR直接定的薪资，看的是我们技术能力。华为是大企业，能到华为上班也是有能力的，每个部门都有好多职位，是金子，在哪都会发光。
力扣-Mysql-3293-计算产品最终价格（中等）
最新发布
Jotcy的博客
11-15 679
本题需求为计算产品最终价格，并没有很难思考的点。只需要根据题目要求使用case when 条件判断 进行价格计算即可；进行两表关联时要注意选择 Products表为主表，以及价格计算时要使用 round() 函数四舍五入保留两位小数。
动态规划习题其七【力扣】【算法学习day.29】
2301_79232523的博客
11-11 340
##我做这类文档一个重要的目的还是给正在学习的大家提供方向（例如想要掌握基础用法，该刷哪些题？）我的解析也不会做的非常详细，只会提供思路和一些关键点，力扣上的大佬们的题解质量是非常非常高滴！！！
力扣 LeetCode 239. 滑动窗口最大值（Day5：栈与队列）
qq_61504864的博客
11-15 195
可以把 peek() 改为 peekFirst() ，虽然是一个意思，但看起来更加清楚，对于双端队列能更清晰地表述具体操作。始终维护deque的头元素为最大值，后面来的值更大就会逐一清除前面比它小的值。
LeetCode 216-组合总数Ⅲ
qq_45801839的博客
11-11 275
【代码】LeetCode 216-组合总数Ⅲ。
leetcode104：二叉树的最大深度
D2510466299的博客
11-14 302
给定一个二叉树root，返回其最大深度。二叉树的是指从根节点到最远叶子节点的最长路径上的节点数。32[0, 104]
力扣题目解析--有效的括号
wxtg1921的博客
11-13 1029
学者在最初接触的这道题的时候，刚开始的想法就是利用地图查找法来进行匹配，但是那样写的代码太过于臃肿，而且出了问题。然后经过学习，认为地图查找法可以使用，但是需要辅助。于是利用栈来辅助判断括号。1.栈（下面来详细介绍一下占数组之间有何特点和优点，这样可以帮助我们更加正确的认识这样的使用，在以后解决问题的过程中，我们可以正确的使用栈的特点和优点。如果是左括号，它会在。提供的一个成员函数，用于检查键。，判断字符串是否有效。中找到对应的右括号。
二叉树面试题与考研总结：关键考点详解
本资源主要聚焦于二叉树和树的相关概念以及在计算机科学中的应用，特别是在面试和考研考试中的常见题目。以下是详细的知识点总结： 1. **前缀表达式转换**：前缀表达式（也称逆波兰表达式）是一种数学表达式的书写...
评论 30
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

雪芙花

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值