C++算法学习心得五.二叉树（3）

1.合并二叉树（617题）

题目要求：

给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。

你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。

思路：遍历一个树逻辑是一样的，只不过传入两个树的节点，同时操作 

递归法：参数是两个节点，这个是前序遍历，在1的树上进行修改

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if(root1 == NULL)return root2;//如果1空了，就是2
        if(root2 == NULL)return root1;//如果2空了，就是1
        root1->val += root2->val;//在1的树上进行修改，两个树节点加起来
        root1->left = mergeTrees(root1->left,root2->left);//左
        root1->right = mergeTrees(root1->right,root2->right);//右
        return root1;
    }
};

迭代法：层序遍历，迭代法中，一般一起操作两个树都是使用队列模拟类似层序遍历，同时处理两个树的节点

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if(root1 == NULL)return root2;//1为空返回2
        if(root2 == NULL)return root1;//2为空返回1
        queue<TreeNode*>que;//队列
        que.push(root1);//将1和2压入队列中
        que.push(root2);
        while(!que.empty()){
            TreeNode* node1 = que.front();//节点1队头元素，再弹出
            que.pop();
            TreeNode* node2 = que.front();//节点2队头元素，弹出
            que.pop();//
            node1->val += node2->val;//将两个值相加然后给1的值
            //节点1和节点2的左节点不为空，压入队列
            if(node1->left != NULL && node2->left != NULL){
                que.push(node1->left);
                que.push(node2->left);
            }
            //节点1和节点2的右节点不为空，压入队列
            if(node1->right != NULL && node2->right != NULL){
                que.push(node1->right);
                que.push(node2->right);
            }
            //节点1的左节点为空，节点2的左节点不为空，节点2赋值给1
            if(node1->left == NULL && node2->left != NULL){
                node1->left = node2->left;
            }
            //节点1的右节点为空，节点2的右节点不为空，节点2赋值给1
            if(node1->right == NULL && node2->right != NULL){
                node1->right = node2->right;
            }
        }
        return root1;
    }
};

2.二叉搜索树中的搜索（700题）

题目描述：给定二叉搜索树（BST）的根节点和一个值。 你需要在BST中找到节点值等于给定值的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 NULL。

递归法：因为是二叉搜索树，知道树的特性，左边子树的节点小于中间节点，右边子树的节点大于中间节点

class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        if(root == NULL || root->val == val)return root;//根节点为空或者根节点的值等于目标值返回根节点
        TreeNode* result = NULL;//结果
        if(root->val > val)result = searchBST(root->left,val);//因为二叉搜索树，左边的节点小于根节点，相当于左遍历
        if(root->val < val)result = searchBST(root->right,val);//右边节点的值大于根节点的值，相当于右遍历
        return result;
    }
};

迭代法：普通二叉树用栈或者队列做迭代，但是二叉搜索树特性节点有序，不用辅助也可以写迭代

class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        //循环条件
        while(root != NULL){
            if(root->val > val)root = root->left;//根节点的值大于目标值，向左
            else if(root->val < val)root = root->right;//根节点的值小于目标值，向右
            else return root;//相等返回根节点
        }
        return NULL;//不等返回空
    }
};

要记住二叉搜索树的特性，节点有序 

3.验证二叉搜索树（98题）

题目描述：

给定一个二叉树，判断其是否是一个有效的二叉搜索树。

假设一个二叉搜索树具有如下特征：

  • 节点的左子树只包含小于当前节点的数。
  • 节点的右子树只包含大于当前节点的数。
  • 所有左子树和右子树自身必须也是二叉搜索树。

递归法： 1.数组方法

class Solution {
private:
    //中序遍历，把用数组接收，最后看数组是否升序即可
    vector<int>vec;
    void traversal(TreeNode* root){
        if(root == NULL)return ;//终止条件
        traversal(root->left);//左
        vec.push_back(root->val);//中
        traversal(root->right);//右
    }
public:
    bool isValidBST(TreeNode* root) {
        vec.clear();
        traversal(root);//递归函数
        //遍历数组，然后判断是否数组升序
        for(int i = 1;i < vec.size();i++){
            if(vec[i] <= vec[i-1])return false;//逻辑
        }
        return true;
    }
};

