链队列

/***********************************************
队列的链式存储
by Rowandjj
2014/4/11
***********************************************/
#include <IOSTREAM>
using namespace std;


#define OK 1
#define TRUE 1
#define ERROR 0
#define FALSE 0
#define OVERFLOW 0

typedef int Status;
typedef int ElemType;
//-------------队列链式存储结构-----------------
typedef struct _NODE_
{
    ElemType data;
    struct _NODE_ *next;
}QNode,*QueuePtr;
typedef struct _LINKQUEUE_
{
    QueuePtr front;//队头指针
    QueuePtr rear;//队尾指针
}LinkQueue;

//------------操作定义-------------------------
Status InitQueue(LinkQueue &Q);
Status DestroyQueue(LinkQueue &Q);
Status ClearQueue(LinkQueue &Q);
Status QueueEmpty(LinkQueue Q);
int QueueLength(LinkQueue Q);
Status GetHead(LinkQueue Q,ElemType &e);
Status EnQueue(LinkQueue &Q,ElemType e);
Status DeQueue(LinkQueue &Q,ElemType &e);
Status QueueTraverse(LinkQueue &Q,void (*visit)(ElemType));

void visit(ElemType e);
//-----------具体实现-------------------------------
Status InitQueue(LinkQueue &Q)
{
    Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));
    if(!Q.front)
    {
        exit(OVERFLOW);
    }
    Q.front->next = NULL;
    return OK;
}

Status DestroyQueue(LinkQueue &Q)
{
    while(Q.front)
    {
        Q.rear = Q.front->next;
        free(Q.front);
        Q.front = Q.rear;
    }
    return OK;
}

Status ClearQueue(LinkQueue &Q)
{
    QueuePtr p,q;
    p = Q.front->next;
    Q.rear = Q.front;
    Q.front->next = NULL;
    while(p)
    {
        q = p->next;
        free(p);
        p = q;
    }
    return OK;
}
Status QueueEmpty(LinkQueue Q)
{
    if(Q.front == Q.rear)
    {
        return TRUE;
    }
    else
    {
        return ERROR;
    }
}
int QueueLength(LinkQueue Q)
{
    QueuePtr p = Q.front;
    int i = 0;
    while(p != Q.rear)
    {
        i++;
        p = p->next;
    }
    return i;
}
Status GetHead(LinkQueue Q,ElemType &e)
{
    QueuePtr p = Q.front->next;
    if(p)
    {
        e = p->data;
        return OK;
    }
    return ERROR;
}
Status EnQueue(LinkQueue &Q,ElemType e)
{
    QueuePtr p = (QueuePtr)malloc(sizeof(QNode));
    if(!p)
    {
        exit(OVERFLOW);
    }
    p->data = e;
    p->next = NULL;
    Q.rear->next = p;
    Q.rear = p;
    return OK;
}
Status DeQueue(LinkQueue &Q,ElemType &e)
{    
    QueuePtr p;
    if(Q.front == Q.rear)
    {
        return ERROR;
    }
    p = Q.front->next;
    Q.front->next = p->next;
    e = p->data;
    if(p == Q.rear)
    {
        Q.rear = Q.front;
    }
    free(p);
    return OK;
}
Status QueueTraverse(LinkQueue &Q,void (*visit)(ElemType))
{
    QueuePtr p = Q.front->next;
    while(p)
    {
        visit(p->data);
        p = p->next;
    }
    cout<<endl;

    return OK;
}

void visit(ElemType e)
{
    cout<<e<<" ";
}