【STL】stack,deque,queue 基础，应用与操作

stack

1.stack相关介绍

stack（栈）

栈是一种后进先出（LIFO, Last In First Out）的数据结构，意味着最后插入的数据最先被移除。C++ 中的栈是通过容器适配器实现的，底层默认使用 deque（双端队列）来实现，也可以选择 vector 或 list 作为底层容器。

2.stack基础操作汇总

1.构造函数：
stack<T> stk;                       
//stack采用模板类实现， stack对象的默认构造形式

stack(const stack& stk);             
//拷贝构造函数

2.赋值操作：
stack& operator=(const stack& stk);  
//重载等号操作符

3.数据存取：
push(elem);          
//向栈顶添加元素

pop();                
//从栈顶移除第一个元素

top();                
//返回栈顶元素

4.大小操作：
empty();           
//判断堆栈是否为空

size();            
//返回栈的大小

3.整体操作实现

//stack:先进后出的栈结构
//不允许进行遍历操作
#include<iostream>
#include<stack>
using namespace std;


//1.构造函数：
//stack<T> stk;                        //stack采用模板类实现， stack对象的默认构造形式
//stack(const stack& stk);             //拷贝构造函数

//2.赋值操作：
//stack& operator=(const stack& stk);  //重载等号操作符

//3.数据存取：
//push(elem);           //向栈顶添加元素
//pop();                //从栈顶移除第一个元素
//top();                //返回栈顶元素

//4.大小操作：
//empty();            //判断堆栈是否为空
//size();             //返回栈的大小


void test0()
{
	//1.默认构造
	stack<int>a;

	//入栈
	a.push(10);
	a.push(20);
	a.push(30);
	a.push(40);

	cout << "栈的大小为：" << a.size() << endl;

	//只要栈不为空，查看栈顶，并且出栈
	while (!a.empty())
	{
		//查看栈顶元素
		cout <<"当前栈顶元素为：" << a.top() << endl;
		//出栈操作
		a.pop();
	}

	cout << "栈的大小为：" << a.size() << endl;


	//2.拷贝构造
	stack<int>b(a);
	cout << "栈b的大小为：" << b.size() << endl;
}



int main()
{
	test0();
	return 0;
}

4.总结

特点：

• 数据结构：后进先出（LIFO，Last In First Out），意味着最后插入的元素最先被移除。
• 底层实现：stack 是一个容器适配器，默认底层使用 deque 实现，可以替换为 vector 或 list。
• 接口简单：只允许访问和操作栈顶元素，提供 push()、pop()、top() 等操作。
  存储有序：元素按插入顺序排列，但无法随机访问中间的元素。

适用场景：

• 需要追踪嵌套或递归操作，如函数调用栈、括号匹配。
• 实现回溯算法，如深度优先搜索（DFS）。
• 需要保存和恢复中间状态的应用场景。

注意事项：

• 无法访问中间元素： 不能像 vector 或 deque 那样使用索引访问中间元素，只能操作栈顶。
• 不提供遍历接口： 无法使用迭代器或范围循环遍历栈中的元素。
• 内存增长策略： 如果底层容器是 deque，则内存分配会按块进行，而不是连续分配。

deque

1.deque相关介绍

2.deque基础操作汇总

deque（双端队列）

deque 是双端队列，支持在两端进行高效的插入和删除操作。与 vector 类似，deque 是动态数组，但它的内存分配是分段的，允许在前后两端添加和移除元素。

1.deque构造函数：deque容器构造
deque<T> deqT;                     
//默认构造形式

deque(beg, end);                    
//构造函数将[beg, end)区间中的元素拷贝给本身。

deque(n, elem);                    
//构造函数将n个elem拷贝给本身。

deque(const deque& deq);           
 //拷贝构造函数


2.deque赋值操作:给deque容器进行赋值
deque & operator=(const deque & deq);         
//重载等号操作符

assign(beg, end);                             
//将[beg, end)区间中的数据拷贝赋值给本身。

