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

news2024/9/20 16:57:19

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 是非常合适的选择。

整体对比总结

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2149462.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

数字电子技术-数值比较器

数字电子技术-数值比较器

目录 数值比较器 1、1位二进制数值比较器 多位数值比较器 4位数值比较器74LS85(TTL型) 74LS85数值比较器的使用说明 数值比较器 Digital Comparator,又称数字比较器&#xff0c;用以对两个数字的大小或是否相等进行比较的逻辑电路。 1、1位二进制数值比较器 A和B只能取值…
阅读更多...
硬盘数据恢复必备：4 款强大硬盘数据恢复软件推荐！

硬盘数据恢复必备：4 款强大硬盘数据恢复软件推荐！

在数字化的时代&#xff0c;我们的生活和工作越来越离不开电脑&#xff0c;而硬盘作为重要的数据存储设备&#xff0c;一旦出现数据丢失的情况&#xff0c;往往会给我们带来极大的困扰。别担心&#xff0c;今天就为大家推荐四款强大的硬盘数据恢复软件&#xff0c;帮助你轻松找…
阅读更多...
六西格玛绿带培训多少钱？从授“鱼”到授“渔”

六西格玛绿带培训多少钱？从授“鱼”到授“渔”

六西格玛作为一种全球公认的质量管理方法&#xff0c;其影响力日益扩大&#xff0c;而六西格玛绿带培训作为这一体系中的关键环节&#xff0c;更是吸引了众多希望在职场上脱颖而出的专业人士。本文&#xff0c;深圳天行健企业管理咨询公司将从多个维度深入探讨“六西格玛绿带培…
阅读更多...
巴菲特的长期投资策略：新投资者实现财务自由的启示

巴菲特的长期投资策略：新投资者实现财务自由的启示

在投资界&#xff0c;沃伦巴菲特的名字几乎无人不晓。作为伯克希尔哈撒韦公司的董事长和首席执行官&#xff0c;巴菲特以其卓越的投资智慧和长期价值增长策略&#xff0c;成为了全球投资者的偶像。巴菲特的成功不仅仅是因为他的财富&#xff0c;更在于他对投资的深刻理解和对财…
阅读更多...
Linux嵌入式驱动开发指南(速记版)---Linux基础篇

Linux嵌入式驱动开发指南(速记版)---Linux基础篇

第一章 Ubuntu系统入门 1.1 Linux磁盘管理 1.1.1 Linux磁盘管理基本概念 关键词&#xff1a; Linux 磁盘管理 挂载点 /etc/fstab文件 分区 ls /dev/sd* 联系描述&#xff1a; Linux 磁盘管理体系通过“挂载点”概念替代了 Windows 中的“分区”概念&#xff0c;将硬盘部分以文…
阅读更多...
如何保养净水器

如何保养净水器

俗话说&#xff0c;“三分用&#xff0c;七分养”&#xff0c;这句话道出了家电这类消费品使用寿命的秘诀。家电的长久运行并不仅仅依赖于其出厂时的品质&#xff0c;更与我们日常的维护保养息息相关。虽然行业标准或制造商通常会规定家电的推荐使用年限&#xff0c;但在许多家…
阅读更多...
【计算机网络】传输层协议UDP

【计算机网络】传输层协议UDP

目录 一、端口号1.1 端口号范围划分1.2 认识知名端口号 二、UDP协议2.1 UDP协议端格式2.2 UDP的特点2.3 UDP的缓冲区2.4 UDP使用注意事项2.5 基于UDP的应用层协议 一、端口号 传输层协议负责数据的传输&#xff0c;从发送端到接收端。端口号标识一个主机上进行通信的不同的应用…
阅读更多...
Go语言的io输入输出流

Go语言的io输入输出流

Go语言的输入输出流不如其他语言那么直观&#xff0c;由于是通过实现接口方法的隐式继承所以比较抽象&#xff0c;今天具体介绍一下go语言的输入输出流。 go语言输入输出在io库中&#xff0c;使用Reader接口&#xff0c;如下&#xff1a; type Reader interface {Read(p []by…
阅读更多...
windows下用cmake编译腾讯云的对象存储COS的XML C++SDK

windows下用cmake编译腾讯云的对象存储COS的XML C++SDK

首先在腾讯云官网上下载sdk&#xff0c;网址及官方说明文档如下&#xff1a; 对象存储 快速入门-SDK 文档-文档中心-腾讯云 我下载解压之后的路径如下图&#xff1a; 下载完后就要编译了。 1.下载VS&#xff0c;我的开发环境是 visual studio 2019 2. 下载CMake&#xff…
阅读更多...
UNRAID系统忘记密码解决办法

UNRAID系统忘记密码解决办法

前言 unraid系统自己通过命令修改密码以后&#xff0c;怎么也进不去了。 这次带来如何重置密码 操作
阅读更多...
1-2.Jetpack 之 Navigation 跳转编码模板

