various queue

test1

#include<map>                                                                                                                                                    
#include  <string>
#include  <queue>
#include  <list>
#include  <iostream>
using namespace std;

int main(int argc,char* argv[])
{
    queue<int,list<int> > q2; //双向链表作底层容器
    q2.push(3);
    q2.push(32);
    q2.push(33);
    q2.push(34);

    while(!q2.empty())
    {   
        cout<<q2.front()<<endl;
        q2.pop();
        //int dd = q2.pop();
    }   
    return 0;
}

队列是一种常用的数据结构,通常以消息队列的形式应用于进程间的通信。C++ STL 提供的queue容器对 队列的数据结构和受限操作进行了泛化封装，包括队列初始化，元素入队列，取队首元素，元素出队列，队列是否为空以及获取当前队列长度等操作。

与堆栈一样，queue队列也是默认使用qeque 双端队列作底层架构，元素的出队也不返回队首元素，需要先用取值函数将之读出。通过检查当前队列长度，来决定是否允许元素入队，可实现具有固定长度的队列。

test2

priority queue 

优先队列也是一种入队出队的队列，不同于一般队列的是，队列中最大的元素总是位于队首位置，因此，元素的出队并非按照先进先出的要求，将最先入队的元素出队，而是将当前队列中的最大元素出队。

C++ STL 优先队列的泛化，底层默认采用vector容器,使得队列容器的元素可做数组操作，从而应用堆算法找到当前队列最大元素，并将它调整到队首位置，确保最大元素先出队。 heap algorithm 具有nlog(n)阶的算法时间复杂度。

#include  <map>
#include  <string>
#include  <queue>
#include  <list>
#include  <iostream>
using namespace std;
int main(int argc,char* argv[])
{
    priority_queue<int>  pq;
    pq.push(4);
    pq.push(19);
    pq.push(33);
    pq.push(26);
    pq.push(34);
    while(!pq.empty())
    {         cout<<pq.top(<<endl;                                                                                                                                          
        pq.pop();
        //int dd = q2.pop();
    }   
    return 0;
}

test3:

#include  <iostream>                                                                                                                                                         
#include  <stdio.h>
#include  <stdlib.h>
#include  <string>
#include  <string.h>

using namespace std;
template <typename T>
class CircularQueue
{
public:
    CircularQueue(int  init= 100);

    ~CircularQueue() {if(base) delete [] base;}   

   bool cqempty() const ;
    void cqtraverse()const;
    int  cqlength() const;

    bool cqenqueue(T e);
    bool cqdequeue();

private:
    int size;
    int front;
    int rear;
    T *base;
};
template<typename T>
CircularQueue<T>::CircularQueue(int init)
{
    size = init;
    base = new T[size];
    if(!base)
      exit(-1);
    front = rear = 0;
}

template<typename T>
int CircularQueue<T>::cqlength() const
{
    return ((rear -front + size) % size);

}
template<typename T>
void CircularQueue<T>::cqtraverse() const
{
    int length = (rear - front + size)% size;
    cout<<"traverse ...."<<endl;
    for(int i=0;i<length;i++)
    {
        cout<<base[front+i]<<" ";
    }
    cout<<endl;
}

template<typename T>
bool CircularQueue<T>::cqenqueue(T e)
{
    if( (rear+1) % size ==  front)
      return false;
    base[rear]=e;
    rear = (rear+1) % size;
    return true;
}
template<typename T>
bool CircularQueue<T>::cqdequeue()
{
    if(front == rear)
      return false;
    front  = (front+1) % size;
    return true;
}

int main(int argc,char* argv[])
{
    CircularQueue<long> *cq =  new CircularQueue<long>;
    cq->cqenqueue(33);
    cq->cqenqueue(31);
    cq->cqenqueue(23);
    cq->cqenqueue(11);
    cq->cqenqueue(23);
    cq->cqenqueue(56);
    cq->cqenqueue(43);

    cout<<"circular queue len: "<<cq->cqlength()<<endl;
    cq->cqtraverse();
    cout<<"after deleting top ele "<<endl;
    cq->cqdequeue();
    cout<<"circular queue len: "<<cq->cqlength()<<endl;
    cq->cqtraverse();

    return 0;

}