数据结构基础3：队列

本文分别介绍了队列的链表实现和顺序实现，其中顺序实现写为循环队列，两种实现的接口和调用基本相同。

1.链表实现：

Queue.h

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

#define ElemType int
#define Status int 
#define ERROR -1;
#define OK 0
#define TRUE 1
#define FALSE 0

typedef struct QNode {
    ElemType value;
    struct QNOde *next;
}QNode, *QuePtr;

typedef struct {
    QuePtr front;
    QuePtr rear;
} LinkQue;

LinkQue* InitQueue();

int QueueLength(LinkQue *que);

Status EnQueue(LinkQue *que, ElemType x);

Status DeQueue(LinkQue *que, ElemType *x);

Status QueueEmpty(LinkQue *que);

Status QueueTraverse(LinkQue *que);

Status ClearQueue(LinkQue *que);

Status DestroyQueue(LinkQue *que);

main.c

#include "Queue.h"

int main(int argc, char *argv[])
{
    int i = 0, d = 0;
    LinkQue *queue = InitQueue();
    
    for(i = 0; i < 3; i++)
        EnQueue(queue, i);
        
    QueueTraverse(queue);
    
    for(i = 0; i < 3; i++) {
        DeQueue(queue, &d);
        printf("%d ", d);
    }
    printf("\n");
    
    ClearQueue(queue);
    DestroyQueue(queue);
        
    printf("Press enter to continue ...");
    getchar();
    	
    return 0;
}

Queue.c

#include "Queue.h"

LinkQue* InitQueue()
{
    LinkQue *que = malloc(sizeof(LinkQue));
    
    if(!que)
        exit(-1);
    
    que->front = que->rear = malloc(sizeof(QNode));
    
    return que;
}

int QueueLength(LinkQue *que)
{
    if(!que)
        return ERROR;
        
    int i = 0;
    QuePtr tmpNode = que->front;
    
    while(tmpNode != que->rear) {
        i++;
        tmpNode = tmpNode->next;
    }
    
    return i;
}

Status EnQueue(LinkQue *que, ElemType x)
{
    if(!que)
        return ERROR;
    
    QuePtr insertNode = NULL;
    
    que->rear->value = x;
    insertNode = malloc(sizeof(QNode));
    
    if(!insertNode)
        exit(-1);
        
    que->rear->next = insertNode;
    insertNode->next = NULL;
    que->rear = insertNode;
    
    return OK;
}

Status DeQueue(LinkQue *que, ElemType *x)
{
    if(!que)
        return ERROR;
    
    if(que->front == que->rear)
        return ERROR;
    
    QuePtr storeNode = NULL;  
    storeNode = que->front->next;
    *x = que->front->value;
    free(que->front);
    que->front = storeNode;
    
    return OK;
}

int QueueEmpty(LinkQue *que)
{
    if(!que)
        return ERROR;
    
    if(que->front == que->rear)
        return 1;
    else
        return 0;
}

Status QueueTraverse(LinkQue *que)
{
    if(!que)
        return ERROR;
    
    QuePtr tmpNode = que->front;
    
    while(tmpNode != que->rear) {
        printf("%d ", tmpNode->value);
        tmpNode = tmpNode->next;
    }
    printf("\n");
    
    return OK;
}

Status ClearQueue(LinkQue *que)
{
    if(!que)
        return ERROR;
    
    QuePtr tmpNode = que->front;
    
    while(tmpNode != que->rear) {
        tmpNode->value = 0;
        tmpNode = tmpNode->next;
    }
    
    return OK;    
}

Status DestroyQueue(LinkQue *que)
{
    if(!que)
        return ERROR;
    
    QuePtr tmpNode = que->front;
    QuePtr storeNode = NULL;
    
    while(tmpNode != que->rear) {
        storeNode = tmpNode->next;
        free(tmpNode);
        tmpNode = storeNode;
    }
    free(que->rear);
    free(que);
    
    return OK;
}

2.顺序实现（写为循环队列）

Queue.h

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

#define ElemType int
#define Status int 
#define ERROR -1;
#define OK 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 10

typedef struct {
    ElemType* base;
    ElemType front;
    ElemType rear;
} SeqQue;

SeqQue* InitQueue(int maxsize);

int QueueLength(SeqQue *que);

Status EnQueue(SeqQue *que, ElemType x);

Status DeQueue(SeqQue *que, ElemType *x);

int QueueEmpty(SeqQue *que);

Status QueueTraverse(SeqQue *que);

Status ClearQueue(SeqQue *que);

Status DestroyQueue(SeqQue *que);

main.c

#include "Queue.h"

int main(int argc, char *argv[])
{
    int i = 0, d = 0;
    SeqQue *queue = InitQueue(MAXSIZE);
    
    for(i = 0; i < 3; i++)
        EnQueue(queue, i);
    
    QueueTraverse(queue);
    
    for(i = 0; i < 3; i++) {
        DeQueue(queue, &d);
        printf("%d ", d);
    }
    printf("\n");
    
    ClearQueue(queue);
    DestroyQueue(queue);
        
    printf("Press enter to continue ...");
    getchar();
    	
    return 0;
}

Queue.c

#include "Queue.h"

SeqQue* InitQueue(int maxsize)
{
    SeqQue *queue = malloc(sizeof(SeqQue));
    
    if(!queue)
        exit(-1);
    
    queue->base = malloc(sizeof(int) * maxsize);
    
    if(!queue->base)
        exit(-1);
    
    queue->front = queue->rear = 0;
    
    return queue;
}

int QueueLength(SeqQue *que)
{
    if(!que)
        exit(-1);
        
    return (que->rear - que->front + MAXSIZE) % MAXSIZE;
}

Status EnQueue(SeqQue *que, ElemType x)
{
    if(!que)
        exit(-1);
    
    if((que->rear + 1) % MAXSIZE == que->front)
        return ERROR;
        
    que->base[que->rear] = x;
    que->rear = (que->rear + 1) % MAXSIZE;
    
    return OK;
}

Status DeQueue(SeqQue *que, ElemType *x)
{
    if(!que)
        exit(-1);
    
    if(que->front == que->rear)
        return ERROR;
        
    *x = que->base[que->front];
    que->front = (que->front + 1) % MAXSIZE;
    
    return OK;
}

int QueueEmpty(SeqQue *que)
{
    if(!que)
        exit(-1);
    
    if(que->front == que->rear)
        return TRUE;
    else
        return FALSE;   
}

Status QueueTraverse(SeqQue *que)
{
    if(!que)
        exit(-1);
    
    int i;
    for(i = que->front; i != que->rear; i = (i + 1) % MAXSIZE)
        printf("%d ", que->base[i]);
        
    printf("\n");
    
    return OK;   
}

Status ClearQueue(SeqQue *que)
{
    if(!que)
        exit(-1);
    
    int i;
    for(i = que->front; i == que->rear; i = (i + 1) % MAXSIZE)
        que->base[i] = 0;
    
    return OK;    
}

Status DestroyQueue(SeqQue *que)
{
    if(!que)
        exit(-1);
    
    free(que->base);
    free(que);
    
    return OK;  
}