代码随想录算法训练营第36期DAY18

DAY18

二叉树的层序遍历

102二叉树的层序遍历

“队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。”

二叉树层序遍历模版：

  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     TreeNode *left;
  6.  *     TreeNode *right;
  7.  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
  8.  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
  9.  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  10.  * };
  11.  */
  12. class Solution {
  13. public:
  14.     vector<vector<int>> levelOrder(TreeNode* root) {
  15.         queue<TreeNode*> que;
  16.         vector<vector<int>> result;
  17.         if(root!=nullptr) que.push(root);
  18.         while(!que.empty())
  19.         {
  20.             int size=que.size();
  21.             vector<int> vec;
  22.             for(int i=0;i<size;i++)
  23.             {
  24.                 TreeNode* node=que.front();
  25.                 que.pop();
  26.                 vec.push_back(node->val);
  27.                 if(node->left) que.push(node->left);
  28.                 if(node->right) que.push(node->right);
  29.             }
  30.             result.push_back(vec);
  31.         } 
  32.         return result;
  33.     }
  34. };

二叉树层序遍历递归模版：

  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     TreeNode *left;
  6.  *     TreeNode *right;
  7.  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
  8.  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
  9.  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  10.  * };
  11.  */
  12. class Solution {
  13. public:
  14.     void order(TreeNode* node,vector<vector<int>> &result,int depth)
  15.     {
  16.         if(node==nullptr) return;
  17.         if(result.size()==depth) result.push_back(vector<int>());
  18.         result[depth].push_back(node->val);
  19.         if(node->left) order(node->left,result,depth+1);
  20.         if(node->right) order(node->right,result,depth+1);
  21.     }
  23.     vector<vector<int>> levelOrder(TreeNode* root) {
  24.         vector<vector<int>> result;
  25.         int depth=0;
  26.         order(root,result,depth);
  27.         return result;
  28.     }
  29. };

107二叉树的层序遍历II

递归法模版：

  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     TreeNode *left;
  6.  *     TreeNode *right;
  7.  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
  8.  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
  9.  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  10.  * };
  11.  */
  12. class Solution {
  13. public:
  14.     void order(TreeNode* node,vector<vector<int>> &result,int depth)
  15.     {
  16.         if(node==nullptr) return;
  17.         if(result.size()==depth) result.push_back(vector<int>());
  18.         result[depth].push_back(node->val);
  19.         if(node->left) order(node->left,result,depth+1);
  20.         if(node->right) order(node->right,result,depth+1);
  21.     }
  22.     vector<vector<int>> levelOrderBottom(TreeNode* root) {
  23.         vector<vector<int>> result;
  24.         int depth=0;
  25.         order(root,result,depth);
  26.         reverse(result.begin(),result.end());
  27.         return result;
  28.     }
  29. };

正常模版：

  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     TreeNode *left;
  6.  *     TreeNode *right;
  7.  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
  8.  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
  9.  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  10.  * };
  11.  */
  12. class Solution {
  13. public:
  14.     vector<vector<int>> levelOrderBottom(TreeNode* root) {
  15.         vector<vector<int>> result;
  16.         queue<TreeNode*> que;
  17.         if(root!=nullptr) que.push(root);
  18.         while(!que.empty())
  19.         {
  20.             int size=que.size();
  21.             vector<int> vec;
  22.             for(int i=0;i<size;i++)
  23.             {
  24.                 TreeNode* node=que.front();
  25.                 que.pop();
  26.                 vec.push_back(node->val);
  27.                 if(node->left) que.push(node->left);
  28.                 if(node->right) que.push(node->right);
  29.             }
  30.             result.push_back(vec);
  31.         }
  32.         reverse(result.begin(),result.end());
  33.         return result;
  34.     }
  35. };

199二叉树的右视图

现在变成一维vector的return result，该怎么写递归的模版呢？递归似乎更麻烦了。

先试试普通方法：

不行，思路错了：不能只遍历根节点和右孩子，因为会出现这种：

加了一句else if();新的问题又出现了：....

有想法了（“不如把思路逆转过来！”）：正常层序遍历，vector<vector<int>> result的每行，取最后一列，就是答案。怎么写语法呢？看答案吧：

代码随想录的思路要更直接：判断是否遍历到单层的最后面的元素，如果是，就放进result数组里，随后返回result就可以了。

