门禁考勤网站建设,如何访问服务器上的网站,装修公司网站怎么做的,建筑人才网987vector
向量#xff08;Vector#xff09;是STL中最常用的容器之一#xff0c;它提供了动态数组的功能#xff0c;支持随机访问和动态调整大小。下面是向量的一些基本操作#xff1a;
创建向量#xff1a;
#include vector
std::vectorint vec;
// …vector
向量Vector是STL中最常用的容器之一它提供了动态数组的功能支持随机访问和动态调整大小。下面是向量的一些基本操作
创建向量
#include vector
std::vectorint 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] ;
}
或者使用 C11 中的范围遍历
for (int element : vec) { std::cout element ;
}
删除向量中的元素
vec.pop_back();
// 删除向量末尾的元素
清空向量
vec.clear();
// 清空向量中的所有元素
这些是向量的一些基本操作可以用来创建、添加、访问、遍历、删除和清空向量中的元素。
需要注意的是向量支持动态调整大小因此在需要时可以动态地添加或删除元素。 stack
栈Stack是一种后进先出LIFO的数据结构它的基本操作包括
创建栈
#include stack
std::stackint 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::queueint q;// 创建一个空的整型队列
向队列中添加元素
q.push(10);
// 将元素10添加到队列末尾
访问队列中的元素
由于队列是先进先出的数据结构因此不能像向量一样直接访问任意位置的元素。只能访问队列的头部元素。
int frontElement q.front();
// 获取队列头部的元素值但不会删除元素
删除队列中的元素
q.pop();
// 删除队列头部的元素
检查队列是否为空
if (q.empty()) { // 队列为空 }
else { // 队列不为空 }
获取队列中的元素个数
int size q.size();
// 获取队列中元素的个数
队列的基本操作主要包括创建队列、添加元素、访问元素、删除元素、检查队列是否为空以及获取队列中的元素个数。
需要注意的是队列只允许在队列的一端添加元素尾部在另一端删除元素头部并且只能访问头部的元素。 set
集合Set是一种关联容器其中的元素是唯一的并且按照一定的排序规则进行自动排序。以下是集合的基本操作
创建集合
#include set
std::setint 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::mapstd::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 }
获取映射中的元素个数
int size myMap.size();
// 获取映射中键值对的个数
遍历映射中的键值对
for (const auto pair : myMap) { std::cout Key: pair.first , Value: pair.second std::endl;
}
也可以使用 C11 中的结构化绑定
for (auto [first, second] : myMap) { std::cout Key: first , Value: second std::endl;
}
这些是映射的基本操作可以用来创建映射、添加键值对、访问元素、删除元素、检查键是否存在、获取元素个数以及遍历键值对。
映射中的键值对是按照键的排序规则自动排序的。 priority_queue
优先队列Priority Queue是一种特殊的队列其中的元素按照一定的优先级顺序进行排列具有较高优先级的元素先被取出。其基本操作包括
创建优先队列
#include queue
std::priority_queueint myPriorityQueue;
// 创建一个空的整数优先队列默认按照降序排序#include queue
std::priority_queueint, vectorint, greaterint 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::dequeint 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_mapstd::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_setint 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::multisetint 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中的元素按照排序规则组织因此它是有序的容器。
相比于setmultiset允许存储重复的元素并且可以方便地统计重复元素的个数。 tuple
Tuple元组是C中的一种标准库容器用于存储固定数量的对象。元组中的对象可以是不同的类型且元组的大小在编译时确定。基本操作包括
创建tuple
#include tuple
std::tupleint, double, std::string myTuple(10, 3.14, hello);
// 创建一个包含int、double和string类型对象的元组
访问tuple中的元素
int intValue std::get0(myTuple);
// 获取第一个元素整数 double doubleValue std::get1(myTuple);
// 获取第二个元素双精度浮点数 std::string stringValue std::get2(myTuple);
// 获取第三个元素字符串
修改tuple中的元素
std::get0(myTuple) 20;
// 修改第一个元素的值为20
将tuple中的元素解包到变量中
int a;
double b;
std::string c;
std::tie(a, b, c) myTuple;
// 将元组中的元素解包到变量a、b、c中
比较tuple
使用std::tuple进行比较时会按照元素的顺序逐个比较。
std::tupleint, int tuple1(1, 2);
std::tupleint, int tuple2(1, 3);
if (tuple1 tuple2) { // tuple1小于tuple2 }
else { // tuple1大于或等于tuple2 }
Tuple可以在不引入新的数据结构的情况下方便地将多个值打包为一个单元并支持解包操作。由于元组中的对象类型不必相同因此在一些特定场景下使用十分方便。 array
在C中std::array 是一个模板类提供了类似于数组的功能但是具有更多的特性和安全性。它具有固定大小并且在创建后大小不能更改。以下是 std::array 的基本操作
创建 array
#include array
std::arrayint, 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::arrayint, 3 anotherArray {1, 2, 3};
// 使用初始化列表初始化数组
比较 array
std::arrayint, 3 array1 {1, 2, 3};
std::arrayint, 3 array2 {1, 2, 3}; if (array1 array2) { // 两个数组相等 }
else { // 两个数组不相等 }
填充 array
myArray.fill(0);
// 将数组中的所有元素填充为0
std::array 提供了数组的很多功能并且更加安全和方便因为它提供了许多与容器一样的操作比如 size()、begin()、end() 等同时还支持初始化列表和比较操作。 list
链表List是一种线性数据结构它的基本操作包括
创建链表
#include list
std::listint 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) { // 对链表中的每个元素执行操作
}
链表是一种非常灵活的数据结构它允许在任意位置插入和删除元素因此在某些场景下比数组更为适用。
链表的操作复杂度取决于操作的位置而不是链表的长度。