assign(n, elem);                              
//将n个elem拷贝赋值给本身


3.deque大小操作:对deque容器的大小进行操作
deque.empty();                                
//判断容器是否为空

deque.size();                                 
//返回容器中元素的个数

deque.resize(num);                            
//重新指定容器的长度为num,若容器变长，则以默认值填充新位置。
//如果容器变短，则末尾超出容器长度的元素被删除。

deque.resize(num, elem);                     
//重新指定容器的长度为num,若容器变长，则以elem值填充新位置。
//如果容器变短，则末尾超出容器长度的元素被删除

4.deque 插入和删除: 向deque容器中插入和删除数据


两端插入操作：
push_back(elem);                             
在容器尾部添加一个数据

push_front(elem);                            
 //在容器头部插入一个数据

pop_back();                                   
//删除容器最后一个数据

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位置的数据，返回下一个数据的位置（注意这里的参数是迭代器，不能传数字）

5.deque 数据存取: 对deque 中的数据的存取操作
at(int idx);                                 
//返回索引idx所指的数据

operator[];                                  
 //返回索引idx所指的数据

front();                                      
//返回容器中第一个数据元素

back();                                       
//返回容器中最后一个数据元素

6.deque 排序: 利用算法实现对deque容器进行排序
sort(iterator beg, iterator end)             
 //对beg和end区间内元素进行排序

3.deque的创建与相关基础操作

3.1deque容器的遍历说明

//遍历时可改写
void print1(deque<int>& dd)
{
	for (deque<int>::iterator it = dd.begin(); it != dd.end(); it++)
	{
		*it += 20;
		cout << *it << " ";
	}
}

//遍历时不可改写
//此时传入const引用
//迭代器应使用const_iterator
void print2(const deque<int>& dd)
{
	for (deque<int>::const_iterator it = dd.begin(); it != dd.end(); it++)
	{
		cout << *it << " ";
	}
}

如果传入的参数是const修饰的；那么在使用迭代器遍历的时候，就需要使用const_iterator进行遍历了

3.2deque构造函数：deque容器构造

• deque<T> deqT;

  //默认构造形式

• deque(beg, end);

  //构造函数将[beg, end)区间中的元素拷贝给本身。

• deque(n, elem);

  //构造函数将n个elem拷贝给本身。

• deque(const deque& deq);

  //拷贝构造函数

//1.deque构造函数：deque容器构造
void text0()
{
	//1.默认构造形式
	deque<int> d1;

	for (int i = 0; i < 4; i++)
	{
		d1.push_back(i);
	}

	print2(d1);
	cout << endl;
	print1(d1);

	cout << endl;

	//2.构造函数将[beg, end)区间中的元素拷贝给本身。
	deque<int>d2(d1.begin(),d1.end());
	print2(d2);
	cout << endl;


	//3.构造函数将n个elem拷贝给本身。
	deque<int>d3(5, 10);
	print2(d3);

	cout << endl;

	//4.拷贝构造函数
	deque<int>d4(d3);
	print2(d4);
}

3.3deque赋值操作:给deque容器进行赋值

• deque & operator=(const deque & deq);

  //重载等号操作符

• assign(beg, end);

  //将[beg, end)区间中的数据拷贝赋值给本身。

• assign(n, elem);

  //将n个elem拷贝赋值给本身

//2.deque赋值操作:给deque容器进行赋值
void text1()
{
	
	deque<int> d1;

	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i);
	}

	cout << "d1:";
	print2(d1);
	cout<< endl;

	//1.等号赋值
	deque<int>d2;
	d2 = d1;

	cout << "d2:";
	print2(d2);
	cout << endl;
	
	//assign赋值

	//区间赋值：注意左闭右开
	deque<int>d3;
	d3.assign(d2.begin(), d2.end());

	cout << "d3:";
	print2(d3);
	cout << endl;

	//赋值多个元素
	deque<int>d4;
	d4.assign(10,100);

	cout << "d4:";
	print2(d4);
	cout << endl;

}

