面试经典150题 -- 二叉树 (总结)

总的地址 : 

面试经典 150 题 - 学习计划 - 力扣（LeetCode）全球极客挚爱的技术成长平台

104 . 二叉树的最大深度

104 . 二叉树的最大深度

递归 : 

直接用递归访问 ， 访问左孩子 和 右孩子 ， 如果 存在 ， 深度就+1 ；

class Solution {public int maxDepth(TreeNode root) {if(root == null) return 0 ;int lm = maxDepth(root.left) ;int rm = maxDepth(root.right) ;;return Math.max(lm, rm) + 1 ;}
}

层序遍历

找到一层 就 ans ++ ;

/*** 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:int maxDepth(TreeNode* root) {int ans = 0;queue<TreeNode*> que;if(root != nullptr) que.push(root);while(!que.empty()){int size = que.size();ans ++;for(int i=0;i<size;i++){TreeNode* node = que.front();que.pop();if(node->left) que.push(node->left);if(node->right) que.push(node->right);}}return ans;}
};

100 . 相同的树

链接 : 

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

LeetCode题解链接 : 

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

[迭代]

> 采用广度优先遍历，用队列先存入两个树的头节点，每次判断队尾的两个结点是不是满足相等，不相等直接返回false,同时为空，继续下一对结点的判断 ;

都不为空且值相等，就依次将两个节点的左孩子 和 右孩子 存入队列中；然后开始下一次的判断 ; 知道两个队列都为空为止 ;

Java :

class Solution {public boolean isSameTree(TreeNode p, TreeNode q) {if(p==null && q==null) return true;if(p==null || q==null) return false;if(p.val !=q.val) return false;Queue<TreeNode> qp = new LinkedList<TreeNode>();Queue<TreeNode> qq = new LinkedList<TreeNode>();qp.offer(p);qq.offer(q);while(!qp.isEmpty() && !qq.isEmpty()){TreeNode cp = qp.poll();TreeNode cq = qq.poll();if(cp==null&& cq==null) continue;if((cp==null || cq==null) || cp.val != cq.val) return false;qp.offer(cp.left) ;qq.offer(cq.left) ;qp.offer(cp.right) ;qq.offer(cq.right) ;}return true ;}}

cpp 

class Solution {public:bool isSameTree(TreeNode* p, TreeNode* q) {if(p==nullptr && q==nullptr) return true;if(p==nullptr || q==nullptr) return false;if(p->val !=q->val) return false;queue<TreeNode*> qp ;queue<TreeNode*> qq;qp.push(p);qq.push(q);while(!qp.empty() && !qq.empty()){TreeNode* cp = qp.front() ; qp.pop();TreeNode* cq = qq.front() ; qq.pop();if(cp==nullptr && cq==nullptr) continue;if((cp==nullptr || cq==nullptr) || cp->val != cq->val) return false;qp.push(cp->left) ;qq.push(cq->left) ;qp.push(cp->right) ;qq.push(cq->right) ;}return true ;}};

[递归]

> 用递归的思想实现上面迭代的过程，先判断两个根节点是否满足题意，满足就同时递归判断两个节点的左子树和右子树 ;

Java 

class Solution {public boolean isSameTree(TreeNode p, TreeNode q) {if(p==null && q==null) return true;if(p==null || q==null) return false;if(p.val != q.val) return false;return isSameTree(p.left,q.left) && isSameTree(p.right,q.right) ;}}

cpp 

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

226 . 反转二叉树

链接

226 . 反转二叉树

递归 : 

遍历一个结点就继续向下反转其左子树 和 右子树 ;

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

前序遍历

按照中左右的顺序，先处理中间结点(交换其左右子树),然后将其左子树和右子树加入栈中 ；

class Solution {
public:TreeNode* invertTree(TreeNode* root) {if (root == NULL) return root;stack<TreeNode*> st;st.push(root);while(!st.empty()) {TreeNode* node = st.top();              // 中st.pop();swap(node->left, node->right);if(node->right) st.push(node->right);   // 右if(node->left) st.push(node->left);     // 左}return root;}
};

层序遍历

和前序遍历类似，采用队列queue存放结点 ;

广度优先，在遍历的过程中将每一层的每一个结点的左右孩子结点交换即可；

class Solution {
public:TreeNode* invertTree(TreeNode* root) {queue<TreeNode*> que;if (root != NULL) que.push(root);while (!que.empty()) {int size = que.size();for (int i = 0; i < size; i++) {TreeNode* node = que.front();que.pop();swap(node->left, node->right); // 节点处理if (node->left) que.push(node->left);if (node->right) que.push(node->right);}}return root;}
};

101 . 对称二叉树

递归

对于二叉树是否对称，要比较的是根节点的左子树与右子树是不是相互翻转的，理解这一点就知道了其实我们要比较的是两个树（这两个树是根节点的左右子树），所以在递归遍历的过程中，也是要同时遍历两棵树。

我们要通过递归函数的返回值来判断两个子树的内侧节点和外侧节点是否相等。(遍历顺序 : 左右中 / 右左中 , "后序遍历 ")


class Solution {
public:bool cmp(TreeNode* left,TreeNode* right){if(left==nullptr && right!=nullptr) return false;else if(left!=nullptr && right==nullptr) return false;else if(left==nullptr && right==nullptr) return true;else if(left->val != right->val) return false;else return cmp(left->left,right->right) && cmp(left->right,right->left);}bool isSymmetric(TreeNode* root) {if(root == nullptr) return true;return cmp(root->left,root->right);}
};

迭代

也就是用类似层序遍历的方式来实现递归的步骤 ;

详细请看代码 : 

/*** 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 isSymmetric(TreeNode* root) {if(root == nullptr) return true;queue<TreeNode*> que;que.push(root->left);que.push(root->right);while(!que.empty()){TreeNode* l = que.front();que.pop();TreeNode* r = que.front();que.pop();if(!l && !r) continue;//左右结点均为空，直接下一步;if((l&&!r) || (!l&&r)) return false;//左右结点一个为空，返回false;if(l->val != r->val) return false;//均不为空但不相等，直接返回false;que.push(l->left);que.push(r->right);que.push(l->right);que.push(r->left);}return true;}
};

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

详细请看代码 : 

/*** 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* traversal(vector<int>& preorder,vector<int>& inorder){if(preorder.size() == 0) return nullptr;int num = preorder[0];TreeNode* root = new TreeNode(num);// 叶子节点if(preorder.size() == 1) return root;// 找到切割下标int splitIndex;for(splitIndex=0;splitIndex<inorder.size();splitIndex++){if(inorder[splitIndex] == num)break;}//切割中序数组vector<int> leftVecI(inorder.begin(),inorder.begin()+splitIndex);vector<int> rightVecI(inorder.begin()+splitIndex+1,inorder.end());// 去掉前序数组中的第一个元素preorder.erase(preorder.begin());// 切割前序数组vector<int> leftVecP(preorder.begin(),preorder.begin()+leftVecI.size());vector<int> rightVecP(preorder.begin()+leftVecI.size(),preorder.end());root->left = traversal(leftVecP,leftVecI);root->right = traversal(rightVecP,rightVecI);return root;}TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {if(!preorder.size() || !inorder.size()) return nullptr;return traversal(preorder,inorder);}
};

106. 从中序与后序遍历序列构造二叉树

详细请看代码 : 

/*** 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 {
private:// 中序区间：[inorderBegin, inorderEnd)，后序区间[postorderBegin, postorderEnd)TreeNode* traversal (vector<int>& inorder, int inorderBegin, int inorderEnd, vector<int>& postorder, int postorderBegin, int postorderEnd) {if (postorderBegin == postorderEnd) return NULL;int rootValue = postorder[postorderEnd - 1];TreeNode* root = new TreeNode(rootValue);if (postorderEnd - postorderBegin == 1) return root;int delimiterIndex;for (delimiterIndex = inorderBegin; delimiterIndex < inorderEnd; delimiterIndex++) {if (inorder[delimiterIndex] == rootValue) break;}// 切割中序数组// 左中序区间，左闭右开[leftInorderBegin, leftInorderEnd)int leftInorderBegin = inorderBegin;int leftInorderEnd = delimiterIndex;// 右中序区间，左闭右开[rightInorderBegin, rightInorderEnd)int rightInorderBegin = delimiterIndex + 1;int rightInorderEnd = inorderEnd;// 切割后序数组// 左后序区间，左闭右开[leftPostorderBegin, leftPostorderEnd)int leftPostorderBegin =  postorderBegin;int leftPostorderEnd = postorderBegin + delimiterIndex - inorderBegin; // 终止位置是 需要加上 中序区间的大小size// 右后序区间，左闭右开[rightPostorderBegin, rightPostorderEnd)int rightPostorderBegin = postorderBegin + (delimiterIndex - inorderBegin);int rightPostorderEnd = postorderEnd - 1; // 排除最后一个元素，已经作为节点了root->left = traversal(inorder, leftInorderBegin, leftInorderEnd,  postorder, leftPostorderBegin, leftPostorderEnd);root->right = traversal(inorder, rightInorderBegin, rightInorderEnd, postorder, rightPostorderBegin, rightPostorderEnd);return root;}
public:TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {if (inorder.size() == 0 || postorder.size() == 0) return NULL;// 左闭右开的原则return traversal(inorder, 0, inorder.size(), postorder, 0, postorder.size());}
};

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

链接 : 

. - 力扣（LeetCode）

层序遍历 , 借助一个pre结点 来 将每一层的结点的next指针指向右边的结点 ;

class Solution {
public:Node* connect(Node* root) {// 层序遍历queue<Node*> que ;if(root!=nullptr) que.push(root) ;while(!que.empty()){int size = que.size() ;Node* pre  ;Node* cur ;for(int i=0;i<size;i++){if(i==0){pre = que.front() ;cur = pre ;que.pop() ;}else {cur = que.front() ;que.pop() ;pre -> next = cur ;pre = cur ;}if(cur->left) que.push(cur->left);if(cur->right) que.push(cur->right);}}return root ;}
};

114 . 二叉树展开成链表

其实就是一个递归的过程 ;

详细请看lc大佬的题解 :  

 - 力扣（LeetCode）b​​​​​​​t

题中函数实现的三个步骤 : 

将root的左子树展开成链表，将root的右子树展开成链表，将root的左子树链表插到右子树链表头节点前 ;(注意清空左指针)

然后给出递归代码 : 

class Solution {
public:void flatten(TreeNode* root) {if(root == nullptr) return  ;flatten(root->left) ;flatten(root->right) ;TreeNode* tmp = root->right ;root->right = root->left ;root->left = nullptr ;while(root->right != nullptr) root = root -> right ;root->right = tmp ;}
};

112 . 路径总和

深度优先遍历，查找每一条路径是否能够和为targetSum;

用递归实现 ;

具体请看代码+注释 : 

class Solution {
public:bool dfs(TreeNode* root ,int t){// 1 . 递归终止条件编写 :  // 左右子树全空，且t=0,表示找到一条路径和为tif(!root->left && !root->right && t==0) return true ;// 左右子树全空 ， 但t!=0,直接返回false;if(!root->left && !root->right) return false;// 2 . 编写递归逻辑 : if(root->left){if(dfs(root->left , t - root->left->val))return true  ;}  if(root -> right){if(dfs(root->right , t - root->right->val))return true ;}return false ;}bool hasPathSum(TreeNode* root, int t) {if(!root) return false ;return dfs(root , t - root->val) ;}
};

129 . 求根节点到叶子结点的数字之和

深度优先

采取先序遍历的方式 ，找到每一个叶子节点 ，然后返回其和 ，先处理root的数据，然后遍历左子树和右子树 ;

class Solution {
public:int dfs(TreeNode* root,int k){if(root == nullptr) return 0 ;// 深度优先 ， 中左右 --> 先序遍历int sum = k * 10 + root -> val ;if(!root->left && !root->right) return sum ;return dfs(root->left,sum) + dfs(root->right,sum) ;}   int sumNumbers(TreeNode* root) {return dfs(root , 0) ;}
};

124 . 二叉树中的最大路径和

采用动态规划的思想 :

    // 思考从下到上的顺序

    // 一个结点如果作为根节点 ， 那么ress(贡献) = root->val + max(max_left,max_right)

    // 那么它对自己根节点的贡献也就是res ;

    // 结点作为路径的子节点，那么ans = max(ans,root->val+max_left+max_right)

    // 递归 ， 在遍历每个节点的过程中 ，跟新最大值 即可

class Solution {
public:// 思考从下到上的顺序// 一个结点如果作为根节点 ， 那么ress(贡献) = root->val + max(max_left,max_right)// 那么它对自己根节点的贡献也就是res ;// 结点作为路径的子节点，那么ans = max(ans,root->val+max_left+max_right) // 递归 ， 在遍历每个节点的过程中 ，跟新最大值 即可int ans = INT_MIN ;int get(TreeNode* root){if(root == nullptr) return 0 ;// 递归计算左右结点的最大贡献值int leftGain = max(get(root->left),0);int rightGain = max(get(root->right),0);// 计算作为子节点的最大路径和int ansP = root->val + leftGain + rightGain ;// 更新答案ans = max(ans , ansP) ;// 返回作为根节点的最大贡献int res = root->val + max(leftGain , rightGain) ;return res ;}int maxPathSum(TreeNode* root) {// 调用递归函数int k = get(root) ;return ans ;}
};

173 . 二叉搜索树迭代器

先中序遍历 ， 按顺序将所有结点的值存起来；

然后按照题目要求模拟 ;

class BSTIterator {
private:void inorder(TreeNode* root, vector<int>& res) {if (!root) {return;}inorder(root->left, res);res.push_back(root->val);inorder(root->right, res);}vector<int> inorderTraversal(TreeNode* root) {vector<int> res;inorder(root, res);return res;}vector<int> arr;int idx;
public:BSTIterator(TreeNode* root): idx(0), arr(inorderTraversal(root)) {}int next() {return arr[idx++];}bool hasNext() {return (idx < arr.size());}
};

222 . 完全二叉树的结点个数

层序遍历 : 

遍历每一层 ， 将每一层的节点数加入ans中 ;

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

递归

一个结点 如果 作为根节点 ， 那么总结点数 也就是 1 + 左子树结点数 + 右子树节点数 ;

这样用递归就好 ;

class Solution {
public:int getSum(TreeNode* node){if(node == nullptr) return 0 ;int l = getSum(node->left) ;int r = getSum(node->right) ;return l + r + 1 ;}int countNodes(TreeNode* root) {int ans = getSum(root);return ans ;}
};

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

详细参考 : 代码随想录

采用后序遍历的思想 , 回溯解决 ；

 根据题目定义 : 

若 root是 p,q的 最近公共祖先 ，则只可能为以下情况之一：

1 . p和 q在 root的子树中，且分列 root的 异侧（即分别在左、右子树中）；
2 . p=root ，且 q 在 root的左或右子树中；
3 . q=root，且 p 在 root 的左或右子树中；

class Solution {
public:TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {if(root == nullptr || root == p || root == q) return root;TreeNode *left = lowestCommonAncestor(root->left, p, q);TreeNode *right = lowestCommonAncestor(root->right, p, q);if(left == nullptr) return right;if(right == nullptr) return left;return root;}
};

参考 : 

  • https://programmercarl.com/%E4%BA%8C%E5%8F%89%E6%A0%91%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE
  • 二叉树基础知识总结-CSDN博客
  • 二叉树遍历总结 -- 基于LeetCode-CSDN博客

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

如若内容造成侵权/违法违规/事实不符，请联系瞎胡闹网进行投诉反馈，一经查实，立即删除！

相关文章

vue-router 三级路由，路由跳转页面异常白屏或404，或刷新三级路由页面后一级和二级路由菜单丢失

vue-router 三级路由，路由跳转页面异常白屏或404，或刷新三级路由页面后一级和二级路由菜单丢失

问题描述 情况1. vue-router 定义三级路由&#xff0c;路由跳转了&#xff0c;页面404或者白屏情况2. 点击菜单三级路由后&#xff0c;刷新页面后一级和二级路由菜单丢失 解决方案&#xff1a; 某些时候是因为二级和三级的路由共用router-view&#xff0c;可以使用router-vi…
阅读更多...
基于springboot+vue的大创管理系统(前后端分离)

基于springboot+vue的大创管理系统(前后端分离)

博主主页&#xff1a;猫头鹰源码 博主简介&#xff1a;Java领域优质创作者、CSDN博客专家、阿里云专家博主、公司架构师、全网粉丝5万、专注Java技术领域和毕业设计项目实战&#xff0c;欢迎高校老师\讲师\同行交流合作 ​主要内容&#xff1a;毕业设计(Javaweb项目|小程序|Pyt…
阅读更多...
【Android 性能优化：内存篇】——ExoPlayer 释放后内存没有恢复问题探索

【Android 性能优化：内存篇】——ExoPlayer 释放后内存没有恢复问题探索

背景 最近笔者承接项目的内存优化指标&#xff0c;在内存调研的过程中发现项目中视频播放结束后&#xff0c;内存没有恢复到播放前到水平。项目中用的 EXO 版本为2.19.1&#xff0c;并且笔者自己也写了个简单的 Demo&#xff0c;发现也是如此。虽然有一些偏门方法可以优化&…
阅读更多...
阶段四python编程第四章循环

阶段四python编程第四章循环

一级目录循环的基本使用 循环的作用&#xff1a;让指定的代码重复执行 while循环最常用的应用场景就是让执行的代码按照指定的次数重复执行 while基本语法&#xff1a; 如果要输出的是100个hello world,该怎么做&#xff1f; 死循环&#xff1a; 程序应该避免出现死循环 whi…
阅读更多...
nginx 具体介绍

nginx 具体介绍

一&#xff0c;nginx 介绍 &#xff08;一&#xff09;nginx 与apache 1&#xff0c; Apache event 模型 相对于 prefork 模式 可以同时处理更多的请求 相对于 worker 模式 解决了keepalive场景下&#xff0c;长期被占用的线程的资源浪费问题 因为有监听线程&#…
阅读更多...
stm32——hal库学习笔记(IIC)

stm32——hal库学习笔记(IIC)

一、IIC总线协议介绍&#xff08;掌握&#xff09; 二、AT24C02介绍&#xff08;了解&#xff09; 三、AT24C02读写时序&#xff08;掌握&#xff09; 四、AT24C02驱动步骤&#xff08;掌握&#xff09; 五、编程实战&#xff08;掌握&#xff09; myiic.c #include "./B…
阅读更多...
C++ 基础算法 双指针 数组元素的目标和

C++ 基础算法 双指针 数组元素的目标和

给定两个升序排序的有序数组 A 和 B &#xff0c;以及一个目标值 x 。 数组下标从 0 开始。 请你求出满足 A[i]B[j]x 的数对 (i,j) 。 数据保证有唯一解。 输入格式 第一行包含三个整数 n,m,x &#xff0c;分别表示 A 的长度&#xff0c;B 的长度以及目标值 x 。 第二行包…
阅读更多...
在UE5中制作UI环形进度条

在UE5中制作UI环形进度条

在日常开发中&#xff0c;经常会有环形进度条UI的效果&#xff0c;例如技能CD时间、加载动画等&#xff0c;本文将通过材质球节点实现该效果&#xff0c;相较于准备美术素材&#xff0c;这样的做法更为方便&#xff0c;效果如下&#xff1a; 1.制作环状效果材质函数 在内容面…
阅读更多...
Vue3 + Ts (使用lodash)

Vue3 + Ts (使用lodash)

安装 npm i --save lodash使用 import _ from lodash⚠️报警告&#xff1a;&#xff01;&#xff01;&#xff01; 此时还需要安装ts声明文件库 npm install types/lodash -D安装之后重启Vscode还是会提示上面的警告&#xff0c;此时还需在tsconfig.ts里面配置 {"c…
阅读更多...
Leetcode 209.长度最小的子数组

Leetcode 209.长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 target 。 找出该数组中满足其总和大于等于 target 的长度最小的 连续子数组 [numsl, numsl1, ..., numsr-1, numsr] &#xff0c;并返回其长度。如果不存在符合条件的子数组&#xff0c;返回 0 。 示例 1&#xff1a; 输入&…
阅读更多...
城市白模：裸眼3D下的未来都市构想

城市白模：裸眼3D下的未来都市构想

随着科技的飞速发展&#xff0c;城市规划与建设已经迈入了一个全新的时代。在这个时代里&#xff0c;“城市白模”成为了设计师、建筑师、城市规划者乃至普通市民的热门话题。那么&#xff0c;什么是“城市白模”&#xff1f;它又如何改变我们对城市的认知与期待呢&#xff1f;…
阅读更多...
后端程序员入门react笔记（四）-综合运用，写一个小demo

后端程序员入门react笔记（四）-综合运用，写一个小demo

样式模块化 有时候我们会遇到这样的问题&#xff0c;有两个css对一个class声明了样式&#xff0c;这样的话后引入的css会覆盖前面的css样式&#xff0c;导致样式冲突&#xff0c;那么我们怎么解决这种问题呢&#xff0c;我们可以使用样式的模块化&#xff0c;我们起名一个inde…
阅读更多...
百度百科词条在网络推广中的六大作用

百度百科词条在网络推广中的六大作用

也许很多网友都发现了&#xff0c;在网上查资料&#xff0c;百科词条往往是优先展示的。一方面因为百科是搜索引擎自身的平台&#xff0c;另一方面就是因为百科信息权威&#xff0c;网友认可度高。所以企业开展网络营销&#xff0c;百科营销是一块重要阵地。 也有的企业认为百科…
阅读更多...
笔试题讲解（C语言进阶）

笔试题讲解（C语言进阶）

目录 前言 1、题目 2、答案 3、解析 结语 前言 “纸上得来终觉浅&#xff0c;绝知此事要躬行”。本篇通过对指针实际案例的分析&#xff0c;由浅入深&#xff0c;来加强我们对指针的理解。 1、题目 这是一道难题&#xff0c;小心哦。 #include <stdio.h> int main(…
阅读更多...
数字化转型导师坚鹏：政府数字化转型社会管理类案例研究

数字化转型导师坚鹏：政府数字化转型社会管理类案例研究

政府数字化转型社会管理类案例研究 课程背景&#xff1a; 很多地方政府存在以下问题&#xff1a; 不清楚直辖市政府数字化转型的社会管理类成功案例 不清楚地级市政府数字化转型的社会管理类成功案例 不清楚县区级政府数字化转型的社会管理类成功案例 课程特色&#x…
阅读更多...
【LeetCode每日一题】 单调栈的案例84 柱状图中最大的矩形

【LeetCode每日一题】 单调栈的案例84 柱状图中最大的矩形

84 柱状图中最大的矩形 给定 n 个非负整数&#xff0c;用来表示柱状图中各个柱子的高度。每个柱子彼此相邻&#xff0c;且宽度为 1 。 求在该柱状图中&#xff0c;能够勾勒出来的矩形的最大面积。 示例 1: 输入&#xff1a;heights [2,1,5,6,2,3] 输出&#xff1a;10 解释…
阅读更多...
实验室预约|实验室预约小程序|基于微信小程序的实验室预约管理系统设计与实现(源码+数据库+文档)

实验室预约|实验室预约小程序|基于微信小程序的实验室预约管理系统设计与实现(源码+数据库+文档)

实验室预约小程序目录 目录 基于微信小程序的实验室预约管理系统设计与实现 一、前言 二、系统功能设计 三、系统实现 1、微信小程序前台 2、管理员后台 &#xff08;1&#xff09;管理员登录 &#xff08;2&#xff09;实验室管理 &#xff08;3&#xff09;公告信息…
阅读更多...
(全注解开发)学习Spring-MVC的第三天

(全注解开发)学习Spring-MVC的第三天

全注解开发 第一部分 : 1.1 消除spring-mvc.xml 这些是原来spring-mvc.xml配置文件的内容 <!--1、组件扫描, 使Controller可以被扫描到--><context:component-scan base-package"com.itheima.controller"/><!--2、非自定义的Bean, 文件上传解析器--&…
阅读更多...
【simulink】将STL文件导入simulink无法创造新的frame，导致无法装配

【simulink】将STL文件导入simulink无法创造新的frame，导致无法装配

将SolidWorks零件格式改成step格式&#xff0c;即可。因为STL模型无法选中线和面&#xff0c;因此无法按自己的需求创造新的frame坐标&#xff0c;进行装配 并且得在这里重命名&#xff0c;把STEP改成stp 推荐使用相对路径&#xff0c;绝对路径的话&#xff0c;发给别人要重新…
阅读更多...
2024 2.17~2.23 周报

2024 2.17~2.23 周报

一、本周计划 学习如何缝合模块&#xff0c;跑代码InversionNet、想idea并实验&#xff0c;准备开题报告&#xff0c;学习python基础语法 二、完成情况 1 学习如何在代码中加入模块 可添加的模块如&#xff1a; 通道注意力CA 空间注意力SA self attention变体 频域快速傅里…
阅读更多...
最新文章

Copyright @ 2022~2023