一些c++容器的基本操作

vector

向量（Vector）是STL中最常用的容器之一，它提供了动态数组的功能，支持随机访问和动态调整大小。下面是向量的一些基本操作：

  • 创建向量：
#include <vector> 
std::vector<int> vec; 
// 创建一个空的整型向量
  • 向向量中添加元素：
vec.push_back(10); 
// 在向量末尾添加元素10
  • 获取向量的大小：
int size = vec.size(); 
// 获取向量中元素的个数
  • 访问向量中的元素：
int firstElement = vec[0]; 
// 访问第一个元素 int lastElement = vec.back(); 
// 访问最后一个元素
  • 遍历向量中的元素：
for (int i = 0; i < vec.size(); ++i) { std::cout << vec[i] << " "; 
}

或者使用 C++11 中的范围遍历：

for (int element : vec) { std::cout << element << " "; 
}
  • 删除向量中的元素：
vec.pop_back(); 
// 删除向量末尾的元素
  • 清空向量：
vec.clear(); 
// 清空向量中的所有元素

这些是向量的一些基本操作，可以用来创建、添加、访问、遍历、删除和清空向量中的元素。

需要注意的是，向量支持动态调整大小，因此在需要时可以动态地添加或删除元素。

stack

栈（Stack）是一种后进先出（LIFO）的数据结构，它的基本操作包括：

  • 创建栈：
#include <stack> 
std::stack<int> myStack; 
// 创建一个空的整数栈
  • 向栈顶压入元素：
myStack.push(10); 
// 将元素10压入栈顶
  • 从栈顶弹出元素：
myStack.pop(); 
// 弹出栈顶元素（10）
  • 访问栈顶元素：
int topElement = myStack.top(); 
// 获取栈顶元素的值（不弹出）
  • 检查栈是否为空：
