数据结构之队列

队列的顺序存储

定义

#define MaxSize 10
typedef struct
{
    ElemType data[MaxSize];
    int front,rear;//队头和队尾指针
}SqQueue;

初始化

void InitQueue(SqQueue &Q)
{
    Q.front=Q.rear = 0;
}

判空

bool QueueEmpty(SqQueue Q)
{
    if(Q.front==Q.rear)
        return true;
    return false;
}

获取队头元素

bool GetHead(SqQueue Q,ElemType &x)
{
    if(Q.front == Q.rear)
        return false;
    x = Q.data[Q.front];
    return true;
}

入队

如何判断队列已满呢？当rear的下一个位置为front时，说明队列已满。这里必须牺牲掉最后一个存储单元。

如果不牺牲这个存储单元的话，如果rear指向2时，此时又有一个新的元素入队后，rear++，此时rear会等于front，而在前面的判空代码中rear==front代表队列为空，所以这中情况时不允许的。因而必须牺牲掉最后一个存储单元。

如果不想牺牲这一个存储单元，有两种方法可以避免牺牲！

1.可以在队列的定义中添加一个size变量，用来记录当前队列中元素的数量，这样判空的条件就变成了size==0，判满的条件就变成了size==MaxSize了。

2.在队列的定义中添加一个tag，tag=1表示上一个进行的操作时入队，tag=0表示上一个进行的操作是出队。

当q.read==q.front&&tag==1时表明是因为入队而导致队头队尾指针重合，那么一定是队列满了。当q.read==q.front&&tag==0时表明时因为出队而导致队头队尾指针重合，那么一定时队列空了。

 此外，入队后，rear并不是简单地加一，而是加一后取模。

bool EnQueue(SqQueue &Q,ElemType x)
{
    if((Q.rear+1)%MaxSize == Q.front)
        return false;
    Q.data[Q.rear] = x;
    Q.rear = (Q.rear+1)%MaxSize;
    return true;
}

出队

bool DeQueue(SqQueue &Q,ElemType &x)
{
    if(Q.rear==Q.front)
      return false;
    x = Q.data[Q.front];
    Q.front = (Q.front+1)%MaxSize;
    return true;
}

队列的链式存储

定义

typedef struct LinkNode//链式队列节点
{
    ElemType data;
    struct LinkNode *next;
}LinkNode;
typedef struct          //链式队列
{
    LinkNode *front,*rear;//队列的队头和队尾指针
}LinkQueue;

初始化

带头节点

void InitQueue(LinkQueue &Q)
{
    Q.front = Q.rear = (LinkNode*)malloc(sizeof(LinkNode));
    Q.front->next = NULL;
}

不带头节点

void InitQueue(LinkQueue &Q)
{
    Q.front=Q.rear = NULL;
}

判空

bool QueueEmpty(LinkQueue Q)
{
    return Q.front == Q.rear;
}

入队

带头结点

void EnQueue(LinkQueue &Q,ElemType e)
{
    LinkNode *x = (LinkNode*)malloc(sizeof(LinkNode));
    x->data = e;
    x->next = NULL;
    Q.rear = x;
}

不带头结点

void EnQueue(LinkQueue &Q,ElemType e)
{
    LinkNode *x = (LinkNode*)malloc(sizeof(LinkNode));
    x->data = e;
    x->next = NULL;
    if(Q.front==NULL)
    {
        Q.front=Q.rear=s;
    }
    else
    {
        Q.rear->next=s;
        Q.rear->s;
    }
}

出队

带头节点

bool DeQueue(LinkQueue &Q,ElemType &e)
{
    if(Q.front == Q.rear)
        return false;
    LinkNode *p = Q.front->next;
    x=p->data;
    Q.front->next = p->next;
    if(Q.rear==p)
        Q.rear=Q.front;
    free(p);
    return true;
}

不带头节点

bool DeQueue(LinkQueue &Q,ElemType &e)
{
    if(Q.front == Q.rear)
        return false;
    x = Q.front->next;
    Q.front->next = x->next;
    e = x->data;
    if(Q.rear==x)
    {
        Q.rear=Q.front=NULL;
    }
    free(x);
    return true;
}