2.节点方法：相当于数组的双指针，pre记录前一个节点走过遍历

class Solution {
public:
    TreeNode* pre = NULL; // 用来记录前一个节点
    bool isValidBST(TreeNode* root) {
        if (root == NULL) return true;
        bool left = isValidBST(root->left);

        if (pre != NULL && pre->val >= root->val) return false;
        pre = root; // 记录前一个节点

        bool right = isValidBST(root->right);
        return left && right;
    }
};

迭代法：中序遍历

class Solution {
public:
    bool isValidBST(TreeNode* root) {
        stack<TreeNode*> st;
        TreeNode* cur = root;
        TreeNode* pre = NULL;//记录前一个节点
        while (cur != NULL || !st.empty()) {
            if (cur != NULL) {
                st.push(cur);
                cur = cur->left;//左
            } else {
                cur = st.top();//中
                st.pop();
                if (pre != NULL && cur->val <= pre->val) return false;
                    pre = cur;
                    cur = cur->right;//右
            }
        }
        return true;
    }
};

4.二叉搜索树的最小绝对差（530题）

题目描述：

给你一棵所有节点为非负值的二叉搜索树，请你计算树中任意两节点的差的绝对值的最小值。

递归法： 1.首先可以中序遍历，因为是二叉搜索树，有序，中序遍历之后是一个单调递增的数组，在进行处理就很简单了

class Solution {
//递归中序遍历求一个数组接收中序遍历的数
private:
    vector<int>vec;
    void traversal(TreeNode* root){
        if(root == NULL)return ;
        traversal(root->left);//左
        vec.push_back(root->val);//中
        traversal(root->right);//右
    }
public:
    int getMinimumDifference(TreeNode* root) {
        vec.clear();
        traversal(root);
        int result = INT_MAX;//结果
        if(vec.size() < 2)return 0;//数组的大小小于2直接返回错位
        //对数组两个树的差进行运算取最小值
        for(int i = 1;i < vec.size();i++){
            result = min(result,vec[i] - vec[i-1]);
        }
        return result;
    }
};

2.递归，使用的是两个节点思想来实现，双指针的思想可以实现

class Solution {
private:
    int result = INT_MAX;//定义一个最小值
    TreeNode* pre;//定义一个节点指向前一个节点位置
    void traversal(TreeNode* cur){
        if(cur == NULL)return ;//终止条件
        traversal(cur->left);//左
        //前一个指针现在为空，当后面赋值之后不为空，在进行比较
        if(pre != NULL){
            result = min(result,cur->val - pre->val);//前一个节点和当前节点值相减比较取最小值
        }
        pre = cur;//赋值当前节点
        traversal(cur->right);//右
    }
public:
    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        return result;
    }
};

迭代法：也是中序遍历

class Solution {
public:
    int getMinimumDifference(TreeNode* root) {
        stack<TreeNode*>st;
        TreeNode* cur = root;
        TreeNode* pre = NULL;
        int result = INT_MAX;
        while(cur != NULL || !st.empty()){
            if(cur != NULL){
                st.push(cur);
                cur = cur->left;
            }else{
                cur = st.top();
                st.pop();
                if(pre != NULL){
                    result = min(result,cur->val - pre->val);
                }
                pre = cur;
                cur = cur->right;
            }
        }
        return result;
    }
};

5.二叉搜索树中的众数（501题）

题目描述：

给定一个有相同值的二叉搜索树（BST），找出 BST 中的所有众数（出现频率最高的元素）。

