C++ deque

最新推荐文章于 2023-08-21 14:51:20 发布

Moseas

最新推荐文章于 2023-08-21 14:51:20 发布

阅读量255

点赞数

分类专栏： C++ 文章标签： c++ 数据结构

本文链接：https://blog.csdn.net/m0_46336023/article/details/115529822

版权

C++ 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

deuque

deque是连续空间（至少逻辑上看来如此），连续线性空间总是令我们联想到array或vector。array无法成长，vector虽然可以成长，却只能向尾端成长，而且其所谓的成长是个假象，事实上是：一另觅更大空间，二将原有数据复制过去，三释放原空间三部曲。如果不是vector每次配置新空间是都有留下一个余裕，其成长假象所带来的带起将是相当高昂。deque系由一段一段的定量连续空间构成。一旦有必要在deque的前端或尾端增加新空间，便配置一段定量连续空间，串接在deqeu的头部或尾部。便是在这些分段的定量连续空间上，维护其整体连续的假象，并提供随机存取的接口。避开了“重新配置，复制，释放”的轮回，代价则是复杂的迭代器架构。受到分段连续线性空间的字面影响，我们可能以为deque的实现复杂程度和vector相比较虽不中亦不远矣，其实不然。主要因为，既曰分段连续线性空间，就必须有中央控制，而为了维持整体连续的假象，数据结构的设计及迭代器前进后退等操作都颇为繁琐。deque的实现代码分量远比vector或list都多得多。deque采用一块所谓的map（注意：不是STL的map容器），作为主控，这里所谓map是一小块连续空间，其中每个元素（此处成为一个节点，node）都是指针，指向另一段（较大的）连续线性空间，成为缓冲区。缓冲区才是deque的存储空间主体。

deque::deque()函数功能：创建一个新双向队列

#include<iostream>
#include<deque>
using namespace std;
int main(){
	//deque::deque()函数 功能：创建一个新双向队列
	deque<int>first;//empty deque if ints
	deque<int>second(5,20);//five ints with values 20
	deque<int>third(second.begin(),second.end());//iterating through second
	deque<int>fourth(third);//a copy of third
	//the iterator constructor can also be used to construct from arrays
	int myints[]={1998,11,3,520,13,14};
	
	deque<int>fifth(myints,myints+sizeof(myints)/sizeof(int));
	cout<<"the contents of first are:";
	for(int i=0;i<first.size();i++){
		cout<<" "<<first[i];
	}
	cout<<endl;
	cout<<"the contents of second are:";
	for(int i=0;i<second.size();i++){
		cout<<" "<<second[i];
	}
	cout<<endl;
	cout<<"the contents of third are:";
	for(int i=0;i<third.size();i++){
		cout<<" "<<third[i];
	}
	cout<<endl;
	cout<<"the contents of fourth are:";
	for(int i=0;i<fourth.size();i++){
		cout<<" "<<fourth[i];
	}

	cout<<endl;
	cout<<"the contents of fifth are:";
	for(int i=0;i<fifth.size();i++){
		cout<<" "<<fifth[i];
	}
	cout<<endl;   
}

运行结果

the contents of first are:
the contents of second are: 20 20 20 20 20
the contents of third are: 20 20 20 20 20
the contents of fourth are: 20 20 20 20 20
the contents of fifth are: 1998 11 3 520 13 14

deque::operator=()函数功能赋值双向队列

#include<iostream>
#include<deque>
using namespace std;
int main(){
	///deque::operator=()函数 功能赋值双向队列 
	deque<int>first(3);//deque with 3 zero-initialized ints
	deque<int>second(5);//deque with 5 zero-initialized ints
	second=first;
	first=deque<int>(6);
	cout<<"size of fist "<<int(first.size())<<endl;
	cout<<"size of second "<<int(second.size())<<endl;
}

运行结果

size of fist 6
size of second 3

deque::operator函数功能：Access element

#include<iostream>
#include<deque>
using namespace std;
int main(){
	// deque::operator[]()函数 功能：Access element
    deque<int>mydeque(10);//10 zero-initialized elements
	deque<int>::size_type sz=mydeque.size();
	for(int i=0;i<sz;i++)mydeque[i]=2*i;
	//reverse order of elements using operator[]:
	for(int i=0;i<sz/2;i++){
		int temp;
		temp=mydeque[sz-1-i];
		mydeque[sz-1-i]=mydeque[i];
		mydeque[i]=temp;
	}
	cout<<"mydeque contains:"<<endl;
	for(int i=0;i<sz;i++){
		cout<<" "<<mydeque[i];
	}
	cout<<endl;
}

