`

双端队列deque (非原创)

阅读更多

http://hi.baidu.com/xuehuo_0411/item/f72d5120d5006ad0a517b6b8  原文出处。

 

C++ STL 容器技术 之 deque双端队列容器

简介:

deque双端队列容器(double-ended queue)与vector非常相似,算法的时间复杂度也是常数阶O(1),deque内部的数据机制和执行性能与vector不同,一般说来,当考虑到容器元素的内存分配策略和操作的性能时,deque相对vector较为有优势。deque双端队列采用分块的线性结构来存储数据,具有高效的删除首尾元素的函数,由于deque容器是以deque块为单位进行内存的分配,并使用了二级的Map进行管理,因此不容易实现类似于vector的capacity和reverse函数,而且deque容器也不需要这样的获取和调整容器大小的函数。

deque应用基础:

创建deque对象:

1、deque() 创建一个空的deque对象。

如:deque<int> d;

2、deque(size_type n) 创建一个具有n个元素的deque对象,每个deque元素具有它的类型下的默认值。

如:deque<int> d(10);

3、deque(size_type n, const T& value) 创建一个具有n个元素的deque对象,每个元素具有初始值value。

如:deque<int> d(10, 5);

4、deque(const deque&) 通过拷贝一个deque对象的各个元素值,创建一个新的deque对象。

如:deque<int> d1(10, 5);        deque<int> d2(d1);

5、deque(const InputIterator first, const InputIterator last, const A& a=A()) 通过拷贝迭代器区间[first, last)的元素值,创建一个新的deque对象中,内存分配器可省略。

如:int iArray[] = {1,2,3};      deque<int> d(iArray, iArray+3);

初始化赋值:

deque提供的push_back函数常用来进行deque容器的初始化,push_back函数在容器的尾端插入新元素value。

void push_back(const T&)

元素的遍历访问:

deque的元素可采用数组或迭代器的方式进行遍历访问。

元素的插入:

由于deque使用了两个迭代器分别指向双端队列的首尾,因此deque具有高效的头部插入元素的函数push_front()

void push_front(const T&)

其它位置的插入,将涉及相关元素的移位拷贝,insert函数的一个较常用的原型为:

iterator insert(iterator pos, const T& x)

元素的删除:

void pop_front() 删除deque的第一个元素

void pop_back() 删除deque的最后一个元素

iterator erase(iterator pos) 删除迭代器pos所指的元素

iterator erase(iterator first, iterator last) 删除迭代器区间[first, last)的所有元素

void clear() 调用erase函数,清除所有元素

元素的反向遍历:

reverse_iterator rbegin()

reverse_iterator rend()

deque的交换:

void swap(deque&)

其它常用函数:

bool empty()

size_type size()

size_type max_size()

reference front()

reference back()

 

 

举例分析:

1、

//用数组的方式访问deque元素
#include <iostream>
#include <deque>
using namespace std;
int main(void)
{
deque<int> d;
d.push_back(13);
d.push_back(32);
d.push_back(29);
for (int i=0; i<d.size(); i++)
{
   cout << "d[" << i << "] = " << d[i] << endl;
}

return 0;
}

2、

 

//用迭代器访问deque元素
#include <deque>
#include <iostream>
using namespace std;

int main(void)
{
deque<string> d;
d.push_back("a");
d.push_back("b");
d.push_back("c");
deque<string>::iterator i, iend;
iend = d.end();
int j;
for (i=d.begin(),j=0; i!=iend; i++,j++)
{
   cout << *i << " ";
}
cout << endl;

return 0;
}

3、

 

//头部和中间位置插入deque元素
#include <deque>
#include <iostream>
using namespace std;

int main(void)
{
deque<int> d;
d.push_back(6);
d.push_back(7);   
//头部插入
d.push_front(5);
for (int i=0; i<d.size(); i++)
{
   cout << d[i] << " ";
}
cout << endl;

//中间位置插入
d.insert(d.begin()+1, 9);
for (int j=0; j<d.size(); j++)
{
   cout << d[j] << ' ';
}
cout << endl;

return 0;
}

4、

 

//头尾和其它位置删除deque元素
#include <deque>
#include <iostream>
using namespace std;

int main(void)
{
deque<int> d;
d.push_back(4);
d.push_back(5);
d.push_back(3);
d.push_back(3);
d.push_back(3);
d.push_back(6);
for (int i=0; i<d.size(); i++)
{
   cout << d[i] << ' ' ;
}
cout << endl;

//头尾和任意位置删除元素
d.erase(d.begin()+1);
d.pop_front();
d.pop_back();
for (int j=0; j<d.size(); j++)
{
   cout << d[j] << ' ' ;
}
cout << endl;

//删除所有元素
d.clear();
cout << "执行clear()" << endl << "deque元素全部清除" << endl;

return 0;
}

5、

 

//deque元素的反向遍历
#include <deque>
#include <iostream>
using namespace std;

int main(void)
{
deque<int> d;
d.push_back(1);    
d.push_back(3);
d.push_back(5);
d.push_back(7);
d.push_back(9);

//deque元素的前向遍历
deque<int>::iterator i, iend;
iend = d.end();
for (i=d.begin(); i!=iend; i++)
{
   cout << *i << " ";
}
cout << endl;

//deque元素的反向遍历
deque<int>::reverse_iterator ri, riend;
riend = d.rend();
for (ri=d.rbegin(); ri!=riend; ri++)
{
   cout << *ri << " ";
}
cout << endl;

return 0;
}

6、

//两个deque容器的元素交换
#include <deque>
#include <iostream>
using namespace std;

void print(deque<int>& d)
{
for (int i=0; i<d.size(); i++)
{
   cout << d[i] << " ";
}
cout << endl;
}

int main(void)
{
deque<int> d1;
d1.push_back(11);
d1.push_back(12); 
d1.push_back(13);
cout << "d1 = ";
print(d1);

deque<int> d2;
d2.push_back(90);
d2.push_back(91);
d2.push_back(92);
cout << "d2 = ";
print(d2);

//d1和d2交换
d1.swap(d2);
cout << "d1与d2交换后" << endl;
cout << "d1 = ";
print(d1);
cout << "d2 = ";
print(d2);

return 0;
}

7、

 

//deque其它常用函数的使用
#include <deque>
#include <iostream>
using namespace std;

int main(void)
{
deque<string> d;
//打印deque为空
cout << "d是否为空: " << d.empty() << endl;
//装入元素
d.push_back("红楼梦");
d.push_back("源氏物语");
d.push_back("教父");
d.push_back("水浒传");
d.push_back("24史");

//打印deque所有元素
deque<string>::iterator i, iend;
iend = d.end();
for (i=d.begin(); i!=iend; i++)
{
   cout << *i << " ";
}
cout << endl;

//打印首元素
cout << "deque首元素为: " << d.front() << endl;
//打印末元素
cout << "deque末元素为: " << d.back() << endl;
//打印元素个数
cout << "deque元素个数为: " << d.size() << endl;
//打印可支持的最大deque元素个数
cout << "deque最大元素个数为: " << d.max_size() << endl;

return 0;
}

分享到:
评论

相关推荐

    python--双端队列deque(csdn)————程序.pdf

    Python中的`collections`模块提供了一个高效且功能丰富的数据结构,其中`deque`(双端队列)是一个重要的部分。双端队列允许我们在其两端进行插入和删除操作,这使得它在很多场景下比列表更加实用,特别是对于需要...

    双端队列C++实现 双端队列C++实现

    双端队列(Double-Ended Queue,简称deque)是一种线性数据结构,它允许在队列的两端进行插入和删除操作。在C++标准库中,`std::deque`是内置的双端队列容器,提供了高效且灵活的内存管理。然而,如果你想要自定义一...

    双端队列派生类

    双端队列,在基础类上派生 用来实现平移递推滤波数据存储

    双端队列源代码

    双端队列(Double-Ended Queue,简称deque)是一种数据结构,它允许我们在队列的两端进行插入和删除操作。这种特性使得双端队列在许多算法和数据处理场景中非常有用,比如作为栈的替代品,或者在需要快速访问两端...

    学学Python_56标准模块4 双端队列

    在Python编程语言中,双端队列(deque)是一个高效的数据结构,它允许在两端进行插入和删除操作。双端队列是collections模块的一部分,属于Python的标准库,提供了线程安全和高性能的特性,适用于需要频繁在头部和...

    【实验报告】 线性数据结构的实现与应用_双端队列_逆波兰式_呼叫中心_XAUAT_(原问题自杜克大学C++ Stacks and Queues and List

    本次实验的主要目的是理解和掌握线性数据结构——双端队列(Double-Ended Queue,简称deque)的实现与应用。通过实际编程,加深对双端队列特性的理解,如其在头部和尾部进行插入和删除操作的灵活性。同时,将双端...

    双端队列Deque及Python实现

    双端队列(Deque,全称Double-Ended Queue)是一种线性数据结构,它具有队列的特点,同时允许在队列的两端进行插入和删除操作。这种数据结构的设计使得它在处理某些特定问题时非常高效,例如在需要快速地在两端进行...

    Socket异步通信,线程,双端队列-计算机网络原理课程设计

    Socket异步通信、线程管理和双端队列(deque)是计算机网络编程中的核心概念,尤其是在构建高效、可扩展的网络应用时。本课程设计旨在让学生深入理解这些概念,并通过实践来掌握它们。 首先,让我们从Socket异步...

    java双端队列的实现-Java实现自定义双端队列(链表和数组两种方式) 数组和链表.pdf

    Java 中的双端队列(Deque)是一种特殊的队列,能够在队列的两端进行元素的添加和删除操作。与单端队列不同,双端队列可以在队列的头部和尾部同时进行插入和删除操作。 Java 实现自定义双端队列可以通过链表和数组...

    duilie.rar_双端队列

    双端队列(Double-Ended Queue,简称deque)是一种数据结构,它允许在队列的两端进行插入和删除操作。这种特性使得双端队列在许多算法和程序设计中非常实用,比如作为栈的替代,或者在需要快速访问两端元素的场景下...

    用数组实现的双端队列(类模板)

    双端队列(Double-Ended Queue,简称deque)是一种数据结构,它允许在队列的两端进行插入和删除操作。在C++中,标准库提供了一个名为`deque`的容器,但在这里,我们讨论的是一个自定义实现的基于数组的双端队列类...

    双端队列就是一个两端都是结尾的队列的程序

    双端队列(Deque,Double-ended Queue)是一种特殊的数据结构,它既可以在队列的一端进行元素的插入与删除操作,也可以在队列的另一端进行同样的操作。这种特性使得双端队列比普通的队列更加灵活。根据题目中的描述...

    Python实现的数据结构与算法之双端队列详解

    双端队列(deque,全名double-ended queue)是一种具有队列和栈性质的线性数据结构。双端队列也拥有两端:队首(front)、队尾(rear),但与队列不同的是,插入操作在两端(队首和队尾)都可以进行,删除操作也一样...

    自定义双端队列

    所谓双端队列(double-ended queue,deque),就是在列表的两端都可以插入和删除数据。 因此它允许的操作有Create、IsEmpty、IsFull、Left、Right、AddLeft、AddRight、DeleteLeft、 DeleteRight。使用循环数组方式...

    【课件】3.2.4_双端队列.pdf

    - **双端队列(Deque)**:双端队列结合了栈和队列的优点,可以在两端进行插入和删除操作,提供了更多的灵活性。它可以模拟栈的行为(仅使用一端),也可以模拟队列的行为(在两端分别进行插入和删除)。 ### 双端...

    数据结构笔记:双端队列

    双端队列(deque,double-ended queue),是一种具有队列和栈的性质的数据结构。 双端队列中每一端,都可以进行存入和取出,去其中一段,都像一个栈一样。 存取也只限定在两端,不能在中间 双端队列的实现 通过...

    Socket异步通信,线程,双端队列

    本示例着重介绍如何通过线程管理和双端队列(deque)来实现局域网内的多人异步聊天应用。 首先,理解Socket的基础概念是至关重要的。Socket是操作系统提供的接口,允许应用程序通过它来发送和接收数据。在TCP/IP...

    数据结构-用双端队列实现栈

    在这个主题中,我们将探讨如何使用双端队列(deque)来实现栈的功能。栈是一种特殊的数据结构,遵循“后进先出”(LIFO)的原则,即最后进入的元素最先出来。在C++编程中,双端队列是一种灵活的容器,它可以支持在两...

    算法-数据结构和算法-5-队列和双端队列.rar

    本资源主要聚焦于两种常用的数据结构:队列和双端队列(deque),这些都是编程中不可或缺的部分,尤其是在处理顺序访问和存储的问题时。 首先,队列是一种遵循“先进先出”(FIFO)原则的数据结构。想象一下现实...

Global site tag (gtag.js) - Google Analytics