3.4deque大小操作:对deque容器的大小进行操作

• deque.empty();

  //判断容器是否为空

• deque.size();

  //返回容器中元素的个数

• deque.resize(num);

  //重新指定容器的长度为num,若容器变长，则以默认值填充新位置。

  //如果容器变短，则末尾超出容器长度的元素被删除。

• deque.resize(num, elem);

  //重新指定容器的长度为num,若容器变长，则以elem值填充新位置。

  //如果容器变短，则末尾超出容器长度的元素被删除

//3.deque大小操作:对deque容器的大小进行操作
//与vector的区别：deque没有容量限制，通过中控器直接维护内存分配
void text2()
{
	deque<int>d1;
	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i);
	}

	cout << "d1:";
	print2(d1);
	cout << endl;

	if (d1.empty())
	{
		cout << "d1为空" << endl;
	}
	else
	{
		cout << "d1不为空,d1的大小为：" << d1.size() << endl;
		//deque没有容量的概念
	}

	//重新指定大小：若指定的更大，默认用0填充新位置，可以利用重载版本替换默认填充
	d1.resize(15,1);
	
	cout << "d1:";
	print2(d1);
	cout << endl;

	//若指定的更小，超出部分元素被删除
	d1.resize(3);

	cout << "d1:";
	print2(d1);
	cout << endl;

}

3.6deque 插入和删除 : 向deque容器中插入和删除数据

两端插入操作：

• push_back(elem);

  在容器尾部添加一个数据

• push_front(elem);

  //在容器头部插入一个数据

• pop_back();

  //删除容器最后一个数据

• 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位置的数据，返回下一个数据的位置（注意这里的参数是迭代器，不能传数字）

//4.deque 插入和删除 : 向deque容器中插入和删除数据

//两端的插入与删除操作:
void text03()
{
	deque<int>d1;

	//插入操作：尾插、头插
	//尾插：
	d1.push_back(10);
	d1.push_back(20);

	//头插：
	d1.push_front(2);
	d1.push_front(3);//应输出：3 2 10 20

	cout << "d1:";
	print2(d1);
	cout << endl;
	//删除操作：头删、尾删

	//尾删：
	d1.pop_back();
	

	//头删：
	d1.pop_front();//应输出 2 10
	

	cout << "d1:";
	print2(d1);
}


//指定位置的插入与删除操作:
void text13()
{
	//插入操作:

	deque<int>d1;
	d1.push_back(10);
	d1.push_back(20);
	d1.push_front(2);
	d1.push_front(3);//应输出：3 2 10 20

	cout << "d1:";
	print2(d1);
	cout << endl;

	//指定位置插入一个值,注意：第一个参数是迭代器，第二个参数是要插入的值
	d1.insert(d1.begin() + 1, 10000);//应输出：3 10000 2 10 20

	cout << "d1:";
	print2(d1);
	cout << endl;

	//指定位置插入n个相同元素，注意：第一个参数是迭代器，第二个参数是要插入的个数，第三个参数是插入的值
	d1.insert(d1.begin() + 1, 3, 999);//应输出：3 999 999 999 10000 2 10 20

	cout << "d1:";
	print2(d1);
	cout << endl;

	//指定位置插入一个范围，注意：第一个参数是迭代器，第二个参数是范围开始，第三个参数是范围结束
	deque <int> d2;
	d2.push_back(1);
	d2.push_back(1);
	d2.push_back(1);

	d2.insert(d2.begin() + 2, d1.begin() + 1, d1.end() - 1);//应输出：1 1 999 999 999 10000 2 10 1
	//这里将1 1 1 2 10 1插入到d2的3号位置
	cout << "d2:";
	print2(d2);
	cout << endl;


	//删除操作：

	//删除指定位置数据：（注意这里的参数是迭代器，不能传数字）
	d2.erase(d2.begin()+2);//删除d2的3号数据
	//应输出：1 1 999 999 10000 2 10 1
	cout << "d2:";
	print2(d2);
	cout << endl;

	//删除指定区间数据：
	d2.erase(d2.begin() + 2,d2.begin()+5);//删除d2的3号到6号数据
	//应输出：1 1 2 10 1
	cout << "d2:";
	print2(d2);
	cout << endl;

	//清空容器的所有数据：
	d2.clear();
	//等价于d2.erase(d2.begin(), d2.end());
	cout << "d2:";
	print2(d2);
	cout << endl;
}