运行结果

mydeque contains:
 18 16 14 12 10 8 6 4 2 0

deque::assign函数功能：设置双向队列的值

#include<iostream>
#include<deque>
using namespace std;
int main(){
    //deque::assign函数 功能：设置双向队列的值
	deque<int>first;
	deque<int>second;
	deque<int>third;
	first.assign(6,11);//a repetition 6 times of value 11
	deque<int>::iterator it;
	it=first.begin()+1;
	second.assign(it,first.end());//the 5 values of first
	int myints[]={1998,11,3};
	third.assign(myints,myints+3);//assigning from array
	cout<<"size of first: "<<int(first.size())<<endl;
	cout<<"size of second: "<<int(second.size())<<endl;
	cout<<"size of third: "<<int(third.size())<<endl;
}

运行结果

size of first: 6
size of second: 5
size of third: 3

deque::begin()函数功能：返回指向第一个元素的迭代器

deque::end()函数功能：返回指向尾部的迭代器

deque::rbegin()函数功能：返回指向尾部的逆向迭代器

deque::rend()函数功能：返回指向头部的逆向迭代器

#include<iostream>
#include<deque>
using namespace std;
int main(){
     //deque::begin()函数 功能：返回指向第一个元素的迭代器
	 //deque::end()函数 功能：返回指向尾部的迭代器
	 //deque::rbegin()函数 功能：返回指向尾部的逆向迭代器
	 //deque::rend()函数 功能：返回指向头部的逆向迭代器
	  
	deque<int>mydeque;
	deque<int>::iterator it;
	deque<int>::reverse_iterator rit;
	for(int i=0;i<9;i++){
	 	mydeque.push_back(i);
	 }
	cout<<"mydeque contains:";
	 
	for(it=mydeque.begin();it!=mydeque.end();it++){
	 	cout<<" "<<*it;
	 } 
	cout<<endl;
    it=mydeque.begin();
    cout<<"begin to end";
    while(it!=mydeque.end()){
    	cout<<" "<<*it++;
	}
	
	rit=mydeque.rbegin();
	cout<<endl;
	cout<<"mydeque contains:";
	cout<<"rbegin to rend";
	while(rit!=mydeque.rend()){
		cout<<" "<<*rit++; 
	}
}

运行结果

mydeque contains: 0 1 2 3 4 5 6 7 8
begin to end 0 1 2 3 4 5 6 7 8
mydeque contains:rbegin to rend 8 7 6 5 4 3 2 1 0

deque::back()函数功能：返回最后一个元素

#include<iostream>
#include<deque>
using namespace std;
int main(){
    //deque::back()函数 功能：返回最后一个元素
	deque<int>mydeque;
	mydeque.push_back(10);
	while(mydeque.back()!=0){
	mydeque.push_back(mydeque.back()-1);
	}
	cout<<"mydeque contains: ";
	for(int i=0;i<mydeque.size();i++){
	cout<<" "<<mydeque[i]; 
	}
	cout<<endl;
}

运行结果

mydeque contains:  10 9 8 7 6 5 4 3 2 1 0

deque::front()函数功能：返回第一个元素

#include<iostream>
#include<deque>
using namespace std;
int main(){
    //deque::front()函数 功能：返回第一个元素 
	deque<int>mydeque;
	mydeque.push_back(11);
	mydeque.push_back(3);
	mydeque.push_front(1998);
	mydeque.front()+=mydeque.back();
	cout<<"mydeque contains:";
	for(int i=0;i<mydeque.size();i++){
		cout<<" "<<mydeque[i];
	} 
}

运行结果

mydeque contains: 2001 11 3

deque::push_back()函数功能：在尾部加入一个元素

deque::pop_back()函数功能: 删除尾部的元素

deque::push_front()函数功能：在头部加入一个元素

deque::pop_front()函数功能：删除头部的元素

