代码随想录_刷题记录_第四次

二叉树 — 理论基础

种类：

  • 满二叉树（所有层的节点都是满的，k：深度 节点数量：2^k - 1）
  • 完全二叉树（除了最后一层，其余层全满，并且最后一层从左到右连续）
  • 二叉搜索树（对于每一个父节点来说，左子树的所有节点都小于父节点，右子树的所有节点都大于父节点 时间复杂度 ： log(n) ）
  • 平衡二叉搜索树（左子树和右子树的高度差不能大于1 时间复杂度：log(n)

存储方式：

  • 链式存储（左指针、右指针）
  • 线式存储（数组 父节点 i，左子节点 2i + 1，右子节点 2i + 2）

遍历方式：

  • 深度优先搜索：递归方式实现（前序、中序、后序）、迭代法（使用栈）
  • 广度优先搜索：一层一层的去遍历（迭代法，使用队列）（层序遍历）

前序：中左右 中序：左中右 后序：左右中

定义方法：

struct TreeNode{
	int value;
	TreeNode* left;
	TreeNode* right;
	TreeNode(int val) : value(val) left(NULL) right(NULL) {}
}

**二叉树节点的深度：**从根节点到该节点的最长简单路径边的条数（前序递归求深度）

**二叉树节点的高度：**从该节点到叶子节点（左右子节点都为空）的最长简单路径边的条数（后序递归求高度）

前序遍历求深度，后序遍历求高度

二叉树 — 递归遍历

递归遍历的三步骤：

  1. 确定递归函数的参数和返回值
  2. 确定终止条件
  3. 确定单层递归的逻辑

前序遍历

题目链接：144. 二叉树的前序遍历 - 力扣（LeetCode）

**题目要求：**给你二叉树的根节点 root ，返回它节点值的 前序 遍历。

示例 ：

**输入：**root = [1,2,3,4,5,null,8,null,null,6,7,9]

输出：[1,2,4,5,6,7,3,8,9]

解释：

img

思路：

  1. 确定参数（根节点、vec数组）和返回值（void）

    void traversal(TreeNode* cur, vector<int>& vec)

  2. 确定终止条件（深度优先搜索，cur == NULL return）

    if (cur == NULL) return;

  3. 确定单层递归的逻辑

    vec.push_back(cur->val);    // 中
traversal(cur->left, vec);  // 左
traversal(cur->right, vec); // 右

解法：

  • C++
class Solution {
public:
    void traversal(TreeNode* cur, vector<int>& vec){
        if(cur == NULL) return;
        vec.push_back(cur->val);      // 中
        traversal(cur->left, vec);    // 左
        traversal(cur->right, vec);   // 右
    }

    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root, result);   // 传入根节点和存放结果的数组
        return result;
    }
};

中序遍历

题目链接：94. 二叉树的中序遍历 - 力扣（LeetCode）

  • C++
class Solution {
public:
    void traversal(TreeNode* cur, vector<int>& vec){
        if(cur == NULL) return;
        traversal(cur->left, vec);    // 左
        vec.push_back(cur->val);      // 中
        traversal(cur->right, vec);   // 右
    }


    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root, result);   // 传入根节点和存放结果的数组
        return result;
    }
};

后序遍历

题目链接：145. 二叉树的后序遍历 - 力扣（LeetCode）

  • C++
class Solution {
public:
    void traversal(TreeNode* cur, vector<int>& vec){
        if(cur == NULL) return;
        traversal(cur->left, vec);    // 左
        traversal(cur->right, vec);   // 右
        vec.push_back(cur->val);      // 中
    }

    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root, result);   // 传入根节点和存放结果的数组
        return result;
    }
};

二叉树 — 迭代遍历

**递归的实现：**每一次递归调用都会把函数的局部变量、参数值和返回地址等压入调用栈中，然后递归返回的时候，从栈顶弹出上一次递归的各项参数，所以这就是递归为什么可以返回上一层位置的原因

所以，我们使用栈也可以实现二叉树的前中后序遍历

前序遍历

**思路：**用栈存放节点，用数组存放结果

先将根节点放入栈中，进入循环直到栈为空，取出栈顶结点作为中间节点（中左右），放入这个节点的右子节点，再放入这个节点的左子节点（取出时是先取左子节点）（如果为空则不放入）

解法：

  • C++