首尾进行插入与删除

指定位置进行插入与删除

3.7deque 数据存取: 对deque 中的数据的存取操作

• at(int idx);

  //返回索引idx所指的数据

• operator[];

  //返回索引idx所指的数据

• front();

  //返回容器中第一个数据元素

• back();

  //返回容器中最后一个数据元素

//5.deque 数据存取: 对deque 中的数据的存取操作
void text4()
{
	deque<int>d1;
	d1.push_back(1);
	d1.push_back(12);
	d1.push_back(11);
	d1.push_back(1213);
	d1.push_back(14);
	d1.push_back(15);

	//通过[]访问元素
	for (int i = 0;i<d1.size();i++)
	{
		cout << d1[i] << " ";
	}
	cout << endl;


	//通过at访问元素:参数为下标
	for (int i = 0; i < d1.size(); i++)
	{
		cout << d1.at(i) << " ";
	}
	cout << endl;


	//访问首尾元素:
	cout << "front元素为:" << d1.front() << endl;
	cout << "back元素为:" << d1.back() << endl;
}

3.8deque 排序: 利用算法实现对deque容器进行排序

• sort(iterator beg, iterator end)
  //对beg和end区间内元素进行排序

//6.deque 排序: 利用算法实现对deque容器进行排序
void text5()
{
	deque<int>d1;
	d1.push_back(0);
	d1.push_back(90);
	d1.push_back(-10);
	d1.push_back(106);
	d1.push_back(2);
	d1.push_back(133);

	cout<<"排序前:";
	print2(d1);

	//进行排序;（默认从小到大排序）
	//对于支持访问的迭代器的容器，都可以使用sort算法对其直接排序
	sort(d1.begin(),d1.end());

	cout << "排序后:";
	print2(d1);
}

4.总结

特点：

• 数据结构：支持双端插入和删除操作的动态数组，既可以在前端进行插入和删除操作，也可以在末端进行操作。
• 底层实现：通常实现为分段的连续内存块，允许在两端进行常数时间的插入和删除。
• 支持随机访问：与 vector 一样支持通过索引进行随机访问，deque[i] 的操作时间复杂度为 O(1)。
• 动态调整容量：与 vector 类似，deque 可以自动调整大小，但它的内存分配更加灵活，允许在两端都进行扩展。

适用场景：

• 需要频繁在容器的两端进行插入和删除操作的场景，如双端队列、滑动窗口问题。
• 实现队列、双向队列等需要灵活操作两端数据的算法。

注意事项：

• 比 vector 稍慢的随机访问：虽然 deque 支持随机访问，但由于其内存分配是分段的，访问效率略低于 vector。
• 遍历性能稍逊：由于其内存分布分段，遍历性能不如 vector。
• 空间开销：deque 需要额外的内存来管理不同的内存块，因此在某些场景下，空间开销可能大于 vector。

5.整体代码一览

//0.双端数组：deque：可以头端插入，删除；也可以尾端插入，删除
//与vector容器十分相似,但没有容量限制
//支持随机访问
#include<iostream>
#include<deque>
#include<algorithm>
using namespace std;



//1.deque构造函数：deque容器构造
//deque<T> deqT;                      //默认构造形式
//deque(beg, end);                    //构造函数将[beg, end)区间中的元素拷贝给本身。
//deque(n, elem);                     //构造函数将n个elem拷贝给本身。
//deque(const deque& deq);            //拷贝构造函数