假定 BST 有如下定义：

  • 结点左子树中所含结点的值小于等于当前结点的值
  • 结点右子树中所含结点的值大于等于当前结点的值
  • 左子树和右子树都是二叉搜索树

 递归法：普通二叉树做法，并且使用哈希表来实现，把这个树都遍历了，用map统计频率，把频率排个序，最后取前面高频的元素的集合。

class Solution {
//递归方法
private:
    //如果按照普通二叉树的方法来实现，需要一个哈希表，对这个数据的数值进行统计
    void searchbst(TreeNode* cur,unordered_map<int,int>& map){
        if(cur == NULL)return ;
        map[cur->val]++;//中处理逻辑，每个节点进行哈希表记录数值
        searchbst(cur->left,map);//左
        searchbst(cur->right,map);//右
        return ;
    }
    //自定义一个比较的规则，比较哈希表排序，第一个最大
    bool static cmp(const pair<int,int>& a,const pair<int,int>& b){
        return a.second > b.second;//
    }
public:
    vector<int> findMode(TreeNode* root) {
        unordered_map<int,int>map;//哈希表
        vector<int>result;
        if(root == NULL)return result;//节点为空，返回
        searchbst(root,map);//递归
        vector<pair<int,int>>vec(map.begin(),map.end());//把哈希表的值放到数组里，不能直接排序
        sort(vec.begin(),vec.end(),cmp);//排序数组
        result.push_back(vec[0].first);//第一个放到结果里
        //取出现频率最高的元素放入result数组里
        for(int i = 1;i < vec.size();i++){
            if(vec[i].second == vec[0].second){
                result.push_back(vec[i].first);
            }else{
                break;
            }
        }
        return result;
    }
};

二叉搜索树的方法：弄一个指针指向前一个节点，这样每次cur（当前节点）才能和pre（前一个节点）作比较。而且初始化的时候pre = NULL，这样当pre为NULL时候，我们就知道这是比较的第一个元素。清空数组那步很绝，最大频率更新把数组清空再放入新的数，

class Solution {
private:
    int maxcount;//最大频率
    int count;//统计频率
    TreeNode* pre;//前一个节点
    vector<int>result;//结果
    //中序遍历，二叉搜索树特性，有序，
    void searchbst(TreeNode* cur){
        if(cur == NULL)return ;//终止条件
        searchbst(cur->left);//左
        //第一个节点，记录频率1
        if(pre == NULL){
            count = 1;
        }else if(pre->val == cur->val){
            count++;//前一个节点和当前节点值相等，频率+1
        }else{
            count = 1;//不同时候，频率为1
        }
        pre = cur;//更新上一个节点，其实和双指针没什么差别
        //如果频率和最大值相同，都加入数组中
        if(count == maxcount){
            result.push_back(cur->val);
        }
        //如果频率大于最大值
        if(count > maxcount){
            maxcount = count;//更新最大频率
            result.clear();//清空数组这步很关键
            result.push_back(cur->val);
        }

        searchbst(cur->right);//右
        return ;
    }
public:
    vector<int> findMode(TreeNode* root) {
        count = 0;
        maxcount = 0;
        TreeNode* pre = NULL;//记录前一个节点
        result.clear();
        searchbst(root);
        return result;
    }
};

迭代法：中序遍历转迭代法，其中处理逻辑没什么变化

class Solution {
public:
    vector<int> findMode(TreeNode* root) {
        stack<TreeNode*> st;
        TreeNode* cur = root;
        TreeNode* pre = NULL;
        int maxCount = 0; // 最大频率
        int count = 0; // 统计频率
        vector<int> result;
        while (cur != NULL || !st.empty()) {
            if (cur != NULL) { // 指针来访问节点，访问到最底层
                st.push(cur); // 将访问的节点放进栈
                cur = cur->left;                // 左
            } else {
                cur = st.top();
                st.pop();                       // 中
                if (pre == NULL) { // 第一个节点
                    count = 1;
                } else if (pre->val == cur->val) { // 与前一个节点数值相同
                    count++;
                } else { // 与前一个节点数值不同
                    count = 1;
                }
                if (count == maxCount) { // 如果和最大值相同，放进result中
                    result.push_back(cur->val);
                }

                if (count > maxCount) { // 如果计数大于最大值频率
                    maxCount = count;   // 更新最大频率
                    result.clear();     // 很关键的一步，不要忘记清空result，之前result里的元素都失效了
                    result.push_back(cur->val);
                }
                pre = cur;
                cur = cur->right;               // 右
            }
        }
        return result;
    }
};

