stack 容器(栈容器)
stack是一种先进后出(FirstInLastOut,FILO)的数据结构，它只有一个出口，形式 如图所示。stack容器允许新增元素，移除元素，取得栈顶元素，但是除了最顶端 外，没有任何其他方法可以存取stack的其他元素。换言之，stack不允许有遍历 行为。 有元素推入栈的操作称为:push,将元素推出stack的操作称为pop.
先进后出的数据结构。
push入栈、pop出栈、top永远指向栈顶元素
stack没有迭代器
案例：stack 容器的 构造函数 数据存取操作 大小操作
stack构造函数
stack<T> stkT;//stack采用模板类实现， stack对象的默认构造形式：
stack(const stack &stk);//拷贝构造函数
3.4.3.2 stack赋值操作
stack& operator=(const stack &stk);//重载等号操作符
stack数据存取操作
push(elem);//向栈顶添加元素
pop();//从栈顶移除第一个元素
top();//返回栈顶元素
3.4.3.4 stack大小操作
empty();//判断堆栈是否为空
size();//返回堆栈的大小
*/
void test01()
{
stack<int> s;
//入栈
s.push(10);
s.push(20);
s.push(30);
s.push(40);
if(s.empty())
{
cout<<"栈容器为空"<<endl;
}
else
{
cout<<"栈容器非空"<<endl;
cout<<"size = "<<s.size()<<endl;
}
while(!s.empty())//非空 返回false
{
cout<<s.top()<<endl;
//出栈
s.pop();
}
}
queue 容器 (队列容器)
队列容器：先进先出 队尾插入数据 对头删除数据
queue容器：没有迭代器 不具备遍历功能 只能通过front、back访问
案例：queue构造函数 存取、插入和删除操作 赋值操作 大小操作
queue构造函数
queue<T> queT;//queue采用模板类实现，queue对象的默认构造形式：
queue(const queue &que);//拷贝构造函数
queue存取、插入和删除操作
push(elem);//往队尾添加元素
pop();//从队头移除第一个元素
back();//返回最后一个元素
front();//返回第一个元素
queue赋值操作
queue& operator=(const queue &que);//重载等号操作符
queue大小操作
empty();//判断队列是否为空
size();//返回队列的大小
*/
#include<queue>
void test02()
{
queue<int> q;
q.push(10);
q.push(20);
q.push(30);
q.push(40);
if(q.empty())
{
cout<<"容器为空"<<endl;
}
else
{
cout<<"容器非空"<<endl;
cout<<"size = "<<q.size()<<endl;
cout<<"对头元素 = "<<q.front()<<endl;//10
cout<<"队尾元素 = "<<q.back()<<endl;//40
}
cout<<"遍历队列"<<endl;
while(!q.empty())
{
cout<<q.front()<<" ";
q.pop();//出队
}
}
运行结果:
list容器(链表容器)
list容器（双向链表）的迭代器 必须具备前移、后移 提供的是双向迭代器
vector 单端动态数组（随机访问迭代器）
deque:双端动态数组（随机访问迭代器）
stack：栈容器（没有迭代器）
queue：队列容器（没有迭代器）
list：链表容器（双向迭代器）
案例：
1、list的常规操作
#include <iostream>
using namespace std;
list构造函数
list<T> lstT;//list采用采用模板类实现,对象的默认构造形式：
list(beg,end);//构造函数将[beg, end)区间中的元素拷贝给本身。
list(n,elem);//构造函数将n个elem拷贝给本身。
list(const list &lst);//拷贝构造函数。
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(pos);//删除pos位置的数据，返回下一个数据的位置。
remove(elem);//删除容器中所有与elem值匹配的元素。
list大小操作
size();//返回容器中元素的个数
empty();//判断容器是否为空
resize(num);//重新指定容器的长度为num，
若容器变长，则以默认值填充新位置。
如果容器变短，则末尾超出容器长度的元素被删除。
resize(num, elem);//重新指定容器的长度为num，
若容器变长，则以elem值填充新位置。
如果容器变短，则末尾超出容器长度的元素被删除。
list赋值操作
assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem);//将n个elem拷贝赋值给本身。
list& operator=(const list &lst);//重载等号操作符
swap(lst);//将lst与本身的元素互换。
list数据的存取
front();//返回第一个元素。
back();//返回最后一个元素。
list反转排序
reverse();//反转链表，比如lst包含1,3,5元素，运行此方法后，lst就包含5,3,1元素。
sort(); //list排序
#include<list>
#include<algorithm>
void printListInt(list<int> &L)
{
for(list<int>::iterator it=L.begin();it!=L.end();it++)
{
cout<<(*it)<<" ";
}
cout<<endl;
}
void test01()
{
list<int> L;
L.push_back(10);
L.push_back(20);
L.push_back(30);
L.push_back(40);
printListInt(L);//10 20 30 40
//迭代器+n 只有随机访问迭代器支持
//而list容器的迭代器是双向迭代器 不支持+n
//L.insert(L.begin()+2, 3, 100);//err
list<int>::iterator it = L.begin();
//++ 随机访问迭代器 以及 双向迭代器 都支持
it++;
it++;
L.insert(it,3,100);
printListInt(L);//10 20 100 100 100 30 40
//remove(elem);//删除容器中所有与elem值匹配的元素。
L.remove(100);//删除所有100
printListInt(L);//10 20 30 40
//链表反转
L.reverse();
printListInt(L);//40 30 20 10
//sort是系统提供的算法 仅支持 随机访问迭代器（不支持list）
//list容器不能使用系统算法 list会自己提供算法
//sort(L.begin(),L.end());
L.sort();
printListInt(L);//10 20 30 40
}
int main(int argc, char *argv[])
{
test01();
return 0;
}
运行结果：
2、list存放自定义数据 如果删除某个节点 必须重载 ==运算符
#include <iostream>
#include <list>
#include<algorithm>
#include<string>
using namespace std;
class Person
{
public:
string name;
int age;
public:
Person(string name,int age)
{
this->name = name;
this->age = age;
}
//成员函数重载 ==运算符
bool operator==(const Person &ob)
{
if(this->name == ob.name && this->age == ob.age)
return true;
return false;
}
};
void printListPerson(list<Person> &L)
{
cout<<"-----------"<<endl;
for(list<Person>::iterator it=L.begin(); it!= L.end();it++)
{
cout<<(*it).name<<" "<<(*it).age<<endl;
}
}
void test01()
{
//存放自定义数据
list<Person> L;
L.push_back(Person("德玛西亚",48));
L.push_back(Person("提莫", 28));
L.push_back(Person("狗头", 18));
L.push_back(Person("牛头", 19));
printListPerson(L);
//删除狗头
Person tmp("狗头", 18);
//重载==运算符
L.remove(tmp);
printListPerson(L);
}
int main(int argc, char *argv[])
{
test01();
return 0;
}
运行结果：
3、list容器 对自定义数据排序 重载<运算符
//成员函数重载 <运算符
bool operator<(const Person &ob)
{
if(this->age < ob.age)
return true;
return false;
}
void test02()
{
//存放自定义数据
list<Person> L;
L.push_back(Person("德玛西亚",48));
L.push_back(Person("提莫", 28));
L.push_back(Person("狗头", 18));
L.push_back(Person("牛头", 19));
printListPerson(L);
//对于自定义数据 我们可以重载<运算符
L.sort();
printListPerson(L);
}
运行结果：
4、list 对自定义数据排序 指定排序规则
bool myComparePerson(const Person &ob1, const Person &ob2)
{
return ob1.age < ob2.age;
}
void test03()
{
//存放自定义数据
list<Person> L;
L.push_back(Person("德玛西亚",48));
L.push_back(Person("提莫", 28));
L.push_back(Person("狗头", 18));
L.push_back(Person("牛头", 19));
printListPerson(L);
//对于自定义数据 我们可以重载<运算符
L.sort(myComparePerson);
printListPerson(L);
}
运行结果：
lambda表达式
void myPrintVectorInt(vector<int> &v)
{
for(vector<int>::iterator it=v.begin();it!=v.end();it++)
{
cout<<*it<<" ";
}
cout<<endl;
}
//指定打印方式
void myPrint01(int val)
{
cout<<val<<" ";
}
void test06()
{
vector<int> v;
v.push_back(10);
v.push_back(20);
v.push_back(30);
v.push_back(40);
//方法1:访问v容器 普通函数
myPrintVectorInt(v);
//方法2:访问v容器 系统算法for_each
for_each(v.begin(),v.end(), myPrint01);
cout<<endl;
//方法3:访问v容器 lambda表达式
//[]表示函数名 ()参数列表 {}函数体
for_each(v.begin(),v.end(), [](int val){
cout<<val<<" ";
} );
}
运行结果：