class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
    	vector<int> result;
        stack<TreeNode*> st;
        if(root == NULL) return result;
        st.push(root);   // 先将根节点放入栈中
        while(!st.empty()){
            TreeNode* cur = st.top();   // 取出栈顶结点作为这次的中间节点
            st.pop();           
            result.push_back(cur->val);
            if(cur->right) st.push(cur->right);   // 向栈中放入右子节点，如果为空则不放入
            if(cur->left)  st.push(cur->left);    // 向栈中放入左子节点
        } 
        return result;
    }
};

后序遍历

**思路：**跟前序遍历相同，只不过调转了左右子节点入栈的顺序，此时输出的结果为 中右左，所以需要调换顺序输出 左右中

解法：

  • C++
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
    	vector<int> result;
        stack<TreeNode*> st;
        if(root == NULL) return result;
        st.push(root);   // 先将根节点放入栈中
        while(!st.empty()){
            TreeNode* cur = st.top();   // 取出栈顶结点作为这次的中间节点
            st.pop();
            result.push_back(cur->val);
            if(cur->left)  st.push(cur->left);    // 向栈中放入左子节点
            if(cur->right) st.push(cur->right);   // 向栈中放入右子节点，如果为空则不放入
        }   
        reverse(result.begin(), result.end());    // 中右左 -> 左右中
        return result;
    }
};

中序遍历

思路：

写法与前序遍历、后序遍历不同，因为前序遍历和后序遍历的顺序是中左右、中右左（最后反转），要访问的元素和要处理的元素顺序是一致的，但是中序遍历 左中右 处理顺序和访问顺序是不一致的

所以，在使用迭代法写中序遍历的时候，就需要借用指针的遍历来帮助访问节点，栈则用来处理节点上的元素

解法：

  • C++
class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        TreeNode* cur = root;
        while(cur || !st.empty()){
            if(cur){   // 向该子节点的左子节点一直遍历，直到为空
                st.push(cur);   // 将所有节点放入栈中
                cur = cur->left;
            }else{   // 若已经遍历到底
                cur = st.top();   // 取出栈顶元素（最左子节点）
                st.pop();
                result.push_back(cur->val);   // 放入左子节点
                cur = cur->right;   // 取出右子节点重复操作
            }
        }
        return result;
    }
};

二叉树 — 层序遍历

层序遍历 I

题目链接：102. 二叉树的层序遍历 - 力扣（LeetCode）

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

示例1：

image-20240924171110192

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

示例 2：

输入：root = [1]
输出：[[1]]

示例 3：

输入：root = []
输出：[]

**思路：**借助队列保存每一层中遍历的元素

解法：

  • C++
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        vector<vector<int>> result;
        if(root == NULL) return result;
        que.push(root);
        while(!que.empty()){
            vector<int> vec;   // 保存每一层的节点数据
            int size = que.size();   // 记录每一层节点的数量
            for(int i = 0; i < size; i++){
                TreeNode* cur = que.front();   // 访问队列的头部元素
                que.pop();
                vec.push_back(cur->val);
                if(cur->left)  que.push(cur->left);
                if(cur->right) que.push(cur->right);
            }
            result.push_back(vec);
        }
        return result;
    }
};

二叉树的最大深度

题目链接：104. 二叉树的最大深度 - 力扣（LeetCode）

题目要求：

给定一个二叉树 root ，返回其最大深度。

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

**思路：**仍然是使用队列保存每一层的数据，不过在进行层切换时要计数

解法：

  • C++
class Solution {
public:
    int maxDepth(TreeNode* root) {
        queue<TreeNode*> que;
        int result = 0;
        if(!root) return result;
        que.push(root);
        while(!que.empty()){
            result++;
            int size = que.size();
            while(size--){
                TreeNode* cur = que.front();
                que.pop();
                if(cur->left)  que.push(cur->left);
                if(cur->right) que.push(cur->right);
            }
        }
        return result;
    }
};

二叉树的最小深度

题目链接：111. 二叉树的最小深度 - 力扣（LeetCode）

题目要求：

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点（左右子节点都为 NULL 的节点）的最短路径上的节点数量。

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

示例 1：

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

示例 2：

输入：root = [2,null,3,null,4,null,5,null,6]
输出：5

解法：

  • C++
class Solution {
public:
    int minDepth(TreeNode* root) {
        queue<TreeNode*> que;
        int result = 0;
        if(!root) return result;
        que.push(root);
        while(!que.empty()){
            result++;
            int size = que.size();
            while(size--){
                TreeNode* cur = que.front();
                que.pop();
                if(cur->left)  que.push(cur->left);
                if(cur->right) que.push(cur->right);
                if(!cur->left && !cur->right) // 当左子节点与右子节点都为空时就代表最小深度
                    return result;
            }
        }
        return result;
    }
};

