代码随想录算法训练营第十一天 | 二叉树基础

news2024/11/16 17:44:46

代码随想录算法训练营第十一天 | 二叉树基础

文章目录

  • 代码随想录算法训练营第十一天 | 二叉树基础
    • 1 二叉树的理论基础
      • 1.1 二叉树的类型
      • 1.2 二叉树的存储方式
      • 1.3 二叉树的遍历方式
      • 1.4 二叉树的定义
    • 2 二叉树的递归遍历
      • 2.1 前序遍历
      • 2.2 中序遍历
      • 2.3 后序遍历
    • 3 二叉树的迭代遍历
      • 3.1 前序遍历
      • 3.2 中序遍历
      • 3.3 后序遍历
    • 4 二叉树的统一迭代法
      • 4.1 中序遍历
      • 4.2 前序遍历
      • 4.3 后序遍历

1 二叉树的理论基础

二叉树作为408的高频考点，不管是考试还是面试我们都要好好学习一下有关二叉树的相关知识。

1.1 二叉树的类型

（1）普通二叉树

普通二叉树是最基本的二叉树结构，每个节点最多有两个子节点，分别是左子节点和右子节点，它不强制要求每个节点都有子节点，因此可能呈现出不平衡的状态。

（2）满二叉树

满二叉树是一种特殊的二叉树，每一层的节点数都达到了可能的最大值，换句话说，除了叶子节点外，每个节点都有两个子节点。一棵高度为h的满二叉树，含有 2 h − 1 2^h-1 2h−1个节点，可以对满二叉树按层序编号：约定编号从根结点(根结点编号为1)起，自上而下，自左向右。这样每个结点对应一个编号，对于编号为i的结点，若有双亲，则其双亲为i/2」,若有左孩子，则左孩子为2i；若有右孩子，则右孩子为2i+1。

在这里插入图片描述

（3）完全二叉树

完全二叉树类似于满二叉树，但最后一层的节点可以不完全填满，并且所有节点都靠左排列，它是堆结构的基础。

完全二叉树其特点如下：

①若i≤Ln/2]，则结点i为分支结点，否则为叶结点。

②叶结点只可能在层次最大的两层上出现。对于最大层次中的叶结点，都依次排列在该层最左边的位置上。

③若有度为1的结点，则只可能有一个，且该结点只有左孩子而无右孩子（重要特征)。

④按层序编号后，一旦出现某结点（编号为i）为叶结点或只有左孩子，则编号大于i的结点均为叶结点。

⑤若n为奇数，则每个分支结点都有左孩子和右孩子;若n为偶数，则编号最大的分支结点（编号为n/2）只有左孩子，没有右孩子，其余分支结点左、右孩子都有。

在这里插入图片描述

（4）二叉搜索树（BST）

二叉搜索树是一种特殊的二叉树，它对节点的排列有严格要求：任一节点的左子树只包含比该节点小的值，右子树只包含比该节点大的值，这一特性使得二叉搜索树在查找数据时非常高效。

（5）平衡二叉树（AVL树）

AVL树是一种自平衡的二叉搜索树，它要求任何节点的左右子树的高度差不能超过1，这种严格的平衡要求保证了树的查找效率。

（6）红黑树

红黑树（408考试目前还没有考察过，但估计很快就会考察简单的概念题目）是一种自平衡的二叉搜索树，它通过确保任何一条从根到叶子的路径不会包含两个连续的红色节点来保持平衡，红黑树在计算机科学中广泛应用，特别是在数据结构如map和set中。

1.2 二叉树的存储方式

（1）顺序存储

顺序存储意味着将二叉树的节点数据存放在数组中，对于完全二叉树，这种方法非常高效，数组的索引和树的节点之间有直接的关系：对于索引i的节点，其左子节点的索引是2*i + 1，右子节点的索引是2*i + 2。

在这里插入图片描述

（2）链式存储

在链式存储中，每个节点包含三部分：值、指向左子节点的指针和指向右子节点的指针，这是二叉树最常见的存储方式，因为它能有效地表示树的结构，即使是对于不完全的二叉树。

在这里插入图片描述

1.3 二叉树的遍历方式

（1）前序遍历

前序遍历首先访问根节点，然后递归地进行左子树的前序遍历，接着是右子树的前序遍历。

