deque容器基本概念
功能：双端数组，可以对头端进行插入删除操作
deque与vector区别：
1.vector对于头的插入删除效率低，数据量越大，效率越低
2.deque相对而言，对头部的插入删除速度会比vector快
3.vector访问元素时的速度会比deque快，这和两者内部实现有关。
deque内部工作原理：
deque内部有个中控器，维护每段缓冲区中的内容，缓冲区中存放真实的数据
中控器维护的是每个缓冲区的地址，使得使用deque时像一片连续的内存空间
deque容器的迭代器支持随机访问的
deque构造函数
功能：deque容器的构造#
函数原型：
deque<T> deqT; //默认构造形式
deque(beg,end); //构造函数将[beg,end]区间中的元素拷贝给本身
deque(n,elem); //构造函数将n个elem拷贝给本身
deque(const deque &deq); //拷贝构造函数总结：deque容器和vector容器的构造函数方式几乎一样，可以灵活使用
例子：
#include <iostream>
using namespace std;
#include <deque>
//deque构造函数
//deque<T> deqT; //默认构造形式
//deque(beg, end); //构造函数将[beg,end]区间中的元素拷贝给本身
//deque(n, elem); //构造函数将n个elem拷贝给本身
//deque(const deque& deq); //拷贝构造函数
void printf(const deque<int> d)
{
//如果需要设置只读，迭代器也要为const型
for (deque<int>::const_iterator de = d.begin(); de != d.end(); de++)
{
/**de = 100;*/ //容器中的数据不可以修改
cout << *de << " ";
}
cout << endl;
}
void test()
{
deque<int> d1;
for (int i = 0; i < 10; i++)
{
d1.push_back(i);
}
printf(d1);
deque<int> d2(d1.begin(),d1.end());
printf(d2);
deque<int> d3(10,1);
printf(d3);
deque<int> d4(d1);
printf(d4);
}
int main()
{
test();
system("pause");
return 0;
}deque容器赋值操作
功能：给deque容器进行赋值
函数原型：
deque& operator=(const deque& deque);//重载等号操作符
assign(beg,end); //将[beg,end]区间中的数据拷贝赋值给本身
assign(n,elem); //将n个elem拷贝赋值给本身例子：
#include <iostream>
using namespace std;
#include <deque>
//deque容器赋值操作
//函数原型
//deque& operator=(const deque& deque); //重载等号操作符
//assign(beg, end); //将[beg,end]区间中的数据拷贝赋值给本身
//assign(n, elem); //将n个elem拷贝赋值给本身
void printf(deque<int> d1)
{
for (deque<int>::iterator it = d1.begin(); it != d1.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test()
{
deque<int> d;
for (int i = 0; i < 10; i++)
{
d.push_back(i);
}
printf(d);
deque<int> d2;
d2 = d;
printf(d2);
deque<int> d3(d.begin(),d.end());
printf(d3);
deque<int> d4(10,100);
printf(d4);
}
int main()
{
test();
system("pause");
return 0;
}deque大小操作
功能：对deque容器的大小进行操作
函数原型：
deque.empty(); //判断容器是否为空
deque.size(); //返回容器中元素个数
deque.resize(num); //重新指定容器的长度为num，若容器变长，则以默认值
//填充新位置，若容器长度变短，则超出容器长度的元素被删除
deque.resize(num,elem);////重新指定容器的长度为num，若容器变长，则以elem值
//填充新位置，若容器长度变短，则超出容器长度的元素被删除总结:
deque没有容器的概念
empty----判断容器是否为空
size ----返回容器中的个数
resize----重新定义容器长度
例子：
#include <iostream>
using namespace std;
#include <deque>
//deque容器大小
//函数原型
//deque.empty(); //判断容器是否为空
//deque.size(); //返回容器中元素个数
//deque.resize(num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置，若容器长度变短，则超出容器长度的元素被删除
//deque.resize(num, elem);//重新指定容器的长度为num，若容器变长，则以elem值填充新位置，若容器长度变短，则超出容器长度的元素被删除
void printf(deque<int> d1)
{
for (deque<int>::iterator it = d1.begin(); it != d1.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test()
{
deque<int> d;
for (int i = 0; i < 10; i++)
{
d.push_back(i);
}
//如果d.empty返回值为1，则内容为空，反之，存在内容
if (d.empty())
{
cout << "d的内容为空" << endl;
}
else
{
cout << "d的内容：";
printf(d);
cout << "d的大小：";
cout << d.size() << endl;
}
d.resize(11);
printf(d);
d.resize(5);
printf(d);
d.resize(20, 1);
printf(d);
}
int main()
{
test();
system("pause");
return 0;
}deque插入和删除
功能：向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]区间的数据，无返回值
claar(); //清空容器的所有数据
erase(beg,end); //删除[beg,end]区间的是数据，返回下一个数据的位置
erase(pos); //删除pos位置的数据，返回下一个数据的位置总结：插入和删除都是迭代器
尾插----push_back
尾删----pop_back
头插----push_front
头删----pop_front
例子
#include <iostream>
using namespace std;
#include <deque>
void printf(deque<int> d)
{
for (deque<int>::iterator it = d.begin(); it != d.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
//deque插入和删除
//两端插入操作：
//push_back(elem); //在容器尾部添加一个数据
//push_front(elem); //在容器头部插入一个数据
//pop_back(); //删除容器最后一个数据
//pop_front(); //删除容器第一个数据
void test()
{
cout << "两端插入：" << endl;
deque<int> d1;
//尾插
d1.push_back(10);
d1.push_back(20);
printf(d1);
//头插
d1.push_front(100);
d1.push_front(200);
//200 100 10 20
printf(d1);
//尾删
d1.pop_back();
//200 100 10
printf(d1);
//头删
d1.pop_front();
//100 10
printf(d1);
}
//指定位置操作：
//insert(pos, elem); //在pos位置插入一个elem元素的拷贝，返回新数据的位置
//insert(pos, n, elem);//在pos位置插入n个elem数据，无返回值
//insert(pos, beg, end);//在pos位置插入[beg,end]区间的数据，无返回值
//claar(); //清空容器的所有数据
//erase(beg, end); //删除[beg,end]区间的是数据，返回下一个数据的位置
//erase(pos); //删除pos位置的数据，返回下一个数据的位置
void test1()
{
cout << "指定位置操作:" << endl;
deque<int> d2;
d2.push_back(200);
d2.push_back(100);
d2.push_front(300);
d2.push_front(400);
//400 300 100 200
printf(d2);
//insert插入
d2.insert(d2.begin(), 500);
d2.insert(d2.end(), 99);
printf(d2);
d2.insert(d2.begin(), 3, 600);
d2.insert(d2.end(), 3, 98);
printf(d2);
//删除
d2.erase(d2.begin(), d2.end());
printf(d2);
cout << "d1:" << endl;
deque<int> d1;
d1.push_back(1);
d1.push_back(2);
d1.push_front(3);
d1.push_front(4);
//4 3 1 2
printf(d1);
//按区间插入
d1.insert(d1.begin(), d1.begin(), d1.end());
printf(d1);
d1.erase(d1.begin());
printf(d1);
}
int main()
{
test();
test1();
system("pause");
return 0;
}deque数据存取
功能：对deque中的数据进行存取操作
函数原型：
at(int idx); //返回索引idx的数据
operator[]; //返回索引idx所指的数据
front(); //返回容器中第一个数据元素
back(); //返回容器中最后一个元素总结：除了用迭代器获取deque中的元素，[]和at也可以
front返回容器中第一个元素
back返回容器中最后一个元素
例子：
#include <iostream>
using namespace std;
#include <deque>
//deque数据存取
//函数原型
//at(int idx); //返回索引idx的数据
//operator[]; //返回索引idx所指的数据
//front(); //返回容器中第一个数据元素
//back(); //返回容器中最后一个元素
void test()
{
deque<int> d;
d.push_back(10);
d.push_back(20);
d.push_back(30);
d.push_back(40);
d.push_back(50);
//通过[]方式访问数据
for (int i = 0; i < d.size(); i++)
{
cout << d[i] << " ";
}
cout << endl;
//通过at方式访问数据
for (int i = 0; i < d.size(); i++)
{
cout << d.at(i)<< " ";
}
cout << endl;
cout <<"第一个元素为：" << d.front() << endl;
cout <<"最后一个元素为：" << d.back() << endl;
}
int main()
{
test();
system("pause");
return 0;
}deque排序
功能：利用算法实现对deque容器进行排序
算法：
sort(iterator beg,iterator end) //对[beg,end]区间内元素进行排序总结：sort使用时需包含头文件algorithm
例子：
#include <iostream>
using namespace std;
#include <deque>
#include <algorithm> //标准头文件
void printf(deque<int> d)
{
for (deque<int>::iterator it = d.begin(); it != d.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
//deque容器排序
//算法
//rt(iterator beg,iterator end) //对[beg,end]区间内元素进行排序
void test()
{
deque<int> d1;
d1.push_back(10);
d1.push_back(0);
d1.push_back(20);
d1.push_back(50);
cout << "未排序前：" << endl;
printf(d1);
//默认排序规则从小到大 升序
//对于支持随机访问的迭代器的容器，都可以利用sort算法直接对其进行排序
//vector容器也可以利用 sort排序
sort(d1.begin(), d1.end());
cout << "排序后：" << endl;
printf(d1);
}
int main()
{
test();
stem("pause");
return 0;
}stack容器
概念：stack是一种先进后出(后进先出)的数据结构，他只有一个出口。
栈中只有顶端元素才可以被外界使用，因此栈不允许有遍历行为。
栈中入数据称为----入栈 push
栈中出数据称为----出栈 pop
栈的常用接口
功能：栈容器常用的对外接口
//构造函数
stack<T> stk; //stack采用模板类实现，stack对象的默认构造形式
stack(const stack &stk); //拷贝构造函数
//赋值操作
stack& operator=(const stack &stk); //重载等号操作符
//数据存取
push(elem); //向栈顶添加元素
pop(); //从栈顶移除第一个元素
top(); //返回栈顶元素
//大小操作
empty(); //判断堆栈是否为空
size(); //返回栈的大小总结：
入栈---push
出栈---pop
返回栈顶---top
判断栈是否为空---empty
返回栈大小---size
例子：
#include <iostream>
using namespace std;
#include <stack>
//栈stack容器
////构造函数
//stack<T> stk; //stack采用模板类实现，stack对象的默认构造形式
//stack(const stack& stk); //拷贝构造函数
////赋值操作
//stack& operator=(const stack& stk); //重载等号操作符
////数据存取
//push(elem); //向栈顶添加元素
//pop(); //从栈顶移除第一个元素
//top(); //返回栈顶元素
////大小操作
//empty(); //判断堆栈是否为空
//size(); //返回栈的大小
void test()
{
//特点：符合先进后出(后进先出)的数据结构
stack<int> s;
s.push(5);
s.push(4);
s.push(3);
s.push(2);
s.push(1);
//operator=操作
stack<int> s1;
s1 = s;
//只要栈不为空，就一直出栈
while (s.empty() != 1)
{
//查看栈顶元素
cout << "s=" << s.top() << " ";
cout << "容器大小：" << s.size() << endl;
//出栈
s.pop();
cout << " ";
cout << endl;
}
cout << "栈中元素全部移出" << endl;
cout << endl;
cout << "s1容器：" << endl;
while (s1.empty() != 1)
{
//查看栈顶元素
cout << "s1=" << s1.top() << " ";
cout << "s1容器大小：" << s1.size() << endl;
//出栈
s1.pop();
cout << endl;
}
cout << "栈中元素全部移出" << endl;
}
int main()
{
test();
system("pause");
return 0;
}queue容器
概念：queue容器是一种先进先出的数据结构，他有两个出口
注意：
队头只能出数据，队尾只能进数据
只有队头和队尾能被外界访问，因此不允许有遍历行为
队列中进数据称为---入队 push
队列中出数据称为---出队 pop
queue容器常用接口
功能：栈容器常用对外接口
//构造函数
queue<T> que; //queue采用模板类实现，queue对象的默认构造函数
queue(const queue & que); //拷贝构造函数
//赋值操作
queue& operator=(const queue& que); //重载等号操作符
//数据存取
push(elem); //向队尾添加元素
pop(); //从队头移除第一个元素
back(); //返回最后一元素
front(); //返回第一个元素
//大小操作
empty(); //判断栈是否为空
size(); //返回栈的大小总结：
入队---push
出队---pop
返回队头元素---front
返回队尾元素---back
判断队是否为空---empty
返回队列大小---size
例子:
#include <iostream>
using namespace std;
#include <queue>
//queue容器
////构造函数
//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 test()
{
//创建队列
queue<person> q;
//准备数据
person p1("张三", 30);
person p2("李四", 40);
person p3("王五", 50);
person p4("赵六", 60);
//入队
q.push(p1);
q.push(p2);
q.push(p3);
q.push(p4);
while (!q.empty()) //判断栈是否为空
{
//查看容器大小
cout << "q容器大小：" << q.size() << endl;
//查看栈头
cout << "栈头---姓名：" << q.front().m_name << " " << "年龄：" << q.front().m_age << endl;
//查看栈尾
cout << "栈尾---姓名：" << q.back().m_name << " " << "年龄：" << q.back().m_age << endl;
//移出栈头元素
q.pop();
}
}
int main()
{
test();
system("pause");
return 0;
}list容器
功能：将数据进行链式存储
链表：它是一种物理储存单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的。
结点的组成：一个是储存数据元素的数据域，另一个是储存下一个结点地址的指针域
STL中链表是一个双向循环链表。
链表的优点：
可以对任意位置进行快速插入和删除元素
缺点：
容器的遍历速度，没有数组快，占用空间比数组大
由于链表的储存方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器
list优点：
1.采用动态内存分配，不会造成内存浪费和溢出
2.链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素
list缺点：
链表灵活，但空间(指针域)和时间(遍历)额外耗费较大
List有一个重要的性质，插入和删除操作都不会造成原有list迭代器的失效，这在vector是不成立的
总结：STL中List和vector是最常被使用的容器。
list构造函数
函数原型：
list容器构造函数
函数原型：
list<T> lst; //list采用模板类实现，对象的默认构造形式；
list(beg,end); //构造函数将[beg,end]区间中的元素拷贝给本身。
list(n,elem); //构造函数将n个elem拷贝给本身
list(const list & lst) //拷贝构造函数例子：
void printfList(const list<int>& L1)
{
for (list<int>::const_iterator it = L1.begin(); it != L1.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test()
{
//默认构造函数
list<int> L1;
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);
printfList(L1);
//按区间构造
list<int> L2(L1.begin(),L1.end());
printfList(L2);
//拷贝构造函数
list<int> L3(L2);
printfList(L3);
//构造函数将n个elem拷贝给本身
list<int> L4(4, 10);
printfList(L4);
}
int main()
{
test();
system("pause");
return 0;
}总结：使用list容器，需要使用头文件：<list>。
list容器的赋值与交换
功能：给list容器进行赋值，以及交换list容器
函数原型：
list容器赋值与交换
函数原型：
assign(beg, end); //将[beg,end]区间中的数据拷贝赋值给本身
assign(n, elem); //将n个elem拷贝赋值给本身
list& operator=(const list& lst); //重载等号操作符
swap(list); // 将list与本身的元素交换例子：
void printfList(const list<int>&L1)
{
for (list<int>::const_iterator it = L1.begin(); it != L1.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test1()
{
list<int> L1;
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);
printfList(L1);
list<int> L2;
L2 = L1;//=赋值
printfList(L2);
list<int> L3;
L3.assign(L2.begin(),L2.end());
printfList(L3);
list<int> L4;
L4.assign(4, 100);
printfList(L4);
//交换
L4.swap(L3);
printfList(L4);
printfList(L3);
}
int main()
{
test1();
system("pause");
return 0;
}list大小操作
功能：对list容器的大小进行操作；
函数原型：
size(); //返回容器中元素的个数
empty(); //判断容器是否为空
resize(num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。
//若容器变短，则末尾超出容器长度的元素被删除。
resize(num, elem); //重新指定容器的长度为num，若容器变长，则以elem填充新位置。
//若容器变短，则末尾超出容器长度的元素被删除。例子
void printfList(const list<int>& L1)
{
for (list<int>::const_iterator it = L1.begin(); it != L1.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test()
{
list<int> L1;
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);
printfList(L1);
if (L1.empty())
{
cout << "L1容器为空" << endl;
}
else
{
cout << "L1的个数：" << L1.size() << endl;
}
//重新指定大小
L1.resize(6,10);
printfList(L1);
L1.resize(3);
printfList(L1);
}
int main()
{
test();
system("pause");
return 0;
}总结：
size -----判断容器是否为空
empty----返回元素的个数
resize-----重新指定元素个数
list容器插入和删除
函数原型：
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(ps//删除pos位置的数据， 返回下一个数据的位置。
remove(elem);//删除容器中所有与elem值匹配的元素。例子：
void printfList(const list<int>& L1)
{
for (list<int>::const_iterator it = L1.begin(); it != L1.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test()
{
list<int>L1;
//尾插
L1.push_back(10);
L1.push_back(20);
//头插
L1.push_front(30);
L1.push_front(40);
printfList(L1); //40 30 10 20
//尾删
L1.pop_back();
printfList(L1); //40 30 10
//头删
L1.pop_front();
printfList(L1); // 30 10
//insert插入
list<int>::iterator it = L1.begin();
L1.insert(++it, 1000);
printfList(L1);//30,1000，10
//删除
it = L1.begin();
L1.erase(it);
printfList(L1);//1000，10
//移除
L1.push_back (1000);
L1.push_back(1000);
printfList(L1);//1000,10,1000,1000
L1.remove(10);
printfList(L1);//1000,1000,1000
//全删
L1.clear();
if (L1.empty())
{
cout << "删除完毕" << endl;
}
else
{
cout << "L1元素个数：" << L1.size() << endl;
}
}
int main()
{
test();
system("pause");
return 0;
}总结：
尾插————push_back
尾删————pop_back
头插————push_front
头删————pop_front
插入————insert
删除————erase
移除————remove
清空————clear
list的存取
功能：对list容器中数据进行存取
函数原型：
front(); //返回容器中第一个元素
back(); //返回容器中最后一个元素例子
void test()
{
list<int> L1;
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);
//L1[0]; //报错，不能用[]的方式去访问list容器
//L1.get_allocator(0); //报错，不能用at的方式去访问list容器
//因为list容器中的元素是链式存储，元素不是用连续的线性存储空间存储,迭代器也是不支持随机访问
cout << L1.front() << endl;
cout << L1.back() << endl;
//验证迭代器不支持随机访问
list<int>::iterator it = L1.begin();
//it = it + 1; //不支持随机访问
//支持双向
it++;
it--;
}
int main()
{
test();
system("pause");
return 0;
}总结：
list容器中不可以通过[]方式和at方式访问数据
返回第一个元素----front
返回最后一个元素---back
list容器的反转和排序
功能：将容器中的元素反转，以及将容器中的数据进行排序
函数原型：
reverse(); //反转链表
sort(); //链表排序例子：
void printflist(list<int>& L1)
{
for (list<int>::iterator it = L1.begin(); it != L1.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
bool Compare(int v1,int v2)
{
//降序 就让第一个数大于第二个数
return v1 > v2;
}
void test()
{
list<int> L1;
L1.push_back(10);
L1.push_back(20);
L1.push_back(40);
L1.push_back(30);
L1.push_back(50);
cout << "原本元素：";
printflist(L1);
cout << "反转元素：";
L1.reverse();
printflist(L1);
}
void test1()
{
list<int> L1;
L1.push_back(10);
L1.push_back(20);
L1.push_back(40);
L1.push_back(30);
L1.push_back(50);
cout << "原本元素：";
printflist(L1);
cout << "排序元素：";
//默认排序降序
L1.sort();
printflist(L1);
//升序
L1.sort(Compare);
printflist(L1);
}
int main()
{
test();
test1();
system("pause");
return 0;
}总结：
反转————reverse
排序————sort(成员函数）
list排序案例
#include <iostream>
using namespace std;
#include <list>
#include <string>
//排序案例
//将Person自定义数据类型进行排序，Person中属性有性别、年龄、身高。
//排序规则：按照年龄进行升序，如果年龄相同按照身高进行降序
class Person
{
public:
Person(string m_name, int m_age, int m_height)
{
this->name = m_name;
this->age = m_age;
this->height = m_height;
}
public:
string name;
int age;
int height;
};
//指定排序规则
bool comparePerson(Person& p1, Person& p2)
{
//按照年龄排序 升序,如果年龄相同，按身高降序
if(p1.age!=p2.age)
return p1.age < p2.age;
else
{
return p1.height > p2.height;
}
}
void test()
{
list<Person>L;
Person p1("刘备",35,175);
Person p2("曹操",45,180);
Person p3("孙权",40,170);
Person p4("赵云",25,190);
Person p5("张飞",35,160);
Person p6("关羽",35,200);
L.push_back(p1);
L.push_back(p2);
L.push_back(p3);
L.push_back(p4);
L.push_back(p5);
L.push_back(p6);
for (list<Person>::iterator it = L.begin(); it != L.end(); it++)
{
cout << "姓名：" << (*it).name << " " << "年龄：" << (*it).age << " " << "身高：" << (*it).height << "";
cout << endl;
}
//排序
cout << "----------------------------------------------------------------------------" << endl;
cout << "排序后：" << endl;
L.sort(comparePerson);
for (list<Person>::iterator it = L.begin(); it != L.end(); it++)
{
cout << "姓名：" << (*it).name << " " << "年龄：" << (*it).age << " " << "身高：" << (*it).height << "";
cout << endl;
}
}
int main()
{
test();
system("pause");
return 0;
}set/multiset容器
set容器基本概念
简介：所有元素都会在插入时自动被排序
本质：set/multiset属于关联式容器，底层结构是用二叉树实现
set与multiset的区别：
set不允许容器有重复的元素
multiset允许容器中有重复的元素
set构造函数和赋值
功能：创建set容器以及赋值
构造:
set<T> st; //默认构造函数
set(const set& st) //拷贝构造函数赋值：
set& operator=(const set& st);例子
void printf(set<int>& L1)
{
for (set<int>::iterator it = L1.begin(); it != L1.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test()
{
set<int> L1;
L1.insert(10);
L1.insert(20);
L1.insert(30);
L1.insert(40);
L1.insert(30);
//无序变有序
//set容器特点：
//1.所有元素插入时候自动被排序
//2.set不允许插入重复的值
printf(L1);
set<int> L2(L1);
printf(L2);
set<int> L3;
L3 = L2;
printf(L3);
}
int main()
{
test();
system("pause");
return 0;
}总结：
set容器插入数据时用insert
set容器插入数据的数据会自动排序
set大小和交换
功能：统计set容器大小以及交换set容器
函数原型：
size(); //返回容器中元素的个数
empty(); //判断容器是否为空
swap(st); //交换两个集合容器例子
void printf(set<int>& L1)
{
for (set<int>::iterator it = L1.begin(); it != L1.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test()
{
set<int> s1;
s1.insert(10);
s1.insert(20);
s1.insert(30);
cout << s1.size() << endl;
if (s1.empty())
{
cout << "s1容器为空" << endl;
}
else
{
printf(s1);
}
set<int> s2;
s2.insert(20);
s2.insert(30);
s2.insert(40);
s2.insert(50);
cout << "交换前：" << endl;
printf(s1);
printf(s2);
cout << "交换后：" << endl;
s2.swap(s1);
printf(s1);
printf(s2);
}
int main()
{
test();
system("pause");
return 0;
}总结：
统计大小————size
判断是否为空———empty
交换容器—————swap
set插入和删除
功能：set容器进行插入和删除数据
函数原型：
insert(elem); //在容器中插入元素。
clear(); //清除所有元素
erase(pos); //删除pos迭代器所指的元素，返回下一个元素的迭代器。
erase(beg, end); //删除区间[beg ,end)的所有元素，返回下一个元素的迭代器。
erase(elem); //删除容器中值为elem的元素。例子：
void printf(set<int>& L1)
{
for (set<int>::iterator it = L1.begin(); it != L1.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test()
{
set<int> s;
s.insert(10);
s.insert(20);
s.insert(30);
s.insert(13);
printf(s);
//删除
s.erase(s.begin());
printf(s);
s.erase(13);
printf(s);
//清空
s.clear();
}
int main()
{
test();
system("pause");
return 0;
}总结：
插入————insert
删除————erase
清空————clear
set查找和统计
功能：对set容器进行查找数据以及统计数据
函数原型
find(key); //查找key是否存在，若存在，返回该元素的迭代器；若不存在，返回set.end();
count(key); //统计key的元素个数例子
void test()
{
set<int> s;
s.insert(10);
s.insert(20);
s.insert(43);
s.insert(13);
set<int>::iterator pos = s.find(10);
if (pos != s.end())
{
cout << "找到元素：" << *pos << endl;
}
else
{
cout << "未找到元素" << endl;
}
}
void test1()
{
set<int> s;
s.insert(10);
s.insert(10);
s.insert(43);
s.insert(13);
int num=s.count(10);
cout << "10的个数：" << num << endl;
//set容器统计的返回值只有0和1两种结果，因为set容器不允许有重复的值
}
int main()
{
test();
test1();
system("pause");
return 0;
}总结：
查找————find（返回迭代器）
统计————count（对于set，结果是0或者1）
set与multiset的区别
区别：
1、set不可以插入重复的数据，而multiset可以
2、set插入数据的同时会返回插入结果，表示插入成功
3、multiset不会检测数据，因此可以插入重复数据
例子
void test()
{
set<int> s;
//对组
pair<set<int>::iterator,bool>ret=s.insert(10);
if (ret.second)
{
cout << "第一次插入成功" << endl;
}
else
{
cout << "第一次插入失败" << endl;
}
ret = s.insert(10);
if (ret.second)
{
cout << "第一次插入成功" << endl;
}
else
{
cout << "第一次插入失败" << endl;
}
multiset<int> m;
m.insert(10);
m.insert(10);
for (multiset<int>::iterator it = m.begin(); it != m.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
int main()
{
test();
system("pause");
return 0;
}pair对组创建
功能：成对出现的数据，利用对组可以返回两个数据
创建方式：
pair<type,type> p(value1,value2);
pair<type,type> p=make_pair(value1,value2);例子：
void test()
{
//第一种方式
pair<string, int> p("tom", 10);
cout << "姓名：" << p.first << " " << "年龄：" << p.second << endl;
//第二种方式
pair<string, int> p1 = make_pair("Join", 20);
cout << "姓名：" << p1.first << " " << "年龄：" << p1.second << endl;
}
int main()
{
test();
system("pause");
return 0;
}set容器排序
1、利用仿函数改变set内置类型排序
class Mycompare
{
public:
bool operator()(int v1,int v2)const
{
return v1 > v2;
}
};
void printfset(set<int>& s)
{
for (set<int>::iterator it = s.begin(); it != s.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test()
{
set<int>s1;
s1.insert(10);
s1.insert(30);
s1.insert(40);
s1.insert(15);
//默认排序 升序
printfset(s1);
set<int,Mycompare>s2;
s2.insert(10);
s2.insert(30);
s2.insert(40);
s2.insert(15);
//按照降序排列
for (set<int, Mycompare>::iterator it = s2.begin(); it != s2.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
int main()
{
test();
system("pause");
return 0;
}2、利用仿函数改变set容器自定义数据类型排序
例子
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)const
{
//按照年龄作降序
return p1.m_age > p2.m_age;
}
};
void test()
{
Person p1("tom", 18);
Person p2("om", 10);
Person p3("tm", 100);
Person p4("to", 15);
set<Person, comparePerson> s;
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;
}
}
int main()
{
test();
system("pause");
return 0;
}