精华内容
下载资源
问答
  • c++队列
    2020-05-13 15:57:44

    队列

    队列的链式存储结构其实就是简单的链表,只是添加了队头和队尾指针。限制了添加和删除只能从队尾和队头操作。

    代码实现

    #include <iostream>
    using namespace std;
    
    // 结点
    typedef struct QNode
    {
    	int data;
    	struct QNode *next;
    }QNode, *QueuePtr;
    
    
    // 链表结构
    typedef struct
    {
    	QueuePtr front, rear;	// 队头,队尾指针
    }LinkQueue;
    
    
    // 创建队列
    void CreateQueue(LinkQueue *Q, int n)
    {
    	QueuePtr q = new QNode();	// 创建头结点 
    	Q->front = Q->rear = q;		// 并令队头队尾指针指向头结点
    
    	QueuePtr p;
    
    	for (int i = 0; i < n; i++)
    	{
    		p = new QNode();
    		p->data = i;
    		p->next = NULL;
    
    		Q->rear->next = p;
    		Q->rear = p;
    
    		// EnQueue(&p, i);
    	}
    
    }
    
    
    // 队尾添加元素
    void EnQueue(LinkQueue *Q, int data)
    {
    	QueuePtr s = new QNode();
    	s->data = data;
    	s->next = NULL;
    
    	Q->rear->next = s;	//将新节点入队
    	Q->rear = s;	//队尾指向新结点
    }
    
    
    // 队头删除元素
    void DeQueue(LinkQueue *Q, int *data)
    {
    	QueuePtr p;
    	if (Q->front == Q->rear)
    	{
    		cout << "Queue is empty" << endl;
    	}
    
    	p = Q->front->next;		// 获取删除节点
    	Q->front->next = p->next;	// 连接新队列
    	*data = p->data;
    
    	if (Q->rear == p)		// 如果队头是队尾,则将rear指向头结点
    	{
    		Q->rear = Q->front;
    	}
    
    	delete(p);
    }
    
    
    void PrintQueue(LinkQueue *Q)
    {
    	QueuePtr p;
    	p = Q->front->next;
    
    	if (!p) cout << "Queue is empty" << endl;
    
    	while (p)
    	{
    		cout << p->data<<endl;
    		p = p->next;
    	}
    }
    
    更多相关内容
  • C++队列操作入队出队

    2014-10-22 20:12:32
    简单队列操作,vc++实现。队列类实现,小弟新手,大神莫黑
  • C++ 队列

    千次阅读 2018-03-24 11:37:56
    C++ 队列 C++是C语言的继承,C语言是过程化程序设计语言,C++是面向对象的程序设计语言,过程化意思是编程的作用倾向于提供输入通过一系列的代码得到一个输出,面向对象则使适用于模块化设计,C语言的局限性在大型...

    C++ 队列

    C++是C语言的继承,C语言是过程化程序设计语言,C++是面向对象的程序设计语言,过程化意思是编程的作用倾向于提供输入通过一系列的代码得到一个输出,面向对象则使适用于模块化设计,C语言的局限性在大型程序开发设计的过程中则会逐步显现出来。

    这里写图片描述

    C++ 相对C语言有什么优点呢

    • 封装性:对数据的管理上的优点
    • 继承性:体现了代码重用上的优点
    • 多态性:则体现了同一方法对不同类对象有不同的效果

    牢牢记住这三个词:封装、继承、多态,这些是谭浩强C++教学丛书中描述的最基本的概念。


    知道了这些大的概念,知道了C++是面向对象的语言,下一步就可以开始研究我们的对象了,怎么去实现面向对象呢?比如我们要设计一个管理系统,需要先研究这个系统里有哪些类,这些类相应具有什么方法,然后逐步通过代码一步一步讲类和方法码出来。

    这里说一个题外话,为什么很多程序员喜欢戏称自己的工作为“搬砖”,因为在大公司里,很多程序员很少参与到新的模块、代码的设计,所做的工作就是将前人的代码从这个程序搬到另一个程序中,所做的工作就像搬砖,枯燥乏味。

    上面说到设计一个系统要考虑到为了这个系统,需要设计哪些类。而队列,可以考虑为一种类,也可以作为组成某个类的一种数据结构。


    在了解队列之前,需要知道几个最基本的概念:指针、FIFO(先进先出)
    这里就不详细讲解指针的概念,只需要知道指针的值指向电脑寄存器上另外一个地方的值,可以理解它记录的是另外一个变量的位置或者说地址。
    FIFO,First Input First Output的缩写,先进先出队列,这是一种传统的按序执行方法,先进入的指令先完成并引退,跟着才执行第二条指令。生活中时常出现的排队就是一种先进先出的行为——在超市购物之后会提着我们满满的购物车来到收银台排在结账队伍的最后,眼睁睁地看着前面的客户一个个离开。这就是一种先进先出机制,先排队的客户先行结账离开。


    千呼万唤始出来,终于可以开始了解队列了。
    ①队列是一种特殊的线性表,特殊之处在于它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作,和栈一样,队列是一种操作受限制的线性表。进行插入操作的端称为队尾,进行删除操作的端称为队头。
    ②队列中没有元素时,称为空队列。
    ③建立顺序队列结构必须为其静态分配或动态申请一片连续的存储空间,并设置两个指针进行管理。一个是队头指针front,它指向队头元素;另一个是队尾指针rear,它指向下一个入队元素的存储位置。
    ④队列采用的FIFO(first in first out),新元素(等待进入队列的元素)总是被插入到链表的尾部,而读取的时候总是从链表的头部开始读取。每次读取一个元素,释放一个元素。所谓的动态创建,动态释放。因而也不存在溢出等问题。由于链表由结构体间接而成,遍历也方便。(先进先出)
    这里写图片描述


    实际上,上面所说的概念是顺序队列的概念,你有没有看出顺序队列的弊端?
    对!实际上当A、B、C依次加入队列,然后又按照A、B、C的顺序依次读取释放之后,front和rear指针从队列的0号位置,指向了最末的3号位置,假如这个队列只静态申请了0到3这4个单元位置,到此这个队列就没法再添加进新的元素了,因为假如添加D之后,rear再往后移将没有空间给它指向了!(这也被称为假上溢现象),这就是顺序队列的弊端。

    知道了顺序队列的弊端如何去改进呢,我们就引申出循环队列的概念。
    好,我们一起把顺序队列、循环队列再过一遍。

    顺序队列

    建立顺序队列结构必须为其静态分配或动态申请一片连续的存储空间,并设置两个指针进行管理。一个是队头指针front,它指向队头元素;另一个是队尾指针rear,它指向下一个入队元素的存储位置,如图所示

    每次在队尾插入一个元素是,rear增1;每次在队头删除一个元素时,front增1。随着插入和删除操作的进行,队列元素的个数不断变化,队列所占的存储空间也在为队列结构所分配的连续空间中移动。当front=rear时,队列中没有任何元素,称为空队列。当rear增加到指向分配的连续空间之外时,队列无法再插入新元素,但这时往往还有大量可用空间未被占用,这些空间是已经出队的队列元素曾经占用过得存储单元。
    顺序队列中的溢出现象:
    (1) “下溢”现象:当队列为空时,做出队运算产生的溢出现象。“下溢”是正常现象,常用作程序控制转移的条件。
    (2)”真上溢”现象:当队列满时,做进栈运算产生空间溢出的现象。“真上溢”是一种出错状态,应设法避免。
    (3)”假上溢”现象:由于入队和出队操作中,头尾指针只增加不减小,致使被删元素的空间永远无法重新利用。当队列中实际的元素个数远远小于向量空间的规模时,也可能由于尾指针已超越向量空间的上界而不能做入队操作。该现象称为”假上溢”现象。

    总结一下:
    1、队列时先进先出的一种数据结构(类比排队有助理解);
    2、顺序队列有两个指针,队列非空时,front指向下一个要删除的元素的位置,rear指向下一个要插入的元素的位置;
    3、顺序队列当rear指向申请的存储单元最末时,无法再进行添加操作(上溢);
    4、front=rear , 代表队列为空。

    循环队列

    在实际使用队列时,为了使队列空间能重复使用,往往对队列的使用方法稍加改进:无论插入或删除,一旦rear指针增1或front指针增1 时超出了所分配的队列空间,就让它指向这片连续空间的起始位置。自己真从MaxSize-1增1变到0,可用取余运算rear%MaxSize和front%MaxSize来实现。这实际上是把队列空间想象成一个环形空间,环形空间中的存储单元循环使用,用这种方法管理的队列也就称为循环队列。除了一些简单应用之外,真正实用的队列是循环队列。
    在循环队列中,当队列为空时,有front=rear,而当所有队列空间全占满时,也有front=rear。为了区别这两种情况,规定循环队列最多只能有MaxSize-1个队列元素,当循环队列中只剩下一个空存储单元时,队列就已经满了。因此,队列判空的条件是front=rear,而队列判满的条件是front=(rear+1)%MaxSize。

    判空的条件很好理解,判满怎么理解呢?
    一个循环队列,假如有六个存储单位,0-5,往里面依次加入A、B、C、D、E这5个元素,则依次占满了0-4这个五个存储位置,因为只有插入操作,所以front的值不变,仍然为0,rear的值则变为5,此时已经满足了队列满的条件(只剩下5这一个存储单位了),我们代入公式看一下:
    front=0
    (rear+1)%6=(5+1)%6=0
    满足判满条件,可以判断队列是满的。

    如果继续删除一个元素然后添加一个元素呢。
    此时front=1,rear=0
    (rear+1)%6=(0+1)%6=1
    仍然满足条件。

    总结一下:
    1、判空:front=rear 判满:front=(rear+1)%MaxSize;
    2、取余运算使得队列可以进行循环使用;
    3、和顺序队列的区别是存储空间可以循环使用;
    4、需要预留一个存储空间大小,即还剩一个存储空间时,队列已经满了。

    对队列概念的讲解就到这里,下一篇内容我们就要着手开始用C++语言来实现C++循环队列。


    了解了队列,之后也一定会遇到“堆”,”栈”,”堆栈”的概念,这些数据结构和队列有一定相似之处,这些到底是什么意思?最关键的是即使你去面试,这些都还会问到,所以如果你不懂对你是损失很大的。


    [1] https://jingyan.baidu.com/article/6c67b1d6a09f9a2786bb1e4a.html
    [2] https://www.cnblogs.com/liumce/p/7760670.html
    [3] https://blog.csdn.net/xiaolei09bupt/article/details/44565255

    展开全文
  • C++队列堆栈小作业

    2018-06-17 13:14:27
    C++队列堆栈小作业 
  • C++队列的基本用法

    2021-05-17 20:59:26
    C++队列的用法 队列的数据结构 ADT 队列(Queue) Data 同线性表。具有相同的数据类型,相邻的元素存在前驱和后继关系 Opreation InitQueue(): 初始化一个空的队列 DestoryQueue(): 销毁队列 ClearQueue():...

    PS.更多数据结构知识详见:

    八大数据结构

    C++队列的用法

    队列的数据结构

    ADT 队列(Queue)
    Data
    	同线性表。具有相同的数据类型,相邻的元素存在前驱和后继关系
    Opreation
    	InitQueue(): 			初始化一个空的队列
    	DestoryQueue():			销毁队列
    	ClearQueue():			清空队列元素
    	QueueEmpty():			判断队列是否为空,是则返回true,否则返回false
    	GetHead():				获取队首元素
    	EnQueue(e):				将元素e入队列
    	DeQueue():				删除队首元素
    	QueueLength():			返回队列Q的元素个数
    

    基于数组的队列

    class ArrayQueue {
    	int length;
    	int head;
    	int tail;
    	int* ptr;
    	int count;
    public:
    	ArrayQueue(int len)
    	{
    		length = len;
    		head = 0;
    		tail = 0;
    		count = 0;
    		ptr = new int[len];
    	}
    
    	~ArrayQueue()
    	{
    		delete[]ptr;
    	}
    
    	void clear()
    	{
    		head = tail = count = 0;
    	}
    
    	bool empty()
    	{
    		return count == 0 ? true : false;
    	}
    
    	int front()
    	{
    		if (count)
    		{
    			return ptr[head];
    		}
    		return -1;
    	}
    
    	void push(int val)
    	{
    		if (tail != length)
    		{
    			ptr[tail] = val;
    			tail++;
    			count++;
    		}
    		else
    		{
    			cout << "队列空间已满!" << endl;
    		}
    	}
    
    	void pop()
    	{
    		if (count)
    		{
    			head++;
    			count--;
    		}
    	}
    
    	int size()
    	{
    		return count;
    	}
    };
    

    基于链表的队列

    struct LinkList
    {
    	int val;
    	LinkList* next;
    	LinkList(int val = -1, LinkList* next = nullptr) :val(val), next(next) {}
    
    };
    
    class LinkQueue
    {
    	LinkList* head;
    	LinkList* tail;
    	int count;
    public:
    	LinkQueue()
    	{
    		head = new LinkList(0);
    		tail = head;
    		count = 0;
    	}
    
    	~LinkQueue()
    	{
    		clear();
    		delete head;
    	}
    
    	void clear()
    	{
    		while (head->next)
    		{
    			LinkList* del = head->next;
    			head->next = del->next;
    			delete del;
    		}
    		count = 0;
    	}
    
    	bool empty()
    	{
    		return count == 0 ? true : false;
    	}
    
    	void push(int val)
    	{
    		tail->next = new LinkList(val);
    		tail = tail->next;
    		count++;
    	}
    
    	int front()
    	{
    		if (count)
    			return head->next->val;
    		return -1;
    	}
    
    	void pop()
    	{
    		if (head != tail)
    		{
    			LinkList* del = head;
    			head = head->next;
    			delete del;
    			count--;
    		}
    	}
    
    	int size()
    	{
    		return count;
    	}
    };
    

    测试队列

    基于数组的队列

    void testArrayQueue()
    {
    	//定义队列
    	ArrayQueue* que = new ArrayQueue(10);
    
    	//队列的基本操作
    	que->push(1);
    	que->push(2);
    	que->push(3);
    	que->push(4);
    	que->push(5);
    	cout << "输出队列的所有元素:" << endl;
    	while (!que->empty())
    	{
    		cout << que->front() << "	";
    		que->pop();
    	}
    	que->push(1);
    	que->push(2);
    	que->push(3);
    	que->push(4);
    	que->push(5);
    	cout << endl << endl;
    	cout << "队首元素为 :" << que->front() << endl;
    	cout << "队内的元素个数为:" << que->size() << endl;
    	cout << endl << endl;
    
    	cout << "删除队首元素" << endl;
    	que->pop();
    	cout << "队首元素为 :" << que->front() << endl;
    	cout << "队内的元素个数为:" << que->size() << endl;
    	cout << endl << endl;
    
    	cout << "清空队内元素 " << endl;
    	que->clear();
    	cout << "队首元素为 :" << que->front() << endl;
    	cout << "队内的元素个数为:" << que->size() << endl;
    }
    

    基于链表的队列

    void testLinkQueue()
    {
    	//定义队列
    	LinkQueue* que = new LinkQueue;
    
    	//队列的基本操作
    	que->push(1);
    	que->push(2);
    	que->push(3);
    	que->push(4);
    	que->push(5);
    	cout << "输出队列的所有元素:" << endl;
    	while (!que->empty())
    	{
    		cout << que->front() << "	";
    		que->pop();
    	}
    	que->push(1);
    	que->push(2);
    	que->push(3);
    	que->push(4);
    	que->push(5);
    	cout << endl << endl;
    	cout << "队首元素为 :" << que->front() << endl;
    	cout << "队内的元素个数为:" << que->size() << endl;
    	cout << endl << endl;
    
    	cout << "删除队首元素" << endl;
    	que->pop();
    	cout << "队首元素为 :" << que->front() << endl;
    	cout << "队内的元素个数为:" << que->size() << endl;
    	cout << endl << endl;
    
    	cout << "清空队内元素 " << endl;
    	que->clear();
    	cout << "队首元素为 :" << que->front() << endl;
    	cout << "队内的元素个数为:" << que->size() << endl;
    }
    

    运行结果

    在这里插入图片描述

    队列的应用

    1.单调队列求滑动窗口的最大值

    2.优先级队列求最大的k个值

    展开全文
  • 这个是我上课时候老师要求编写的程序,可以运行,放心下载~
  • C++队列用法实例

    2020-12-25 20:33:44
    本文实例讲述了C++队列用法。分享给大家供大家参考。具体如下: /* 队列使用时必须包含头文件 #include <queue> 有以下几种方法 入队push(),出队pop(), 读取队首元素front(),读取队尾元素back() , 判断队是否有...
  • C++ 队列的基本声明和定义

    千次阅读 2022-03-17 14:38:03
    c++ 队列 数据结构

    队列是一种遵从“先进先出”的容器,只允许在一端进行插入操作,而另一端进行删除操作的线性表。

     类的声明:

    template <class DataType>
    class CirQueue
    {
    public:
    	void EnQueue(DataType x); //入队
    	DataType DeQueue(); //出队并返回出队元素
    	bool Empty();//判断队列是否为空
    	DataType GetQueue();//获得队首元素
    private:
    	DataType data[QueueSize];//队列的内部结构,一个有限数组,容量自定义
    	int front = 0, rear = 0;//队首队尾下标
    };

     入队操作

    template <class DataType>
    void CirQueue<DataType> ::EnQueue(DataType x) 
    {
    	if ((rear + 1) % QueueSize == front) throw "上溢";
    	rear = (rear + 1) % QueueSize;
    	data[rear] = x;
    }

     出队操作

    template <class DataType>
    DataType CirQueue<DataType> ::DeQueue()
    {
    	front = (front + 1) % QueueSize; // 队头指针在循环意义上加1
    	return data[front];
    }

     判断队列是否为空

    template <class DataType>
    bool CirQueue<DataType> ::Empty()//是否为空
    {
    	if (front == rear) return 1;
    	else return 0;
    }

     获取队首元素

    template <class DataType>
    DataType CirQueue<DataType> ::GetQueue()
    {
    	if (rear == front) throw "下溢";
    	int i = (front + 1) % QueueSize; ; // 注意不要给队头指针赋值
    	return data[i];
    }

     完整代码头文件

    #pragma once
    
    using namespace std;
    
    const int QueueSize = 10000;
    template <class DataType>
    class CirQueue
    {
    public:
    	void EnQueue(DataType x); //入队
    	DataType DeQueue(); //出队并返回出队元素
    	bool Empty();//判断队列是否为空
    	DataType GetQueue();//获得队首元素
    private:
    	DataType data[QueueSize];//队列的内部结构,一个有限数组,容量自定义
    	int front = 0, rear = 0;//队首队尾下标
    };
    
    template <class DataType>
    void CirQueue<DataType> ::EnQueue(DataType x) 
    {
    	if ((rear + 1) % QueueSize == front) throw "上溢";
    	rear = (rear + 1) % QueueSize;
    	data[rear] = x;
    }
    
    template <class DataType>
    DataType CirQueue<DataType> ::DeQueue()
    {
    	front = (front + 1) % QueueSize; // 队头指针在循环意义上加1
    	return data[front];
    }
    
    template <class DataType>
    bool CirQueue<DataType> ::Empty()//是否为空
    {
    	if (front == rear) return 1;
    	else return 0;
    }
    
    template <class DataType>
    DataType CirQueue<DataType> ::GetQueue()
    {
    	if (rear == front) throw "下溢";
    	int i = (front + 1) % QueueSize; ; // 注意不要给队头指针赋值
    	return data[i];
    }

    展开全文
  • C++队列的用法

    2020-10-11 17:34:32
    队列的基本用法 特点:后进先出 头文件: #include<queue> 基本函数: q.push(item) //将item压入队列尾部 q.pop() //删除队首元素,但不返回 q.front() //返回队首元素,但不删除 q.back() //返回队尾元素,...
  • C++数据结构——队列的创建和基本操作
  • C++ 队列(queue)使用简述

    千次阅读 2022-03-27 21:55:25
    至于队列的结构与原理(FIFO,先入先出)这里就不细说了,这里主要记录下 C++ 的头文件 <queue> 中有关队列的操作是如何使用的。 1、有关函数的作用 queue<type> q; 定义一个参数类型为 type 的...
  • C++队列queue用法详解

    万次阅读 多人点赞 2020-11-17 16:13:42
    C++队列queue用法详解一、定义一、queue初始化初始化示例注意:不能用vector容器初始化queue二、queue常用函数1.常用函数2.函数运用示例 一、定义 queue是一种容器转换器模板,调用#include< queue>即可使用...
  • C++ 中消息队列函数实例详解 1.消息队列结构体的定义 typedef struct{ uid_t uid; /* owner`s user id */ gid_t gid; /* owner`s group id */ udi_t cuid; /* creator`s user id */ gid_t cgid; /* creator`s ...
  • C++队列排序问题

    千次阅读 2020-12-19 23:40:09
    队列排序 问题描述: 本关要求编写函数rotateLeft,该函数实现对一个 n × n 方阵中的每个元素循环向左移 m 个位置( 0 < m < n ),即将第 0 、 1 、…、 n - 1 列变换为第 n - m 、 n - m + 1 、…、 n - 1 ...
  • C++ 队列的实现

    千次阅读 2020-07-24 22:19:01
    点击此处浏览C++官方的queue详细内容 主要功能有以下几个 函数 功能 back 返回对在 queue 后部最近添加的最后一个元素的引用 empty 测试 queue 是否为空 front 返回对 queue 前部的第一个元素的引用 ...
  • c++队列存放的是元素的拷贝而不是元素本身,所以存在一个问题:当我们需要使用队列进行搜索,搜索的过程中又需要更改元素本身(如修改结构体内部某个指针等)应该怎么操作? 尝试使用指针队列:发现对于基本类型int...
  • C++队列实现

    千次阅读 2019-04-28 10:51:30
    一、相关定义 原理:queue队列也是一个线性存储表,元素数据的插入在...C++队列是一种容器适配器,默认使用双端队列deque来实现,将deque容器转换为queue容器。当然,也可以利用其他合适的序列容器作为底层实现que...
  • 参考:数据结构图文解析之:队列详解与C++模板实现 队列简介 队列(Queue)特点: 1、队列中的数据元素遵循“先进先出”(First In First Out)的原则,简称FIFO结构。 2、在队尾添加元素,在队头添加元素。 队列的...
  • c++队列的使用

    千次阅读 2019-11-06 20:07:32
    https://blog.csdn.net/ZHLZYF/article/details/83280481
  • cout 已新建队列,当前5个队列全部为空,请选择你要操作几号队列:"; do { cin >> seq; } while (seq|| seq>LIMIT); cout 当前为" 号队列,选择你的操作i.入队 d.出队 p.显示 c.复制队列 a.显示全部 q.退出 ...
  • back() 返回最后一个元素 empty() 如果队列空则返回真 front() 返回第一个元素 pop() 删除第一个元素 push() 在末尾加入一个元素 size() 返回队列中元素的个数
  • queue #include<... q.pop() //删除队列第一个元素 q.size() //返回队列中元素个数 q.empty() //如果队列空则返回true q.front() //返回队列中的第一个元素 q.back() // 返回队列中最后一个元素 }
  • C++队列queue模板类的定义在头文件中,queue 模板类需要两个模板参数,一个是元素类型,一个容器类型,元素类型是必要的,容器类型是可选的,默认为deque 类型。C++队列Queue是一种容器适配器,它给予程序员一种先进...
  • C++队列queue的front()方法

    千次阅读 2020-11-27 16:18:26
    C++队列queue的front()方法 代码 #include<queue> #include<iostream> #include<vector> #define N 100 using namespace std; struct Node{ int lv;//记录当前层数 int wei;//当前重量 int ...
  • C++实现队列源代码

    2016-09-15 23:22:13
    数据结构实验基础——使用C++实现队列源代码
  • 摘要:VC/C++源码,算法相关,队列优化,最短路径算法 C++队列优化的Bellmanford最短路算法(SPFA),使用C++实现的Queue improved Bellman-Ford单源最短路算法,在国内还被叫做SPFA。这个程序输入一个图,找到图中的一...
  • c/c++队列的代码实现

    2018-11-14 11:14:59
    数组是一种神奇的工具,我们可以根据自己的需要来设计一种数据结构,队列也是一个最佳的例子。它实现的是数据的先入先出功能,顾名思义,就是排队,先排队的先办事。 名词术语/函数名称 back() 返回最后一个元素 ...
  • 写一个c++的关于队列排序的算法,队列的特性是先入先出,可以对队列中的数据进行升序、降序的排列组合
  • 实现消息队列的关键因素是考量不同线程访问消息队列的同步问题。本实现涉及到几个知识点 std::lock_guard 介绍 std::lock_gurad 是 C++11 中定义的模板类。定义如下: template <class> class lock_guard; lock_...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 195,837
精华内容 78,334
关键字:

c++队列

c++ 订阅
友情链接: zubo.rar