C++ 里面 系统自带的队列类queue 怎么用？

Posted 2023-05-09

1需要什么头文件来包含？
2这个类里面都有什么方法，怎么用？
3帮我把下面代码中关于queue的方法名修改正确。

void Graph::BFS(int u,int* parent,ColorType *color)

queue<int> q(QSize);
color[u]=Gray; //标记起始结点u为活结点
cout<<""<<u;
q.push(u); //将起始结点u加入队列q
while (!q.empty())

u=q.front();q.Serve(); //选择一个活结点为E-结点
for (ENode* w=a[u];w;w=->nextArc)//检测E-结点u的全部邻接点

int v=w->adjVex;
if (color[v]==White)

color[v]=Gray;
cout<<" "<<v;
parent[v]=u; //构造BFS生成森林
q.Append(v); //新的活结点进入活结点表q


color[u]=Black; //标记死结点

queue 是 STL 中的一个容器，就是队列，特点是先进先出
一个例子你几乎就能了解它的大部分功能了：

int main()

std::queue<int> q;
q.push( 1 );
q.push( 2 );
q.push( 3 );
while (!q.empty())

cout << q.front() << endl;
q.pop();

return 0;
;

用到了queue的 4 个操作：
push() 入队列
empty() 队列是否为空
front() 队列的头
pop() 出队列（先进先出，当然是头出了）
完. 参考技术A 参考使用方法如下：
class MyQueue

//存放元素的数组
private object[] _array;
//增长因子
private int _growFactor;

//队头下标
private int _head;
//队尾下标
private int _tail;
private int _size;

private const int _MinGrow = 4;
//初始容量
private const int _ShrikThreadhold = 0x20;

public MyQueue()
: this(_ShrikThreadhold, 2f)



public MyQueue(int capacity, float growFactor)

if (capacity < 0)

throw new ArgumentOutOfRangeException("capacity", "初始容量不能为负！");

if ((growFactor < 1.0) || (growFactor > 10))

throw new ArgumentOutOfRangeException("growFactor", "增长因子应介于1和10之间!");

this._array = new object[capacity];
this._head = 0;
this._size = 0;
this._tail = 0;
this._growFactor = (int)(growFactor * 100f);


//入队
public virtual void Enqueue(object obj)


if (this._size == this._array.Length)
//队列已满
int capacity = (int)((this._array.Length * this._growFactor) / 100L);
if (capacity < (this._array.Length + _MinGrow))

capacity = this._array.Length + _MinGrow;

SetCapacity(capacity);

this._array[this._tail] = obj;
this._tail = (this._tail + 1) % this._array.Length;
this._size++;


//内存设置
private void SetCapacity(int capacity)

object[] dest = new object[capacity];
if (this._head < this._tail)//尾指针在头指针后

Array.Copy(this._array, this._head, dest, 0, this._size);

else//头指针在尾指针后

Array.Copy(this._array, this._head, dest, 0, this._array.Length - this._head);
Array.Copy(this._array, 0, dest, this._array.Length - this._head, this._tail);


this._array = dest;
this._head = 0;
this._tail = (this._size == capacity) ? 0 : this._size;


//出队
public virtual object Dequeue()

if (this._size == 0)

throw new InvalidOperationException("队列为空");


object obj = this._array[this._head];//出队
this._array[this._head] = null;
this._head = (this._head + 1) % this._array.Length;
this._size--;
return obj;

public virtual int Count

get return this._size;



static void Main(string[] args)


Program main = new Program();
main.testQueue();

private void testQueue()

Queue<int> myQueue = new Queue<int>();
//MyQueue myQueue = new MyQueue();//与上面类使用一样
myQueue.Enqueue(1);
myQueue.Enqueue(2);
myQueue.Enqueue(3);
myQueue.Enqueue(4);

Console.WriteLine("总数量："+myQueue.Count.ToString());
while (myQueue.Count > 0)

Console.WriteLine("出列："+myQueue.Dequeue());

Console.WriteLine("数量："+myQueue.Count.ToString());
Console.ReadLine();
参考技术B 标准库是头文件 #include<queue>

