C++容器详解-优快云博客

本文链接：https://blog.youkuaiyun.com/u013647812/article/details/38374673

1.queue 队列

queue的头文件是<queue>.

定义queue对象的示例代码如：

queue<int>q; 队列内存放的是int类型的数

queue<double>队列内存放的是double类型的数

queue<node>q; 队列内存放的是结构体类型

入队列：q.push(x) 将x元素放到队列的末端。

出队列：q.pop() 将第一个元素删除

访问队首元素： q.front();

访问队中的元素的个数： q.size();

2. deque 双端队列

deque的用法：

3.priority_queue 优先队列

priority_queue模板类有三个模板参数，第一个是元素类型，第二个容器类型，第三个是比较算子，其中后两个都可以省略，默认容器为vector，默认算子为less，即小的往前排，大的往后排（出队时序列尾的元素出队）。

定义priority_queue对象的示例代码如下：

priority_queue<int> p;

priority_queue<int, vector<int>,greater<int> > p //从小到大排列

priority_queue<int,vector<int>,less<int>>p;// 从大到小排列

自定义数据类型

定义自己的比较算子，方法有多种，重载比较运算符。

struct node

{

int a,b;

bool operator <(const node &x)const

{

return a<x.a;

}

};

priority_queue<node>q;

注意：

这里是按照a的顺序从大到小出队的。

访问优先队列的队首元素 q.top() ;

出队列：q.pop();

入队列：q.push(x);

判断优先队列是否为空： q.empty();

示例代码：

#include<cstdio>

#include<cstring>

#include <queue>

#include<algorithm>

using namespace std;

struct node

{

int a,b;

bool operator <(const node &x)const

{

return a<x.a;

}

}p[100];

int main()

{

priority_queue<node>q;

p[0].a = 6; p[0].b = 1;

p[1].a = 9; p[1].b = 5;

p[2].a = 2; p[2].b = 3;

p[3].a = 8; p[3].b = 2;

p[4].a = 1; p[4].b = 4;

for(int i=0; i<5; i++)

{

q.push(p[i]);

}

while(!q.empty())

{

node st=q.top();

printf("%d %d\n",st.a,st.b);

q.pop();

}

return 0;

}

4.stack 栈

stack的头文件 <stack>.

定义stack对象的示例代码如下：

stack<int> s1;
stack<string> s2;

Stack 操作：

入栈：q.push(x);

出栈：q.pop(); 注意，出栈操作只是删除栈顶元素，并不返回该元素。

访问栈顶：q.top();

判断栈空：q.empty(); 当栈空的时，返回true。

访问栈中的元素个数：q.size();

5.List 双向链表

List1的元素(1,2,3) list2(4,5,6);

list<int>::iterator it;

List 构造函数

list<int>L //空链表

list<int>L1(9) //建一个含个默认值的元素的链表

list <int > L2 (5,1);// 建一个含个元素的链表，值都是.

list <int > L3 (L2); // 建一个L 2 的 copy 链表

list <int > L4 (L0.begin (), L0 .end ());// 建一个含 L0 一个区域的元素

assign() 分配值，有两个重载

L1. assign ( 4,3); // L1(3,3,3,3)

L1. assign( ++list1.beging(),list2.end()); // L 1(2,3)

operator=赋值重载运算符

L1 = list1; // L1 (1,2,3)

front()返回第一个元素的引用

int n = list1.front() // n= 1

back()返回最后一元素的引用

int n = list1.back() // n = 3

begin()返回第一个元素的指针(iterator)

it = list1.begin(); // *it = 1
end() 返回最后一个元素的下一位置的指针(list为空时end()=begin())

it = list1.end();--it; // *it = 3

rbegin()返回链表最后一元素的后向指针(reverse_iteratoror const)

list <int>::reverse_iterator it = list1 .rbegin (); // *it = 3

rend()返回链表第一元素的下一位置的后向指针

list<int>::reverse_iterator it = list1 .rend(); // *(--riter) = 1

push_back()增加一元素到链表尾

list1.push_back( 4) //list1(1,2,3, 4 )