6.二叉树的最近公共祖先（236题）

题目描述：

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

 递归：首先最容易想到的一个情况：如果找到一个节点，发现左子树出现结点p，右子树出现节点q，或者 左子树出现结点q，右子树出现节点p，那么该节点就是节点p和q的最近公共祖先。后序遍历回溯方法来实现

判断逻辑是 如果递归遍历遇到q，就将q返回，遇到p 就将p返回，那么如果 左右子树的返回值都不为空，说明此时的中节点，一定是q 和p 的最近祖先。

class Solution {  
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(root == q || root == p || root == NULL)return root;//终止条件
        TreeNode* left = lowestCommonAncestor(root->left,p,q);//本题需要递归返回值，但是需要遍历整颗树，需要判断左右完成递归
        TreeNode* right = lowestCommonAncestor(root->right,p,q);//右
        if(left != NULL && right != NULL)return root;//左右子树不为空，返回根节点
        if(left == NULL && right != NULL)return right;//左子树为空，右子树
        else if(left != NULL && right == NULL)return left;//左节点不为空，返回左节点
        else{
            return NULL;//否则返回空
        }
    }
};

需要搞清楚递归逻辑，以及遍历整颗树，还有回溯的后序遍历过程。

7.二叉搜索树的最近公共祖先（235题）

题目描述：

给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

递归法： 从上向下去递归遍历，第一次遇到 cur节点是数值在[q, p]区间中，那么cur就是 q和p的最近公共祖先。需要注意的是此时不知道p和q谁大，所以两个都要判断

class Solution {
private:
    //这里我们找到值立刻返回，二叉搜索树是一个有序树，我们前序遍历即可实现，从上到下递归，找到节点在q和p之间就返回
    TreeNode* traversal(TreeNode* cur,TreeNode* p,TreeNode* q){
        if(cur == NULL)return NULL;//终止条件
        //当前节点的值大于左右节点，向左递归
        if(cur->val > p->val && cur->val > q->val){
            TreeNode* left = traversal(cur->left,p,q);//左
            if(left != NULL){
                return left;//返回左
            }
        }
        //当前节点的值小于左右节点，向右递归
        if(cur->val < p->val && cur->val < q->val){
            TreeNode* right = traversal(cur->right,p,q);//右
            if(right != NULL){
                return right;//返回右
            }
        }
        return cur;
    }
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        return traversal(root,p,q);
    }
};

迭代法：节点如果当前节点大于pq值左边迭代，反之，最后找到根节点返回，没找到返回空

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

总结：

合并二叉树：遍历一个树逻辑是一样的，只不过传入两个树的节点，同时操作，注意终止条件如果一空返回2,2空返回1，我们可以在1树上进行操作即可实现前序遍历即可，层序遍历也可以实现模版，注意需要考虑节点空的情况即可

二叉搜索树中的搜索，二叉搜素树特性，左子树小于根节点， 右子树大于根节点，有序树，这里需要注意有返回值去接收，二叉搜索树不要队列或者栈也可以实现迭代，不需要辅助就可以完成

验证二叉搜索树：因为二叉搜索树的特性是一个有序树，可以遍历，中序让节点值放入数组，自然升序，判断是否升序就可以实现了，节点方法：注意需要定义一个指针这个指针需要走当前节点的前一个节点，pre=cur注意，先判断pre=null时候，在执行，迭代法中序实现即可，