//2.deque赋值操作:给deque容器进行赋值
//deque & operator=(const deque & deq);         //重载等号操作符
//assign(beg, end);                             //将[beg, end)区间中的数据拷贝赋值给本身。
//assign(n, elem);                              //将n个elem拷贝赋值给本身


//3.deque大小操作:对deque容器的大小进行操作
//deque.empty();                                //判断容器是否为空
//deque.size();                                 //返回容器中元素的个数

//deque.resize(num);                            //重新指定容器的长度为num,若容器变长，则以默认值填充新位置。
                                                //如果容器变短，则末尾超出容器长度的元素被删除。

//deque.resize(num, elem);                      //重新指定容器的长度为num,若容器变长，则以elem值填充新位置。
                                                //如果容器变短，则末尾超出容器长度的元素被删除

//4.deque 插入和删除: 向deque容器中插入和删除数据


//两端插入操作：
//push_back(elem);                              //在容器尾部添加一个数据
//push_front(elem);                             //在容器头部插入一个数据
//pop_back();                                   //删除容器最后一个数据
//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位置的数据，返回下一个数据的位置（注意这里的参数是迭代器，不能传数字）

//5.deque 数据存取: 对deque 中的数据的存取操作
//at(int idx);                                  //返回索引idx所指的数据
//operator[];                                   //返回索引idx所指的数据
//front();                                      //返回容器中第一个数据元素
//back();                                       //返回容器中最后一个数据元素

//6.deque 排序: 利用算法实现对deque容器进行排序
//sort(iterator beg, iterator end)              //对beg和end区间内元素进行排序
 
	   
		 

//遍历时可改写
void print1(deque<int>& dd)
{
	for (deque<int>::iterator it = dd.begin(); it != dd.end(); it++)
	{
		*it += 20;
		cout << *it << " ";
	}
}

//遍历时不可改写
//此时传入const引用
//迭代器应使用const_iterator
void print2(const deque<int>& dd)
{
	for (deque<int>::const_iterator it = dd.begin(); it != dd.end(); it++)
	{
		cout << *it << " ";
	}
}

//1.deque构造函数：deque容器构造
void text0()
{
	//1.默认构造形式
	deque<int> d1;

	for (int i = 0; i < 4; i++)
	{
		d1.push_back(i);
	}

	print2(d1);
	cout << endl;
	print1(d1);

	cout << endl;

	//2.构造函数将[beg, end)区间中的元素拷贝给本身。
	deque<int>d2(d1.begin(),d1.end());
	print2(d2);
	cout << endl;


	//3.构造函数将n个elem拷贝给本身。
	deque<int>d3(5, 10);
	print2(d3);

	cout << endl;

	//4.拷贝构造函数
	deque<int>d4(d3);
	print2(d4);
}


//2.deque赋值操作:给deque容器进行赋值
void text1()
{
	
	deque<int> d1;

	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i);
	}

	cout << "d1:";
	print2(d1);
	cout<< endl;

	//1.等号赋值
	deque<int>d2;
	d2 = d1;

	cout << "d2:";
	print2(d2);
	cout << endl;
	
	//assign赋值

	//区间赋值：注意左闭右开
	deque<int>d3;
	d3.assign(d2.begin(), d2.end());

	cout << "d3:";
	print2(d3);
	cout << endl;

	//赋值多个元素
	deque<int>d4;
	d4.assign(10,100);

	cout << "d4:";
	print2(d4);
	cout << endl;

}

//3.deque大小操作:对deque容器的大小进行操作
//与vector的区别：deque没有容量限制，通过中控器直接维护内存分配
void text2()
{
	deque<int>d1;
	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i);
	}

	cout << "d1:";
	print2(d1);
	cout << endl;

	if (d1.empty())
	{
		cout << "d1为空" << endl;
	}
	else
	{
		cout << "d1不为空,d1的大小为：" << d1.size() << endl;
		//deque没有容量的概念
	}

	//重新指定大小：若指定的更大，默认用0填充新位置，可以利用重载版本替换默认填充
	d1.resize(15,1);
	
	cout << "d1:";
	print2(d1);
	cout << endl;

	//若指定的更小，超出部分元素被删除
	d1.resize(3);

	cout << "d1:";
	print2(d1);
	cout << endl;

}

