C++ STL容器

Posted 2023-04-29 邪童的博客

C++ STL容器的基本用法

vector 变长数组, 倍增的思想

string 字符串, substr() , c_str()

queue 队列, push() , front() , pop()

priority_queue 优先队列, push() , top() , pop()

stack 栈, push() , top() , pop()

deque 双端队列

set , map , multiset , multimap 基于平衡二叉树(红黑树), 动态维护有序序列

unordered_set , unordered_map , unordered_multiset , unordered_multimap 哈希表

bitset 压位

---

vector

初始化:

vector <int> a (10) 长度为10的数组

vector <int> a (10,3) 长度为10的数组, 每一个数为3

vector <int> a [10] 定义了10个vector

vector 支持的函数:

a.size() 返回元素个数

a.empty() 空返回 true , 非空返回 false

a.clear() 清空

a.front() / a.back() 返回第一个数/ 最后一个数

a.push_back() 在最后插入一个数

a.pop_back() 删除最后一个数

a.begin() 返回 a 的第一个元素的迭代器

a.end() 返回 a 的最后一个元素的下一个元素的迭代器

a[] vector 支持随机寻址

vector 的遍历:

for(int i = 0 ; i < a.size() ; i++) cout << a[i] << \' \'; 用数组下标遍历

for(vector<int>::iterator i = a.begin() ; i != a.end() ; i++) cout << *i << \' \'; 用迭代器遍历

for(auto x : a) cout << x << \' \'; C++的范围遍历

倍增思想: 系统为某一程序分配空间时所需时间, 与空间大小无关, 与申请次数有关.

vector 每一次数组长度不够时, 将数组长度扩大一倍.

---

pair

初始化:

pair <int,int> p

pair <int,pair <int,int>> p

pair 支持的操作:

p.first 返回第一个元素

p.second 返回第二个元素

---

string

初始化: string a

string 支持的函数:

a.length() 返回字符串长度

a.size() 返回元素个数

a.empty() 空返回 true , 非空返回 false

a.clear() 清空