#include<iostream>
#include<deque>
using namespace std;
int main(){
	//deque::pop_back()函数 功能: 删除尾部的元素
    //deque::push_back()函数 功能：在尾部加入一个元素
    
    //deque::pop_front()函数 功能：删除头部的元素 
	//deque::push_front()函数 功能：在头部加入一个元素
	
    //deque::back()函数 功能：返回最后一个元素
	//deque::front()函数 功能：返回第一个元素
	deque<int>mydeque;
	int sumback(0);
	int sumfront(0);
	mydeque.push_back(1998);
	mydeque.push_back(11);
	mydeque.push_back(3);
	while(!mydeque.empty()){
		sumback+=mydeque.back();
		mydeque.pop_back();
	}
	mydeque.push_front(1998);
	mydeque.push_front(11);
	mydeque.push_front(3);
	while(!mydeque.empty()){
		sumfront+=mydeque.front();
		mydeque.pop_front();
	}
	cout<<"the elements of mydeque summed "<<sumback<<" or "<<sumfront<<endl; 
}

运行结果

the elements of mydeque summed 2012 or 2012

deque::insert()函数功能：插入一个元素到双向队列中

#include<iostream>
#include<deque>
#include<vector>
using namespace std;
int main(){
    //deque::insert()函数 功能：插入 一个元素到双向队列中
	deque<int>mydeque;
	deque<int>::iterator it;
	//set some initial values
	for(int i=1;i<6;i++){
		mydeque.push_back(i);//1 2 3 4 5
	} 
	it=mydeque.begin();
	it=mydeque.insert(it,1998);
	//it now points to the newly inserted 10
	mydeque.insert(it,3,11);
	//it no longer valid!!!!
	it=mydeque.end()-3;
	vector<int>myvector(2,23);
	mydeque.insert(it,myvector.begin(),myvector.end());
	cout<<"mydeque contains: ";
	for(it=mydeque.begin();it!=mydeque.end();it++){
		cout<<" "<<*it; 
	}
}

运行结果

mydeque contains:  11 11 11 1998 1 2 23 23 3 4 5

deque::erase()函数功能：删除一个元素

#include<iostream>
#include<deque>
using namespace std;
int main(){
    //deque::erase()函数 功能：删除一个元素
	deque<int>mydeque;
	//set some values (from 1 to 10)
	for(int i=1;i<11;i++){
		mydeque.push_back(i);
	}
	//erase the 6th element
	mydeque.erase(mydeque.begin()+5);
	cout<<"mydeque contains: ";
	for(int i=0;i<mydeque.size();i++){
		cout<<" "<<mydeque[i]; 
	}
	cout<<endl;
	//erase the first 3 elements
	mydeque.erase(mydeque.begin(),mydeque.begin()+3);
	cout<<"mydeque contains: ";
	for(int i=0;i<mydeque.size();i++){
		cout<<" "<<mydeque[i]; 
	}
	cout<<endl;
}

运行结果

mydeque contains:  1 2 3 4 5 7 8 9 10
mydeque contains:  4 5 7 8 9 10

deque::clear()函数功能：删除所有元素

#include<iostream>
#include<deque>
using namespace std;
int main(){
    //deque::clear()函数 功能：删除所有元素 
    deque<int>mydeque;
    mydeque.push_back(1998);
    mydeque.push_back(11);
    mydeque.push_back(3);
    cout<<"mydeque contains: ";
    for(int i=0;i<mydeque.size();i++){
    	cout<<" "<<mydeque[i]; 
	}
	cout<<endl;
	mydeque.clear();
	
	cout<<"size of mydeque: "<<mydeque.size()<<endl;
	
	mydeque.push_back(2000);
	mydeque.push_back(2);
	cout<<"mydeque contains: ";
    for(int i=0;i<mydeque.size();i++){
    	cout<<" "<<mydeque[i]; 
	}
	cout<<endl;
}

运行结果

mydeque contains:  1998 11 3
size of mydeque: 0
mydeque contains:  2000 2

deque::empty()函数功能：返回真如果双向队列为空

#include<iostream>
#include<deque>
using namespace std;
int main(){
    //deque::empty()函数 功能：返回真如果双向队列为空
	deque<int>mydeque;
	int sum(0);
	for(int i=0;i<=10;i++){
		mydeque.push_back(i);
	}
	while(!mydeque.empty()){
		sum+=mydeque.back();
		mydeque.pop_back();
	}
	cout<<"total:"<<sum;
}

运行结果

total:55

deque::size()函数功能：返回双向队列中元素的个数

deque::resize()函数功能：改变双向队列的大小