二叉搜索树的最小绝对差：数组的方法也是一样的，寻找两个节点之间的最小差值即可，依然中序遍历，节点法：也是需要定义一个节点去走当前节点上一个节点，然后进行差值比较就可以实现，注意pre的赋值就可以中序遍历，迭代法：中序遍历

二叉搜索树的众数：普通二叉树的话，需要使用哈希表来结合，我们遍历整个树，然后使用map去对键值对进行记录，然后利用数组pair进行接收，排序，取最高频率元素即可实现，二叉搜索树的方法：也是双指针，就是再来一个节点记录当前走过的前一个节点的位置，然后比较两个节点是否相等，相等进行操作，记录频率，和最大频率，这里需要注意最大频率如果出现更新需要对数组清除然后再已添加元素，仍然使用中序遍历法，迭代法：其实没什么差别使用

二叉树的最近公共祖先：这里需要注意递归函数需要返回值，找到就需要返回，需要后序遍历进行到二叉树的根节点，这里需要注意中间节点的处理方法，需要判断左右节点的是否为空，再进行处理，需要遍历整棵树的逻辑，

二叉搜索树的最近公共祖先：二叉搜索树是有序树，前序遍历就可以实现，从上到下递归，终止条件需要注意，这里需要判断当前节点的值和左右节点的值进行对比，如果在这个区间就直接返回，迭代法：节点如果当前节点大于pq值左边迭代，反之，最后找到根节点返回，没找到返回空

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

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

相关文章

红日靶场5

红日靶场5

目录 前言 外网渗透 信息收集 1、arp探测 2、nmap 3、nikto 4、whatweb 5、gobuster 6、dirsearch 漏洞探测 ThinKPHP漏洞 漏洞利用 get shell 内网渗透 信息收集 CS 启动&#xff01; CS连接 CS信息收集 1、hashdump 2、猕猴桃 3、端口扫描 MSF启动&…
阅读更多...
解决“百度网盘启动缓慢”问题

解决“百度网盘启动缓慢”问题

最近在使用百度网盘&#xff0c;双击桌面的《百度网盘》图标&#xff0c;发现有等好几分钟&#xff0c;软件才会启动。百度网盘启动太慢了&#xff0c;后面发现百度网盘&#xff0c;使用dll注入技术&#xff0c;附加到很多不相干的进程里&#xff0c;比如附加explorer进程、附加…
阅读更多...
构建基于RHEL8系列(CentOS8,AlmaLinux8,RockyLinux8等)的支持63个常见模块的PHP8.1.20的RPM包

构建基于RHEL8系列(CentOS8,AlmaLinux8,RockyLinux8等)的支持63个常见模块的PHP8.1.20的RPM包

本文适用&#xff1a;rhel8系列&#xff0c;或同类系统(CentOS8,AlmaLinux8,RockyLinux8等) 文档形成时期&#xff1a;2023年 因系统版本不同&#xff0c;构建部署应略有差异&#xff0c;但本文未做细分&#xff0c;对稍有经验者应不存在明显障碍。 因软件世界之复杂和个人能力…
阅读更多...
Spark原理——逻辑执行图

Spark原理——逻辑执行图

逻辑执行图 明确逻辑计划的边界 在 Action 调用之前&#xff0c;会生成一系列的RDD,这些RDD之间的关系&#xff0c;其实就是整个逻辑计划 val conf new SparkConf().setMaster("local[6]").setAppName("wordCount_source") val sc new SparkContext(conf)v…
阅读更多...
vue前端开发自学练习,Props数据传递-类型校验,默认值的设置！

vue前端开发自学练习,Props数据传递-类型校验,默认值的设置！

vue前端开发自学练习,Props数据传递-类型校验,默认值的设置&#xff01; 实际上&#xff0c;vue开发框架的时候&#xff0c;充分考虑到了前端开发人员可能会遇到的各种各样的情况&#xff0c;比如大家经常遇到的&#xff0c;数据类型的校验&#xff0c;再比如&#xff0c;默认…
阅读更多...
Web安全测试基础