push_front()增加一元素到链表头

list1.push_front( 4) // list1( 4 ,1,2,3)

pop_back()删除链表尾的一个元素

list1.pop_back( ) // list1(1,2)

pop_front()删除链表头的一元素

list1.pop_front() // list1(2,3)

clear()删除所有元素

list1.clear(); // list1 空了,list1.size()= 0；

erase()删除一个元素或一个区域的元素 ( 两个重载函数)

list1.erase(list1.begin()); //list1(2,3)

list1.erase(++list1.begin(),list1.end()); // list1(1)

remove()删除链表中匹配值的元素( 匹配元素全部删除)

list 对象L1( 4 ,3,5,1, 4 )

L1.remove( 4); // L1(3,5,1);

remove_if()删除条件满足的元素( 遍历一次链表) ，参数为自定义的回调函数

// 小于2 的值删除

bool myFun (const int &value ) { return (value < 2); }

list1.remove_if( myFun); // list1(3)

empty()判断是否链表为空

bool bRet = L1.empty(); // 若L1 为空，bRet = true ，否则bRet = false 。

max_size()返回链表最大可能长度

list <int >::size_typenMax = list1 .max_size ();// nMax = 1073741823

size()返回链表中元素个数

list< int>::size_typenRet = list1.size(); // nRet = 3

resize()重新定义链表长度( 两重载函数)

list1.resize(5) // list1 (1,2,3, 0,0 ) 用默认值填补

list1.resize(5,4) // list1 (1,2,3, 4,4 ) 用指定值填补

reverse()反转链表:

list1.reverse( ); // list1(3,2,1)

sort()对链表排序，默认升序( 可自定义回调函数 )

list 对象L1(4,3,5,1,4)

L1.sort( ); // L1(1,3,4,4,5)

L1.sort( greater <int>() ); // L1(5,4,4,3,1)

merge()合并两个有序链表并使之有序

// 升序

list1.merge(list2); // list1(1,2,3,4,5,6) list2 现为空

// 降序

L1( 3,2,1), L2(6,5,4)

L1.merge(L2, greater <int>() ); // list1(6,5,4,3,2,1) list2 现为空

insert()在指定位置插入一个或多个元素( 三个重载函数)

list1.insert(++list1.begin(),9); // list1(1,9,2,3)

list1.insert(list1.begin(),2,9); // list1(9,9,1,2,3);

list1.insert(list1.begin(),list2.begin(),--list2.end());//list1(4,5,1,2,3);

swap()交换两个链表( 两个重载)

list1.swap(list2); // list1 （4 ，5 ，6 ） list2 （1 ，2 ，3 ）

unique()删除相邻重复元素

L1( 1, 1 ,4,3,5,1)

L1.unique( ); // L1(1,4,3,5,1)

list成员	说明
constructor	构造函数
destructor	析构函数
operator=	赋值重载运算符
assign	分配值
front	返回第一个元素的引用
back	返回最后一元素的引用
begin	返回第一个元素的指针(iterator)
end	返回最后一个元素的下一位置的指针
rbegin	返回链表最后一元素的后向指针(reverse_iterator or const)
rend	返回链表第一元素的下一位置的后向指针
push_back	增加一元素到链表尾
push_front	增加一元素到链表头
pop_back	pop_back()删除链表尾的一个元素
pop_front	删除链表头的一元素
clear	删除所有元素
erase	删除一个元素或一个区域的元素(两个重载)
remove	删除链表中匹配值的元素(匹配元素全部删除)
remove_if	删除条件满足的元素(遍历一次链表)，参数为自定义的回调函数
empty	判断是否链表为空
max_size	返回链表最大可能长度
size	返回链表中元素个数
resize	重新定义链表长度(两重载函数)
reverse	反转链表
sort	对链表排序，默认升序
merge	合并两个有序链表并使之有序
splice	对两个链表进行结合(三个重载函数) 结合后第二个链表清空
insert	在指定位置插入一个或多个元素(三个重载函数)
swap	交换两个链表(两个重载)
unique	删除相邻重复元素