数据结构基础--------【二叉树题型】

1、前提(待补充)

1.**DFS（Depth First Search）😗*递归法得到最终的数组（深度优先算法）

其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，如果遇到死路就往回退，回退过程中如果遇到没探索过的支路，就进入该支路继续深入，每个节点只能访问一次。

深度优先搜索应用：先序遍历，中序遍历，后序遍历。二叉树的前序、中序、后序遍历，本质上可以认为是深度优先遍历。是一种回溯思想。

2.BFS（Breadth First Search）:迭代法实现层序遍历，每次遍历二叉树的某一层。
它并不考虑结果的可能位置，彻底地搜索整张图，直到找到结果为止。基本过程，BFS是从根节点开始，沿着树(图)的宽度遍历树(图)的节点。如果所有节点均被访问，则算法中止。一般用队列数据结构来辅助实现算法。

广度优先搜索应用：层序遍历、最短路径、求二叉树的最大高度、由点到面遍历图、拓扑排序

2、题型

1、广度优先BFS

按照每层队列入队出队的逻辑，依次访问每层元素：

【102】二叉树的层序遍历

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。（即逐层地，从左到右访问所有节点）。

    vector<vector<int>> levelOrder(TreeNode* root){vector<vector<int>> ret ;if(!root) return ret;queue <TreeNode*> q;//定义辅助队列q.push(root);while(!q.empty()){int csize = q.size();//每层的列数ret.push_back(vector<int>());//ret中添加空的一维数组 创建for(int i =1;i<=csize;i++){auto node  = q.front();q.pop();ret.back().push_back(node->val);if(node->left)q.push(node->left);//需要更新q,否则第一次 q.pop()以后，q就为空了if(node->right)q.push(node->right);}}return ret;}

root = [3,1,4,null,2] 则返回的应该改是{{3}，{1，4}，{2}}

【1302】层数最深叶子节点的和

给你一棵二叉树的根节点 root ，请你返回 层数最深的叶子节点的和 。
解:到ret的最后一层，然后再累加。每一层更新一下sum

【429】N叉树的层序遍历

给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。
比二叉树的分支更多了，不止左右子树，所以分组的时候要用for循环去分

/*
// Definition for a Node.
class Node {
public:int val;vector<Node*> children;Node() {}Node(int _val) {val = _val;}Node(int _val, vector<Node*> _children) {val = _val;children = _children;}
};
*/class Solution {
public:vector<vector<int>> levelOrder(Node* root) {vector<vector<int>>ret;//定义返回向量queue<Node*> q;//定义辅助队列if(!root)return ret;q.push(root);//队头push进while(!q.empty()){ret.push_back(vector<int>());int csize = q.size();for(int i =1;i<=csize;i++){auto node = q.front();//取队头q.pop();//弹出队头ret.back().push_back(node->val);//每次都是在数组尾更新值//N叉树需要去遍历每个值for(int j = 0;j< node->children.size();j++){if(node->children[j])q.push(node->children[j]);}}}// reverse(ret.begin(), ret.back());return ret;}
};

【199】二叉树右视图

给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

这道题还是层序遍历的变形，需要注意的是熟练掌握cize = q.size()是每一层的列数，灵活运用这一特质。

/*** 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:vector<int> rightSideView(TreeNode* root) {vector<int> ret;//定义返回数组if(!root)return ret;//如果二叉树为空，返回空数组queue<TreeNode*>q;//定义辅助队列q.push(root);//将根节点push进队列while(!q.empty()){int cize = q.size();//列数(！！)for(int i = 0;i<cize;i++){auto node = q.front();q.pop();if(i == (cize -1))ret.push_back(node->val);//返回每一层最后if(node->left)q.push(node->left);if(node->right)q.push(node->right);}}return ret;}
};

【637】二叉树的层平均值

给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。

特别注意：返回如果有精度要求，那么每层和就要设为double 类型。

/*** 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:vector<double> averageOfLevels(TreeNode* root) {vector<double> ret;//定义返回数组if(!root)return ret;queue<TreeNode*>q;//定义辅助队列q.push(root);//根结点入队头while(!q.empty()){int csize = q.size();//每一层的列数double sum = 0;//每层和 double类型for(int i = 0;i< csize;i++){auto node = q.front();//取队头q.pop();sum+=node->val;if(node->left)q.push(node->left);if(node->right)q.push(node->right);}ret.push_back(sum/csize);//每层求均值}return ret;}
};

【515】找到每行最大值

给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。

/*** 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:vector<int> largestValues(TreeNode* root) {vector<int> ret;//定义返回数组if(!root)return ret;queue<TreeNode*> q;//定义辅助队列q.push(root);//把树根结点推入vector<vector<int>> aux;//定义辅助一维向量数组while(!q.empty()){aux.push_back(vector<int>());int csize = q.size();//列数for(int i=0;i<csize;i++){auto node = q.front();q.pop();aux.back().push_back(node->val);if(node->left)q.push(node->left);if(node->right)q.push(node->right);;}}//看作一维向量数组for(auto row:aux){//遍历每行int max = row[0];//取第一个值作为比较for(int col:row){if(col>max){max = col;}}ret.push_back(max);}return ret;}
};

【103】二叉树的锯齿形层序遍历

给你二叉树的根节点 root ，返回其节点值的 锯齿形层序遍历 。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[20,9],[15,7]]

/*** 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:vector<int> reverse_level(vector<int> vec){//reverse函数int vecsize = vec.size();int temp =0;for(int i=0;i<vecsize/2;i++){//遍历到中间temp = vec[vecsize-i-1];vec[vecsize-i-1] = vec[i];vec[i] = temp; }return vec; }vector<vector<int>> zigzagLevelOrder(TreeNode* root) {vector<vector<int>> ret;//定义返回的一维数组if(!root)return ret;queue<TreeNode*> q;//定义辅助队列q.push(root);//把root推入q队列while(!q.empty()){ret.push_back(vector<int>());//推入一维空数组int csize = q.size();//列数for(int i =0;i<csize;i++){auto node = q.front();q.pop();ret.back().push_back(node->val);if(node->left)q.push(node->left);if(node->right)q.push(node->right);}}int count_level =0;for(vector<int> row:ret){count_level++;//更新层数if(count_level%2==0){//偶数层ret[count_level-1] = reverse_level(row);//偶数层颠倒}}return ret;}
};

2、深度优先DFS

2.1.二叉树的高度和深度

深度：根节点—>该节点 最长边数 +1（前序）

高度：叶节点---->该节点 最长边数 +1（后序）

对于二叉树，深度：根节点到它的叶节点，高度：叶节点到它的根节点。

注意：树的高度和深度都是一样的，但是具体到树的某个节点，深度和高度就是不一样的。

在这里插入图片描述
如上图树的高度和深度都是4（看层数=边数+1），节点8 的高度是2 深度是3（都是从1开始的），节点5的高度是4 深度是3。

假设我构造一个二叉树：

        5/ \2   3/ \   1   4

我要求他的深度：此时先遍历左子树再遍历右子树：5->2->1 到底返回1，回溯到2再到4 ，返回1，再到2，返回2。5–>3返回1，再到5，返回3和2的最大值 3。
在这里插入图片描述

//求二叉树的高度/深度
#include <iostream>
#include <stdio.h>
using namespace std;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) {}
};int high(TreeNode* node){if(!node)return 0;cout<<"node is"<<node->val<<endl;int h_left = high(node->left);int h_right=high(node->right);int res = h_right>h_left ? h_right+1:h_left+1;cout<<"res is"<<res<<endl;return res;
}int main() {TreeNode* node = new TreeNode(5);TreeNode* nodel = new TreeNode(2);TreeNode* noder = new TreeNode(3);TreeNode* nodell = new TreeNode(1);TreeNode* nodelr = new TreeNode(4);node->left = nodel;node->right =noder;nodel->left =nodell;nodel->right=nodelr;int nodehigh =0;nodehigh = high(node);cout<<"final res:"<<nodehigh<<endl;return 0;
}

【100】验证树是否一致

给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的.

/*** 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 isSameTree(TreeNode* p, TreeNode* q) {if(p==nullptr || q== nullptr)return false;if(p == nullptr&& q == nullptr)return true;if(p->val != q->val)return false;return isSameTree(p->left, q->left)&&isSameTree(p->right, q->right);}
};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);

【108】AVL树

递归

给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 高度平衡 二叉搜索树。

高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。

由于是升序序列，于是可以选择中间元素作为根节点。

示例1:

输入：nums = [-10,-3,0,5,9]
输出：[0,-3,9,-10,null,5]
解释：[0,-10,5,null,-3,null,9] 也将被视为正确答案：
//如果看成链式结构的话，发现顺序并没有发生变化
image-20230817105118425 image-20230817105148170 


/*** 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* sortedArrayToBST(vector<int>& nums) {int len = nums.size();//得到数组长度  每次取midreturn dfs(nums,0,len);}TreeNode* dfs(vector<int>& vec,int left,int right){if(left>=right)return NULL;//注意也不能等于 len = 0 空节点int mid = (left+right)/2;//得到midTreeNode* curr= new TreeNode(vec[mid]);//！新建结点 值curr->left = dfs(vec,left,mid);//递归 左节点curr->right = dfs(vec,mid+1,right);//右节点return curr;}
};

这道题非常有意思是如何去创建这个新的结点。首先要更新节点值：

TreeNode* curr = new TreeNode(val);//创建一个节点,并且存入值

curr->left = …

curr->right = …

规定左右子树。

【144】前序遍历

给你二叉树的根节点 root ，返回它节点值的 前序 遍历。前中后序遍历都用递归的方式去实现。

输入：root = [1,null,2,3]
输出：[1,2,3]//返回的是值，所以vector<int>
输入：root = []
输出：[]
输入：root = [1]
输出：[1]
输入：root = [1,null,2]
输出：[1,2]

可以从题解中得出，先序遍历的顺序是NLR，基本上就是输入什么，输出什么，去掉null就好了。特别的，当root为空的时候，应该返回空集。

/*** 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:vector<int> preorderTraversal(TreeNode* root) {vector<int> vec;//初始化返回向量traversal(root,vec);return vec;}//回归void traversal(TreeNode* curr,vector<int>& vec){if(NULL == curr)return;//如果root为空,则直接返回空向量//如果root不为空 前序遍历vec.push_back(curr->val);//中traversal(curr->left,vec);//左traversal(curr->right,vec);//右}};

用全局变量会加快一点速度

class Solution {
public:vector<int> vec;//返回节点值 的前序遍历向量vector<int> preorderTraversal(TreeNode* root) {traversal(root);return  vec;}void traversal(TreeNode* curr){if(!curr)return;vec.push_back(curr->val);//返回的是节点值traversal(curr->left);traversal(curr->right);}};

【94】中序遍历

给你二叉树的根节点 root ，返回它节点值的 中序 遍历。中序遍历LNR，Inorder

输入：root = [1,null,2,3]
输出：[1,3,2]
输入：root = []
输出：[]
输入：root = [1]
输出：[1]

/*** 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:vector<int> inorderTraversal(TreeNode* root) {vector<int> vec;//声明返回向量traversal(root,vec);return vec;}void traversal(TreeNode* root,vector<int> &vec){if(root ==nullptr)return;traversal(root->left,vec);//Lvec.push_back(root->val);//Ntraversal(root->right,vec);//R}
};

【145】后续遍历

给你一棵二叉树的根节点 root ，返回其节点值的 后序遍历 。

输入：root = [1,null,2,3]
输出：[3,2,1]
输入：root = []
输出：[]
输入：root = [1]
输出：[1]

/*** 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:vector<int> postorderTraversal(TreeNode* root) {vector<int> vec;//声明返回向量 也可以返回到全局变量去traversal(root,vec);return vec;}void traversal(TreeNode* root,vector<int> &vec){if(root ==nullptr)return;traversal(root->left,vec);//Ltraversal(root->right,vec);//Rvec.push_back(root->val);//N}
};

【104】给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

/*** 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) {}* };*/
//递归问题
#include<algorithm>
class Solution {
public:int maxDepth(TreeNode* root) {if(root == nullptr)return 0;//边界条件return max(maxDepth(root->left),maxDepth(root->right))+1;//非边界条件逻辑//加一是把当前结点算进去了 比如最后一个叶结点深度是0，但是高度是1}
};//其中max函数是包含在algorithm中的
template<class T>
const T& max(const T&a,const T&b)
{return (a < b)?b:a;
}

树为什么是一种递归问题？

image-20230703205635250

他这个遍历的方式是根结点-左-右，这种常识要记住

maxDepth是怎么运行的：递归

演示网站：Python Tutor code visualizer: Visualize code in Python, JavaScript, C, C++, and Java

递归就是要明白代码的边界条件和非边界条件的逻辑。

计算机怎么执行递归的？栈，最后放进去的结点最先出来，空间复杂度o(n)

【104】二叉树最大深度

输入：root = [3,9,20,null,null,15,7]
输出：3

二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。

/*** 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) {}* };*/
//递归问题
#include<algorithm>
class Solution {
public:int maxDepth(TreeNode* root) {if(root == nullptr)return 0;//边界条件return max(maxDepth(root->left),maxDepth(root->right))+1;//非边界条件逻辑//加一是把当前结点算进去了 比如最后一个叶结点深度是0，但是高度是1}
};

【559】N叉树的最大深度

给定一个 N 叉树，找到其最大深度。

最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。

N 叉树输入按层序遍历序列化表示，每组子节点由空值分隔（请参见示例）。

/*
// Definition for a Node.
class Node {
public:int val;vector<Node*> children;Node() {}Node(int _val) {val = _val;}Node(int _val, vector<Node*> _children) {val = _val;children = _children;}
};
*/class Solution {
public:int maxDepth(Node* root) {if(root == nullptr)return 0;int depth = 0;//初始化深度//int n = root->children.size();for(int i= 0;i<root->children.size();i++){depth = max(depth,maxDepth(root->children[i]));//第二层马上跳到第三层}return depth + 1;}
};

用拷贝的形式传入形参

用数组的方式比容器的快

【111】二叉树的最小深度

给定一个二叉树，找出其最小深度。（最小层数）最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

**说明：**叶子节点是指没有子节点的节点。（易错点：当数退化成链表的时候，最小深度不是1，而是从根节点到叶子节点的长度）

/*** 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 minDepth(TreeNode* root) {if(root == nullptr)return 0;//线性表情况if(root->left==nullptr && root->right != nullptr)return minDepth(root->right)+1;//这是一个递归if(root->right==nullptr && root->left != nullptr)return minDepth(root->left)+1;//这是一个递归//一般情况return min(minDepth(root->left),minDepth(root->right))+1;}
};

【543】二叉树的直径

给你一棵二叉树的根节点，返回该树的 直径 。

二叉树的 直径 是指树中任意两个节点之间最长路径的 长度 。这条路径可能经过也可能不经过根节点 root 。

两节点之间路径的 长度 由它们之间边数表示。

总结：做DFS的题都可以把题目往左右子树深度去想

这里的直径 = 左子树深度+右子树深度（不包括根节点）

错误写法：得到的都是0

/*** 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) {}* };*/
//根节点为root的二叉树的直径 = 左子树的最大深度（不包括根节点）+右子树的最大深度（不包括根节点）
class Solution {
public:int ans = 0;int depth(TreeNode* rt){//回溯要单独写if(!rt)return 0;int L = depth(rt->left);//左儿子为根的子树深度int R = depth(rt->right);ans = max(ans,L+R);//计算diameter（返回每个节点的最大直径）return max(L,R)+1;//返回节点深度 正常深度应该+1}int diameterOfBinaryTree(TreeNode* root) {depth(root);return ans;}
};

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

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

相关文章

短剧新风潮：海外制作的艺术与技术

短剧新风潮：海外制作的艺术与技术

海外短剧新风潮在艺术与技术两个维度上都展现出了显著的创新与进步。 艺术层面 1、内容创新&#xff1a; &#xff08;1&#xff09;多元化与包容性&#xff1a;海外短剧在内容创新上更加注重多元化和包容性&#xff0c;将不同地域、民族的文化元素融入创作中&#xff0c;展现丰…
阅读更多...
FUSE（用户空间文件系统）命令参数

FUSE（用户空间文件系统）命令参数

GPT-4 (OpenAI) FUSE (Filesystem in Userspace)是一个允许创建用户空间文件系统的接口。它提供了一个API&#xff0c;让开发者在未修改内核代码的情况下&#xff0c;通过自己的程序实现文件系统。FUSE 文件系统通常通过 mount 命令来挂载&#xff0c;而且这个命令可以接受各…
阅读更多...
【QML之·基础语法概述】

【QML之·基础语法概述】

系列文章目录 文章目录 前言一、QML基础语法二、属性三、脚本四、核心元素类型4.1 元素可以分为视觉元素和非视觉元素。4.2 Item4.2.1 几何属性(Geometry&#xff09;:4.2.2 布局处理:4.2.3 键处理&#xff1a;4.2.4 变换4.2.5 视觉4.2.6 状态定义 4.3 Rectangle4.3.1 颜色 4.4…
阅读更多...
人话学Python-基础篇-字符串

人话学Python-基础篇-字符串

一&#xff1a;字符串的定义 在Python中使用引号来定义。不论是单引号还是双引号。 str1 Hello World str2 "Hello World" 二&#xff1a;字符串的访问 如果我们要取出字符串中单独的字符&#xff0c;需要使用方括号来表示取得的位置。如果要取出字符串的子串&…
阅读更多...
电脑引导坏了怎么修复?电脑引导坏了全自动修复教程

电脑引导坏了怎么修复?电脑引导坏了全自动修复教程

电脑怎么修复引导?我们知道目前电脑有两种引导模式legacy和uefi&#xff0c;所以会出现legacy和uefi引导修复的问题&#xff0c;随着uefi的流行&#xff0c;越来越多的小伙伴经常遇到电脑引导丢失的问题&#xff0c;也不知道怎么修复&#xff0c;以前的一些修复工具都只能修复…
阅读更多...
20240710 每日AI必读资讯

20240710 每日AI必读资讯

&#x1f916;微软&#xff1a;不会像 OpenAI 一样阻止中国访问 AI 模型 - OpenAI 将于周二&#xff08;7 月 9 日&#xff09;开始阻止中国用户访问其 API。 - 微软发言人表示&#xff1a;Azure OpenAI API服务在中国的提供方式没有变化。 - 公司仍然通过部署在中国以外地区…
阅读更多...
递归、搜索与回溯算法 2024.7.4-24.7.9

递归、搜索与回溯算法 2024.7.4-24.7.9

专题介绍&#xff1a; 一、递归 1、汉诺塔问题 class Solution {public void hanota(List<Integer> A, List<Integer> B, List<Integer> C) {int n A.size();move(n,A,B,C);// 将A柱上的n个盘子通过借助B盘子全部挪到C柱子上}void move(int m,List<Integ…
阅读更多...
7.9实验室总结 SceneBuilder的使用方法+使用javafx等

7.9实验室总结 SceneBuilder的使用方法+使用javafx等

由于下错了东西&#xff0c;所以一直运行不出来&#xff0c;今天一直在配置环境&#xff0c;配置好了才学&#xff0c;所以没学多少&#xff0c;看了网课学习了SceneBuilder的使用方法还有了解了javafx是怎么写项目的&#xff0c;&#xff0c; 学习了怎么跳转页面&#xff1a;…
阅读更多...
如何在Vue中实现拖拽功能？

如何在Vue中实现拖拽功能？

Vue.js是一款流行的JavaScript框架&#xff0c;用于构建用户界面。其中一个常见的需求是在Vue中实现拖拽功能&#xff0c;让用户可以通过拖拽元素来进行交互。今天&#xff0c;我们就来学习如何在Vue中实现这一功能。 首先&#xff0c;我们需要明白拖拽功能的基本原理&#xf…
阅读更多...
javaweb零碎知识3

javaweb零碎知识3

// 假设您已经导入了 axios import axios from axios;// 获取表单元素 const form document.getElementById(myForm);// 为表单添加 submit 事件监听器 form.addEventListener(submit, function(e) {// 阻止表单的默认提交行为e.preventDefault();// 创建 FormData 对象并从表…
阅读更多...
OJhelper一款帮助你获取各大oj信息的软件

OJhelper一款帮助你获取各大oj信息的软件

项目地址 应用功能 目前应用支持&#xff1a;查询、自定义、收藏各大oj比赛信息&#xff0c;跳转比赛界面。查询各大oj的Rating分以及题量&#xff0c;查看题量饼状图。 应用环境 windows和安卓端 应用预览&#xff1a; 维护概况 后期会提供持续更新&#xff0c;具体可以…
阅读更多...
STM32学习历程（day6）

STM32学习历程（day6）

EXTI外部中断使用教程 首先先看下EXTI的框图 看这个框图就能知道要先初始化GPIO外设 那么和前面一样 1、先RCC使能时钟 2、配置GPIO 选择端口为输入模式&#xff0c; 3、配置AFIO&#xff0c;选择我们用的GPIO连接到后面的EXTI 4、配置EXTI&#xff0c;选择边沿触发方式…
阅读更多...
全网最适合入门的面向对象编程教程：12 类和对象的 Python 实现-Python 使用 logging 模块输出程序运行日志

全网最适合入门的面向对象编程教程：12 类和对象的 Python 实现-Python 使用 logging 模块输出程序运行日志

全网最适合入门的面向对象编程教程&#xff1a;12 类和对象的 Python 实现-Python 使用 logging 模块输出程序运行日志 摘要&#xff1a; 本文主要介绍了日志的定义和作用&#xff0c;以及 Python 内置日志处理的 logging 模块&#xff0c;同时简单说明了日志等级和 logging …
阅读更多...
中职网络安全B模块渗透测试server2380

中职网络安全B模块渗透测试server2380

使用nmap扫描添加参数-sV Flag:2.4.38 添加参数-A不然扫不全 &#xff08;这两题可以直接加-sV -A&#xff09; Flag: 4.3.11-Ubuntu 根据nmap扫描发现系统为ubuntu系统&#xff0c;ubuntu操作系统在某些版本中默认包含一个名为"ubuntu"的用户帐户。这是为了方…
阅读更多...
leetcode--从前序与中序遍历序列构造二叉树

leetcode--从前序与中序遍历序列构造二叉树

leetcode地址&#xff1a;从前序与中序遍历序列构造二叉树 给定两个整数数组 preorder 和 inorder &#xff0c;其中 preorder 是二叉树的先序遍历&#xff0c; inorder 是同一棵树的中序遍历&#xff0c;请构造二叉树并返回其根节点。 示例 1: 输入: preorder [3,9,20,15,…
阅读更多...
中职网络安全Server2216

中职网络安全Server2216

任务环境说明&#xff1a;✓ 服务器场景&#xff1a;Server2216&#xff08;开放链接&#xff09;✓ 用户名:root密码&#xff1a;1234561.黑客通过网络攻入本地服务器,通过特殊手段在系统中建立了多个异常进程找出启动异常进程的脚本&#xff0c;并将其绝对路径作为Flag值提交…
阅读更多...
Java中的 this 关键字是什么意思? this() 又是什么?

Java中的 this 关键字是什么意思? this() 又是什么?

目录 问题问题一&#xff1a;什么是this关键字?问题二&#xff1a;什么是this()&#xff1f; 问题 问题一&#xff1a;什么是this关键字? 定义&#xff1a;this 代表当前对象。这个定义比较抽象&#xff0c;举例来回答。 思考一个问题&#xff1a;如果没有 this 会怎样&…
阅读更多...
领导者视角：识别系统问题的信号

领导者视角：识别系统问题的信号

作为企业的领导者&#xff0c;有时候我们面对的不仅是表面的小问题&#xff0c;而是根深蒂固的系统性问题。如果您发现以下症状&#xff0c;可能就是时候深入挖掘了&#xff1a; 1、资源消耗大&#xff1a;一个看似小的问题&#xff0c;解决起来却不断耗费大量资源。 2、反复无…
阅读更多...
图论---无向图中国邮路的实现

图论---无向图中国邮路的实现

开始编程前分析设计思路和程序的整体的框架&#xff0c;以及作为数学问题的性质&#xff1a; 程序流程图&#xff1a; 数学原理&#xff1a; 本质上是找到一条欧拉回路&#xff0c;考虑图中的边权重、顶点的度数以及如何通过添加最少的额外边来构造欧拉回路&#xff0c;涉及到欧…
阅读更多...
double和float的区别与使用

double和float的区别与使用

double和float类型的区别与使用 在Java中&#xff0c;double和float都是基本数据类型&#xff0c;用于表示浮点数&#xff08;即带有小数点的数&#xff09;。 它们在精度和范围上有所不同&#xff1a; double类型提供了更高的精度和更大的范围&#xff0c;而float类型则精度更…
阅读更多...
最新文章

Copyright @ 2022~2023