在这里插入图片描述

（2）中序遍历

中序遍历首先递归地进行左子树的中序遍历，然后访问根节点，最后是右子树的中序遍历，对于二叉搜索树，中序遍历可以按升序访问所有节点。

在这里插入图片描述

（3）后序遍历

后序遍历首先递归地进行左子树的后序遍历，然后是右子树的后序遍历，最后访问根节点。

在这里插入图片描述

（4）层序遍历

层次遍历按照树的层次进行，从根节点开始，然后是第二层，以此类推，通常使用队列来辅助实现这种遍历方式。

在这里插入图片描述

1.4 二叉树的定义

（1）顺序存储定义

  • Python代码定义（在Python中，顺序存储通常使用列表（数组）实现）

    class BinaryTree:
    def __init__(self, size):
        self.array = [None] * size

    def insert(self, value, index):
        if index < len(self.array):
            self.array[index] = value
        else:
            print("Index out of range.")

bt = BinaryTree(10) # 创建一个大小为10的二叉树
bt.insert(1, 0)     # 在根位置插入1
bt.insert(2, 1)     # 在左子节点位置插入2
bt.insert(3, 2)     # 在右子节点位置插入3

  • C++代码定义（在C++中，顺序存储可以使用数组或标准模板库（STL）中的vector实现）

    #include <vector>
#include <iostream>

class BinaryTree {
public:
    std::vector<int> array;

    BinaryTree(int size) {
        array.resize(size, -1); // 初始化为-1，代表空节点
    }

    void insert(int value, int index) {
        if (index < array.size()) {
            array[index] = value;
        } else {
            std::cout << "Index out of range." << std::endl;
        }
    }
};

int main() {
    BinaryTree bt(10);
    bt.insert(1, 0);  // 在根位置插入1
    bt.insert(2, 1);  // 在左子节点位置插入2
    bt.insert(3, 2);  // 在右子节点位置插入3
    return 0;
}

（2）链式存储定义

  • Python代码定义

    class TreeNode:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None

class BinaryTree:
    def __init__(self, root=None):
        self.root = root

root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
bt = BinaryTree(root)

  • C++代码定义

    #include <iostream>

struct TreeNode {
    int value;
    TreeNode *left, *right;

    TreeNode(int val) : value(val), left(nullptr), right(nullptr) {}
};

class BinaryTree {
public:
    TreeNode *root;
    BinaryTree() : root(nullptr) {}
};

int main() {
    BinaryTree bt;
    bt.root = new TreeNode(1);
    bt.root->left = new TreeNode(2);
    bt.root->right = new TreeNode(3);
    return 0;
}

2 二叉树的递归遍历

2.1 前序遍历

（1）Python版本代码

# 前序遍历-递归-LC144_二叉树的前序遍历
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []

        left = self.preorderTraversal(root.left)
        right = self.preorderTraversal(root.right)

        return  [root.val] + left +  right

（2）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;
    }
};

下面是王道数据结构上面的二叉树前序遍历代码：

在这里插入图片描述

2.2 中序遍历

（1）Python版本代码

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;
    }
};

（2）C++版本代码

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

下面是王道数据结构上面的二叉树中序遍历代码：

在这里插入图片描述

2.3 后序遍历

（1）Python版本代码

# 后序遍历-递归-LC145_二叉树的后序遍历
class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []

        left = self.postorderTraversal(root.left)
        right = self.postorderTraversal(root.right)

        return left + right + [root.val]

（2）C++版本代码

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

下面是王道数据结构上面的二叉树后序遍历代码：

在这里插入图片描述

下面是王道数据结构上面树这一章中关于二叉树的递归算法实现的介绍：