#include<iostream>
#include<deque>
using namespace std;
int main(){
    //deque::resize()函数 功能：改变双向队列的大小
    //deque::size()函数 功能：返回双向队列中元素的个数 
	deque<int>mydeque;
	deque<int>::iterator it;
	//set some initial content
	for(int i=1;i<11;i++){
		mydeque.push_back(i);
	}
	mydeque.resize(5);
	cout<<"mydeque contains:";
	for(it=mydeque.begin();it!=mydeque.end();it++){
		cout<<" "<<*it;
	} 
	cout<<" size of mydeque： "<<mydeque.size();
	cout<<endl;
	mydeque.resize(8,23);
	cout<<"mydeque contains:";
	for(it=mydeque.begin();it!=mydeque.end();it++){
		cout<<" "<<*it;
	} 
	cout<<" size of mydeque： "<<mydeque.size();
	cout<<endl;
	mydeque.resize(11);
	cout<<"mydeque contains:";
	for(it=mydeque.begin();it!=mydeque.end();it++){
		cout<<" "<<*it;
	} 
	cout<<" size of mydeque： "<<mydeque.size(); 
	cout<<endl;
}

运行结果

mydeque contains: 1 2 3 4 5 size of mydeque： 5
mydeque contains: 1 2 3 4 5 23 23 23 size of mydeque： 8
mydeque contains: 1 2 3 4 5 23 23 23 0 0 0 size of mydeque： 11

deque::swap()函数功能：和另一个双向队列交换元素

#include<iostream>
#include<deque>
using namespace std;
int main(){
    //deque::swap()函数 功能：和另一个双向队列交换元素
	deque<int>first(3,1998);//three ints with a value of 1998
	deque<int>second(5,20);//five ints with value of 20
	cout<<"before first contains: ";
	for(int i=0;i<first.size();i++){
		cout<<" "<<first[i];
	}
	cout<<endl;
	cout<<"before second contains: ";
	for(int i=0;i<second.size();i++){
		cout<<" "<<second[i];
	}
	cout<<endl;
	first.swap(second);
	cout<<"after first contains: ";
	for(int i=0;i<first.size();i++){
		cout<<" "<<first[i];
	}
	cout<<endl;
	cout<<"after second contains: ";
	for(int i=0;i<second.size();i++){
		cout<<" "<<second[i];
	}
	cout<<endl;
	 
}

运行结果

before first contains:  1998 1998 1998
before second contains:  20 20 20 20 20
after first contains:  20 20 20 20 20
after second contains:  1998 1998 1998

deque::get_allocator()函数功能：返回双向队列的配置器

#include<iostream>
#include<deque>
using namespace std;
int main(){
    //deque::get_allocator()函数 功能：返回双向队列的配置器
	deque<int>mydeque;
	int *p;
	unsigned int i;
	//allocate an array of 5 elements using deque's allocator
	p=mydeque.get_allocator().allocate(5);
	//assign some values to array
	for(i=0;i<5;i++){
		p[i]=i;
	}
	cout<<"the allocated array contains:";
	for(i=0;i<5;i++){
		cout<<" "<<p[i]; 
	}
    cout<<endl;
    mydeque.get_allocator().deallocate(p,5);
}

运行结果

the allocated array contains: 0 1 2 3 4

deque()::at()函数功能：返回指定元素

#include<iostream>
#include<deque>
using namespace std;
int main(){
     //deque()::at()函数 功能：返回指定元素
	deque<int>mydeque(10);
	//10 zero-initialized ints
	//assign some values
	for(int i=0;i<mydeque.size();i++){
		mydeque.at(i)=i;}
		
		cout<<"mydeque contains: ";
		for(int i=0;i<mydeque.size();i++){
			cout<<" "<<mydeque.at(i);
		} 
		cout<<endl;	 
}

运行结果

mydeque contains:  0 1 2 3 4 5 6 7 8 9

deque::max_size()函数功能：返回双向队列能容纳的最大元素个数

#include<iostream>
#include<deque>
using namespace std;
int main(){
    //deque::max_size()函数 功能：返回双向队列能容纳的最大元素个数
	deque<int>mydeque;
	int i;
	cout<<"enter number of elements:";
	cin>>i;
	if(i<mydeque.max_size())mydeque.resize(i);
	else cout<<"that size exceeds the limit \n"; 
}