Web安全测试基础

SQL注入 当下最常用的一个攻击手段&#xff0c;就是通过SQL命令插入到Web表单中或页面请求查询字符串中&#xff0c;最终达到欺骗服务器执行恶意的SQL语句的目的&#xff0c;SQL注入一旦成功&#xff0c;轻则直接绕开服务器验证&#xff0c;直接登录成功&#xff0c;重则将服务…
阅读更多...
php多小区智慧物业管理系统源码带文字安装教程

php多小区智慧物业管理系统源码带文字安装教程

多小区智慧物业管理系统源码带文字安装教程 运行环境 服务器宝塔面板 PHP 7.0 Mysql 5.5及以上版本 Linux Centos7以上 统计分析以小区为单位&#xff0c;统计如下数据&#xff1a;小区总栋数、小区总户数、小区总人数、 小区租户数量、小区每月收费金额统计、小区车位统计、小…
阅读更多...
专业130+总400+哈尔滨工业大学803信号与系统和数字逻辑电路考研经验哈工大，电子信息，信息与通信工程，信通

专业130+总400+哈尔滨工业大学803信号与系统和数字逻辑电路考研经验哈工大，电子信息，信息与通信工程，信通

今年专业课803信号与系统和数字逻辑130总分400如愿考上哈尔滨工业大学电子信息&#xff08;信息与通信工程-信通&#xff09;&#xff0c;总结了一些各门课程复习心得&#xff0c;希望对大家复习有帮助。 数学一 资料选择&#xff1a; ①高数&#xff1a;张宇强化班 ②线性…
阅读更多...
基于JavaWeb+BS架构+SpringBoot+Vue+Hadoop的物品租赁系统的设计与实现

基于JavaWeb+BS架构+SpringBoot+Vue+Hadoop的物品租赁系统的设计与实现

基于JavaWebBS架构SpringBootVueHadoop的物品租赁系统的设计与实现 文末获取源码Lun文目录前言主要技术系统设计功能截图订阅经典源码专栏Java项目精品实战案例《500套》 源码获取 文末获取源码 Lun文目录 目　　录 I 1绪 论 1 1.1开发背景 1 1.2开发目的与意义 1 1.2.1开发目…
阅读更多...
【Redis】Redis 进阶

【Redis】Redis 进阶

文章目录 1. BigKey1.1 MoreKey1.2 BigKey 2. 缓存双写一致性更新策略2.1 读缓存数据2.2 数据库和缓存一致性的更新策略2.3 canal 实现双写一致性 3. 进阶应用3.1 统计应用3.2 hyperloglog3.3 GEO3.4 bitmap 4. 布隆过滤器5. Redis 经典问题5.1 缓存预热5.2 缓存穿透5.3 缓存击…
阅读更多...
C++ 类 对象

C++ 类 对象

C 在 C 语言的基础上增加了面向对象编程&#xff0c;C 支持面向对象程序设计。类是 C 的核心特性&#xff0c;通常被称为用户定义的类型。 类用于指定对象的形式&#xff0c;是一种用户自定义的数据类型&#xff0c;它是一种封装了数据和函数的组合。类中的数据称为成员变量&a…
阅读更多...
Anaconda定制Python编程并打包

Anaconda定制Python编程并打包

本文主要介绍如何使用Anaconda定制一个Python编程环境并打包&#xff0c;方便编程环境迁移。 文章参考 谢作如 邱奕盛两位老师的《为信息科技教学定制一个Python编程环境》 * 开发不同的项目需要不同的库&#xff08;甚至不同版本&#xff09;&#xff0c;把所有的库安装到一…
阅读更多...
Jenkins基础篇--添加用户和用户权限设置

Jenkins基础篇--添加用户和用户权限设置