下面用带箭头的虚线表示了这三种遍历算法的递归执行过程。其中，向下的箭头表示更深一层的递归调用，向上的箭头表示从递归调用退出返回; ,虚线旁的三角形、圆形和方形内的字符分别表示在先序、中序和后序遍历的过程中访问根结点时输出的信息。例如，由于中序遍历中访问结点是在遍历左子树之后、遍历右子树之前进行的，则带圆形的字符标在向左递归返回和向右递归调用之间。由此，只要沿虚线从1出发到2结束，将沿途所见的三角形(或圆形或方形)内的字符记下，便得到遍历二叉树的先序(或中序或后序）序列。例如在下图中，沿虚线游走可以分别得到先序序列为ABDEC、中序序列为DBEAC、后序序列为DEBCA。

在这里插入图片描述

3 二叉树的迭代遍历

3.1 前序遍历

在前序遍历中，我们首先访问根节点，然后左节点，最后右节点。使用栈来实现时，我们首先将根节点放入栈中，然后循环直到栈为空，在每次循环中，我们取出栈顶元素，访问它，然后先将其右子节点压入栈（如果有），再将左子节点压入栈（如果有）。

（1）Python版本代码

def preorder_traversal(root):
    if not root:
        return []

    stack, output = [root, ], []
    while stack:
        node = stack.pop()  # 弹出栈顶元素
        if node:
            output.append(node.value)  # 访问节点
            if node.right:  # 如果存在右子节点，先压入栈
                stack.append(node.right)
            if node.left:  # 如果存在左子节点，后压入栈
                stack.append(node.left)
    return output

（2）C++版本代码

vector<int> preorderTraversal(TreeNode* root) {
    vector<int> result;
    if (!root) return result;

    stack<TreeNode*> stack;
    stack.push(root);

    while (!stack.empty()) {
        TreeNode* node = stack.top(); stack.pop(); // 弹出栈顶元素
        if (node) {
            result.push_back(node->value); // 访问节点
            if (node->right) stack.push(node->right); // 先将右子节点压入栈
            if (node->left) stack.push(node->left); // 再将左子节点压入栈
        }
    }
    return result;
}

3.2 中序遍历

在中序遍历中，我们首先访问最左侧节点，然后根节点，最后右节点。使用栈实现时，我们从根节点开始，首先将所有左侧节点压入栈中，然后弹出栈顶元素访问，再处理这个节点的右子树。

（1）Python版本代码

def inorder_traversal(root):
    stack, output = [], []
    current = root

    while current or stack:
        while current:
            stack.append(current)  # 将左子节点压入栈
            current = current.left
        current = stack.pop()  # 弹出栈顶元素
        output.append(current.value)  # 访问节点
        current = current.right  # 转到右子树

    return output

（2）C++版本代码

vector<int> inorderTraversal(TreeNode* root) {
    vector<int> result;
    stack<TreeNode*> stack;
    TreeNode* current = root;

    while (current || !stack.empty()) {
        while (current) {
            stack.push(current); // 将左子节点压入栈
            current = current->left;
        }
        current = stack.top(); stack.pop(); // 弹出栈顶元素
        result.push_back(current->value); // 访问节点
        current = current->right; // 转到右子树
    }
    return result;
}

3.3 后序遍历

后序遍历的顺序是先左节点，然后右节点，最后根节点。其非递归的实现是三种遍历方法中最难的，因为在后序遍历中，要保证左孩子和右孩子都已被访问并且左孩子在右孩子前访问才能访问根节点，我们使用栈实现时，我们可以利用前序遍历的顺序，首先访问根节点，然后右节点，最后左节点，并将结果逆序输出。

（1）Python版本代码

def postorder_traversal(root):
    if not root:
        return []

    stack, output = [root, ], []
    while stack:
        node = stack.pop()  # 弹出栈顶元素
        if node:
            output.append(node.value)  # 访问节点
            if node.left:  # 如果存在左子节点，先压入栈
                stack.append(node.left)
            if node.right:  # 如果存在右子节点，后压入栈
                stack.append(node.right)
    return output[::-1]  # 反转输出结果

（2）C++版本代码

vector<int> postorderTraversal(TreeNode* root) {
    vector<int> result;
    if (!root) return result;

    stack<TreeNode*> stack;
    stack.push(root);

    while (!stack.empty()) {
        TreeNode* node = stack.top(); stack.pop(); // 弹出栈顶元素
        if (node) {
            result.push_back(node->value); // 访问节点
            if (node->left) stack.push(node->left); // 先将左子节点压入栈
            if (node->right) stack.push(node->right); // 再将右子节点压入栈
        }
    }
    reverse(result.begin(), result.end()); // 反转输出结果
    return result;
}

在这些实现中，我们使用栈来模拟递归过程，栈的特性（后进先出）允许我们以非递归的方式来实现树的深度优先遍历，对于前序和后序遍历，我们都是先处理右子树，以确保左子树先被处理。对于中序遍历，我们首先迭代地将所有左子树压入栈中，然后处理节点，并转向右子树。

4 二叉树的统一迭代法

因为统一风格的迭代法并不好理解，而且在面试中也不好直接写，不如递归法简单，所以在这里我就不做过多的研究，感兴趣的可以去卡哥的代码随想录：二叉树的统一迭代法去看看，这里我就只贴出卡哥的代码。

4.1 中序遍历

中序遍历代码如下：（详细注释）

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if (root != NULL) st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node != NULL) {
                st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
                if (node->right) st.push(node->right);  // 添加右节点（空节点不入栈）

                st.push(node);                          // 添加中节点
                st.push(NULL); // 中节点访问过，但是还没有处理，加入空节点做为标记。

                if (node->left) st.push(node->left);    // 添加左节点（空节点不入栈）
            } else { // 只有遇到空节点的时候，才将下一个节点放进结果集
                st.pop();           // 将空节点弹出
                node = st.top();    // 重新取出栈中元素
                st.pop();
                result.push_back(node->val); // 加入到结果集
            }
        }
        return result;
    }
};