那么如何知道“是否遍历到单层的最后面的元素”呢？我们有que.size()来记录这层树的节点个数！i 是节点的指针，那么i==size-1的话，就是答案；push_back.

  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     TreeNode *left;
  6.  *     TreeNode *right;
  7.  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
  8.  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
  9.  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  10.  * };
  11.  */
  12. class Solution {
  13. public:
  14.     vector<int> rightSideView(TreeNode* root) {
  15.         queue<TreeNode*> que;
  16.         vector<int> res;
  17.         if(root!=nullptr) que.push(root);
  18.         while(!que.empty())
  19.         {
  20.             int size=que.size();
  21.             for(int i=0;i<size;i++)
  22.             {
  23.                 TreeNode* node=que.front();
  24.                 que.pop();
  25.                 if(i==size-1) res.push_back(node->val);
  26.                 if(node->left) que.push(node->left);
  27.                 if(node->right) que.push(node->right);
  28.             }
  29.         }
  30.         return res;
  31.     }
  32. };

637二叉树的层平均值

语法怎么写

在层外和层里面操作就好啦：也就是：for里面和for外面。灵活一点！

数据上没有为难人，写好就通过了：

  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     TreeNode *left;
  6.  *     TreeNode *right;
  7.  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
  8.  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
  9.  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  10.  * };
  11.  */
  12. class Solution {
  13. public:
  14.     vector<double> averageOfLevels(TreeNode* root) {
  15.         queue<TreeNode*> que;
  16.         vector<double> res;
  17.         if(root!=nullptr) que.push(root);
  18.         while(!que.empty())
  19.         {
  20.             int size=que.size();
  21.             double sum=0;
  22.             for(int i=0;i<size;i++)
  23.             {
  24.                 TreeNode* node=que.front();
  25.                 que.pop();
  26.                 sum+=node->val;
  27.                 if(node->left) que.push(node->left);
  28.                 if(node->right) que.push(node->right);
  30.             }
  31.             res.push_back(sum/size);
  32.         }
  33.         return res;
  34.     }
  35. };

牢记：有size来记录每层节点数量。

429 N叉树的层序遍历

Node的孩子不为空的时候，push_back就好，语法怎么写，尤其是这个children的迭代。。

哦：node->children[i]。因为它是一个vector，进一步，用for来迭代。记住for里面有个for，逻辑。

  1. /*
  2. // Definition for a Node.
  3. class Node {
  4. public:
  5.     int val;
  6.     vector<Node*> children;
  8.     Node() {}
  10.     Node(int _val) {
  11.         val = _val;
  12.     }
  14.     Node(int _val, vector<Node*> _children) {
  15.         val = _val;
  16.         children = _children;
  17.     }
  18. };
  19. */
  21. class Solution {
  22. public:
  23.     vector<vector<int>> levelOrder(Node* root) {
  24.     vector<vector<int>> res;
  25.     queue<Node*> que;
  26.     if(root!=nullptr) que.push(root);
  27.     while(!que.empty())
  28.     {
  29.         int size=que.size();
  30.         vector<int> vec;
  31.         for(int i=0;i<size;i++)
  32.         {
  33.             Node* node=que.front();
  34.             que.pop();
  35.             vec.push_back(node->val);
  36.             for(int j=0;j<node->children.size();j++)
  37.             {
  38.                 que.push(node->children[j]);
  39.             }
  40.         }
  41.         res.push_back(vec);
  42.     }
  43.     return res;
  44.     }
  45. };

515在每个树行中找最大值

最大的int怎么写？INT32_MAX;过不了，初始化的num不够小。

初始化：不要num=-1*INT32_MAX;要：num=INT_MIN.

可能是因为这个：

  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     TreeNode *left;
  6.  *     TreeNode *right;
  7.  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
  8.  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
  9.  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  10.  * };
  11.  */
  12. class Solution {
  13. public:
  14.     vector<int> largestValues(TreeNode* root) {
  15.         vector<int> res;
  16.         queue<TreeNode*> que;
  17.         if(root!=nullptr) que.push(root);
  18.         while(!que.empty())
  19.         {
  20.             int num=INT_MIN;
  21.             int size=que.size();
  22.             for(int i=0;i<size;i++)
  23.             {
  24.                 TreeNode* node=que.front();
  25.                 que.pop();
  26.                 num=max(num,node->val);
  27.                 if(node->left) que.push(node->left);
  28.                 if(node->right) que.push(node->right);
  29.             }
  30.             res.push_back(num);
  31.         }
  32.         return res;
  33.     }
  34. };