1-2.Jetpack 之 Navigation 跳转编码模板

一、Navigation 1、Navigation 概述 Navigation 是 Jetpack 中的一个重要成员&#xff0c;它主要是结合导航图&#xff08;Navigation Graph&#xff09;来控制和简化 Fragment 之间的导航&#xff0c;即往哪里走&#xff0c;该怎么走 2、Navigate 引入 在模块级 build.gra…
阅读更多...
《关节机械臂：智能仓库的高效助手》

《关节机械臂：智能仓库的高效助手》

关节机械臂作为一种高度精密的机器设备&#xff0c;在现代制造工厂的智能仓库系统中发挥着至关重要的作用。其设计初衷便是精准地模拟人类手臂在订单拣选操作中的各种运动&#xff0c;以实现高效、准确的物流作业。 这些多功能的机器人由多个关节巧妙组合而成&#xff0c;通常拥…
阅读更多...
人工智能【AI】：未来的驱动力

人工智能【AI】：未来的驱动力

在21世纪&#xff0c;人工智能&#xff08;AI&#xff09;已经成为推动技术进步和创新的关键力量。AI不仅仅是科幻小说中的概念&#xff0c;它已经渗透到我们日常生活的方方面面&#xff0c;从智能手机的语音助手到复杂的医疗诊断系统&#xff0c;AI的应用无处不在。 人工智能…
阅读更多...
KG Structure as Prompt：利用知识图谱构建Prompt，提高大模型对因果关系的理解

KG Structure as Prompt：利用知识图谱构建Prompt，提高大模型对因果关系的理解

KG Structure as Prompt&#xff1a;利用知识图谱构建Prompt&#xff0c;提高大模型对因果关系的理解 秒懂大纲提出背景解法拆解创意视角中文意译 论文&#xff1a;Knowledge Graph Structure as Prompt: Improving Small Language Models Capabilities for Knowledge-based Ca…
阅读更多...
Mybatis框架映射---代码实现(XML配置以及注解形式)

Mybatis框架映射---代码实现(XML配置以及注解形式)

目录 一. 映射关系 1 对 1-映射方式 1.通过xml文件实现映射的一对一关系 总结 &#xff1a; 2.通过注解的方式来实现下面的 1 对 1 的映射关系&#xff0c;实现级联查询 总结&#xff1a; 二. 映射关系多对一 1.通过xml文件实现映射的多对一关系 2.通过注解的方式来实现…
阅读更多...
PHP发邮件教程：配置SMTP服务器发送邮件？

PHP发邮件教程：配置SMTP服务器发送邮件？

PHP发邮件的几种方式&#xff1f;如何使用PHP通过SMTP协议发信&#xff1f; PHP作为一种广泛使用的服务器端脚本语言&#xff0c;提供了多种方式来发送邮件。AokSend将详细介绍如何通过配置SMTP服务器来实现PHP发邮件教程的核心内容。 PHP发邮件教程&#xff1a;设置参数 这…
阅读更多...
Qt 模型视图(一):概述

Qt 模型视图(一):概述

文章目录 Qt 模型视图(一):概述1、模型/视图结构基本原理2、模型3、视图4、代理5、简单实例 Qt 模型视图(一):概述 ​ 模型/视图结构是一种将数据存储和界面展示分离的编程方法。模型存储数据&#xff0c;视图组件显示模型中的数据&#xff0c;在视图组件里修改的数据会被自动…
阅读更多...
PCIe扫盲（11）

PCIe扫盲（11）

系列文章目录 PCIe扫盲&#xff08;一&#xff09; PCIe扫盲&#xff08;二&#xff09; PCIe扫盲&#xff08;三&#xff09; PCIe扫盲&#xff08;四&#xff09; PCIe扫盲&#xff08;五&#xff09; PCIe扫盲&#xff08;六&#xff09; PCIe扫盲&#xff08;七&#xff09…
阅读更多...
剪画：一带一路机遇下，自媒体如何跨越语言障碍！

剪画：一带一路机遇下，自媒体如何跨越语言障碍！

随着国家 “一带一路” 的持续推进&#xff0c;我国的文化魅力如璀璨星辰&#xff0c;在世界舞台上熠熠生辉。美食的独特风味、华服的精美绝伦&#xff0c;越来越受到外国人的喜爱。这对于做自媒体的小伙伴们而言&#xff0c;无疑是一个巨大的机遇。 然而&#xff0c;机遇往往与…
阅读更多...
利用Leaflet.js和turf.js创建交互式地图：航道路线绘制

利用Leaflet.js和turf.js创建交互式地图：航道路线绘制

引言 在现代Web应用中&#xff0c;地图的交互性是提供丰富用户体验的关键。Leaflet.js是一个轻量级的开源JavaScript库&#xff0c;它提供了简单易用的API来构建交云的地图。与此同时&#xff0c;turf.js作为一个强大的地理空间分析库&#xff0c;能够处理复杂的地理数据操作。…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023