添加用户 点击系统管理&#xff0c;点击管理用户&#xff0c;然后点击创建用户&#xff08;Create User&#xff09; 用户权限管理 点击系统管理&#xff0c;点击全局安全配置&#xff0c;找到授权策略&#xff0c;选择安全矩阵&#xff0c;配置好用户权限后&#xff0c;点击…
阅读更多...
计算机网络-VLAN间通信

计算机网络-VLAN间通信

之前复习了VLAN的概念以及几个接口类型。VLAN在二层可以实现广播域的划分&#xff0c;VLAN间可以实现二层通信&#xff0c;但是不能实现三层通信&#xff0c;需要借助其它方式。 一、概述 实际网络部署中一般会将不同IP地址段划分到不同的VLAN。同VLAN且同网段的PC之间可直接进…
阅读更多...
【Unity】Joystick Pack摇杆插件实现锁四向操作

【Unity】Joystick Pack摇杆插件实现锁四向操作

Joystick Pack ​ 简介&#xff1a;一款Unity摇杆插件&#xff0c;非常轻量化 ​ 摇杆移动类型&#xff1a;圆形、横向、竖向 ​ 摇杆类型&#xff1a; Joystick描述Fixed固定位置Floating浮动操纵杆从用户触碰的地方开始&#xff0c;一直固定到触碰被释放。Dynamic动态操纵…
阅读更多...
【设计模式】01-前言

【设计模式】01-前言

23 Design Patterns implemented by C. 从本文开始&#xff0c;一系列的文章将揭开设计模式的神秘面纱。本篇博文是参考了《设计模式-可复用面向对象软件的基础》这本书&#xff0c;由于该书的引言 写的太好了&#xff0c;所以本文基本是对原书的摘抄。 0.前言 评估一个面向对…
阅读更多...
孩子用什么样的灯对眼睛没有伤害？分享最合适孩子的护眼台灯

孩子用什么样的灯对眼睛没有伤害？分享最合适孩子的护眼台灯

为人父母以后&#xff0c;孩子健康成长一定是摆放在首位的&#xff0c;随着孩子慢慢长大&#xff0c;步入更高的年级&#xff0c;作业课程也在随之增多。不少孩子哪怕夜色已经降临&#xff0c;仍就伏案在桌子上完成没有做完的功课&#xff0c;作为父母的我们不得不担心孩子的视…
阅读更多...
Unity 工具 之 Azure 微软连续语音识别ASR的简单整理

Unity 工具 之 Azure 微软连续语音识别ASR的简单整理

Unity 工具 之 Azure 微软连续语音识别ASR的简单整理 目录 Unity 工具 之 Azure 微软连续语音识别ASR的简单整理 一、简单介绍 二、实现原理 三、注意实现 四、实现步骤 五、关键脚本 一、简单介绍 Unity 工具类&#xff0c;自己整理的一些游戏开发可能用到的模块&#x…
阅读更多...
书客、明基、好视力护眼台灯大比拼，哪款更胜一筹？

书客、明基、好视力护眼台灯大比拼，哪款更胜一筹？

在现代生活中&#xff0c;我们经常面对着各种电子屏幕&#xff0c;给眼睛造成了一定的压力&#xff0c;时间一长&#xff0c;会发现眼睛很疲劳。很多家长仔细观察&#xff0c;当孩子长时间处在不合适地灯光下玩耍、学习&#xff0c;会发现他们有揉眼的动作&#xff0c;这就是不…
阅读更多...
Mac 使用nvm use命令无法切换node版本

Mac 使用nvm use命令无法切换node版本

解决方案&#xff1a;先卸载使用brew安装的node&#xff08; 具体操作请移步使用brew卸载node&#xff09;&#xff0c;再使用nvm use命令切换node版本。 问题复现&#xff1a;使用nvm use命令显示切换成功&#xff0c;但是实际版本还是原来的node版本&#xff0c;应该是与bre…
阅读更多...
最新文章

Copyright @ 2022~2023