方法很多 其他的都对 但是
q.Serve()q.Append(）没有 参考技术C #include <queue>
using namespace std;

void main()
queue<int> qint;
qint.push_back();
qint.pop();
qint.top();
//以及其它增，删，改操作
参考技术D 买本书看看吧，，关于STL的

C++ 知识回顾总结 -- queue 队列容器

一、说明

queue 是一种队列适配器，专门设计用于FIFO中操作(先进先出)，元素从一端插入容器并从另一端提取。

相关API地址为：http://www.cplusplus.com/reference/queue/queue/

二、使用方法

在C++中只要#include<queue>即可使用队列类，其中在面试或笔试中常用的成员函数如下（按照最常用到不常用的顺序）

push、pop、size、empty、front、back

接下来逐一举例说明：

1. push

队列中由于是先进先出，push即在队尾插入一个元素，如：

1 queue<string> q;
2 q.push("Hello World!");
3 q.push("China");
4 cout<<q.front()<<endl;

可以输出：Hello World！

2. pop

将队列中最靠前位置的元素拿掉，是没有返回值的void函数。如：

1 queue<string> q;
2 q.push("Hello World!");
3 q.push("China");
4 q.pop();
5 cout<<q.front()<<endl;

可以输出：China

原因是Hello World！已经被除掉了。

3. size

返回队列中元素的个数，返回值类型为unsigned int。如：

queue<string> q;
cout<<q.size()<<endl;
q.push("Hello World!");
q.push("China");
cout<<q.size()<<endl;

输出两行，分别为0和2，即队列中元素的个数。

4. empty

判断队列是否为空的，如果为空则返回true。如：

1 queue<string> q;
2 cout<<q.empty()<<endl;
3 q.push("Hello World!");
4 q.push("China");
5 cout<<q.empty()<<endl;

输出为两行，分别是1和0。因为一开始队列是空的，后来插入了两个元素。

5. front

返回值为队列中的第一个元素，也就是最早、最先进入队列的元素。注意这里只是返回最早进入的元素，并没有把它剔除出队列。如：

1 queue<string> q;
2 q.push("Hello World!");
3 q.push("China");
4 cout<<q.front()<<endl;
5 q.pop();
6 cout<<q.front()<<endl;

输出值为两行，分别是Hello World！和China。只有在使用了pop以后，队列中的最早进入元素才会被剔除。

6. back

返回队列中最后一个元素，也就是最晚进去的元素。如：

1 queue<string> q;
2 q.push("Hello World!");
3 q.push("China");
4 cout<<q.back()<<endl;

输出值为China，因为它是最后进去的。这里back仅仅是返回最后一个元素，也并没有将该元素从队列剔除掉。

 三、使用链表将queue实现

#include<iostream>
#include<string>
using namespace std;

template <typename T>
struct Node{
    T value;
    Node<T> *next;
    Node<T>(){next = NULL;}
};
 
template <typename T>
class MyQueue{
private:
    unsigned int num;
    Node<T> *first;
    Node<T> *last;
    
public:
    MyQueue();
    ~MyQueue();
    unsigned int size();
    void push(T element);
    void pop();
    bool empty();
    T back();
    T front();
};

template <typename T>
MyQueue<T>::MyQueue(){
    num = 0;
    first = NULL;
    last = NULL;
}

template <typename T>
MyQueue<T>::~MyQueue(){
    while(!empty()){
        pop();
    }
}

template <typename T>
unsigned int MyQueue<T>::size(){
    return num;
}

template <typename T>
bool MyQueue<T>::empty(){
    return (0==num);
}

template <typename T>
void MyQueue<T>::push(T element){
    Node<T> *temp = new Node<T>;
    temp->next = NULL;
    temp->value = element;
    if (0 == this->num){
        first = temp;
        last = temp;
    }else{
        last->next = temp;
        last = temp;
    }
    (this->num)++;
}

template <typename T>
void MyQueue<T>::pop(){
    if (0==this->num){
        cout<<"No elements in the queue!"<<endl;
    }else if(1 == this->num){
        delete first;
        first = NULL;
        last = NULL;
        this->num = 0;
    }else{
        Node<T> *temp = first;
        first = first->next;
        delete temp;
        (this->num)--;
    }
}

template <typename T>
T MyQueue<T>::back(){
    if (0==this->num){
        cout<<"No elements in the queue!"<<endl;
        return NULL;
    }
    return last->value;
}

template <typename T>
T MyQueue<T>::front(){
    if(0== this->num){
        cout<<"No elements in the queue!"<<endl;
        return NULL;
    }
    return first->value;
}

int main(){
    MyQueue<string> q;
    q.push("Hello world");
    q.push("China");
    cout<<q.front()<<endl;
    cout<<q.size()<<endl;
    cout<<q.back()<<endl;
    q.pop();
    cout<<q.empty()<<endl;
    cout<<q.back()<<endl;
    cout<<q.front()<<endl;
    q.pop();
    cout<<q.size()<<endl;
    cout<<q.empty()<<endl;
    system("pause");
    return 0;
}