面试经典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,表示找到一条路径和为t
        if(!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://www.mfbz.cn/a/405901.html

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

相关文章

利用R语言进行典型相关分析实战

利用R语言进行典型相关分析实战

&#x1f349;CSDN小墨&晓末:https://blog.csdn.net/jd1813346972 个人介绍: 研一&#xff5c;统计学&#xff5c;干货分享          擅长Python、Matlab、R等主流编程软件          累计十余项国家级比赛奖项&#xff0c;参与研究经费10w、40w级横向 文…
阅读更多...
幻兽帕鲁(Palworld 1.4.1)私有服务器搭建(docker版)

幻兽帕鲁(Palworld 1.4.1)私有服务器搭建(docker版)

文章目录 说明客户端安装服务器部署1Panel安装和配置docker服务初始化设置设置开机自启动设置镜像加速 游戏服务端部署游戏服务端参数可视化配置 Palworld连接服务器问题总结 说明 服务器硬件要求&#xff1a;Linux系统/Window系统&#xff08;x86架构&#xff0c;armbian架构…
阅读更多...
Linux设备模型(二) - kset/kobj/ktype APIs

Linux设备模型(二) - kset/kobj/ktype APIs

一&#xff0c;kobject_init_and_add 1&#xff0c;kobject_init_and_add实现 /** * kobject_init_and_add() - Initialize a kobject structure and add it to * the kobject hierarchy. * kobj: pointer to the kobject to initialize * ktype: p…
阅读更多...
Spring注入

Spring注入

文章目录 3.1 什么是注入3.1.1 为什么需要注入3.1.2 如何进行注入3.1.3 注入好处 3.2 Spring 注入的原理分析&#xff08;简易版&#xff09;3.3 Set 注入详解3.3.1 JDK内置类型3.3.2 自定义类型3.3.2.1 第一种方式3.3.2.2 第二种方式 3.4 构造注入3.4.1 步骤3.4.2 构造方法重载…
阅读更多...
RobotGPT：利用ChatGPT的机器人操作学习框架，三星电子研究院与张建伟院士、孙富春教授、方斌教授合作发表RAL论文

RobotGPT：利用ChatGPT的机器人操作学习框架，三星电子研究院与张建伟院士、孙富春教授、方斌教授合作发表RAL论文

1 引言 大型语言模型&#xff08;LLMs&#xff09;在文本生成、翻译和代码合成方面展示了令人印象深刻的能力。最近的工作集中在将LLMs&#xff0c;特别是ChatGPT&#xff0c;整合到机器人技术中&#xff0c;用于任务如零次系统规划。尽管取得了进展&#xff0c;LLMs在机器人技…
阅读更多...
第八篇【传奇开心果系列】python的文本和语音相互转换库技术点案例示例：Google Text-to-Speech虚拟现实（VR）沉浸式体验经典案例

第八篇【传奇开心果系列】python的文本和语音相互转换库技术点案例示例：Google Text-to-Speech虚拟现实（VR）沉浸式体验经典案例

传奇开心果博文系列 系列博文目录python的文本和语音相互转换库技术点案例示例系列 博文目录前言一、雏形示例代码二、扩展思路介绍三、虚拟导游示例代码四、交互式学习示例代码五、虚拟角色对话示例代码六、辅助用户界面示例代码七、实时语音交互示例代码八、多语言支持示例代…
阅读更多...
大模型平民化技术之LORA

大模型平民化技术之LORA

1. 引言 在这篇博文中&#xff0c; 我将向大家介绍LoRA技术背后的核心原理以及相应的代码实现。 LoRA 是 Low-Rank Adaptation 或 Low-Rank Adaptors 的首字母缩写词&#xff0c;它提供了一种高效且轻量级的方法&#xff0c;用于微调预先训练好的的大语言模型。这包括 BERT 和…
阅读更多...
数据之巅：揭秘企业数据分析师如何成为企业的决策智囊

数据之巅：揭秘企业数据分析师如何成为企业的决策智囊

引言 在数字化浪潮中&#xff0c;企业数据分析师已成为企业决策的重要支撑。他们如同探险家&#xff0c;在数据的丛林中寻找着能够指引企业前行的宝贵信息。本文将深入剖析企业数据分析师的角色、挑战与成就&#xff0c;带你领略这个充满智慧与激情的职业风采。 一、从数字到智…
阅读更多...
计算机毕业设计 基于SpringBoot的宠物商城网站系统的设计与实现 Java实战项目 附源码+文档+视频讲解

计算机毕业设计 基于SpringBoot的宠物商城网站系统的设计与实现 Java实战项目 附源码+文档+视频讲解

博主介绍&#xff1a;✌从事软件开发10年之余&#xff0c;专注于Java技术领域、Python人工智能及数据挖掘、小程序项目开发和Android项目开发等。CSDN、掘金、华为云、InfoQ、阿里云等平台优质作者✌ &#x1f345;文末获取源码联系&#x1f345; &#x1f447;&#x1f3fb; 精…
阅读更多...
代理模式笔记

代理模式笔记

代理模式 代理模式代理模式的应用场景先理解什么是代理&#xff0c;再理解动静态举例举例所用代码 动静态的区别静态代理动态代理 动态代理的优点代理模式与装饰者模式的区别 代理模式 代理模式在设计模式中是7种结构型模式中的一种&#xff0c;而代理模式有分动态代理&#x…
阅读更多...
WordPres Bricks Builder 前台RCE漏洞

WordPres Bricks Builder 前台RCE漏洞

免责声明&#xff1a;文章来源互联网收集整理&#xff0c;请勿利用文章内的相关技术从事非法测试&#xff0c;由于传播、利用此文所提供的信息或者工具而造成的任何直接或者间接的后果及损失&#xff0c;均由使用者本人负责&#xff0c;所产生的一切不良后果与文章作者无关。该…
阅读更多...
＜网络安全＞《48 网络攻防专业课＜第十四课 - 华为防火墙的使用（1）＞

＜网络安全＞《48 网络攻防专业课＜第十四课 - 华为防火墙的使用（1）＞

1 DHCP Snooping 概述 DHCP Snooping功能用于防止 1、DHCP Server仿冒者攻击&#xff1b; 2、中间人攻击与IP/MAC Spoofing攻击&#xff1b; 3、改变CHADDR值的DoS攻击。 1.2 DHCP Server 仿冒者攻击 1.3 中间人与IP/MAC Spoofing 攻击 1.4 改变CHADDR 值的DoS 攻击 CHADDR…
阅读更多...
2024年数学建模美赛详细总结以及经验分享

2024年数学建模美赛详细总结以及经验分享

前言&#xff1a; 本文记录与二零二四年二月六日&#xff0c;正好今天是数学建模结束&#xff0c;打算写篇文章记录一下整个过程&#xff0c;以及一些感受、还有经验分享。记录这个过程的原因就是我在赛前&#xff0c;在博客上找了很久&#xff0c;也没有像我这么类似记…
阅读更多...
Gemma模型论文详解（附源码）

Gemma模型论文详解（附源码）

原文链接&#xff1a;Gemma模型论文详解&#xff08;附源码&#xff09; 1. 背景介绍 Gemma模型是在2023.2.21号Google新发布的大语言模型, Gemma复用了Gemini相同的技术(Gemini也是Google发布的多模态模型)&#xff0c;Gemma这次发布了了2B和7B两个版本的参数&#xff0c;不…
阅读更多...
JAVA--File类与IO流

JAVA--File类与IO流

目录 1. java.io.File类的使用 1.1 概述 1.2 构造器 1.3 常用方法 1、获取文件和目录基本信息 2、列出目录的下一级 3、File类的重命名功能 4、判断功能的方法 5、创建、删除功能 2. IO流原理及流的分类 2.1 Java IO原理 2.2 流的分类 2.3 流的API 3. 节点流之一…
阅读更多...
微服务学习

微服务学习

一、服务注册发现 服务注册就是维护一个登记簿&#xff0c;它管理系统内所有的服务地址。当新的服务启动后&#xff0c;它会向登记簿交待自己的地址信息。服务的依赖方直接向登记簿要Service Provider地址就行了。当下用于服务注册的工具非常多ZooKeeper&#xff0c;Consul&am…
阅读更多...
Jetson Xavier NX 与笔记本网线连接 ，网络共享，ssh连接到vscode

Jetson Xavier NX 与笔记本网线连接 ，网络共享，ssh连接到vscode

Jetson Xavier NX 与笔记本网线连接 &#xff0c;网络共享&#xff0c;ssh连接到vscode Jetson Xavier NX桌面版需要连接显示屏、鼠标和键盘&#xff0c;操作起来并不方便&#xff0c;因此常常需要ssh远程连接到本地笔记本电脑&#xff0c;这里介绍一种连接方式&#xff0c;通过…
阅读更多...
Linux实验记录：使用PXE+Kickstart无人值守安装服务

Linux实验记录：使用PXE+Kickstart无人值守安装服务

前言&#xff1a; 本文是一篇关于Linux系统初学者的实验记录。 参考书籍&#xff1a;《Linux就该这么学》 实验环境&#xff1a; VmwareWorkStation 17——虚拟机软件 RedHatEnterpriseLinux[RHEL]8——红帽操作系统 备注&#xff1a; 实际生产中安装操作系统的工作&…
阅读更多...
论文笔记：利用词对比注意增强预训练汉字表征

论文笔记：利用词对比注意增强预训练汉字表征

整理了 ACL2020短文 Enhancing Pre-trained Chinese Character Representation with Word-aligned Att&#xff09;论文的阅读笔记 背景模型实验 论文地址&#xff1a;论文 背景 近年来&#xff0c;以 BERT 为代表的预训练模型在 NLP 领域取得取得了非常显著的效果。但是&…
阅读更多...
谈谈对BFC的理解

谈谈对BFC的理解

文章目录 一、是什么二、触发条件三、应用场景防止margin重叠&#xff08;塌陷&#xff09;清除内部浮动自适应多栏布局小结 参考文献 一、是什么 我们在页面布局的时候&#xff0c;经常出现以下情况&#xff1a; 这个元素高度怎么没了&#xff1f;这两栏布局怎么没法自适应&…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站