数据结构---------------------------------------循环队列和链队列的实现

下面将队列的一些基本操作实现一下，包括一些元素的入队，出队，取队首等操作。

下面分别贴上代码：

1）循环队列：

#include<iostream>
#include<algorithm>
#include<string.h>
#define MAXQSIZE 105+10
using namespace std;
typedef int QElemType;
typedef int Status;
typedef struct{
    QElemType *base; //初始化时动态分配存储空间
    int front; //头指针
    int rear; //尾指针
}SqQueue;
//构造一个空队列
Status InitQueue(SqQueue &Q)
{
    Q.base = new QElemType[MAXQSIZE]; //为队列分配一个最大容量为MAXQSIZE的数组空间
    if(!Q.base)
        return 0; //存储分配失败
    Q.front = Q.rear = 0; //头指针和尾指针置为0，队列为空
    return 1;
}
//求循环队列的长度
int QueueLength(SqQueue Q)
{
    //因为这是个循环队列，可能Q.rear - Q.front为负，为避免这种情况，加上队列的最大容量
    return (Q.rear - Q.front + MAXQSIZE) % MAXQSIZE;
}
//循环队列的入队
Status EnQueue(SqQueue &Q,QElemType e) //插入元素e为Q的新队尾元素
{
    //如果尾指针在循环意义上加1后等于头指针，那么说明这个队列已经满了
    if((Q.rear + 1)%MAXQSIZE  == Q.front)
        return 0;
    Q.base[Q.rear] = e; //新元素插入队尾
    Q.rear = (Q.rear + 1)%MAXQSIZE; //队尾指针加1
    return 1;
}
//循环队列的出队
Status DeQueue(SqQueue &Q,QElemType &e)
{
    if(Q.rear == Q.front)
        return 0; //队空
    e = Q.base[Q.front]; //保存队头元素
    Q.front = (Q.front + 1)%MAXQSIZE; //对头指针加1
    return 1;
}
//取队列头元素
QElemType GetHead(SqQueue Q,QElemType &e)
{
    if(Q.front != Q.rear) //队列非空
        e = Q.base[Q.front]; //返回队头元素的值，队头指针不变
    return 1;
}
int main()
{
    ios::sync_with_stdio(false); //可加可不加
    SqQueue Q;
    InitQueue(Q);
    //下面是一些操作，关于这个队列的一些入队，出队，去队首元素等操作
    int n;
    cin>>n;
    for(int i=1;i<=n;i++)
        EnQueue(Q,i);
    //取循环队首元素
    int t;
    cin>>t;
    while(t--)
    {
        int m;
        cin>>m;
        DeQueue(Q,m);
        cout<<m<<endl;
    }
    //取队首元素
   int m1;
   cin>>m1;
   GetHead(Q,m1);
   cout<<m1<<endl;
    return 0;
}

2）链队的实现：

先解析一番：

初始化时的大致的想法（构建轮廓）

队列的链式存储结构

初始化的重要操作代码如下：

typedef struct QNode{
    QElemType data;
    struct QNode *next;
}QNode,*QueuePtr;
typedef struct{
    QueuePtr front; //队头指针
    QueuePtr rear; //队尾指针
}LinkQueue;

下图所示说明了一个链队Q的动态变化过程。图（a）是链队的初始状态，图（b）是在链队中进队3个元素后的状态，图（c）是链队中出队一个元素后的状态。

指针初始化

链队的入队

链队的出队

基本操作就这样，然后下面附上代码：

#include<iostream>
#include<algorithm>
#include<string.h>
using namespace std;
typedef int QElemType;
typedef int Status;
typedef struct QNode{
    QElemType data;
    struct QNode *next;
}QNode,*QueuePtr;
typedef struct{
    QueuePtr front; //队头指针
    QueuePtr rear; //队尾指针
}LinkQueue;
//链队列的初始化
Status InitQueue(LinkQueue &Q) //构造一个空队列Q
{
    Q.front = Q.rear = new QNode; //生成新结点作为头结点,队头和队尾都指向此结点
    Q.front -> next = NULL; //头结点的指针域置空
    return 1;
}
//链队的入队
Status EnQueue(LinkQueue &Q,QElemType e) //插入元素e为Q的新的队首元素
{
    QueuePtr p;
    p = new QNode; //为入队元素分配结点空间，用指针p指向
    p -> data = e; //将新结点数据域置为e
    p -> next = NULL;
    Q.rear -> next = p; //将新结点插入到队尾
    Q.rear = p; //修改队尾指针
    return 1;
}
//链队的出队
Status DeQueue(LinkQueue &Q,QElemType &e) //删除Q的队头元素,用e返回其值
{
    QueuePtr p;
    if(Q.front == Q.rear)
        return 0; //队列为空的话，直接返回0
    p = Q.front -> next; //p指向队头元素
    e = p -> data; //用e保存队头元素的值
    Q.front -> next = p -> next; //修改头指针
    if(Q.rear == p)
        Q.rear = Q.front; //最后一个元素被删，队尾指针指向头结点
    delete p; //释放原队头元素的空间
    return 1;
}
//取链队的队头元素，不修改队头指针
QElemType GetHead(LinkQueue Q,QElemType &e)
{
    if(Q.front != Q.rear) //队列非空
        e = Q.front -> next -> data; //返回队头元素的值，队头指针不变
    return 1;
}
int main()
{
    ios::sync_with_stdio(false); //可加可不加，个人习惯加了
    LinkQueue Q;
    InitQueue(Q);
    //往队列中加点元素
    int n;
    cin>>n; //不妨让n取值为10
    for(int i=2;i<=n;i++)
        EnQueue(Q,i);
    //删除队首元素，并取出来
    int t; //测试t次
    cin>>t;
    while(t--)
    {
        int m;
        cin>>m;
        DeQueue(Q,m);
        cout<<m<<endl;
    }
    //下面进行一下操作即以上操作完成之后再取队首元素(如果有的情况)
    int m1; //m1虽然是实参，不过引用参数传递的时候，形参改变实参就跟着改变
    cin>>m1;
    GetHead(Q,m1);
    cout<<m1<<endl;
    return 0;
}