116填充每个节点的下一个右侧节点指针

怎么写，他要返回什么，怎么把next这个信息穿回去呢？

接上，为什么对node=que.front操作,return root就是答案？把root、node当做同一个东西就好。

思路（来自代码随想录）：

本题依然是层序遍历，只不过在单层遍历的时候记录一下本层的头部节点，然后在遍历的时候让前一个节点指向本节点就可以了

  1. /*
  2. // Definition for a Node.
  3. class Node {
  4. public:
  5.     int val;
  6.     Node* left;
  7.     Node* right;
  8.     Node* next;
  10.     Node() : val(0), left(NULL), right(NULL), next(NULL) {}
  12.     Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}
  14.     Node(int _val, Node* _left, Node* _right, Node* _next)
  15.         : val(_val), left(_left), right(_right), next(_next) {}
  16. };
  17. */
  19. class Solution {
  20. public:
  21.     Node* connect(Node* root) {
  22.         queue<Node*> que;
  23.         if(root!=nullptr) que.push(root);
  24.         while(!que.empty()) 
  25.         {
  26.             Node* nodepre;
  27.             Node* node;
  28.             int size=que.size();
  29.             for(int i=0;i<size;i++)
  30.             {
  31.                 //i是节点的指针，所以这里用i来写if
  32.                 if(i==0){
  33.                     nodepre=que.front();
  34.                     que.pop();
  35.                     node=nodepre;//勿漏
  36.                 }
  37.                 else{
  38.                     node=que.front();//更新node
  39.                     que.pop();
  40.                     nodepre->next=node;//key
  41.                     //不要忘了更新nodepre,nodepre的作用：记录当前节点（node）的上一个节点
  42.                     nodepre=nodepre->next;
  43.                 }
  44.                 if(node->left) que.push(node->left);
  45.                 if(node->right) que.push(node->right);
  46.             }
  47.             nodepre->next=nullptr;
  48.         }
  49.         return root;
  50.         
  51.     }
  52. };

117填充每个节点的下一个右侧节点指针II

只要彻底理解了116，那么会发现这题是完全相同的，就当二刷了：

  1. /*
  2. // Definition for a Node.
  3. class Node {
  4. public:
  5.     int val;
  6.     Node* left;
  7.     Node* right;
  8.     Node* next;
  10.     Node() : val(0), left(NULL), right(NULL), next(NULL) {}
  12.     Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}
  14.     Node(int _val, Node* _left, Node* _right, Node* _next)
  15.         : val(_val), left(_left), right(_right), next(_next) {}
  16. };
  17. */
  19. class Solution {
  20. public:
  21.     Node* connect(Node* root) {
  22.         queue<Node*> que;
  23.         if(root!=nullptr) que.push(root);
  24.         while(!que.empty())
  25.         {
  26.             int size=que.size();
  27.             Node* nodepre;
  28.             Node* node;
  29.             for(int i=0;i<size;i++)
  30.             {
  31.                 if(i==0){
  32.                     nodepre=que.front();
  33.                     que.pop();
  34.                     node=nodepre;
  35.                 }
  36.                 else{
  37.                     node=que.front();
  38.                     que.pop();
  39.                     nodepre->next=node;
  40.                     nodepre=nodepre->next;
  41.                 }
  42.                 if(node->left) que.push(node->left);
  43.                 if(node->right) que.push(node->right);
  44.             }
  45.             nodepre->next=nullptr;
  46.         }
  47.         return root;
  48.     }
  49. };

104二叉树的最大深度

简单：

  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     TreeNode *left;
  6.  *     TreeNode *right;
  7.  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
  8.  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
  9.  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  10.  * };
  11.  */
  12. class Solution {
  13. public:
  14.     int maxDepth(TreeNode* root) {
  15.         queue<TreeNode*> que;
  16.         if(root!=nullptr) que.push(root);
  17.         int res=0;
  18.         while(!que.empty())
  19.         {
  20.             int size=que.size();
  21.             for(int i=0;i<size;i++)
  22.             {
  23.                 TreeNode* node=que.front();
  24.                 que.pop();
  25.                 if(node->left) que.push(node->left);
  26.                 if(node->right) que.push(node->right);
  27.             }
  28.             res++;
  29.         }
  30.         return res;
  31.     }
  32. };

