STL容器:deque双端队列学习

  所谓deque,是"double-ended queue"的缩写;
  它是一种动态数组形式,可以向两端发展,在尾部和头部插入元素非常迅速;
  在中间插入元素比较费时,因为需要移动其它元素;(No)
  双端队列容器,在序列的两端放置和删除元素是高效的;
  而vector只是在序列末尾插入才是高效的。

C++ Code


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
 
/* strdeque.cpp

所谓deque,是"double-ended queue"的缩写;

它是一种动态数组形式,可以向两端发展,在尾部和头部插入元素非常迅速;

在中间插入元素比较费时,因为需要移动其它元素;(No)

双端队列容器,在序列的两端放置和删除元素是高效的;

而vector只是在序列末尾插入才是高效的。

*/

#include <iostream>

#include <deque>

using namespace std;

int main(void)

{

//push_front();

//push_back();

//pop_front();

//pop_back();

deque<int> d;

d.push_back(1);

d.push_back(2);

d.push_back(3);

d.push_front(0);

for (int i = 0; i < d.size(); i++)

{

cout << "d[" << i << "] = " << d[i] << endl;

}

d.pop_front();

d[1] = 23;

for (int i = 0; i < d.size(); i++)

{

cout << "d[" << i << "] = " << d[i] << endl;

}

//迭代器遍历

typedef deque<int>::iterator PITER;

for (PITER piter = d.begin(); piter != d.end(); piter++)

{

cout << *piter << endl;

}

//大小度量

cout << d.size() << endl;

d.resize(10, 23);

cout << d.size() << endl;

cout << d.max_size() << endl;

//返回函数

//begin front rbegin 下同

//end back rend

PITER pIter = d.begin();

cout << "The first element is " << *pIter << endl;

*pIter = 55;

pIter = d.begin();

cout << "The first element is " << *pIter << endl;

int &nRet = d.front();

cout << "The first element is " << nRet << endl;

typedef deque<int>::reverse_iterator PREVITER;

PREVITER pRevIter = d.rbegin();

cout << "The last element is " << *pRevIter << endl;

//判断是否为空

if (d.empty())

{

cout << "empty" << endl;

}

//deque访问

deque<char> dchar;

dchar.push_back(‘A‘);

dchar.push_back(‘B‘);

dchar.push_back(‘C‘);

dchar.push_back(‘D‘);

for (int i = 0; i < dchar.size(); i++)

{

cout << dchar.at(i) << " ";

}

cout << endl;

//deque重置技术

deque<char> dchar2;

dchar2.push_back(‘a‘);

dchar2.push_back(‘b‘);

dchar2.push_back(‘c‘);

dchar2.push_back(‘d‘);

dchar.assign(dchar2.begin(), dchar2.end());

for (int i = 0; i < dchar.size(); i++)

{

cout << dchar.at(i) << " ";

}

cout << endl;

//容器内容交换

deque<int> d1(3, 1);

for (int i = 0; i < d1.size(); i++)

{

cout << d1.at(i) << " ";

}

cout << endl;

deque<int> d2(3, 10);

d1.swap(d2);

for (int i = 0; i < d1.size(); i++)

{

cout << d1.at(i) << " ";

}

cout << endl;

//deque插入和删除技术

deque<int> dInsert(5, 56);

for (int i = 0; i < dInsert.size(); i++)

{

cout << dInsert.at(i) << " ";

}

cout << endl;

dInsert.insert(dInsert.end(), 50);

for (int i = 0; i < dInsert.size(); i++)

{

//cout << dInsert.at(i) << " ";

cout << dInsert[i] << " ";

}

cout << endl;

//erase操作

//注意:尽量少用erase(pos)和erase(beg,end)

/*

deque<int> dErase(3, 7);

dErase.erase(dErase.end());

for (PITER p = dErase.begin(); p != dErase.end(); p++)

{

cout << *p << " ";

}

cout << endl;

*/

//clear操作

deque<int> dClear(3, 100);

for (PITER p = dClear.begin(); p != dClear.end(); p++)

{

cout << *p << " ";

}

cout << endl;

dClear.clear();

if (dClear.empty())

{

cout << "empty it!" << endl;

}

//除此之外还有关系运算符

// == > >= < <=等等 操作省略

cin.get();

return 0;

}

时间: 2024-10-13 11:21:42

STL容器:deque双端队列学习的相关文章

stl之deque双端队列容器

