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;

}