//4.deque 插入和删除 : 向deque容器中插入和删除数据

//两端的插入与删除操作:
void text03()
{
	deque<int>d1;

	//插入操作：尾插、头插
	//尾插：
	d1.push_back(10);
	d1.push_back(20);

	//头插：
	d1.push_front(2);
	d1.push_front(3);//应输出：3 2 10 20

	cout << "d1:";
	print2(d1);
	cout << endl;
	//删除操作：头删、尾删

	//尾删：
	d1.pop_back();
	

	//头删：
	d1.pop_front();//应输出 2 10
	

	cout << "d1:";
	print2(d1);
}


//指定位置的插入与删除操作:
void text13()
{
	//插入操作:

	deque<int>d1;
	d1.push_back(10);
	d1.push_back(20);
	d1.push_front(2);
	d1.push_front(3);//应输出：3 2 10 20

	cout << "d1:";
	print2(d1);
	cout << endl;

	//指定位置插入一个值,注意：第一个参数是迭代器，第二个参数是要插入的值
	d1.insert(d1.begin() + 1, 10000);//应输出：3 10000 2 10 20

	cout << "d1:";
	print2(d1);
	cout << endl;

	//指定位置插入n个相同元素，注意：第一个参数是迭代器，第二个参数是要插入的个数，第三个参数是插入的值
	d1.insert(d1.begin() + 1, 3, 999);//应输出：3 999 999 999 10000 2 10 20

	cout << "d1:";
	print2(d1);
	cout << endl;

	//指定位置插入一个范围，注意：第一个参数是迭代器，第二个参数是范围开始，第三个参数是范围结束
	deque <int> d2;
	d2.push_back(1);
	d2.push_back(1);
	d2.push_back(1);

	d2.insert(d2.begin() + 2, d1.begin() + 1, d1.end() - 1);//应输出：1 1 999 999 999 10000 2 10 1
	//这里将1 1 1 2 10 1插入到d2的3号位置
	cout << "d2:";
	print2(d2);
	cout << endl;


	//删除操作：

	//删除指定位置数据：（注意这里的参数是迭代器，不能传数字）
	d2.erase(d2.begin()+2);//删除d2的3号数据
	//应输出：1 1 999 999 10000 2 10 1
	cout << "d2:";
	print2(d2);
	cout << endl;

	//删除指定区间数据：
	d2.erase(d2.begin() + 2,d2.begin()+5);//删除d2的3号到6号数据
	//应输出：1 1 2 10 1
	cout << "d2:";
	print2(d2);
	cout << endl;

	//清空容器的所有数据：
	d2.clear();
	//等价于d2.erase(d2.begin(), d2.end());
	cout << "d2:";
	print2(d2);
	cout << endl;
}

//5.deque 数据存取: 对deque 中的数据的存取操作
void text4()
{
	deque<int>d1;
	d1.push_back(1);
	d1.push_back(12);
	d1.push_back(11);
	d1.push_back(1213);
	d1.push_back(14);
	d1.push_back(15);

	//通过[]访问元素
	for (int i = 0;i<d1.size();i++)
	{
		cout << d1[i] << " ";
	}
	cout << endl;


	//通过at访问元素:参数为下标
	for (int i = 0; i < d1.size(); i++)
	{
		cout << d1.at(i) << " ";
	}
	cout << endl;


	//访问首尾元素:
	cout << "front元素为:" << d1.front() << endl;
	cout << "back元素为:" << d1.back() << endl;
}