4.2 前序遍历

迭代法前序遍历代码如下： (注意此时我们和中序遍历相比仅仅改变了两行代码的顺序)

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if (root != NULL) st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node != NULL) {
                st.pop();
                if (node->right) st.push(node->right);  // 右
                if (node->left) st.push(node->left);    // 左
                st.push(node);                          // 中
                st.push(NULL);
            } else {
                st.pop();
                node = st.top();
                st.pop();
                result.push_back(node->val);
            }
        }
        return result;
    }
};

4.3 后序遍历

后序遍历代码如下： (注意此时我们和中序遍历相比仅仅改变了两行代码的顺序)

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if (root != NULL) st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node != NULL) {
                st.pop();
                st.push(node);                          // 中
                st.push(NULL);

                if (node->right) st.push(node->right);  // 右
                if (node->left) st.push(node->left);    // 左

            } else {
                st.pop();
                node = st.top();
                st.pop();
                result.push_back(node->val);
            }
        }
        return result;
    }
};

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

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

相关文章

【QT+QGIS跨平台编译】之十：【libbz2+Qt跨平台编译】（一套代码、一套框架，跨平台编译）

【QT+QGIS跨平台编译】之十：【libbz2+Qt跨平台编译】（一套代码、一套框架，跨平台编译）

文章目录 一、libbz2介绍二、文件下载三、文件分析四、pro文件五、编译实践一、libbz2介绍 bzip2是一个基于Burrows-Wheeler 变换的无损压缩软件，压缩效果比传统的LZ77/LZ78压缩算法来得好。它是一款免费软件。可以自由分发免费使用。 bzip2能够进行高质量的数据压缩。它利用…
阅读更多...
SpringBoot-yml文件的配置与读取

SpringBoot-yml文件的配置与读取

配置 值前边必须要有空格&#xff0c;作为分隔符 使用空格作为缩进表示层级关系&#xff0c;相同的层级左侧对齐 获取 使用Value(”${键名}”) 使用ConfigurationProperties(prefix "前缀") 1.前缀要与yml配置文件中的前缀一致 2.实体类的字段名与配置文件中的键名一…
阅读更多...
linux conda 配置 stable video diffusion

linux conda 配置 stable video diffusion

安装教程 1 下载仓库源码 git clone https://github.com/Stability-AI/generative-models.git2 创建conda环境 conda create -n svd python3.10 conda activate svd3 安装pytorch gpu cuda和cudnn请参考其他链接配置&#xff0c;使用 conda 或者 pip 安装 pytorch # 使用c…
阅读更多...
第二集《闻法仪轨》

第二集《闻法仪轨》

请大家打开讲义第三面&#xff0c;甲二、于法、法师发起承事。 我们身为一个大乘的佛弟子&#xff0c;我们这一念明了的心&#xff0c;在一生当中&#xff0c;会遇到很多很多的佛法&#xff0c;也会遇到很多很多的法师&#xff0c;但不是所有的法师跟佛法对我们都是帮助的&…
阅读更多...
EasyCVR视频智能监管系统方案设计与应用

