队列的操作

参考：http://blog.csdn.net/zdcsky123/article/details/6668912

线性结构实现队列操作：

//队列空的条件
rear == front

//队列满的条件
(rear+1) % QueueSize == front

//队列长度计算公式
(rear-front+QueueSize) % QueueSize

#include<stdio.h>
#include<stdlib.h>
#define N 10

typedef int datatype; 
typedef struct{
    datatype data[N];
    int front, rear;
}sequeue;

sequeue *CreateEmptyQueue();
int EmptyQueue(sequeue *sq);
int FullQueue(sequeue *sq);
void ClearQueue(sequeue *sq);
void EnQueue(sequeue *sq, datatype x);
datatype DeQueue(sequeue *sq);

int main()
{
    sequeue *sq;
    int i;
    sq = CreateEmptyQueue();
    for(i=0; i<10; i++){
        if(!FullQueue(sq)){
            EnQueue(sq, i+1);
            printf("%d\t",i+1);
        }
    }
    printf("\n");
    while(!EmptyQueue(sq)){
        printf("%d\t",DeQueue(sq));
    }
    printf("\n");
}


sequeue *CreateEmptyQueue()
{
    sequeue *sq = (sequeue *)malloc(sizeof(sequeue));
    sq->rear = sq->front = 0;
    return sq;
}

int EmptyQueue(sequeue *sq)
{
    return sq->rear==sq->front;
}

int FullQueue(sequeue *sq)
{
    return (sq->rear+1)%N == sq->front;
}

void ClearQueue(sequeue *sq)
{
    sq->front = sq->rear = 0;
}
void EnQueue(sequeue *sq, datatype x)
{
    int re=(sq->rear+1)%N;
    sq->data[re]=x;
    sq->rear = re;
}
datatype DeQueue(sequeue *sq)
{
    int re = (sq->front+1)%N;
    sq->front = re;
    return sq->data[re];
}

队列的链式结构实现：

//指针方向是从队首指向队尾

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

typedef int datatype;

typedef struct Node           //结点结构
{
    datatype data;
    struct Node *next;
}linknode, *linklist;

typedef struct linkqueue      //队列结构
{
    linklist front, rear;     //队头、队尾指针
}linkqueue;

linkqueue *CreateEmptyQueue();
int EmptyQueue(linkqueue *lq);
void EnQueue(linkqueue *lq, datatype x);
datatype DeQueue(linkqueue *lq);
void ClearQueue(linkqueue *lq);

int main()
{
    linkqueue *lq = CreateEmptyQueue();
    int i;
    for(i = 1; i < 10; i++){
        EnQueue(lq, i);
        printf("%d\t",i);
    }
    printf("\n");

    if(EmptyQueue(lq)){
        printf("queue is empty!\n");
    }
    
    while(!EmptyQueue(lq)){
        printf("%d\n",DeQueue(lq));
    }
    printf("\n");

    return 0;
}


linkqueue *CreateEmptyQueue()
{
    linkqueue *lq = (linkqueue *)malloc(sizeof(linkqueue));
    lq->front = lq->rear = (linklist)malloc(sizeof(linknode));
    lq->front->next = NULL;
    return lq;
}

int EmptyQueue(linkqueue *lq)
{
    return lq->front == lq->rear;
}

void EnQueue(linkqueue *lq, datatype x)
{
    linklist ln = (linklist)malloc(sizeof(linknode));
    ln->data = x;
    ln->next = NULL;
    lq->rear->next = ln;
    lq->rear = ln;
}

datatype DeQueue(linkqueue *lq)
{
    datatype x;
    linklist ln = lq->front->next;
    lq->front->next = ln->next;
    x = ln->data;
    
	if(ln == lq->rear)                //如果队头是队尾，则删除后将rear指向头结点
        lq->rear = lq->front;
    free(ln);
    return x;
}


void ClearQueue(linkqueue *lq){
    linklist ln = lq->front->next;
    while(lq->front->next != NULL)
    {
        ln = lq->front->next;
        lq->front->next = ln->next;
        free(ln);
    }
    lq->rear = lq->front;
}