//6.deque 排序: 利用算法实现对deque容器进行排序
void text5()
{
	deque<int>d1;
	d1.push_back(0);
	d1.push_back(90);
	d1.push_back(-10);
	d1.push_back(106);
	d1.push_back(2);
	d1.push_back(133);

	cout<<"排序前:";
	print2(d1);

	//进行排序;（默认从小到大排序）
	//对于支持访问的迭代器的容器，都可以使用sort算法对其直接排序
	sort(d1.begin(),d1.end());

	cout << "排序后:";
	print2(d1);
}

int main()
{
	text0();
	text1();
	text2();
	text03();
	text13();
	text4();
	text5();
	return 0;
}

queue

1.queue相关介绍

队列是一种先进先出（FIFO, First In First Out）的数据结构，意味着第一个插入的数据最先被移除。与 stack 类似，queue 也是一个容器适配器，通常底层使用 deque 实现。

2.queue基础操作汇总

1.构造函数：
-queue<T> que;                                 
//queue采用模板类实现，queue对象的默认构造形式

queue(const queue& que);                      
//拷贝构造函数

2.赋值操作：
queue& operator=(const queue& que);          
//重载等号操作符

3.数据存取：
push(elem);                                   
//往队尾添加元素

pop();                                       
//从队头移除第一个元素

back();                                       
//返回最后一个元素

front();                                      
//返回第一个元素

4.大小操作：
empty();                                     
 //判断队是否为空

size();                                      
 //返回队的大小

3.整体操作实现

//queue:先进先出的队列
//含两端出口：入队端（队尾），出队端（队头）
//不允许有遍历行为
#include<iostream>
#include<queue>
using namespace std;

//1.构造函数：
//queue<T> que;                                 //queue采用模板类实现，queue对象的默认构造形式
//queue(const queue& que);                      //拷贝构造函数

//2.赋值操作：
//queue& operator=(const queue& que);           //重载等号操作符

//3.数据存取：
//push(elem);                                   //往队尾添加元素
//pop();                                        //从队头移除第一个元素
//back();                                       //返回最后一个元素
//front();                                      //返回第一个元素

//4.大小操作：
//empty();                                      //判断队是否为空
//size();                                       //返回队的大小


void text1()
{
	//1.默认构造
	queue<int> q;

	//入队
	for (int i = 0; i < 10; i++)
	{
		q.push(i);
	}


	//2.拷贝构造
	queue<int> q1(q);

	//3.赋值操作
	queue<int> q2=q1;


	//对于队列q：

	cout << "队列q大小：" << q.size() << endl;

	//只要队不为空，查看队头，并且出队
	while (!q.empty())
	{
		cout << q.front() << " ";
		q.pop();
	}

	cout << endl << "队列q大小：" << q.size() << endl;

	//对于队列q1:


	cout << "队列q1大小：" << q1.size() << endl;
	
	//入队4个元素，并查看队尾
	for(int i = 1; i < 5 ; i++)
	{
		q1.push(i);
		cout << q1.back() << " ";
	}

	cout << endl;

	cout << "队列q1大小：" << q1.size() << endl;
}


int main()
{
	text1();
	return 0;
}

4.总结

特点：

• 数据结构：先进先出（FIFO，First In First Out），意味着最先插入的元素最先被移除。
• 底层实现：通常底层实现为 deque，可以替换为其他容器，但只能通过 push() 和 pop() 操作队列的前端和末端。
• 接口限制：只能访问和操作队列的前端和末端，无法随机访问中间元素。
  适用场景：
• 需要按顺序处理任务的场景，如任务调度、消息传递、广度优先搜索（BFS）。
  流水线数据处理，如生产者-消费者模型。
  注意事项：
• 不能随机访问：只能访问队列的前端和末端，无法通过索引访问或操作中间元素。
• 不支持遍历：无法使用迭代器或范围循环遍历队列中的元素。
• 常用于任务调度：如果任务处理顺序严格为 FIFO，queue 是非常合适的选择。

整体对比总结