111二叉树的最小深度

暂时没思路。再想想：左右孩子都为空，则说明到了最低点。

  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     TreeNode *left;
  6.  *     TreeNode *right;
  7.  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
  8.  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
  9.  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  10.  * };
  11.  */
  12. class Solution {
  13. public:
  14.     int minDepth(TreeNode* root) {
  15.         queue<TreeNode*> que;
  16.         int depth=0;
  17.         if(root!=nullptr) que.push(root);
  18.         while(!que.empty())
  19.         {
  20.             depth++;
  21.             int size=que.size();
  22.             for(int i=0;i<size;i++)
  23.             {
  24.                 TreeNode* node=que.front();
  25.                 que.pop();
  26.                 if(node->left) que.push(node->left);
  27.                 if(node->right) que.push(node->right);
  28.                 if(node->left==nullptr && node->right==nullptr) return depth;
  29.             }
  30.         }
  31.         return depth;
  32.     }
  33. };

226翻转二叉树

交换指针竟然可以直接用swap来做。

前序版本：

  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     TreeNode *left;
  6.  *     TreeNode *right;
  7.  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
  8.  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
  9.  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  10.  * };
  11.  */
  12. class Solution {
  13. public:
  14.     TreeNode* invertT(TreeNode* root)
  15.     {
  16.         if(root==nullptr) return root;
  17.         swap(root->left,root->right);
  18.         if(root->left) invertT(root->left);
  19.         if(root->right) invertT(root->right);
  20.         return root;
  21.     }
  22.     TreeNode* invertTree(TreeNode* root) {
  23.         return invertT(root);
  24.     }
  25. };

后序版本：

  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     TreeNode *left;
  6.  *     TreeNode *right;
  7.  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
  8.  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
  9.  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  10.  * };
  11.  */
  12. class Solution {
  13. public:
  14.     TreeNode* invertT(TreeNode* root)
  15.     {
  16.         if(root==nullptr) return root;
  17.         if(root->left) invertT(root->left);
  18.         if(root->right) invertT(root->right);
  19.         swap(root->left,root->right);
  20.         return root;
  21.     }
  22.     TreeNode* invertTree(TreeNode* root) {
  23.         return invertT(root);
  24.     }
  25. };

试试前序遍历的迭代法：

  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     TreeNode *left;
  6.  *     TreeNode *right;
  7.  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
  8.  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
  9.  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  10.  * };
  11.  */
  12. class Solution {
  13. public:
  14.     TreeNode* invertTree(TreeNode* root) {
  15.         stack<TreeNode*> stk;
  16.         if(root!=nullptr) stk.push(root);
  17.         while(!stk.empty())
  18.         {
  19.             TreeNode* node=stk.top();
  20.             stk.pop();
  21.             swap(node->left,node->right);
  22.             if(node->left) stk.push(node->left);
  23.             if(node->right) stk.push(node->right);
  24.         }
  25.         return root;
  26.     }
  27. };

101对称二叉树

需要收集孩子的信息，并向上一级（某个根节点）返回这些信息时候，用后序遍历。

  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     TreeNode *left;
  6.  *     TreeNode *right;
  7.  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
  8.  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
  9.  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  10.  * };
  11.  */
  12. class Solution {
  13. public:
  14.     bool compare(TreeNode* left,TreeNode* right)
  15.     {
  16.         if(left==nullptr&&right==nullptr) return true;
  17.         else if(left==nullptr&&right!=nullptr) return false;
  18.         else if(left!=nullptr&&right==nullptr) return false;
  19.         else if(left->val!=right->val) return false;
  20.         // 此时就是：左右节点都不为空，且数值相同的情况.这时候才可以接着往下走，递归
  21.         // 此时才做递归，做下一层的判断
  22.         //不接着写else if了
  23.         bool outside=compare(left->left,right->right);
  24.         bool inside=compare(left->right,right->left);
  25.         bool res=outside&&inside;
  26.         return res;
  27.         
  28.     }
  29.     bool isSymmetric(TreeNode* root) {
  30.         return compare(root->left,root->right);
  31.     }
  32. };