二叉树 — 翻转二叉树

题目链接：226. 翻转二叉树 - 力扣（LeetCode）

**题目要求：**给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

示例 1：

img

输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]

示例 2：

img

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

示例 3：

输入：root = []
输出：[]

思路：

只要将每一个节点的左右子节点翻转一下，就可以达到整体翻转的效果

使用 前序/后续 对二叉树进行递归遍历，中序（会将某些节点的左右子节点翻转两次）

1、递归函数的参数（TreeNode *），返回值（TreeNode *）

TreeNode* invertTree(TreeNode* cur)

2、终止条件（root == NULL）

if (root == NULL) return NULL;

3、单层递归逻辑（交换传入节点的左右子节点）

swap(root->left, root->right);   // 交换两个变量的值
invertTree(root->left);
invertTree(root->right);

解法：

  • C++（前序遍历 递归）
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(!root) return NULL;
        swap(root->left,root->right); // 中
        invertTree(root->left);       // 左
        invertTree(root->right);      // 右
        return root;
    }
};
  • C++（后序遍历 递归）
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(!root) return NULL;
        invertTree(root->left);       // 左
        invertTree(root->right);      // 右
        swap(root->left,root->right); // 中
        return root;
    }
};

二叉树 — 对称二叉树

题目链接：101. 对称二叉树 - 力扣（LeetCode）

**题目要求：**给你一个二叉树的根节点 root ， 检查它是否轴对称。

示例 1：

img

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

示例 2：

img

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

思路：

判断是否为对称二叉树，其实就是判断左子树和右子树是否可以相互翻转，真正要比较的是两个树（根节点的左右子树）（比较两个子树的里侧和外侧元素是否相等），所以在递归遍历的过程中，也是要同时遍历两棵树

只能使用后续遍历（左右中）

正因为要遍历两棵树而且要比较内测和外侧节点，所以准确来说是一个树的遍历顺序是左右中，一个树的遍历顺序是右左中

1、递归函数的参数（TreeNode* left TreeNode* right），返回值（bool）

bool compare(TreeNode* left, TreeNode* right)

2、确定终止条件

if (left == NULL && right != NULL) return false;
else if (left != NULL && right == NULL) return false;
else if (left == NULL && right == NULL) return true;
else if (left->val != right->val) return false;

3、确定单层递归的逻辑

bool outside = compare(left->left, right->right);   // 左子树：左、 右子树：右
bool inside = compare(left->right, right->left);    // 左子树：右、 右子树：左
bool isSame = outside && inside;                    // 左子树：中、 右子树：中（逻辑处理）
return isSame;

解法：

  • C++
class Solution {
public:
    bool compare(TreeNode* left, TreeNode* right){
        if(left == NULL && right == NULL) return true;
        else if(left != NULL && right == NULL) return false;
        else if(left == NULL && right != NULL) return false;
        else if(left->val != right->val) return false; // 这个条件已经比较了每一个节点的值

        bool cmp_left  = compare(left->left, right->right);
        bool cmp_right = compare(left->right, right->left);
        return cmp_left && cmp_right;
    }

    bool isSymmetric(TreeNode* root) {
        if(root == NULL) return true;
        return compare(root->left, root->right);
    }
};

二叉树 — 二叉树的最大深度

题目链接：104. 二叉树的最大深度 - 力扣（LeetCode）

**思路：**这里使用递归法，也可以使用层序遍历

使用前序递归求深度，使用后序递归求高度，而根节点的高度就是整个二叉树的深度，所以这道题实际上是使用后续递归求根节点的高度

1、确定递归的参数和返回值

int maxDepth(TreeNode* node)

2、确定终止条件（如果为空节点，就返回0，表示高度为0）

if (node == NULL) return 0;

3、单层递归的逻辑：先求它的左子树的深度，再求右子树的深度，最后取左右深度最大的数值 再+1 （加1是因为算上当前中间节点）就是目前节点为根节点的树的深度

int leftdepth = getdepth(node->left);       // 左
int rightdepth = getdepth(node->right);     // 右
int depth = 1 + max(leftdepth, rightdepth); // 中
return depth;

解法：

  • C++
class Solution {
public:
    int maxDepth(TreeNode* root) {
        if (root == NULL) return 0;
        int leftdepth  = maxDepth(root->left);       // 左
        int rightdepth = maxDepth(root->right);      // 右
        int depth = 1 + max(leftdepth, rightdepth);  // 中
        return depth;
    }
};