EasyCVR视频智能监管系统方案设计与应用

随着科技的发展&#xff0c;视频监控平台在各个领域的应用越来越广泛。然而&#xff0c;当前的视频监控平台仍存在一些问题&#xff0c;如视频质量不高、监控范围有限、智能化程度不够等。这些问题不仅影响了监控效果&#xff0c;也制约了视频监控平台的发展。 为了解决这些问…
阅读更多...
HCIA——29HTTP、万维网、HTML、PPP、ICMP；万维网的工作过程；HTTP 的特点HTTP 的报文结构的选择、解答

HCIA——29HTTP、万维网、HTML、PPP、ICMP；万维网的工作过程；HTTP 的特点HTTP 的报文结构的选择、解答

学习目标&#xff1a; 计算机网络 1.掌握计算机网络的基本概念、基本原理和基本方法。 2.掌握计算机网络的体系结构和典型网络协议&#xff0c;了解典型网络设备的组成和特点&#xff0c;理解典型网络设备的工作原理。 3.能够运用计算机网络的基本概念、基本原理和基本方法进行…
阅读更多...
Javaweb之SpringBootWeb案例之阿里云OSS服务入门的详细解析

Javaweb之SpringBootWeb案例之阿里云OSS服务入门的详细解析

2.3.2 入门 阿里云oss 对象存储服务的准备工作我们已经完成了&#xff0c;接下来我们就来完成第二步操作&#xff1a;参照官方所提供的sdk示例来编写入门程序。 首先我们需要来打开阿里云OSS的官方文档&#xff0c;在官方文档中找到 SDK 的示例代码&#xff1a; 参照官方提供…
阅读更多...
爬取第一试卷网高三数学试卷并下载到本地

爬取第一试卷网高三数学试卷并下载到本地

import requests import re import os filename 试卷\\ if not os.path.exists(filename):os.mkdir(filename) url https://www.shijuan1.com/a/sjsxg3/list_727_1.html headers {"User-Agent":"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.…
阅读更多...
【QT+QGIS跨平台编译】之九：【LZ4+Qt跨平台编译】（一套代码、一套框架，跨平台编译）

【QT+QGIS跨平台编译】之九：【LZ4+Qt跨平台编译】（一套代码、一套框架，跨平台编译）

文章目录 一、LZ4介绍二、文件下载三、文件分析四、pro文件五、编译实践一、LZ4介绍 LZ4是一种无损压缩算法，压缩速度为每核心400MB/s。 LZ4是目前效率最高的压缩算法，更加侧重于压缩/解压缩速度，压缩比并不突出，本质上就是时间换空间。 LZ4库是使用BSD许可证作为开放源码…
阅读更多...
Dockerfile里ADD * 保留原来的目录结构

Dockerfile里ADD * 保留原来的目录结构

1、问题 给新模块写Dockerfile&#xff0c;很多静态资源分散在各个目录&#xff0c;于是Dockerfile里我直接一句&#xff1a; ADD ./* /dest/镜像出来后&#xff0c;启动容器&#xff0c;进入容器种后发现&#xff1a;文件拷贝成功&#xff0c;但原来的目录结构都不在了&…
阅读更多...
HCIE之BGP正则表达式（四）

HCIE之BGP正则表达式（四）

BGP 一、AS-Path正则表达式数字| 等同于或的关系[]和.$ 一个字符串的结束_代表任意^一个字符串的开始()括号包围的是一个组合\ 转义字符* 零个或多个&#xff1f;零个或一个一个或多个 二、BGP对等体组 一、AS-Path正则表达式 正则表达式是按照一定模版匹配字符串的公式 AR3上…
阅读更多...
Java面试题(6)

Java面试题(6)

28.创建线程池有哪几种方式 newFixedThreadPool(int nThreads) &#xff1a;创建一个固定长度的线程池&#xff0c;如果有线程发生错误而结束&#xff0c; 线程池会补充一个新线程。 newCachedThreadPool() &#xff1a;创建一个可缓存的线程池&#xff0c;会自动回收和创建空…
阅读更多...
小黑艰难的前端啃bug之路:内联元素之间的间隙问题