对称二叉树的推荐题目：

100相同的树
  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     TreeNode *left;
  6.  *     TreeNode *right;
  7.  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
  8.  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
  9.  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  10.  * };
  11.  */
  12. class Solution {
  13. public:
  14.     bool iscom(TreeNode* p,TreeNode*q)
  15.     {
  16.         if(p==nullptr&&q==nullptr) return true;
  17.         else if(p!=nullptr&&q==nullptr) return false;
  18.         else if(p==nullptr&&q!=nullptr) return false;
  19.         else if(p->val!=q->val) return false;
  20.         bool o=iscom(p->left,q->left);
  21.         bool i=iscom(p->right,q->right);
  22.         bool res=i&&o;
  23.         return res;
  24.     }
  25.     bool isSameTree(TreeNode* p, TreeNode* q) {
  26.     return iscom(p,q);
  27.     }
  28. };

572另一棵树的子树

怎么下手呢？

力扣官方解法：深度优先搜索暴力匹配。

判断t是否和树s的任意子树相等。即：

判断s的每个子节点是否和t相等。3个条件，与的关系：

  • 当前两个树的根节点的值是否相等
  • 并且，s的左子树和t的左子树是否相等
  • 并且，s的右子树和t的右子树是否相等

判断t是否为s的子树的三个条件，是或的关系：

  • 当前两棵树相等
  • 或者，t是s的左子树
  • 或者，t是s的右子树

图片来自力扣官方题解

  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     TreeNode *left;
  6.  *     TreeNode *right;
  7.  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
  8.  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
  9.  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  10.  * };
  11.  */
  12. class Solution {
  13. public:
  14.     //dfs搜到之后，开始检查两个子树是否相等
  15.     bool check(TreeNode*o,TreeNode*t)
  16.     {
  17.         if(o==nullptr&&t==nullptr) return true;
  18.         if((o!=nullptr&&t==nullptr)||(o==nullptr&&t!=nullptr)||(o->val!=t->val)) return false;
  19.         return (check(o->left,t->left) &&check(o->right,t->right));
  20.     }
  21.     //搜哪个是大子树里相等子树的根节点
  22.     bool dfs(TreeNode* o,TreeNode* t)
  23.     {
  24.         if(o==nullptr) return false;
  25.         //下一句一定要注意，是先o,t；前序遍历。注意逻辑，对当前遍历节点用check，需要递归时候，调用的是dfs
  26.         return check(o,t)||dfs(o->left,t) ||dfs(o->right,t);
  27.     }
  28.     bool isSubtree(TreeNode* root, TreeNode* subRoot) {
  29.         return dfs(root,subRoot);
  30.     }
  31. };

结束！明天早起，注意效率。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/611001.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

PostgreSQL的学习心得和知识总结（一百四十二）|深入理解PostgreSQL数据库数据库之 Continuous Integration

PostgreSQL的学习心得和知识总结（一百四十二）|深入理解PostgreSQL数据库数据库之 Continuous Integration

目录结构 注&#xff1a;提前言明 本文借鉴了以下博主、书籍或网站的内容&#xff0c;其列表如下&#xff1a; 1、参考书籍&#xff1a;《PostgreSQL数据库内核分析》 2、参考书籍&#xff1a;《数据库事务处理的艺术&#xff1a;事务管理与并发控制》 3、PostgreSQL数据库仓库…
阅读更多...
办公技巧之合集文档 拆分_word

办公技巧之合集文档 拆分_word

问题 如何将文档合集拆分为单独文档。 操作步骤 软件 word 365 原理简述&#xff1a; 在 word 大纲视图下&#xff0c;通过一级标题确定子文档范围&#xff0c;然后导出即可。 文档结构 从下图可见&#xff0c;文档结构为已建立大纲级别的文档&#xff0c;如果没有建立&a…
阅读更多...
每日一题——力扣27. 移除元素（举一反三）

每日一题——力扣27. 移除元素（举一反三）

题目链接&#xff1a;https://leetcode.cn/problems/remove-element/description/ 菜鸡写法&#xff1a; // 函数定义&#xff0c;移除数组nums中所有值为val的元素&#xff0c;并返回新的数组长度 int removeElement(int* nums, int numsSize, int val) {// 如果数组长度为…
阅读更多...
Steam游戏搬砖，不说破万，月入5K没问题