二叉树 — 二叉树的最小深度

题目链接：111. 二叉树的最小深度 - 力扣（LeetCode）

**思路：**依旧是前序递归遍历求深度，后序递归遍历求高度

这里使用后序遍历求最小深度

最小深度是从根节点到最近叶子节点（左右子节点都为空）的最短路径上的节点数量。

1、确定递归函数的参数和返回值

int minDepth(TreeNode* node)

2、确定终止条件（遇到空节点，返回 0）

if(node == NULL) return 0;

3、确定单层递归的逻辑

int leftDepth = getDepth(node->left);
int rightDepth = getDepth(node->right);
// 当只有一个子节点时，就顺着这个子节点继续往下查
if(node->left == NULL && node->right != NULL){
	return 1 + rightDepth;
}
if(node->left != NULL && node->right == NULL){
	return 1 + leftDepth;
}
int result = 1 + min(leftDepth, rightDepth);
return result;

解法：

  • C++
class Solution {
public:
    int minDepth(TreeNode* root) {
        int result = 0;
        if(root == NULL) return 0;
        int leftDepth  = minDepth(root->left);   // 左
        int rightDepth = minDepth(root->right);  // 右
        if(root->left == NULL && root->right != NULL){
            return rightDepth + 1;
        }
        if(root->left != NULL && root->right == NULL){
            return leftDepth + 1;
        }
        result = 1 + min(leftDepth, rightDepth);
        return result;
    }
};

二叉树 — 完全二叉树的节点数量

题目链接：222. 完全二叉树的节点个数 - 力扣（LeetCode）

题目要求：

给你一棵 完全二叉树 的根节点 root ，求出该树的节点个数。

完全二叉树 的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2h 个节点。

示例 1：

img

输入：root = [1,2,3,4,5,6]
输出：6

示例 2：

输入：root = []
输出：0

示例 3：

输入：root = [1]
输出：1

**思路：**可以使用层序遍历（只需要在遍历每一层时，记录节点的个数就可以），

使用递归的写法和求二叉树的深度写法类似，顺序依旧是后序（左右中）

1、确定递归的参数和返回值

int getNodesNum(TreeNode* cur)

2、确定终止条件（如果为空姐点的话，就返回 0，表示节点数量为 0）

if(cur == NULL) return 0;

3、确定单层递归的逻辑

int leftNum  = getNodesNum(cur->left);  // 左
int rightNum = getNodesNum(cur->right); // 右
int treeNum  = leftNum + rightNum + 1;  // 中
return treeNum;

解法：

  • C++
class Solution {
public:
    int countNodes(TreeNode* root) {
        if(root == NULL) return 0;
        int leftNum  = countNodes(root->left);
        int rightNum = countNodes(root->right);
        int result = leftNum + rightNum + 1;
        return result;
    }
};

示例 3：*

输入：root = [1]
输出：1

**思路：**可以使用层序遍历（只需要在遍历每一层时，记录节点的个数就可以），

使用递归的写法和求二叉树的深度写法类似，顺序依旧是后序（左右中）

1、确定递归的参数和返回值

int getNodesNum(TreeNode* cur)

2、确定终止条件（如果为空姐点的话，就返回 0，表示节点数量为 0）

if(cur == NULL) return 0;

3、确定单层递归的逻辑

int leftNum  = getNodesNum(cur->left);  // 左
int rightNum = getNodesNum(cur->right); // 右
int treeNum  = leftNum + rightNum + 1;  // 中
return treeNum;

解法：

  • C++
class Solution {
public:
    int countNodes(TreeNode* root) {
        if(root == NULL) return 0;
        int leftNum  = countNodes(root->left);
        int rightNum = countNodes(root->right);
        int result = leftNum + rightNum + 1;
        return result;
    }
};

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

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

相关文章

信道衰落的公式

信道衰落的公式

对于天线&#xff1a; 对于天线的面积计算&#xff1a; 天线的接收功率密度&#xff1a; 天线的接收功率&#xff1a; 移动无线信道&#xff08;I&#xff09; (xidian.edu.cn)https://web.xidian.edu.cn/zma/files/20150710_153736.pdf 更加常用的考虑了额外的信道衰落pathlo…
阅读更多...
2024 maya的散布工具sppaint3d使用指南

2024 maya的散布工具sppaint3d使用指南

