定长循环队列C语言实现

#ifndef _CONST_H_
#define _CONST_H_

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

typedef enum
{
False = 0,
True,
}Bool;

typedef int ElemType;

#define QUEUE_MAX_SIZE 10

#define STACK_INIT_SIZE 10
#define STACK_INCREMENT_SIZE 2

#define Null ((void *)0)

typedef enum
{
NORMAL = 0,
ERROR,
UNDERFLOW,
OVERFLOW,
STATUSCOUNT,
}Status;

#endif

#ifndef _QUEUE_H_
#define _QUEUE_H_

#include "Const.h"

typedef struct queue
{
ElemType *base;
int front;
int rear;
}Queue, *pQueue;

Status InitQueue(Queue *pQ);

Bool IsQueueFull(pQueue pQ);

Bool IsQueueEmpty(pQueue pQ);

Bool EnQueue(pQueue pQ, ElemType elme);

Bool DeQueue(pQueue pQ, ElemType *e);

void DestoryQueue(pQueue pQ);

void ClearQueue(pQueue pQ);

ElemType GetHead(pQueue pQ);

int GetQueueLength(pQueue pQ);

#endif

#include "Queue.h"

Status InitQueue(Queue *pQ)
{
pQ->front = 0;
pQ->rear = 0;
pQ->base = (ElemType *)malloc(QUEUE_MAX_SIZE * sizeof(ElemType));
if (Null == pQ->base)
{
printf("Can not malloc target size memory");
return ERROR;
}
}

Bool IsQueueFull(pQueue pQ)
{
if ((pQ->rear + 1) % QUEUE_MAX_SIZE == pQ->front)
{
return True;
}
else
{
return False;
}
}

Bool IsQueueEmpty(pQueue pQ)
{
if (pQ->rear == pQ->front)
{
return True;
}
else
{
return False;
}
}

Bool EnQueue(pQueue pQ, ElemType elme)
{
if (IsQueueFull(pQ))
{
printf("The Queue Is Full.");
return False;
}
else
{
pQ->base[pQ->rear] = elme;
pQ->rear = (pQ->rear + 1) % QUEUE_MAX_SIZE;
}
}

Bool DeQueue(pQueue pQ, ElemType *e)
{
if (IsQueueEmpty(pQ))
{
printf("The Queue Is Empty.");
return False;
}
else
{
*e = pQ->base[pQ->front];
pQ->front = (pQ->front + 1) % QUEUE_MAX_SIZE;
return True;
}
}

void DestoryQueue(pQueue pQ)
{
if (pQ->base)
{
free(pQ->base);
}
pQ->rear = 0;
pQ->front = 0;
pQ->base = Null;
}

void ClearQueue(pQueue pQ)
{
pQ->rear = 0;
pQ->front = 0;
}

ElemType GetHead(pQueue pQ)
{
if (IsQueueEmpty(pQ))
{
printf("The queue is empty.");
return 0;
}
return pQ->base[pQ->front];
}

int GetQueueLength(pQueue pQ)
{
return pQ->rear - pQ->front;
}