Steam游戏搬砖，不说破万，月入5K没问题

steam游戏搬砖项目的玩法就是打汇率差&#xff0c;在steam平台购买道具&#xff0c;挂在网易buff上出售&#xff0c;通过汇率差盈利。一天交易几百美金的道具&#xff0c;大概能搞到200块左右的利润&#xff0c;而且平台是支持这样交易的&#xff0c;还很稳定。目前最主流的游戏…
阅读更多...
设计模式1——初步认识篇

设计模式1——初步认识篇

设计模式1——初步认识篇 一、先让我们浅聊一下面向对象和设计模式。 说起设计模式&#xff0c;我第一次听到它&#xff0c;是在学习面向对象的时候。那么什么是面向对象&#xff0c;什么是设计模式&#xff0c;而且设计模式和面向对象又有什么关系呢&#xff1f; 1、什么是面…
阅读更多...
im8mm 网络卡死 Rx packets:1037578 errors:66 dropped:0 overruns:66 frame:0

im8mm 网络卡死 Rx packets:1037578 errors:66 dropped:0 overruns:66 frame:0

1&#xff1a;网络接收数据包异常 2&#xff1a;问题复现 问题在进行网络数据包同吞吐量测试的时候出现的。同时发现&#xff0c;在使用iperf2测试时&#xff0c;是不会出现网络中断卡死的情况&#xff0c;使用 iperf3时才会出现此问题 指令(下面的指令运行在PC2上面&#xff…
阅读更多...
十二种网络威胁防护方案

十二种网络威胁防护方案

一、SQL注入 SQL注入即是指web应用程序对用户输入数据的合法性没有判断或过滤不严&#xff0c;攻击者可以在web应用程序中事先定义好的查询语句的结尾上添加额外的SQL语句&#xff0c;在管理员不知情的情况下实现非法操作&#xff0c;以此来实现欺骗数据库服务器执行非授权的任…
阅读更多...
kali linux更新卡在libc6:amd64 (2.37-15)

kali linux更新卡在libc6:amd64 (2.37-15)

适配于linux的windows子系统，wsl2，安装kali linux，运行 sudo apt update 卡在：Setting up libc6:amd64 (2.37-15) … 关机重启、重新修复执行也不行 解决办法：kill当前apt进程或者关机重启kali-linux，然后执行： ssudo mv /usr/sbin/telinit /usr/sbin/telinit.baksu…
阅读更多...
安装docker镜像nginx1.26.0版本，与删除docker容器【灵异事件】

安装docker镜像nginx1.26.0版本，与删除docker容器【灵异事件】

为了http3 的这个模块&#xff0c;所以需要升级nginx的版本&#xff0c;需要nginx1.26.0才有 –with-http_v3_module 这个模块 为什么记录一下&#xff1f;因为觉得奇怪 1&#xff1a;删除nginx镜像&#xff0c;显示镜像还被某个容器在使用 luichunluichun:~$ docker rmi ng…
阅读更多...
数电——集成计数器

数电——集成计数器

分析 &#xff08;1&#xff09;74161 4位同步&#xff08;cp相同&#xff09;二进制&#xff0c;模16&#xff08;2的4次方&#xff09; 逻辑符号 端口 D0,D1,D2,D3为输入信号 Q0,Q1,Q2,Q3为输出信号 RCO输出进位标志&#xff1a;记满16个数后&#xff0c;输出1 P,T 控…
阅读更多...
番外篇 | 利用PyQt5+YOLOv5来搭建目标检测系统（附可视化界面+功能介绍+源代码）

番外篇 | 利用PyQt5+YOLOv5来搭建目标检测系统（附可视化界面+功能介绍+源代码）

前言：Hello大家好，我是小哥谈。PyQt5是一个Python绑定的Qt库，是用于创建图形用户界面(GUI)和其他应用程序组件的工具包。PyQt5提供了许多GUI元素，如按钮、文本框、标签等，也提供了许多Qt的功能，如网络、数据库、XML等。通过PyQt5可以在Python中使用Qt的丰富功能和强大的工…
阅读更多...
远程桌面连接不上怎么连服务器，原因是什么？如何解决？

远程桌面连接不上怎么连服务器，原因是什么？如何解决？