目前工具其实可以分为三个版本 1 最老的原版 时间还是2011年的&#xff0c;只支持python2版的maya 2 作者python3更新版 后来作者看maya直到2022上还是没有类似好用方便的工具&#xff0c;于是更新到了2022版本 这个是原作者更新的2022版本&#xff0c;改成了python3&#…
阅读更多...
敏感字段加密 - 华为OD统一考试(E卷)

敏感字段加密 - 华为OD统一考试(E卷)

2024华为OD机试（E卷+D卷+C卷）最新题库【超值优惠】Java/Python/C++合集 题目描述 【敏感字段加密】给定一个由多个命令字组成的命令字符串: 1、字符串长度小于等于127字节，只包含大小写字母，数字，下划线和偶数个双引号; 2、命令字之间以一个或多个下划线 进行分割; 3、可…
阅读更多...
Study-Oracle-10-ORALCE19C-RAC集群搭建（一）

Study-Oracle-10-ORALCE19C-RAC集群搭建（一）

一、硬件信息及配套软件 1、硬件设置 RAC集群虚拟机：CPU:2C、内存：10G、操作系统：50G Openfile数据存储：200G （10G*2） 2、网络设置 主机名公有地址私有地址VIP共享存储（SAN）rac1192.168.49.13110.10.10.20192.168.49.141192.168.49.130rac2192.168.49.13210.10.10.3…
阅读更多...
单体到微服务架构服务演化过程

单体到微服务架构服务演化过程

架构服务化 聊聊从单体到微服务架构服务演化过程 单体分层架构 在 Web 应用程序发展的早期&#xff0c;大部分工程是将所有的服务端功能模块打包到单个巨石型&#xff08;Monolith&#xff09;应用中&#xff0c;譬如很多企业的 Java 应用程序打包为 war 包&#xff0c;最终会形…
阅读更多...
JSP(Java Server Pages)基础使用二

JSP(Java Server Pages)基础使用二

简单练习在jsp页面上输出出乘法口诀表 既然大家都是来看这种代码的人了&#xff0c;那么这种输出乘法口诀表的这种简单算法肯定是难不住大家了&#xff0c;所以这次主要是来说jsp的使用格式问题。 <%--Created by IntelliJ IDEA.User: ***Date: 2024/7/18Time: 11:26To ch…
阅读更多...
线性表二——栈stack

线性表二——栈stack

第一题 #include<bits/stdc.h> using namespace std; stack<char> s; int n; string ced;//如何匹配 出现的右括号转换成同类型的左括号&#xff0c;方便我们直接和栈顶元素 char cheak(char c){if(c)) return (;if(c]) return [;if(c}) return {;return \0;/…
阅读更多...
css边框修饰

css边框修饰

一、设置线条样式 通过 border-style 属性设置&#xff0c;可选择的一些属性如下&#xff1a; dotted&#xff1a;点线 dashed&#xff1a;虚线 solid&#xff1a;实线 double&#xff1a;双实线 效果如下&#xff1a; 二、设置边框线宽度 ① 通过 border-width 整体设置…
阅读更多...
【深度学习】深度卷积神经网络（AlexNet）

【深度学习】深度卷积神经网络（AlexNet）

在 LeNet 提出后&#xff0c;卷积神经网络在计算机视觉和机器学习领域中很有名气&#xff0c;但并未起到主导作用。 这是因为 LeNet 在更大、更真实的数据集上训练的性能和可行性还有待研究。 事实上&#xff0c;在 20 世纪 90 年代到 2012 年之间的大部分时间里&#xff0c;…
阅读更多...
时间技能物品竞品抢拍拍卖发布h5公众号小程序开源版开发

时间技能物品竞品抢拍拍卖发布h5公众号小程序开源版开发

时间技能物品竞品抢拍拍卖发布h5公众号小程序开源版开发 利用新型营销方式&#xff0c;将闲置的物品通过拍卖&#xff0c;让价格一提再提让用户趣在其中&#xff0c;营造一种不一样的购物体验! 拍卖列表页 列表页采用多分类&#xff0c;广告轮播及流动公告和拍卖商品列表组成…
阅读更多...
神经网络（二）：卷积神经网络

神经网络（二）：卷积神经网络

文章目录 一、图像的本质1.1单通道图像&#xff1a;灰度图1.2多通道图像 二、卷积神经网络2.1基本结构2.2卷积层2.2.1卷积操作2.2.2填充padding2.2.3步幅strides2.2.4多通道图像卷积&#xff1a;单卷积核2.2.5多通道图像卷积&#xff1a;多卷积核2.2.5卷积层的参数与激活函数 2…
阅读更多...
【qt】QQ仿真项目1

