队列的数组和链表实现

#ifndef QUEUE_H_
#define QUEUE_H_
typedef int ElementType;

#ifndef _QUEUE_LIST_
#define _QUEUE_LIST_
struct QNode;
typedef struct QNode * QNodePtr;
struct QNode
{
    ElementType Element;
    QNodePtr Next;
}QNode;
typedef struct Node
{
    QNodePtr Front;
    QNodePtr Rear;
}Node,*PtrToNode;

typedef PtrToNode Queue;



int IsEmpty(Queue Q);                       //判断队列是否为空Q->Rear == Q->Front;
Queue CreateQueue();                         //构造队列
void DisposeQueue(Queue Q);                //删除整个队列，回收空间
void MakeEmpty(Queue Q);                  //释放队列空间，将其置为空
void EnQueue(ElementType X, Queue Q);     //在队列尾端插入元素
ElementType Front(Queue Q);              //取出对头元素，但不删除
void Dequeue(Queue Q);                   //删除对头元素
ElementType FrontAndDequeue(Queue Q);   //
void PrintQueue(Queue Q);               //打印队列

#endif

#endif /* QUEUE_H_ */

#include "queue.h"
#include <stdio.h>
#include <stdlib.h>
int IsEmpty(Queue Q) {
    return Q->Rear == Q->Front;
}

void MakeEmpty(Queue Q) {
    if (Q == NULL) {
        printf("The queue is empty! Must use CreateQueue first!\n");
        return;
    } else {
        while (!IsEmpty(Q))
            Dequeue(Q);
    }
}

Queue CreateQueue() {
    //不仅要为对头(Queue)申请空间，还要为队列元素/节点（QNode）申请空间.
    Queue Q;
    Q = (Queue) malloc(sizeof(struct Node));
    if (Q == NULL) {
        printf("Out of space!\n");
        return NULL;
    }
    Q->Front = Q->Rear = (QNodePtr) malloc(sizeof(struct QNode));

    if (Q->Front == NULL) {
        printf("Out of space!\n");
        return NULL;
    }
    Q->Front->Next = NULL;
    return Q;
}

void DisposeQueue(Queue Q) {
    while (Q->Front != NULL) {
        Q->Rear = Q->Front->Next;
        free(Q->Front);
        Q->Front = Q->Rear;
    }
}

void Dequeue(Queue Q) {
    //删除链队列第一个元素
    if (!IsEmpty(Q)) {
        QNodePtr P;
        P = Q->Front->Next;
        Q->Front->Next = P->Next;
        if (Q->Rear == P)          //判断队列中是否只有一个元素
            Q->Rear = Q->Front;
        free(P);
    } else {
        printf("The queue is empty!\n");
    }
}

void EnQueue(ElementType X, Queue Q) {
    QNodePtr P = (QNodePtr) malloc(sizeof(struct QNode));
    if (P == NULL) {
        printf("Out of space!\n");
        return;
    } else {
        P->Next = NULL;
        P->Element = X;
        Q->Rear->Next = P;
        Q->Rear = P;
    }
}

ElementType Front(Queue Q) {
    return Q->Front->Next->Element;
}

ElementType FrontAndDequeue(Queue Q) {
    ElementType X = 0;
    if (!IsEmpty(Q)) {
        X = Front(Q);
        Dequeue(Q);
    } else {
        printf("The queue is empty!\n");
    }
    return X;
}

void PrintQueue(Queue Q) {
    QNodePtr P = Q->Front;
    while (P != Q->Rear) {
        P = P->Next;
        printf("%d\n", P->Element);
    }
}

#include<stdio.h>
#include "queue.h"
int main(void) {
    Queue Q;
    Q = CreateQueue();
    int i;
    for (i = 0; i < 10; i++) {
        EnQueue(i, Q);
    }
    PrintQueue(Q);
    return 0;
}

#ifndef _QUEUE_
#define _QUEUE_
typedef int ElementType;
typedef struct QueueRecord
{
    int Capacity;
    int Front;
    int Rear;
    int Size;
    ElementType *Array;
}*Queue;
int IsEmpty( Queue Q );
int IsFull( Queue Q );
Queue CreateQueue( int MaxElements );
void DisposeQueue( Queue Q );
void MakeEmpty( Queue Q );
void EnQueue( ElementType X, Queue Q );
ElementType Front( Queue Q );
void Dequeue( Queue Q );
ElementType FrontAndDequeue( Queue Q );

#endif

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

int IsEmpty( Queue Q )
{
    return Q->Size == 0;
}

int IsFull( Queue Q )
{
    return Q->Size == Q->Capacity;
}

void MakeEmpty( Queue Q )
{
    Q->Size = 0;
    Q->Front = 1;
    Q->Rear = 0;
}

Queue CreateQueue( int MaxElements )
{
    Queue Q;
    Q = (Queue)malloc(sizeof(struct QueueRecord));
    if (Q == NULL)
    {
        printf("Out of space!\n");
        return NULL;
    }
    Q->Array = (ElementType*)malloc(sizeof(ElementType) * MaxElements);
    if (Q->Array == NULL)
    {
        printf("Out of space!\n");
        return NULL;
    }
    Q->Capacity = MaxElements;
    MakeEmpty(Q);
    return Q;
}

void DisposeQueue( Queue Q )
{
    if (Q != NULL)
    {
        free(Q->Array);
        free(Q);
    }
}

static int Succ(int Value, Queue Q)
{
    if (++Value == Q->Capacity)
        Value = 0;
    return Value;
}


void EnQueue( ElementType X, Queue Q )
{
    if (IsFull(Q))
    {
        printf("Queue is full!\n");
        return;
    }
    else
    {
        Q->Size++;
        Q->Rear = Succ(Q->Rear, Q);     //Q->Rear = (Q->Rear + 1) % Q->Capacity ? Q->Rear + 1 : 0;
        Q->Array[Q->Rear] = X;
    }
}

ElementType Front( Queue Q )
{
    if (!IsEmpty(Q))
    {
        return Q->Array[Q->Front];
    }
    printf("Queue is Empty!\n");
    return 0;
}

void Dequeue( Queue Q )
{
    if (!IsEmpty(Q))
    {
        Q->Size--;
        Q->Front = Succ(Q->Front, Q);
    }
    else
    {
        printf("Queue is Empty!\n");
    }
}

ElementType FrontAndDequeue( Queue Q )
{
    ElementType X = 0;
    if (!IsEmpty(Q))
    {
        Q->Size--;
        X = Q->Array[Q->Front];
        Q->Front = Succ(Q->Front, Q);
    }
    else
    {
        printf("Queue is Empty!\n");
    }
    return X;
}

#include<stdio.h>
#include "queue.h"
int main(void) {
    Queue Q;
    Q = CreateQueue(10);
    int i,j;
    for (i = 0; i < 10; i++) {
        EnQueue(i, Q);
    }
    for(i = 0;i < 10;i++){
        j = FrontAndDequeue(Q);
        printf("%d ",j);
    }
    return 0;
}