前面总结了vector容器的一些知识,这篇文章来总结其他一些容器的相关概念。
1、deque容器
1、基本概念
deque容器的示意图如下所示,他与vector容器的区别在于他是一个双端的数组,因此可以对头部的进行很方便的插入删除操作。
形成这样的工作原理为,deque内部有一个中控器,由中控器维护每段缓冲区的内容,而缓冲区中存放真实的数据,示意图如下所示:(这样整个容器看起来就是一片连续的内存空间)
2、构造函数
deque的构造相关函数如下:
函数名 | 说明 |
---|---|
deque<T> deqT |
默认构造形式 |
deque(beg, end) |
构造函数将[beg, end)区间中的元素拷贝给本身 |
deque(n, elem |
构造函数将n个elem拷贝给本身 |
deque(const deque &deq) |
拷贝构造函数 |
完整示例代码如下,可以看到,基本上和vector容器是一样的:
#include <iostream>
#include <vector>
using namespace std;
#include <deque>
void printDeque(const deque<int>& d)
{
for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
//deque构造
void test01()
{
deque<int> d1; //无参构造函数
for (int i = 0; i < 10; i++)
{
d1.push_back(i);
}
printDeque(d1);
deque<int> d2(d1.begin(), d1.end());
printDeque(d2);
deque<int>d3(10, 100);
printDeque(d3);
deque<int>d4 = d3;
printDeque(d4);
}
int main()
{
test01();
system("pause");
return 0;
}
最终运行结果如下:
3、赋值操作
下面实现对deque容器的赋值操作,相关函数如下:
* deque& operator=(const deque &deq) |
重载等号操作符 |
---|---|
* assign(beg, end) |
将[beg, end)区间中的数据拷贝赋值给本身 |
* assign(n, elem) |
将n个elem拷贝赋值给本身 |
使用上述函数进行赋值,结果如下所示:
void test01()
{
deque<int> d1;
for (int i = 0; i < 10; i++)
{
d1.push_back(i);
}
printDeque(d1);
deque<int>d2;
d2 = d1;
printDeque(d2);
deque<int>d3;
d3.assign(d1.begin(), d1.end());
printDeque(d3);
deque<int>d4;
d4.assign(10, 100);
printDeque(d4);
}
运行结果如下:
4、获取容器的大小
对deque容器的大小进行操作的相关功能函数如下所示:
deque.empty() |
判断容器是否为空 |
---|---|
deque.size() |
返回容器中元素的个数 |
deque.resize(num) |
重新指定容器的长度为num,若容器变长,则以默认值填充新位置,如果容器变短,则末尾超出容器长度的元素被删除 |
deque.resize(num, elem) |
重新指定容器的长度为num,若容器变长,则以elem值填充新位置,如果容器变短,则末尾超出容器长度的元素被删除。 |
相关示例代码如下所示:
void test01()
{
deque<int> d1;
for (int i = 0; i < 10; i++)
{
d1.push_back(i);
}
printDeque(d1);
//判断容器是否为空
if (d1.empty()) {
cout << "d1为空!" << endl;
}
else {
cout << "d1不为空!" << endl;
//统计大小
cout << "d1的大小为:" << d1.size() << endl;
}
cout << "大小变为15,以1填充" << endl;
//重新指定大小
d1.resize(15, 1);
printDeque(d1);
cout << "大小减小为5" << endl;
d1.resize(5);
printDeque(d1);
}
运行结果如下所示:
5、插入和删除
向deque插入和删除元素可以分为两种情况,分别如下所示:
两端插入操作:
- push_back(elem); |
在容器尾部添加一个数据 |
---|---|
- push_front(elem); |
在容器头部插入一个数据 |
- pop_back(); |
删除容器最后一个数据 |
- pop_front(); |
删除容器第一个数据 |
指定位置操作:
insert(pos,elem); |
在pos位置插入一个elem元素的拷贝,返回新数据的位置。 |
---|---|
insert(pos,n,elem); |
在pos位置插入n个elem数据,无返回值。 |
insert(pos,beg,end); |
在pos位置插入[beg,end)区间的数据,无返回值。 |
clear(); |
清空容器的所有数据 |
erase(beg,end); |
删除[beg,end)区间的数据,返回下一个数据的位置。 |
erase(pos); |
删除pos位置的数据,返回下一个数据的位置。 |
相关代码如下:
//两端操作
void test01()
{
deque<int> d;
//尾插
d.push_back(10);
d.push_back(20);
//头插
d.push_front(100);
d.push_front(200);
printDeque(d);
//尾删
d.pop_back();
//头删
d.pop_front();
printDeque(d);
}
//插入
void test02()
{
deque<int> d;
d.push_back(10);
d.push_back(20);
d.push_front(100);
d.push_front(200);
printDeque(d);
d.insert(d.begin(), 1000);
printDeque(d);
d.insert(d.begin(), 2,10000);
printDeque(d);
deque<int>d2;
d2.push_back(1);
d2.push_back(2);
d2.push_back(3);
d.insert(d.begin(), d2.begin(), d2.end());
printDeque(d);
}
//删除
void test03()
{
deque<int> d;
d.push_back(10);
d.push_back(20);
d.push_front(100);
d.push_front(200);
printDeque(d);
d.erase(d.begin());
printDeque(d);
d.erase(d.begin(), d.end());
d.clear();
printDeque(d);
}
尾部插入和头部插入
中间插入
删除操作
6、数据存取
相关的操作函数如下所示:
at(int idx) |
返回索引idx所指的数据 |
---|---|
operator[] |
返回索引idx所指的数据 |
front() |
返回容器中第一个数据元素 |
back() |
返回容器中最后一个数据元素 |
数据存取的样例如下所示:
void test01()
{
deque<int> d;
d.push_back(10);
d.push_back(20);
d.push_front(100);
d.push_front(200);
for (int i = 0; i < d.size(); i++) {
cout << d[i] << " ";
}
cout << endl;
for (int i = 0; i < d.size(); i++) {
cout << d.at(i) << " ";
}
cout << endl;
cout << "front:" << d.front() << endl;
cout << "back:" << d.back() << endl;
}
运行结果如下所示:
7、排序
这里deque容器实现排序也有现成的函数:
sort(iterator beg, iterator end)
对beg和end区间内元素进行排序
使用示例如下:
void test01()
{
deque<int> d;
d.push_back(10);
d.push_back(20);
d.push_front(100);
d.push_front(200);
printDeque(d);
sort(d.begin(), d.end());
printDeque(d);
}
使用这个排序算法需要包含头文件:
运行结果如下所示:
2、stack容器
1、基本概念
下面继续介绍stack容器,这个就跟c中的栈比较像,也是一种先进后出的数据结构,因为只有一个出口,所以就像这样先进去的进入栈底,然后后进去的在栈顶,所以出栈的时候先出。
2、常用接口
stack的常用接口如下所示:
构造操作
stack<T> stk |
stack采用模板类实现, stack对象的默认构造形式 |
---|---|
stack(const stack &stk) |
拷贝构造函数 |
赋值操作:
stack& operator=(const stack &stk) |
重载等号操作符 |
---|
数据存取:
push(elem) |
向栈顶添加元素 |
---|---|
pop() |
从栈顶移除第一个元素 |
top() |
返回栈顶元素 |
大小操作:
empty() |
判断堆栈是否为空 |
---|---|
size() |
返回栈的大小 |
使用栈需要包含他的头文件:
测试上述函数如下所示:
void test01()
{
//创建栈容器 栈容器必须符合先进后出
stack<int> s;
//向栈中添加元素,叫做 压栈 入栈
s.push(10);
s.push(20);
s.push(30);
while (!s.empty())
{
//输出栈顶元素
cout << "栈顶元素为: " << s.top() << endl;
//弹出栈顶元素
s.pop();
}
cout << "栈的大小为:" << s.size() << endl;
}
运行结果如下所示:
3、queue容器
1、基本概念
这个又和c中的一种数据结构很像了,是一种先进先出的数据结构,和stack不同的在于他有两个出口,结构示意图如下所示:
2、常用接口
构造函数:
queue<T> que |
queue采用模板类实现,queue对象的默认构造形式 |
---|---|
queue(const queue &que) |
拷贝构造函数 |
赋值操作:
queue& operator=(const queue &que) |
重载等号操作符 |
---|
数据存取:
push(elem) |
往队尾添加元素 |
---|---|
pop() |
从队头移除第一个元素 |
back() |
返回最后一个元素 |
front() |
返回第一个元素 |
大小操作:
empty() |
判断堆栈是否为空 |
---|---|
size() |
返回栈的大小 |
下面是上述一些接口的使用示例:
开头需要引用容器:
示例代码如下:
class Person
{
public:
Person(string name, int age)
{
this->m_Name = name;
this->m_Age = age;
}
string m_Name;
int m_Age;
};
void test01()
{
//创建队列
queue<Person> q;
//准备数据
Person p1("唐僧", 30);
Person p2("孙悟空", 1000);
Person p3("猪八戒", 900);
Person p4("沙僧", 800);
//向队列中添加元素 入队操作
q.push(p1);
q.push(p2);
q.push(p3);
q.push(p4);
//队列不提供迭代器,更不支持随机访问
while (!q.empty())
{
//输出队头元素
cout << "队头元素-- 姓名: " << q.front().m_Name
<< " 年龄: " << q.front().m_Age << endl;
cout << "队尾元素-- 姓名: " << q.back().m_Name
<< " 年龄: " << q.back().m_Age << endl;
cout << endl;
//弹出队头元素
q.pop();
}
cout << "队列大小为:" << q.size() << endl;
}
运行结果如下所示:
4、list容器
1、基本概念
list容器是将数据进行链式存储,就是链表,链表一种链式表形式的数据结构,但是它在物理储存单元上是非连续的,形成链式表是通过链表中的指针链接实现的,示意图如下所示:
这样的优点在于:
- 采用动态存储分配,不会造成内存浪费和溢出
- 链表执行插入和删除操作十分方便,修改指针即可,不需要移动大量元素
但是也有缺点,就是:
- 本身前后指针会占用内存空间,对内存耗费较大,在进行一些操作的时候时间复杂度和空间复杂度也都会很大
2、构造函数
相应的构造函数如下:
list<T> lst |
list采用采用模板类实现,对象的默认构造形式 |
---|---|
list(beg,end) |
构造函数将[beg, end)区间中的元素拷贝给本身 |
list(n,elem) |
构造函数将n个elem拷贝给本身 |
list(const list &lst) |
拷贝构造函数 |
这里使用前还是要引用一下头文件:
示例代码如下所示:
void printList(const list<int>& L) {
for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
void test01()
{
list<int>L1;
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);
printList(L1);
list<int>L2(L1.begin(), L1.end());
printList(L2);
list<int>L3(L2);
printList(L3);
list<int>L4(10, 1000);
printList(L4);
}
运行结果如下所示:
3、赋值操作
相关操作函数如下所示:
assign(beg, end) |
将[beg, end)区间中的数据拷贝赋值给本身 |
---|---|
assign(n, elem) |
将n个elem拷贝赋值给本身。 |
list& operator=(const list &lst) |
重载等号操作符 |
swap(lst) |
将lst与本身的元素互换。 |
这里主要是赋值和交换的函数,下面分别一一举例来看一下:
void test01()
{
list<int>L1;
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);
printList(L1);
//赋值
list<int>L2;
L2 = L1;
printList(L2);
list<int>L3;
L3.assign(L2.begin(), L2.end());
printList(L3);
list<int>L4;
L4.assign(10, 100);
printList(L4);
}
//交换
void test02()
{
list<int>L1;
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);
list<int>L2;
L2.assign(10, 100);
cout << "交换前: " << endl;
printList(L1);
printList(L2);
cout << endl;
L1.swap(L2);
cout << "交换后: " << endl;
printList(L1);
printList(L2);
}
赋值结果如下
交换的结果如下
4、大小操作
主要是获取容器的大小操作,相关功能函数如下:
size() |
返回容器中元素的个数 |
---|---|
empty() |
判断容器是否为空 |
resize(num) |
重新指定容器的长度为num,若容器变长,则以默认值填充新位置。如果容器变短,则末尾超出容器长度的元素被删除。 |
resize(num, elem) |
重新指定容器的长度为num,若容器变长,则以elem值填充新位置。如果容器变短,则末尾超出容器长度的元素被删除。 |
相关示例代码如下:
void test01()
{
list<int>L1;
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);
if (L1.empty())
{
cout << "L1为空" << endl;
}
else
{
cout << "L1不为空" << endl;
cout << "L1的大小为: " << L1.size() << endl;
}
//重新指定大小
L1.resize(10);
printList(L1);
L1.resize(2);
printList(L1);
}
运行结果如下:
5、插入和删除
相关操作的功能函数如下所示:
push_back(elem) | //在容器尾部加入一个元素 |
---|---|
pop_back() | 删除容器中最后一个元素 |
push_front(elem) | 在容器开头插入一个元素 |
pop_front() | 从容器开头移除第一个元素 |
insert(pos,elem) | 在pos位置插elem元素的拷贝,返回新数据的位置。 |
insert(pos,n,elem) | 在pos位置插入n个elem数据,无返回值。 |
insert(pos,beg,end) | 在pos位置插入[beg,end)区间的数据,无返回值。 |
clear() | 移除容器的所有数据 |
erase(beg,end) | 删除[beg,end)区间的数据,返回下一个数据的位置。 |
erase(pos) | 删除pos位置的数据,返回下一个数据的位置。 |
remove(elem) | 删除容器中所有与elem值匹配的元素。 |
相关示例代码如下:
void test01()
{
list<int> L;
//尾插
L.push_back(10);
L.push_back(20);
L.push_back(30);
//头插
L.push_front(100);
L.push_front(200);
L.push_front(300);
printList(L);
//尾删
L.pop_back();
printList(L);
//头删
L.pop_front();
printList(L);
//插入
list<int>::iterator it = L.begin();
L.insert(++it, 1000);
printList(L);
//删除
it = L.begin();
L.erase(++it);
printList(L);
//移除
L.push_back(10000);
L.push_back(10000);
L.push_back(10000);
printList(L);
L.remove(10000);
printList(L);
//清空
L.clear();
printList(L);
}
运行结果如下所示:
6、数据存取
进行数据存取的相关功能函数如下所示:
front() |
返回第一个元素 |
---|---|
back() |
返回最后一个元素 |
相关示例代码如下所示:
void test01()
{
list<int>L1;
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);
cout << "第一个元素为: " << L1.front() << endl;
cout << "最后一个元素为: " << L1.back() << endl;
}
运行结果如下所示:
7、排序
排序的主要功能函数包括将容器中的元素反转,或者是将容器中的数据进行排序,相关功能函数如下所示:
reverse() |
反转链表 |
---|---|
sort() |
链表排序 |
示例代码如下所示:
bool myCompare(int val1, int val2)
{
return val1 > val2;
}
void test01()
{
list<int> L;
L.push_back(90);
L.push_back(30);
L.push_back(20);
L.push_back(70);
printList(L);
//反转容器的元素
L.reverse();
printList(L);
//排序
L.sort(); //默认的排序规则 从小到大
printList(L);
L.sort(myCompare); //指定规则,从大到小
printList(L);
}
运行结果如下所示:
5、set/ multiset 容器
1、基本概念
set和multiset会根据特定的排序原则将元素排序。两者不同之处在于,multisets允许元素重复,而set不允许重复。他们是关联性容器,底层结构是用二叉树来实现。
2、set的基本构造
示例代码如下所示:
#include <iostream>
#include <string>
#include <set>
using namespace std;
void printSet(set<int> & s)
{
for (set<int>::iterator it = s.begin(); it != s.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test01()
{
set<int> s1;
s1.insert(10);
s1.insert(30);
s1.insert(20);
s1.insert(40);
printSet(s1);
set<int>s2(s1);
printSet(s2);
set<int>s3;
s3 = s2;
printSet(s3);
}
int main()
{
test01();
system("pause");
return 0;
}
相关说明如下所示:
这三个都是排序好的:
3、获取大小
set容器中与大小相关的函数原型如下所示:
size() | 返回容器中元素的数目 |
---|---|
empty() | 判断容器是否为空 |
swap(st) | 交换两个集合容器 |
示例代码如下所示:
//大小
void test01()
{
set<int> s1;
s1.insert(10);
s1.insert(30);
s1.insert(20);
s1.insert(40);
if (s1.empty())
{
cout << "s1为空" << endl;
}
else
{
cout << "s1不为空" << endl;
cout << "s1的大小为: " << s1.size() << endl;
}
}
//交换
void test02()
{
set<int> s1;
s1.insert(10);
s1.insert(30);
s1.insert(20);
s1.insert(40);
set<int> s2;
s2.insert(100);
s2.insert(300);
s2.insert(200);
s2.insert(400);
cout << "交换前" << endl;
printSet(s1);
printSet(s2);
cout << endl;
cout << "交换后" << endl;
s1.swap(s2);
printSet(s1);
printSet(s2);
}
运行结果如下所示:
交换结果
4、插入和删除
相关函数原型如下所示:
insert(elem) | 在容器中插入元素。 |
---|---|
clear() | 清除所有元素 |
erase(pos) | 删除pos迭代器所指的元素,返回下一个元素的迭代器。 |
erase(beg, end) | 删除区间[beg,end)的所有元素 ,返回下一个元素的迭代器。 |
erase(elem) | 删除容器中值为elem的元素。 |
示例代码如下所示:
void test01()
{
set<int> s1;
//插入
s1.insert(10);
s1.insert(30);
s1.insert(20);
s1.insert(40);
printSet(s1);
//删除
s1.erase(s1.begin());
printSet(s1);
s1.erase(30);
printSet(s1);
//清空
s1.clear();
printSet(s1);
}
运行结果如下所示:(最后一次打印是空的,所以就什么也没有)
5、统计和查找
这个函数比较简单,如下所示:
- find(key); //查找key是否存在,若存在,返回该键的元素的迭代器;若不存在,返回set.end();
- count(key); //统计key的元素个数
示例代码如下所示:
void test01()
{
set<int> s1;
//插入
s1.insert(10);
s1.insert(30);
s1.insert(20);
s1.insert(40);
//查找
set<int>::iterator pos = s1.find(30);
if (pos != s1.end())
{
cout << "找到了元素 : " << *pos << endl;
}
else
{
cout << "未找到元素" << endl;
}
//统计
int num = s1.count(30);
cout << "num = " << num << endl;
}
运行结果如下所示:
6、使用set对容器进行排序
set默认情况下是会对加入到容器内的数据进行排序的,但是默认是从小到大的,不过我们可以修改这个排序规则,下面是几种改变排序规则的方法:
方法一:(使用内置数据类型)
void test01()
{
set<int> s1;
s1.insert(10);
s1.insert(40);
s1.insert(20);
s1.insert(30);
s1.insert(50);
cout << "使用默认排序规则" << endl;
//默认从小到大
for (set<int>::iterator it = s1.begin(); it != s1.end(); it++) {
cout << *it << " ";
}
cout << endl;
//指定排序规则
set<int, MyCompare> s2;
s2.insert(10);
s2.insert(40);
s2.insert(20);
s2.insert(30);
s2.insert(50);
cout << "使用指定排序规则" << endl;
for (set<int, MyCompare>::iterator it = s2.begin(); it != s2.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
运行结果如下所示:
方法二:使用自定义数据类型来排序
示例代码如下:
class Person
{
public:
Person(string name, int age)
{
this->m_Name = name;
this->m_Age = age;
}
string m_Name;
int m_Age;
};
class comparePerson
{
public:
bool operator()(const Person& p1, const Person &p2)
{
//按照年龄进行排序 降序
return p1.m_Age > p2.m_Age;
}
};
void test01()
{
set<Person, comparePerson> s;
Person p1("小刘", 17);
Person p2("小张", 52);
Person p3("小赵", 21);
Person p4("小李", 26);
s.insert(p1);
s.insert(p2);
s.insert(p3);
s.insert(p4);
for (set<Person, comparePerson>::iterator it = s.begin(); it != s.end(); it++)
{
cout << "姓名: " << it->m_Name << " 年龄: " << it->m_Age << endl;
}
}
运行结果如下所示:
6、map/multimap容器
1、基本概念
multimap 容器保存的是有序的键/值对,但它可以保存重复的元素。multimap 中会出现具有相同键的元素序列,它们会被添加到容器中。
采用这种的数据类型可以根据key值迅速找到value的值,就跟python里面的字典差不多。
2、构造函数
直接看代码吧,一般构造函数都差不多的:
void printMap(map<int, int>&m)
{
for (map<int, int>::iterator it = m.begin(); it != m.end(); it++)
{
cout << "key = " << it->first << " value = " << it->second << endl;
}
cout << endl;
}
void test01()
{
map<int, int>m; //默认构造
m.insert(pair<int, int>(1, 10));
m.insert(pair<int, int>(2, 20));
m.insert(pair<int, int>(3, 30));
printMap(m);
map<int, int>m2(m); //拷贝构造
printMap(m2);
map<int, int>m3;
m3 = m2; //赋值
printMap(m3);
}
这里跟之前set容器是一样的方法生成的,结果如下所示:
3、获取大小
相关的函数原型如下所示:
- size(); //返回容器中元素的数目
- empty(); //判断容器是否为空
- swap(st); //交换两个集合容器
示例代码如下:
void test01()
{
map<int, int>m;
m.insert(pair<int, int>(1, 10));
m.insert(pair<int, int>(2, 20));
m.insert(pair<int, int>(3, 30));
if (m.empty())
{
cout << "m为空" << endl;
}
else
{
cout << "m不为空" << endl;
cout << "m的大小为: " << m.size() << endl;
}
}
//交换
void test02()
{
map<int, int>m;
m.insert(pair<int, int>(1, 10));
m.insert(pair<int, int>(2, 20));
m.insert(pair<int, int>(3, 30));
map<int, int>m2;
m2.insert(pair<int, int>(4, 100));
m2.insert(pair<int, int>(5, 200));
m2.insert(pair<int, int>(6, 300));
cout << "交换前" << endl;
printMap(m);
printMap(m2);
cout << "交换后" << endl;
m.swap(m2);
printMap(m);
printMap(m2);
}
运行结果如下所示:
交换的结果如下:(这里是两个容器之间的数据交换)
4、map的插入和删除
插入和删除相关的函数原型如下所示:
insert(elem) | 在容器中插入元素 |
---|---|
clear() | 清除所有元素 |
erase(pos) | 删除pos迭代器所指的元素,返回下一个元素的迭代器 |
erase(beg, end) | 删除区间[beg,end)的所有元素 ,返回下一个元素的迭代器 |
erase(key) | 删除容器中值为key的元素 |
示例代码如下所示:
void test01()
{
//插入
map<int, int> m;
//第一种插入方式
m.insert(pair<int, int>(1, 10));
//第二种插入方式
m.insert(make_pair(2, 20));
//第三种插入方式
m.insert(map<int, int>::value_type(3, 30));
//第四种插入方式
m[4] = 40;
printMap(m);
//删除
m.erase(m.begin());
printMap(m);
m.erase(3);
printMap(m);
//清空
m.erase(m.begin(), m.end());
m.clear();
printMap(m);
}
运行结果如下所示:
5、查找和统计元素
这个也是使用find和count函数来实现,示例代码如下所示:
查找如下所示:
map<int, int>::iterator pos = m.find(3);
如果要计数:
int num = m.count(3);
6、map容器排序
这里可以用自己定义的函数来实现自定义排序,示例代码如下所示:
class MyCompare
{
public:
bool operator()(int v1, int v2) {
return v1 > v2;
}
};
void test01()
{
map<int, int, MyCompare> m;
m.insert(make_pair(1, 10));
m.insert(make_pair(2, 20));
m.insert(make_pair(3, 30));
m.insert(make_pair(4, 40));
m.insert(make_pair(5, 50));
for (map<int, int, MyCompare>::iterator it = m.begin(); it != m.end(); it++)
{
cout << "key:" << it->first << " value:" << it->second << endl;
}
}
运行结果如下所示