【qt】QQ仿真项目1

一览全局: QQ仿真项目 一.创建项目添加资源文件二.创建数据库三.自定义标题栏Qt类四.加载样式表标题栏按钮的搭配五.标题栏实现移动窗体六.标题栏按钮连接信号槽七.标题栏双击最大化和还原八.基类窗口实现标题栏按钮信号九.重写基类窗口绘图事件确保设置样式表生效十.用户登录界…
阅读更多...
Leetcode 1235. 规划兼职工作

Leetcode 1235. 规划兼职工作

1.题目基本信息 1.1.题目描述 你打算利用空闲时间来做兼职工作赚些零花钱。 这里有 n 份兼职工作&#xff0c;每份工作预计从 startTime[i] 开始到 endTime[i] 结束&#xff0c;报酬为 profit[i]。 给你一份兼职工作表&#xff0c;包含开始时间 startTime&#xff0c;结束时…
阅读更多...
第二十节：学习Redis缓存数据库实现增删改查（自学Spring boot 3.x的第五天）

第二十节：学习Redis缓存数据库实现增删改查（自学Spring boot 3.x的第五天）

这节记录下如何使用redis缓存数据库。 第一步&#xff1a; 先在服务器端安装redis&#xff0c; 下载地址&#xff1a;Releases tporadowski/redis GitHub。 第二步&#xff1a; 安装redis客户端可视化管理软件redisDesktopmanager Redis Desktop Manager - Download 第…
阅读更多...
革命题材网络电影《突进夹金山》将于10月上线

革命题材网络电影《突进夹金山》将于10月上线

“长征万里险&#xff0c;最忆夹金山”。这座雪山不仅见证了红军战士们的英勇与牺牲&#xff0c;也成为了中国革命历史上的一座重要里程碑。 革命题材网络电影《突进夹金山》&#xff0c;作为四川省2024年度重点影视剧项目以及纪念红军长征90周年献礼的红色作品&#xff0c;由谢…
阅读更多...
SPI驱动学习七（SPI_Slave_Mode驱动程序框架）

SPI驱动学习七（SPI_Slave_Mode驱动程序框架）

目录 一、SPI_Slave_Mode驱动程序框架1. Master和Slave模式差别1.1 主设备 (Master)1.2 从设备 (Slave)1.3 示例 2. SPI传输概述2.1 数据组织方式2.2 SPI控制器数据结构 3. SPI Slave Mode数据传输过程4. 如何编写程序4.1 设备树4.2 内核相关4.3 简单的示例代码4.3.1 master和s…
阅读更多...
DarkLabel2.4版本导入MOT17数据集

DarkLabel2.4版本导入MOT17数据集

目录 背景导入效果MOT17数据集说明DarkLabel导入视频导入gt文件 背景 做目标追踪&#xff0c;目前找了一圈开源工具&#xff0c;发现DarkLabel还是很好用的&#xff0c;提供自动目标跟踪&#xff0c;标注很方便。 由于目标追踪我用的是bytetrack&#xff0c;官网是用mot17数据…
阅读更多...
python爬虫案例——抓取链家租房信息（8）

python爬虫案例——抓取链家租房信息（8）

文章目录 1、任务目标2、分析网页3、编写代码1、任务目标 目标站点：链家租房版块(https://bj.lianjia.com/zufang/) 要求：抓取该链接下前5页所有的租房信息，包括：标题、详情信息、详情链接、价格 如： 2、分析网页 用浏览器打开链接，按F12或右键检查，进入开发者模式；因…
阅读更多...
5.MySQL表的约束

5.MySQL表的约束

目录 表的约束空属性&#xff08;非空约束&#xff09;默认值&#xff08;default约束&#xff09;列描述&#xff08;comment&#xff09;zerofill主键&#xff08;primary key约束&#xff09;自增长&#xff08;auto_increment&#xff09;唯一键&#xff08;unique约束&…
阅读更多...
数据集-目标检测系列-鲨鱼检测数据集 shark ＞＞ DataBall

数据集-目标检测系列-鲨鱼检测数据集 shark ＞＞ DataBall

数据集-目标检测系列-鲨鱼检测数据集 shark >> DataBall 数据集-目标检测系列-鲨鱼检测数据集 shark 数据量&#xff1a;6k 数据样例项目地址&#xff1a; gitcode: https://gitcode.com/DataBall/DataBall-detections-100s/overview github: https://github.com/Te…
阅读更多...
最新文章

Copyright @ 2022~2023