小黑艰难的前端啃bug之路:内联元素之间的间隙问题

今天开始学习前端项目&#xff0c;遇到了一个Bug调了好久&#xff0c;即使margin为0&#xff0c;但还是有空格。 小黑整理&#xff0c;用四种方法解决了空白问题 <!DOCTYPE html> <html><head><meta charset"utf-8"><title></tit…
阅读更多...
关于达梦认证DCA DCP，TIDB认证PCTA PCTP考试那点事儿

关于达梦认证DCA DCP，TIDB认证PCTA PCTP考试那点事儿

文章最后有彩蛋&#xff0c;一定要看到最后... 一、正确的道路上遇到正确的你 伴随中国数据库领域的快速技术进步&#xff0c;国内数据库生态蓬勃发展&#xff0c;并不断涌现出极具创新力的产品&#xff0c;推动了数据库应用的遍地开花。截至2024年1月&#xff0c;墨天轮数据社…
阅读更多...
基于 MQTT 的开源桥接器：自由控制物联网设备 | 开源日报 No.151

基于 MQTT 的开源桥接器：自由控制物联网设备 | 开源日报 No.151

Koenkk/zigbee2mqtt Stars: 10.5k License: GPL-3.0 Zigbee2MQTT 是一个 Zigbee &#x1f41d; 到 MQTT 桥接器 &#x1f309;&#xff0c;可以摆脱专有的 Zigbee 桥接器 &#x1f528; 允许您在不使用供应商桥接器或网关的情况下使用 Zigbee 设备通过 MQTT 桥接事件并控制 Z…
阅读更多...
目标检测数据集 - 车辆检测数据集下载「包含VOC、COCO、YOLO三种格式」

目标检测数据集 - 车辆检测数据集下载「包含VOC、COCO、YOLO三种格式」

数据集介绍&#xff1a;车辆检测数据集&#xff0c;真实场景高质量图片数据&#xff0c;涉及场景丰富&#xff0c;比如城市道路车辆、高速道路车辆、农村道路车辆、车辆遮挡、车辆严重遮挡数据等&#xff0c;且类别丰富&#xff0c;划分为 "Ambulance"、"Bus&qu…
阅读更多...
工业4.0开放平台通信 统一架构OPC UA的一种测试方法

工业4.0开放平台通信 统一架构OPC UA的一种测试方法

工业4.0和工业物联网&#xff08;Industrial Internet of Things, IIoT&#xff09;的核心挑战在于设备、机器以及来自不同行业服务之间的安全和标准化的数据和信息交换。 2016年11月工业4.0平台发布了指导纲要《工业4.0产品需要实现哪些准则》&#xff0c;即对于所有位于工业…
阅读更多...
C语言的模型玩具：结构体的使用以及操作符优先级

C语言的模型玩具：结构体的使用以及操作符优先级

各位少年&#xff0c;大家好&#xff0c;我是博主那一脸阳光&#xff0c;今天分享结构体的使用&#xff0c;声明以及操作符的使用。 前言&#xff1a; 如果你想做一块月饼&#xff0c;你要学习它的制作方法&#xff0c;需要准备面粉&#xff0c;白砂糖&#xff0c;奶粉&…
阅读更多...
再识C语言 DAY12 【再识函数（上）】

再识C语言 DAY12 【再识函数（上）】

文章目录 前言一、函数是什么&#xff1f;二、自定义函数参数返回值void修饰函数的返回值和参数 函数不能嵌套定义形参和实参的区别return的用法补充if……else if……else……的用法 后面会讲解“函数调用&#xff0c;函数声明以及函数原型&#xff0c;块级变量&#xff0c;归…
阅读更多...
微软成立了一个新的人工智能团队，专注于小型模型开发

微软成立了一个新的人工智能团队，专注于小型模型开发

每周跟踪AI热点新闻动向和震撼发展 想要探索生成式人工智能的前沿进展吗&#xff1f;订阅我们的简报&#xff0c;深入解析最新的技术突破、实际应用案例和未来的趋势。与全球数同行一同&#xff0c;从行业内部的深度分析和实用指南中受益。不要错过这个机会&#xff0c;成为AI领…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023