远程桌面连接不上怎么连服务器&#xff0c;原因是什么&#xff1f;如何解决&#xff1f; 面对远程桌面连接不上的困境&#xff0c;我们有办法&#xff01; 当你尝试通过远程桌面连接服务器&#xff0c;但遭遇连接失败的挫折时&#xff0c;不要慌张。这种情况可能由多种原因引起…
阅读更多...
Python运维之协程

Python运维之协程

目录 一、定义协程 二、并发 三、异步请求 协程是一种轻量级的线程&#xff0c;它通过保存和恢复寄存器上下文和栈来实现调度切换&#xff0c;从而保留函数执行的状态。 这种机制使得协程在处理I/O密集型任务时效率较高&#xff0c;因为它们可以在I/O操作期间让出CPU&#…
阅读更多...
【触摸案例-手势解锁案例-错误的样式 Objective-C语言】

【触摸案例-手势解锁案例-错误的样式 Objective-C语言】

一、然后呢，我们再来说一下这个错误的样式 1.首先，在我们的示例程序里边，我现在来连一条线，一撒手的时候， 它先出来一个，红色的按钮的样式，那么这个时候呢，实际上，是在设置另外一种状态，给按钮的另外一种状态，再去设置另外一张红色的图片，然后呢，再去切换成那一种…
阅读更多...
C++青少年简明教程：C++中的常量、变量、表达式和语句

C++青少年简明教程：C++中的常量、变量、表达式和语句

C青少年简明教程&#xff1a;C中的常量、变量、表达式和语句 在C编程中&#xff0c;常量、变量、表达式和语句是基本的编程概念。 常量&#xff08;Constants&#xff09;&#xff1a;在程序中具有固定值的数据称为常量。常量可以是字面值&#xff0c;如整数、浮点数、字符或…
阅读更多...
信息系统项目管理基础

信息系统项目管理基础

目录 一、项目管理概论 1、定义 2、项目管理的十二原则 3、SMART原则 4、项目经理 5、项目的生命周期 二、项目立项管理 1、项目启动过程 三、项目整合管理 1、管理基础 2、项目整合管理过程 ①制定项目章程 ②制定项目管理计划 ③指导与管理项目工作 ④管理项目…
阅读更多...
河南大学大礼堂火灾事故引发安防监控对智能分析技术应用的思考

河南大学大礼堂火灾事故引发安防监控对智能分析技术应用的思考

一、方案背景 2024年5月2日&#xff0c;在修缮施工期间的河南大学河南留学欧美预备学校旧址大礼堂发生火情。现场航拍画面显示&#xff0c;大礼堂经过火灾&#xff0c;房顶已经基本坍塌&#xff0c;被火烧过的建筑呈焦黑状。 公开资料显示&#xff0c;大礼堂属河南留学欧美预…
阅读更多...
【栈】Leetcode 比较含退格的字符串

【栈】Leetcode 比较含退格的字符串

题目讲解 844. 比较含退格的字符串 算法讲解 使用栈模拟&#xff0c;但遇到#字符就让栈顶元素出栈&#xff0c;但是在写的过程中有两点需要注意&#xff1a;当#出现在第一个位置&#xff0c;需要特殊处理一下&#xff1b;当栈为空的时候&#xff0c;还出现#字符需要特殊处理…
阅读更多...
FFmpeg常用API与示例（二）—— 解封装与转封装

FFmpeg常用API与示例（二）—— 解封装与转封装

封装层 封装格式(container format)可以看作是编码流(音频流、视频流等)数据的一层外壳&#xff0c;将编码后的数据存储于此封装格式的文件之内。 封装又称容器&#xff0c;容器的称法更为形象&#xff0c;所谓容器&#xff0c;就是存放内容的器具&#xff0c;饮料是内容&…
阅读更多...
【操作系统】处理机调度

【操作系统】处理机调度

处理机调度 处理机调度概念调度概念调度时机 调度原则调度算法实时调度优先级翻转 处理机调度概念 调度概念 进程切换&#xff1a; CPU资源的当前占用者切换 保存当前进程在PCB中的执行上下文(CPU状态)恢复下一个进程的执行上下文 处理机调度: 从就绪队列中挑选下一个占用…
阅读更多...
最新文章

Copyright @ 2022~2023