deque与vector很相似,不仅能够在尾部插入和删除元素,还能够在头部插入和删除. 只是当考虑到容器元素的内存分配策略和操作性能时.deque相对vector较为有优势. 头文件 #include<deque> 创建deque对象 1)deque();//创建一个没有不论什么元素的deque对象. deque<int> d 2)deque(size_typen);//创建一个具有n个元素的deque对象.每一个元素採用它的类型下的默认值. deque<int> d(

deque双端队列容器

C++中的STL还是比较有用的,尤其是在做科研实现算法的时候,之前也有用过,但是没怎么系统地学过,因此最近找了本书,大致浏览了一下,叶志军的那本<C++ STL开发技术导引>,科普.入门性质的一本书,写得比较浅[呵呵,勿喷].下面的内容大部分是摘自该书. deque双端队列容器(double-ended queue),可以在尾部.头部插入.删除元素,采用分块的线性结构来存储数据,两个迭代器分别指向容器的首尾元素,以deque块为单位进行内存分配,使用二级的Map进行管理. 创建deque对象

std::deque双端队列介绍

在建立vector容器时,一般来说伴随这建立空间->填充数据->重建更大空间->复制原空间数据->删除原空间->添加新数据,如此反复,保证vector始终是一块独立的连续内存空间:在建立deque容器时,一般便随着建立空间->建立数据->建立新空间->填充新数据,如此反复,没有原空间数据的复制和删除过程,是由多个连续的内存空间组成的. C++ STL容器deque和vector很类似,也是采用动态数组来管理元素. 与vector不同的是deque的动态数组首

deque双端队列容器(对象创建,数组、迭代器方式访问,元素的赋值、插入、删除等)

deque与vector非常相似,不仅可以在尾部插入和删除元素,还可以在头部插入和删除.不过当考虑到容器元素的内存分配策略和操作性能时,deque相对vector较为有优势. 头文件 #include<deque> 创建deque对象 1)deque();//创建一个没有任何元素的deque对象. deque<int> d 2)deque(size_typen);//创建一个具有n个元素的deque对象,每个元素采用它的类型下的默认值. deque<int> d(10)

c++ deque 双端队列

双端队列: 函数 描述 c.assign(beg,end)c.assign(n,elem)  将[beg; end)区间中的数据赋值给c.将n个elem的拷贝赋值给c. c.at(idx)  传回索引idx所指的数据,如果idx越界,抛出out_of_range. c.back()  传回最后一个数据,不检查这个数据是否存在. c.begin()  传回迭代器重的可一个数据. c.clear()  移除容器中所有数据. deque<Elem> cdeque<Elem> c1(c2)

Deque 双端队列

Deque允许在队列的头部或尾部进行出队和入队操作 LinkedBlockingDeque是一个线程安全的双端队列实现,可以说他是最为复杂的一种队列,在内部实现维护了前端和后端节点,但是其没有实现读写分离,因此同一时间只能有一个线程对其进行操作.在高并发中性能要远低于其他BlockingQueue.更要低于ConcurrentLinkedQueue,在jdk早期有一个非线程安全的Deque就是ArrayDeque了,java6里添加了LinkedBlockingDeque来弥补多线程场景下线程安

设计循环队列——写起来最清爽的还使用原生的deque 双端队列

622. 设计循环队列 难度中等89收藏分享切换为英文关注反馈 设计你的循环队列实现. 循环队列是一种线性数据结构,其操作表现基于 FIFO(先进先出)原则并且队尾被连接在队首之后以形成一个循环.它也被称为“环形缓冲器”. 循环队列的一个好处是我们可以利用这个队列之前用过的空间.在一个普通队列里,一旦一个队列满了,我们就不能插入下一个元素,即使在队列前面仍有空间.但是使用循环队列,我们能使用这些空间去存储新的值. 你的实现应该支持如下操作: MyCircularQueue(k): 构造器,设置队

deque双端队列(常用方法总结)

1 /*关于C++ STL中deque的学习*/ 2 #include<cstdio> 3 #include<iostream> 4 #include<deque> 5 6 using namespace std; 7 void print(deque<int> d); 8 void rprint(deque<int> d); 9 int main() 10 { 11 deque<int> dq; 12 dq.push_back(1)

deque双端队列用法

#include <iostream> #include <cstdio> #include <deque> #include <algorithm> using namespace std; deque<int> dq; int main() { dq.push_front(102);///插入头部 dq.push_back(101);///插入尾部 sort(dq.begin(),dq.end()); deque<int>::it