队列

队列

队列是只允许在一段进行插入操作，而另一端进行删除操作的线性表，

允许插入的一端为队尾，允许删除的一端为对头。

最先入队者最先出队

数组实现类的声明：

const int size = 100; template <class T> class ArrayQueue { public:          ArrayQueue(){first = last = -1;}          void enqueue(T);          T dequeue();          T gettop();          bool isFull()          {             //return first == 0 && last == size-1 || first == last+1;                    if (first == 0 && last == size -1 || first == last+1)                             return 1;                    else return 0;          }          bool isEmpty()          {              cout << "isempty";                    return first == -1;          } private:          int first, last;          T storage[size]; };

 

入队算法：

template <class T> void ArrayQueue <T>::enqueue(T el) {    if (!isFull())             if (last == size-1 || last == -1)             {                storage[0] = el;                     last = 0;                     if (first == -1)                              first = 0;             }             else storage[++last] = el;             else cout << "Full queue/n"; }

 

出队算法

template <class T> T ArrayQueue<T>::dequeue() {    T tmp;    tmp = storage[first];    if (first == last)             last = first = -1;    else if (first == size-1)             first = 0;    else first ++;    return tmp; }

另一种实现方法：

将数组看成头尾相连的循环结构：

队列的这种头尾相接的顺序存储结构称为循环队列

设存储循环队列的数组长度为QueueSize ，则循环队列的长度为

(rear -front+QueueSize ) % QueueSize

队空的条件为：front=rear

队满的条件为：(rear+1)%QueueSize = front

类的声明：

const int QueueSize = 100;   template <class T> class CirQueue { public:          CirQueue();          ~CirQueue();          void EnQueue(T x);          T DeQueue();          T GetQueue();          bool Empty(); private:          T data[QueueSize];          int front, rear; };

入队算法：

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

出队算法：

template <class T> T CirQueue<T>::DeQueue() {    if (rear == front) throw "下溢";    front = (front + 1) % QueueSize;    return data[front]; }

 

读取队头元素算法：

template <class T> T CirQueue<T>::GetQueue() {    if (rear == front) throw "下溢";   int i = (front+1) % QueueSize;    return data[i]; }

 

 

链队列的实现：

类的声明：

template <class T> struct Node {    T data;    Node<T> *next; }; template <class T> class LinkQueue { public:          LinkQueue();          ~LinkQueue();          void EnQueue(T x);          T DeQueue();          T GetQueue();          bool Empty(); private:     Node<T> *front, *rear; };

 

构造函数算法：

template <class T> LinkQueue<T>::LinkQueue() {    Node<T> *s = new Node<T>;    s->next = NULL;    front = rear = s; }

 

析构函数算法：

template <class T> LinkQueue<T>::~LinkQueue() {          while(front)          {                    Node <T> *p;                    p=front->next;         delete front;              front=p;          } }

入队算法：

template<class T> void LinkQueue<T>::EnQueue(T x) {    Node<T> *s = new Node<T>;    s->data = x;    s->next = NULL;    rear->next = s;    rear = s; }

 

出队算法：

template <class T> T LinkQueue<T>::DeQueue() {    if (front == rear) throw "下溢";    Node<T> *p = front->next;    int x = p->data;    front->next = p->next;    if (p->next == NULL) rear = front;    delete p;    return x; }

取队头元素算法：

template <class T> T LinkQueue<T>::GetQueue() {    if (front != rear) return front->next->data;    else return 0; }

在标准模板库下实现：

#include "stdafx.h" #include <iostream> #include <list> using namespace std; template <class T> class Queue {      Queue(){}      void clear(){lst.clear();}      bool isEmpty() const{return lst.empty();}      T& front(){return lst.front();}      T dequeue()      {         T el = lst.front();         lst.pop_front();         return el;      }      void enqueue(const T& el){lst.push_back(el);} private :      list<T> lst; };

标准模板库中的队列

queue<int> queue1;// 默认为双端队列

queue<int,list<int>> queue2;// 链表/* 在VS2005 环境下*/

#include <iostream> #include <queue> using namespace std; int main() {    queue<int> queue1;//queue()创建一个空队列    queue1.push(1);//void push(const T& el)//在队尾部插入元素el    queue1.push(4);      while (!queue1.empty())    {             cout << "队尾：" << queue1.back() << endl;//T& back()/const T& back() const返回队列最后一个元素       cout << "队头：" << queue1.front() << endl;//T& front()/const T& front() const返回队列第一个元素       cout << "队列中元素数目：" << queue1.size() << endl;//size_type size()const 返回队列中的元素数目           queue1.pop();    }    return 0; }

 

#include "stdafx.h" #include <iostream> #include <queue> #include <list> using namespace std; int main() {    queue<int> q1;    queue<int,list<int>> q2;    q1.push(1);    q1.push(2);    q1.push(3);    q2.push(4);    q2.push(5);    q2.push(6);    q1.push(q2.back());    while (!q1.empty())    {         cout << q1.front() << ' ';         q1.pop();    }    while (!q2.front())    {       cout << q2.front() << ' ';       q2.pop();    }    return 0; }

 

标准模板库中的优先队列：

#include "stdafx.h" #include <iostream> #include <queue> #include <functional>   using namespace std; int main() {    priority_queue<int> pq1;//priority_queue(comp f()) 创建一个空的优先队列，使用一个双变量的布尔函数f对队列的元素排序    priority_queue<int,vector<int>,greater<int>> pq2;// 函数对象greater表明在优先队列中插入元素时使用>而不是<    pq1.push(3);    pq1.push(1);    pq1.push(2);    pq2.push(3);    pq2.push(1);   pq2.push(2);    int a[] = {4,6,5};    priority_queue<int> pq3(a,a+3);    while (!pq1.empty())    {         cout << "pq1 中优先级最高的元素：" << pq1.top() << " ";         pq1.pop();         cout << endl;    }    while (!pq2.empty())    {       cout << "pq2 中优先级最高的元素：" << pq2.top() << ' ';       pq2.pop();       cout << endl;    }    while (!pq3.empty())    {       cout << "pq3 中优先级最高的元素：" << pq3.top() << ' ';       pq3.pop();       cout << endl;    }    return 0; }