a.find(\'x\') 返回字符 x 在字符串中下标

a.substr(,) 返回某个子串

第一个参数表示子串起点下标, 第二个参数表示子串长度.

若第二个参数过大(或无第二个参数), 返回从第一个参数开始的整个子串.

若用 printf 输出 string 要用 a.c_str()

---

queue

初始化: queue <int> a

queue 支持的函数:

a.size() 返回元素个数

a.empty() 空返回 true , 非空返回 false

a.push(x) 向队尾插入一个元素 x

a.front() 返回队头元素

a.back() 返回队尾元素

a.pop() 弹出队头元素

注意: queue 没有 clear 函数

a = queue <int> (); 相当于 clear 功能

---

priority_queue

初始化:

priority_queue <int> heap 优先队列, 默认是大根堆

priority_queue <int,vector<int>,greater<int>> heap 定义小根堆

priority_queue 支持的函数:

heap.push(x) 插入一个元素 x

heap.top() 返回堆顶元素

heap.pop() 弹出堆顶元素

注意: priority_queue 没有 clear 元素

---

stack

初始化: stack <int> a

stack 支持的函数:

a.size() 返回元素个数

a.empty() 空返回 true , 非空返回 false

a.push(x) 向栈顶插入一个元素 x

a.top() 返回栈顶元素

a.pop() 弹出栈顶元素

注意: stack 没有 clear 函数

---

deque

初始化: deque <int> q

deque 支持的函数:

q.size() 返回元素个数

q.empty() 空返回 true , 非空返回 false

q.clear() 清空

q.front() 返回队头元素

q.back() 返回队尾元素

q.push_back() 向队尾插入一个元素 x

q.pop_back() 弹出队尾元素

q.push_front() 向队头插入一个元素 x

q.pop_front() 弹出队头元素

q[] deque 支持随机访址

q.begin() 返回第一个元素的迭代器

q.end() 返回最后一个元素下一个元素的迭代器

---

set / multiset

set 元素不能重复, multiset 元素可以重复

初始化:

set <int> s

multiset <int> ms

set / multiset 支持的函数:

s.size() 返回元素个数

s.empty() 空返回 true , 非空返回 false

s.clear() 清空

s.insert(x) 插入一个数 x

s.find(x) 查找一个数 x , 存在返回 x 的迭代器, 不存在返回 end() 的迭代器

s.count(x) 返回某一个数 x 的个数

s.erase() 输入的是一个数 x , 则删除所有 x ; 输入的是一个迭代器, 则删除这个迭代器

s.lower_bound(x) 返回大于等于 x 的最小的数的迭代器, 不存在则返回 end()

s.upper_bound(x) 返回大于 x 的最小的数的迭代器, 不存在则返回 end()

++ / -- 返回前驱/ 后继的迭代器

---

map / multimap

初始化:

map <string,int> a

a ["xt"] = 666

cout << a ["xt"] <<endl; 输出"1"

可将第一个参数作为数组下标

map / multimap 支持的函数:

a.size() 返回元素个数

a.empty() 空返回 true , 非空返回 false

a.clear() 清空

a.begin() 返回第一个元素的迭代器

a.end() 返回最后一个元素下一个元素的迭代器

++ / -- 返回前驱/ 后继的迭代器

a.insert() 插入的数需要是一个 pair

a.erase() 输入的参数需要是一个 pair 或迭代器

a.find()

a[]

---

unordered_set / unordered_map / unordered_multiset / unordered_multimap

允许存在重复元素的 set 和map

增删查改的时间复杂度是 O(1)

除不支持 lower_bound() 和 upper_bound() 外, 其余支持函数与 set 和map 相同

---

bitset

初始化: bitset <10000> S

bitset 只能存储 0 和 1 , < > 内参数表示长度

bitset 支持的操作:

~S 取反

& , | , ^ 与、或、异或

>> , << 位运算

== , != 等于、不等于

S.count() 返回有多少个 1

S.any() 判断是否至少有一个 1

S.none() 判断是否全为 0

S.set() 把所有位置成 1

S.set(k,v) 把第 k 位变成 v

S.reset() 把所有位置成 0

S.flip() 把所有位取反

S.flip(k) 把第 k 位取反

小白学习C++ 教程二十一C++ 中的STL容器Arrays和vector

@Author：Runsen

C++的标准模板库（STL）是提供数组、向量、队列等数据结构的模板类的集合。STL是由容器、算法、迭代器组成的库。

容器

容器存储对象和数据。它们基本上是基于模板的泛型类。

STL中的容器分为以下几种：

• 顺序容器
  可以以顺序或线性方式访问的容器称为顺序容器。

Array, vector, queue, deque, list, map, set 是线性存储数据的 STL 容器，可以按顺序访问。

• 关联容器

关联容器是实现排序数据结构的容器。这些容器可以快速搜索。关联容器的一些示例是 Map、Set、MultiMap、Multiset 等。这些容器通常以键/值对的方式实现。

Arrays

声明Arrays 容器的一般语法是：

array<object_type, size> array_name;

上面的声明创建了一个数组容器“array_name”，其大小为“size”，对象类型为“object_type”。

我们也可以初始化这个数组容器，如下所示，

array<int,5> myarray = 1,1,2,3,5;

数组容器支持的一些功能包括：

• At：返回数组容器中给定位置的值。如果指定的位置超出数组限制，则抛出“Out_of_range”异常。
• Front：返回数组容器中的第一个元素。
• Back：如果容器被完全填满，则返回数组容器中的最后一个元素，另一个返回容器中最右边的元素。
• Fill：为数组容器中的每个元素分配一个给定的值。
• Swap：交换具有相同类型和相同大小索引的两个数组的内容。
• Empty：用于检查数组容器是否为空的布尔函数。
• Size：返回数组容器中的元素数。
• Max_size：返回数组容器的最大大小。
• Begin：返回指向数组容器开头的迭代器，即数组的第一个元素。
• End：返回指向数组容器中最后一个元素旁边位置的迭代器。

#include <algorithm>
#include <array>
#include <iostream>
#include <iterator>
 
using namespace std;
 
int main() 
  array<int, 5> myarray = 1, 1, 2, 3, 5;
   
  cout << "Size of array: " << endl;
  cout << myarray.size() << endl;
   
  cout << "myarray contents: "  << endl;
  for (auto i : myarray)
    cout << i << ' ';
     
  // sort operation
 sort(myarray.begin(), myarray.end());
    
   cout << "\\nsorted myarray : ";
   for (auto i : myarray)
      cout << i << ' ';
   
   cout<<"\\nFirst element of myarray "<<myarray.at(0);
   cout<<endl;
    
   cout<<"FRONT myarray: "<<myarray.front();
   cout<<endl;
   cout<<"BACK myarray: "<<myarray.back();
   cout<<endl;
    
   // Filling ar2 with 10
   myarray.fill(8);
    
  cout << "\\nFilled myarray : ";
  for (auto i : myarray)
     cout << i << ' ';
 
return 0;

输出如下

Size of array:
5

myarray contents: 1 1 2 3 5
sorted myarray: 1 1 2 3 5
The first element of myarray 1
FRONT myarray: 1
BACK myarray: 5

Filled myarray: 8 8 8 8 8

vector

array是固定大小的静态数组。

如果在程序中间我们必须在数组中存储更多元素，那么当我们尝试存储超出数组限制的元素时，肯定会得到“out_of_bound”异常。

vector是动态数组容器，可在插入或删除元素时自动调整其大小。向量的存储由向量容器本身处理。

vector中的元素存储在连续的位置。就像数组一样，向量元素也可以使用迭代器遍历和访问。

vector支持以下迭代器函数来遍历元素：

• begin() –返回指向向量容器第一个元素的迭代器。
• end() –返回指向向量中最后一个元素之后的元素的迭代器。
• rbegin() –返回指向向量容器中最后一个元素的反向迭代器。
• rend() –返回指向向量容器第一个元素的反向迭代器。
• cbegin() –返回指向向量容器中第一个元素的常量迭代器。
• cend() –返回指向向量容器最后一个元素之后的元素的常量迭代器。
• crbegin() –返回指向向量容器中最后一个元素的反向常量迭代器。
  -crend() –返回指向向量容器中第一个元素的反向常量迭代器。

#include <iostream>
#include <vector>
using namespace std;
int main()
   
      vector<int> v1;
  
      for (int i = 1; i <= 5; i++)
         v1.push_back(i+1);
  
      for (auto i = v1.begin(); i != v1.end(); ++i)
         cout << *i << " ";
  
         cout << "\\nOutput of Vector with rbegin and rend: ";
      for (auto itr = v1.rbegin(); itr != v1.rend(); ++itr)
         cout << *itr << " ";
   
         cout << "\\nOutput Vector of with cbegin and cend: ";
      for (auto itc = v1.cbegin(); itc != v1.cend(); ++itc)
         cout << *itc << " ";
  
         cout << "\\nOutput Vector of with crbegin and crend : ";
      for (auto icr = v1.crbegin(); icr != v1.crend(); ++icr)
         cout << *icr << " ";
         return 0;

输出如下：

Output of Vector with rbegin and rend: 6 5 4 3 2
Output Vector of with cbegin and cend: 2 3 4 5 6
Output Vector of with crbegin and crend: 6 5 4 3 2

函数 size() 返回向量容器中的元素数。这是 std::vector 类的内置函数，可直接用于查找向量的大小。

我们还可以将向量调整为所需的大小，使其可以容纳“n”个元素。这是通过 std::vector类的“resize()”函数实现的。resize 函数以向量的大小为参数，然后将向量容器的大小调整为指定的大小。

#include <iostream>
#include <vector>
using namespace std;
int main()

   vector<int> myvec = 1, 1, 2, 3, 5, 8;
    cout << "Vector Size : " << myvec.size();
   cout << "\\nVector elements are: ";
   for (auto it = myvec.begin(); it != myvec.end(); it++)
                 cout << *it << " ";
   myvec.resize(4);
   cout << "\\nVector Size after resize: " << myvec.size();
   cout << "\\nVector elements after resizing are: ";
   for (auto it = myvec.begin(); it != myvec.end(); it++)
                 cout << *it << " ";
   return 0;

输出如下：

Vector Size : 6
Vector elements are: 1 1 2 3 5 8
Vector Size after resize: 4
Vector elements after resizing are: 1 1 2 3

对向量进行排序

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()

    vector<int> myvec =  10,50,30,20,60,40 ;

    for (auto i = myvec.begin(); i < myvec.end(); ++i)
    
        cout << *i << " ";
    
    cout << endl;

    sort(myvec.begin(), myvec.end());

    for (auto i = myvec.begin(); i < myvec.end(); ++i)
    
        cout << *i << " ";
    
    cout << endl;

输出如下

10 50 30 20 60 40
10 20 30 40 50 60

向量类 std::vector 提供了另一个将值插入向量的函数Insert 。Insert 函数允许我们在指定位置之前向向量中插入元素。

#include <iostream>
#include <vector>
using namespace std;

int main()

	vector<int> myvec =  2,3,4 ;

	for (int i = 0; i < myvec.size(); i++)
		cout << myvec[i] << " ";
	cout << endl;
	myvec.insert(myvec.begin(), 20);
	myvec.insert(myvec.begin() + 1, 30);
	for (int i = 0; i < myvec.size(); i++)
		cout << myvec[i] << " ";

输出如下

2 3 4
20 30 2 3 4

vector 类还为我们提供了将一个向量的内容与另一个相同类型和大小的向量的内容交换或交换的能力。这是通过矢量内置函数“swap”实现的。

#include <iostream>
#include <vector>
using namespace std;

int main()

    // swap operation
    vector<int> v1, v2;
    v1.push_back(1);
    v1.push_back(3);
    v2.push_back(5);
    v2.push_back(7);

    cout << "\\nVector 1: ";
    for (int i = 0; i < v1.size(); i++)
        cout << v1[i] << " ";

    cout << "\\nVector 2: ";
    for (int i = 0; i < v2.size(); i++)
        cout << v2[i] << " ";

    // Swaps v1 and v2
    v1.swap(v2);

    cout << "\\nAfter Swap \\nVector 1: ";
    for (int i = 0; i < v1.size(); i++)
        cout << v1[i] << " ";

    cout << "\\nVector 2: ";
    for (int i = 0; i < v2.size(); i++)
        cout << v2[i] << " ";

输出如下

Vector 1: 1 3
Vector 2: 5 7
After Swap
Vector 1: 5 7
Vector 2: 1 3

函数“find”用于查找向量中是否存在特定元素（称为键）。一旦找到该值，函数就会返回。

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
  
int main()

   // Assign vector
   vector<int> myvec = 1,1,2,3,5,8;
   cout<<"\\nInput vector: ";
   for(auto it=myvec.begin();it<myvec.end();it++)
      cout<<*it<<" ";
   int key;
   cout<<"\\nEnter the key to be searched: "; cin>>key;
   if(find(myvec.begin(),myvec.end(),key)!= myvec.end())
      cout<<"\\nElement found";
   else
      cout<<"\\nElement not found";