if (myStack.empty()) { // 栈为空 } 
else { // 栈不为空 }
  • 获取栈中元素的个数：
int size = myStack.size(); 
// 获取栈中元素的个数

栈是一种非常常见的数据结构，在许多情况下都非常有用，例如函数调用、表达式求值等。

它提供了一种后进先出的存储方式，使得最后进入栈的元素最先被访问。

queue

队列（Queue）是一种先进先出（FIFO）的容器，通常用于在数据结构中保存元素，并且按照它们进入队列的顺序进行处理。以下是队列的基本操作：

  • 创建队列：
#include <queue> 
std::queue<int> q;// 创建一个空的整型队列
  • 向队列中添加元素：
q.push(10); 
// 将元素10添加到队列末尾
  • 访问队列中的元素：

由于队列是先进先出的数据结构，因此不能像向量一样直接访问任意位置的元素。只能访问队列的头部元素。

int frontElement = q.front(); 
// 获取队列头部的元素值，但不会删除元素
  • 删除队列中的元素：
q.pop(); 
// 删除队列头部的元素
  • 检查队列是否为空：
if (q.empty()) { // 队列为空 } 
else { // 队列不为空 }
  • 获取队列中的元素个数：
int size = q.size(); 
// 获取队列中元素的个数

队列的基本操作主要包括创建队列、添加元素、访问元素、删除元素、检查队列是否为空以及获取队列中的元素个数。

需要注意的是，队列只允许在队列的一端添加元素（尾部），在另一端删除元素（头部），并且只能访问头部的元素。

set

集合（Set）是一种关联容器，其中的元素是唯一的，并且按照一定的排序规则进行自动排序。以下是集合的基本操作：

  • 创建集合：
#include <set> 
std::set<int> mySet; 
// 创建一个空的整数集合
  • 向集合中添加元素：
mySet.insert(10); 
// 向集合中插入元素10 mySet.insert(20); 
// 向集合中插入元素20
  • 从集合中删除元素：
mySet.erase(10); 
// 从集合中删除元素10
  • 检查集合中是否存在某个元素：
if (mySet.find(20) != mySet.end()) { // 集合中存在元素20 } 
else { // 集合中不存在元素20 }
  • 获取集合中的元素个数：
int size = mySet.size(); 
// 获取集合中元素的个数
  • 遍历集合中的元素：
for (const auto& element : mySet) { std::cout << element << std::endl; 
}
  • 清空集合：
mySet.clear(); 
// 清空集合，使其不包含任何元素

集合中的元素是唯一的，并且按照一定的排序规则进行自动排序。因此，插入、删除和查找元素的操作都具有较高的效率。集合提供了一种方便的方式来管理一组唯一的元素。

map

映射（Map）是一种关联容器，它将键和值一一对应存储，并且根据键的排序规则自动排序。以下是映射的基本操作：

  • 创建映射：
#include <map> 
std::map<std::string, int> myMap; 
// 创建一个空的映射，键为字符串，值为整数
  • 向映射中添加键值对：
myMap["apple"] = 10; 
// 向映射中添加键值对<"apple", 10> myMap["banana"] = 20; 
// 向映射中添加键值对<"banana", 20>
  • 访问映射中的元素：
int value = myMap["apple"];// 获取键为"apple"的值// 如果键不存在会插入一个新的键值对，值为默认值（对于整数，值为0）
  • 删除映射中的元素：
myMap.erase("banana"); 
// 删除键为"banana"的键值对
  • 检查映射中是否存在某个键：
if (myMap.find("apple") != myMap.end()) { // 存在键"apple" } 
else { // 不存在键"apple" }
  1. 获取映射中的元素个数：
int size = myMap.size(); 
// 获取映射中键值对的个数
  1. 遍历映射中的键值对：
for (const auto& pair : myMap) { std::cout << "Key: " << pair.first << ", Value: " << pair.second << std::endl; 
}

也可以使用 C++11 中的结构化绑定：

for (auto& [first, second] : myMap) { std::cout << "Key: " << first << ", Value: " << second << std::endl; 
}

这些是映射的基本操作，可以用来创建映射、添加键值对、访问元素、删除元素、检查键是否存在、获取元素个数以及遍历键值对。

映射中的键值对是按照键的排序规则自动排序的。

priority_queue

优先队列（Priority Queue）是一种特殊的队列，其中的元素按照一定的优先级顺序进行排列，具有较高优先级的元素先被取出。其基本操作包括：

  • 创建优先队列：
#include <queue> 
std::priority_queue<int> myPriorityQueue; 
// 创建一个空的整数优先队列，默认按照降序排序#include <queue> 
std::priority_queue<int, vector<int>, greater<int>> myPriorityQueue; 
// 创建一个空的整数优先队列，并且按照升序排序
  • 向优先队列中插入元素：
myPriorityQueue.push(10); 
// 插入元素10 myPriorityQueue.push(20); 
// 插入元素20
  • 从优先队列中取出优先级最高的元素：
int topElement = myPriorityQueue.top(); 
// 获取优先级最高的元素值（不弹出）
  • 从优先队列中删除优先级最高的元素：
myPriorityQueue.pop(); 
// 弹出优先级最高的元素
  • 检查优先队列是否为空：
if (myPriorityQueue.empty()) { // 优先队列为空 } 
else { // 优先队列不为空 }
  • 获取优先队列中元素的个数：
int size = myPriorityQueue.size(); 
// 获取优先队列中元素的个数

优先队列常用于需要按照优先级处理元素的场景，例如任务调度、事件处理等。

默认情况下，优先队列按照元素的值进行降序排序，但也可以通过自定义比较函数或使用自定义类型来改变排序方式。

deque

双端队列（Deque）是一种序列容器，允许在两端进行插入和删除操作。以下是双端队列的基本操作：

  • 创建双端队列：
#include <deque> 
std::deque<int> dq; 
// 创建一个空的整型双端队列
  • 向双端队列中添加元素：
dq.push_back(10); 
// 在队列尾部添加元素10 dq.push_front(20); 
// 在队列头部添加元素20
  • 访问双端队列中的元素：
int backElement = dq.back(); 
// 获取队列尾部的元素值，但不会删除元素 int frontElement = dq.front(); 
// 获取队列头部的元素值，但不会删除元素
  • 删除双端队列中的元素：
dq.pop_back(); 
// 删除队列尾部的元素 dq.pop_front(); 
// 删除队列头部的元素
  • 检查双端队列是否为空：
if (dq.empty()) { // 队列为空 } 
else { // 队列不为空 }
  • 获取双端队列中的元素个数：
int size = dq.size(); 
// 获取队列中元素的个数
  • 访问双端队列中的元素（随机访问）：

与向量类似，双端队列也支持随机访问，可以使用索引访问队列中的元素。

int element = dq[2]; 
// 访问队列中索引为2的元素值

双端队列的基本操作主要包括创建队列、添加元素、访问元素、删除元素、检查队列是否为空以及获取队列中的元素个数。

与队列不同的是，双端队列允许在两端进行插入和删除操作，因此具有更灵活的使用方式。

unordered_map

unordered_map（无序映射）是C++中的一种关联容器，它提供了键值对的存储和检索，并且具有快速的查找速度。它的基本操作包括：

  • 创建unordered_map：
#include <unordered_map> 
std::unordered_map<std::string, int> myMap; 
// 创建一个空的无序映射，键为string类型，值为int类型
  • 向unordered_map中插入键值对：
myMap["apple"] = 10; 
// 插入键为"apple"，值为10的键值对 myMap["banana"] = 20; 
// 插入键为"banana"，值为20的键值对
  • 从unordered_map中访问元素：
int value = myMap["apple"]; 
// 获取键为"apple"的值
  • 检查unordered_map中是否存在某个键：
if (myMap.find("apple") != myMap.end()) { // 键"apple"存在于unordered_map中 } 
else { // 键"apple"不存在于unordered_map中 }
  • 删除unordered_map中的键值对：
myMap.erase("banana"); 
// 删除键为"banana"的键值对
  • 获取unordered_map中键值对的个数：
int size = myMap.size(); 
// 获取unordered_map中键值对的个数

unordered_map提供了快速的查找速度，其查找操作的平均时间复杂度为常数级别（O(1)），但不保证元素的顺序。

在某些情况下，unordered_map比map更适合，尤其是对于大量数据而言。

unordered_set

unordered_set（无序集合）是C++中的一种关联容器，它存储唯一的元素，且不按照任何顺序组织它们。它的基本操作包括：

  • 创建unordered_set：
#include <unordered_set> 
std::unordered_set<int> mySet; 
// 创建一个空的无序集合，存储整数类型元素
  • 向unordered_set中插入元素：
mySet.insert(10); 
// 向无序集合中插入元素10 mySet.insert(20); 
// 向无序集合中插入元素20
  • 检查unordered_set中是否存在某个元素：
if (mySet.find(10) != mySet.end()) { // 元素10存在于无序集合中 } 
else { // 元素10不存在于无序集合中 }
  • 删除unordered_set中的元素：
mySet.erase(20); 
// 删除元素20
  • 获取unordered_set中元素的个数：
int size = mySet.size(); 
// 获取无序集合中元素的个数

unordered_set提供了快速的查找和插入速度，其查找和插入操作的平均时间复杂度为常数级别（O(1)）。

由于不会维护元素的顺序，因此在某些情况下，unordered_set比set更适合。

multiset

multiset（多重集合）是C++中的一种关联容器，它允许存储重复的元素，并按照一定的排序规则组织它们。它的基本操作与set类似，但允许存储相同的元素。基本操作包括：

  • 创建multiset：
#include <set> 
std::multiset<int> myMultiset; 
// 创建一个空的多重集合，存储整数类型元素，默认按照升序排序
  • 向multiset中插入元素：
myMultiset.insert(10); 
// 向多重集合中插入元素10 myMultiset.insert(20); 
// 向多重集合中插入元素20 myMultiset.insert(20); 
// 向多重集合中再次插入元素20，允许重复插入
  • 从multiset中访问元素：
// 可以通过迭代器遍历multiset中的元素 
for (auto it = myMultiset.begin(); it != myMultiset.end(); ++it) { std::cout << *it << " "; 
}
  • 检查multiset中是否存在某个元素：
if (myMultiset.find(10) != myMultiset.end()) { // 元素10存在于多重集合中 } 
else { // 元素10不存在于多重集合中 }
  • 删除multiset中的元素：
myMultiset.erase(20); 
// 删除元素20，只删除一个匹配项
  • 获取multiset中元素的个数：
int size = myMultiset.size(); 
// 获取多重集合中元素的个数，包括重复的元素

multiset中的元素按照排序规则组织，因此它是有序的容器。

相比于set，multiset允许存储重复的元素，并且可以方便地统计重复元素的个数。

tuple

Tuple（元组）是C++中的一种标准库容器，用于存储固定数量的对象。元组中的对象可以是不同的类型，且元组的大小在编译时确定。基本操作包括：

  • 创建tuple：
#include <tuple> 
std::tuple<int, double, std::string> myTuple(10, 3.14, "hello"); 
// 创建一个包含int、double和string类型对象的元组
  • 访问tuple中的元素：
int intValue = std::get<0>(myTuple); 
// 获取第一个元素（整数） double doubleValue = std::get<1>(myTuple); 
// 获取第二个元素（双精度浮点数） std::string stringValue = std::get<2>(myTuple); 
// 获取第三个元素（字符串）
  • 修改tuple中的元素：
std::get<0>(myTuple) = 20; 
// 修改第一个元素的值为20
  • 将tuple中的元素解包到变量中：
int a; 
double b;
std::string c; 
std::tie(a, b, c) = myTuple; 
// 将元组中的元素解包到变量a、b、c中
  • 比较tuple：

使用std::tuple进行比较时，会按照元素的顺序逐个比较。

std::tuple<int, int> tuple1(1, 2); 
std::tuple<int, int> tuple2(1, 3); 
if (tuple1 < tuple2) { // tuple1小于tuple2 } 
else { // tuple1大于或等于tuple2 }

Tuple可以在不引入新的数据结构的情况下，方便地将多个值打包为一个单元，并支持解包操作。由于元组中的对象类型不必相同，因此在一些特定场景下使用十分方便。

array

在C++中，std::array 是一个模板类，提供了类似于数组的功能，但是具有更多的特性和安全性。它具有固定大小，并且在创建后大小不能更改。以下是 std::array 的基本操作：

  • 创建 array：
#include <array> 
std::array<int, 5> myArray; 
// 创建一个包含5个整数的数组
  • 访问 array 中的元素：
myArray[0] = 10; 
// 给数组的第一个元素赋值为 10 int value = myArray[1]; 
// 获取数组的第二个元素的值
  • 获取 array 的大小：
int size = myArray.size(); 
// 获取数组的大小，这里将返回5
  • 遍历 array 中的元素：
for (const auto& element : myArray) { cout << element << endl;
}
  • 使用迭代器访问 array 中的元素：
for (auto it = myArray.begin(); it != myArray.end(); ++it) { cout << *it << endl; 
}
  • 初始化 array：
std::array<int, 3> anotherArray = {1, 2, 3}; 
// 使用初始化列表初始化数组
  • 比较 array：
std::array<int, 3> array1 = {1, 2, 3}; 
std::array<int, 3> array2 = {1, 2, 3}; if (array1 == array2) { // 两个数组相等 } 
else { // 两个数组不相等 }
  • 填充 array：
myArray.fill(0); 
// 将数组中的所有元素填充为0

std::array 提供了数组的很多功能，并且更加安全和方便，因为它提供了许多与容器一样的操作，比如 size()、begin()、end() 等，同时还支持初始化列表和比较操作。

list

链表（List）是一种线性数据结构，它的基本操作包括：

  • 创建链表：
#include <list> 
std::list<int> myList; 
// 创建一个空的整数链表
  • 向链表中添加元素：
myList.push_back(10); 
// 在链表尾部添加元素10 myList.push_front(20); 
// 在链表头部添加元素20
  • 从链表中删除元素：
myList.pop_back(); 
// 删除链表尾部的元素 myList.pop_front(); 
// 删除链表头部的元素
  • 访问链表中的元素：
int frontElement = myList.front(); 
// 获取链表头部的元素值 int backElement = myList.back(); 
// 获取链表尾部的元素值
  • 检查链表是否为空：
if (myList.empty()) { // 链表为空 } 
else { // 链表不为空 }
  • 获取链表中元素的个数：
int size = myList.size(); 
// 获取链表中元素的个数
  • 在链表中进行遍历：
for (const auto& element : myList) { // 对链表中的每个元素执行操作 
}

链表是一种非常灵活的数据结构，它允许在任意位置插入和删除元素，因此在某些场景下比数组更为适用。

链表的操作复杂度取决于操作的位置，而不是链表的长度。

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

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

相关文章

【Text2SQL】WikiSQL 数据集与 Seq2SQL 模型

【Text2SQL】WikiSQL 数据集与 Seq2SQL 模型

论文&#xff1a;Seq2SQL: Generating Structured Queries from Natural Language using Reinforcement Learning ⭐⭐⭐⭐⭐ ICLR 2018 Dataset: github.com/salesforce/WikiSQL Code&#xff1a;Seq2SQL 模型实现 一、论文速读 本文提出了 Text2SQL 方向的一个经典数据集 —…
阅读更多...
Linux--10---安装JDK、MySQL

Linux--10---安装JDK、MySQL

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 安装JDK[Linux命令--03----JDK .Nginx. 数据库](https://blog.csdn.net/weixin_48052161/article/details/108997148) 第一步 查询系统中自带的JDK第二步 卸载系统中…
阅读更多...
刀片式服务器是什么？

刀片式服务器是什么？

什么是刀片式服务器&#xff1f; 刀片式服务器是服务器的一种&#xff0c;能够在标准高度的机架式机箱中插装多个卡式的服务器单元&#xff0c;是专门为特殊应用行业和高密度计算环境专门设计的&#xff0c;主要的结构是一大型主体机箱&#xff0c;内部可以插入许多“刀片”。 …
阅读更多...
Unity Physics入门

Unity Physics入门

概述 在unity中物理属性是非常重要的&#xff0c;它可以模拟真实物理的效果在unity中&#xff0c;其中的组件是非常多的&#xff0c;让我们来学习一下这部分的内容吧。 Unity组件入门篇总目录----------点击导航 Character Controller(角色控制) 说明&#xff1a;组件是Unity提…
阅读更多...
华为编程题目（实时更新）

华为编程题目（实时更新）

1.大小端整数 计算机中对整型数据的表示有两种方式&#xff1a;大端序和小端序&#xff0c;大端序的高位字节在低地址&#xff0c;小端序的高位字节在高地址。例如&#xff1a;对数字 65538&#xff0c;其4字节表示的大端序内容为00 01 00 02&#xff0c;小端序内容为02 00 01…
阅读更多...
Java数据结构与算法(平衡二叉树)

Java数据结构与算法(平衡二叉树)

前言 平衡二叉树是为了提高二叉树的查询速度&#xff0c;通过满足特定的条件来保持其平衡性。平衡二叉树具有以下特点&#xff1a; 左子树和右子树的高度差不会大于1&#xff0c;这是为了确保树的高度不会过大&#xff0c;从而减少查询时的磁盘I/O开销&#xff0c;提高查询速…
阅读更多...
【开源】史上最全的JAVA面试题总结

【开源】史上最全的JAVA面试题总结

史上最全的JAVA面试题总结 为什么要做这件事情前言JAVA基础开发框架springSpringMVCmybatisdubbospringbootspringcloudnacos 数据库mysqloracle 缓存redismongodbElasticSearch 消息队列rabbitmqrocketmqkafka 监控prometheusgraylogzabbix 工具篇tcpdumpgitjenkins 容器docke…
阅读更多...
【案例分享】医疗布草数字化管理系统：聚通宝赋能仟溪信息科技

【案例分享】医疗布草数字化管理系统：聚通宝赋能仟溪信息科技

内容概要 本文介绍了北京聚通宝科技有限公司与河南仟溪信息科技有限公司合作开发的医疗布草数字化管理系统。该系统利用物联网技术实现了医疗布草生产过程的实时监控和数据分析&#xff0c;解决了医疗布草洗涤厂面临的诸多挑战&#xff0c;包括人工记录、生产低效率和缺乏实时…
阅读更多...
SpringBoot RPM制作

SpringBoot RPM制作

安装依赖 [root20240423-instance4 ~]# yum install rpmdevtools2.初始化目录 [root20240423-instance4 ~]# rpmdev-setuptree [root20240423-instance4 ~]# tree rpmbuild/ rpmbuild/ ├── BUILD ├── RPMS ├── SOURCES ├── SPECS └── SRPMS5 directories, 0 …
阅读更多...
DNF手游攻略：角色培养与技能搭配！游戏辅助！

DNF手游攻略：角色培养与技能搭配！游戏辅助！

角色培养和技能搭配是《地下城与勇士》中提升战斗力的关键环节。每个职业都有独特的技能和发展路线&#xff0c;合理的属性加点和技能搭配可以最大化角色的潜力&#xff0c;帮助玩家在各种战斗中立于不败之地。接下来&#xff0c;我们将探讨如何有效地培养角色并搭配技能。 角色…
阅读更多...
进程通信，队列，管道

进程通信，队列，管道

【一】进程通信 1.多个进程之间的信息交换过程 2.如何实现(1)消息队列&#xff1a;把信息从一端放入队列中&#xff0c;另一个进程从另一端将消息取出非阻塞的&#xff0c;即发送进程不需要等待接收进程的响应即可继续执行。(2)管道&#xff1a;半双工的通信机制&#xff0c;同…
阅读更多...
架构每日一学 11：快手高级副总裁给年轻人的几点建议

架构每日一学 11：快手高级副总裁给年轻人的几点建议

文章首发于公众平台&#xff1a;腐烂的橘子 于冰毕业于清华大学&#xff0c;从 05 年开始接触音视频领域&#xff0c;到现在已经在垂直行业深耕将近 20 年。先后经历了两次创业&#xff0c;曾在 Hulu、FreeWheel 等公司专攻音视频领域&#xff0c;现任快手高级副总裁。 作为一…
阅读更多...
JavaEE之线程（9) _定时器的实现代码

JavaEE之线程（9) _定时器的实现代码

前言 定时器也是软件开发中的一个重要组件. 类似于一个 “闹钟”。 达到一个设定的时间之后&#xff0c;就执行某个指定好的代码&#xff0c;比如&#xff1a; 在受上述场景中&#xff0c;当客户端发出去请求之后&#xff0c; 就要等待响应&#xff0c;如果服务器迟迟没有响应&…
阅读更多...
新能源汽车结构与原理

新能源汽车结构与原理

第一章 新能源汽车概述 1.1 电动汽车及新能源汽车定义 新能源汽车是指采用非常规的车用燃料作为动力来源&#xff08;或使用常规车用燃料、采用新型车载动力装置&#xff09;&#xff0c;综合车辆的动力控制和驱动方面的先进技术&#xff0c;形成的技术原理先进、具有新技术、…
阅读更多...
大小字符判断

大小字符判断

//函数int my_isalpha(char c)的功能是返回字符种类 //大写字母返回1&#xff0c;小写字母返回-1.其它字符返回0 //void a 调用my_isalpha()&#xff0c;返回大写&#xff0c;输出*&#xff1b;返回小写&#xff0c;输出#&#xff1b;其它&#xff0c;输出&#xff1f; #inclu…
阅读更多...
【Linux】Linux的安装

【Linux】Linux的安装

文章目录 一、Linux环境的安装虚拟机 镜像文件云服务器&#xff08;可能需要花钱&#xff09; 未完待续 一、Linux环境的安装 我们往后的学习用的Linux版本为——CentOs 7 &#xff0c;使用 Ubuntu 也可以 。这里提供几个安装方法&#xff1a; 电脑安装双系统&#xff08;不…
阅读更多...
深入解析力扣162题：寻找峰值（线性扫描与二分查找详解）

深入解析力扣162题：寻找峰值（线性扫描与二分查找详解）

❤️❤️❤️ 欢迎来到我的博客。希望您能在这里找到既有价值又有趣的内容&#xff0c;和我一起探索、学习和成长。欢迎评论区畅所欲言、享受知识的乐趣&#xff01; 推荐&#xff1a;数据分析螺丝钉的首页 格物致知 终身学习 期待您的关注 导航&#xff1a; LeetCode解锁100…
阅读更多...
virtual box ubuntu20 全屏展示

virtual box ubuntu20 全屏展示

virtual box 虚拟机 ubuntu20 系统 全屏展示 ubuntu20.04 视图-自动调整窗口大小 视图-自动调整显示尺寸 系统黑屏解决 ##设备-安装增强功能 ##进入终端 ##终端打不开&#xff0c;解决方案-传送门ubuntu Open in Terminal打不开终端解决方案-CSDN博客 ##点击cd盘按钮进入文…
阅读更多...
YoloV8改进策略：蒸馏改进|MGDLoss|使用蒸馏模型实现YoloV8无损涨点|特征蒸馏

YoloV8改进策略：蒸馏改进|MGDLoss|使用蒸馏模型实现YoloV8无损涨点|特征蒸馏

摘要 在本文中&#xff0c;我们成功应用蒸馏策略以实现YoloV8小模型的无损性能提升。我们采用了MGDLoss作为蒸馏方法的核心&#xff0c;通过对比在线和离线两种蒸馏方式&#xff0c;我们发现离线蒸馏在效果上更为出色。因此&#xff0c;为了方便广大读者和研究者应用&#xff…
阅读更多...
【RabbitMQ】使用SpringAMQP的Publish/Subscribe(发布/订阅)

【RabbitMQ】使用SpringAMQP的Publish/Subscribe(发布/订阅)

Publish/Subscribe **发布(Publish)、订阅(Subscribe)&#xff1a;**允许将同一个消息发送给多个消费者 **注意&#xff1a;**exchange负责消息路由&#xff0c;而不是存储&#xff0c;路由失败则消息丢失 常见的**X(exchange–交换机)***类型&#xff1a; Fanout 广播Direc…
阅读更多...
最新文章

Copyright @ 2022~2023