数据结构---队列(数组实现)

本文用c语言实现队列（数组方法），以下是源码：

#include "queue_array.h"

PtrToQueue CreatQueue(uint32_t size)
{
PtrToQueue Q;

if (size < 1)
{
printf("Queue size is too small!\r\n");
return NULL;
}

Q = (PtrToQueue)malloc(sizeof(QueueType));
if (Q == NULL)
{
printf("Out of space!\r\n");
return NULL;
}

Q->Capacity = size;
Q->Front = 1;
Q->Rear = 0;
Q->Size = 0;
Q->Element = malloc((sizeof(ElementType))*size);
if (Q->Element == NULL)
{
printf("Out of space!\r\n");
return NULL;
}

return Q;
}

bool DisposeQueue(PtrToQueue Q)
{
if (Q != NULL)
{
free(Q->Element);
free(Q);
}
return true;
}

bool IsEmpty(PtrToQueue Q)
{
return (Q->Size == 0);
}
bool IsFull(PtrToQueue Q)
{
return (Q->Size == Q->Capacity);
}

bool MakeEmpty(PtrToQueue Q)
{
Q->Front = 1;
Q->Rear = 0;
Q->Size = 0;
return true;
}

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

bool Enqueue(PtrToQueue Q, ElementType X)
{
if (IsFull(Q))
{
printf("Queue if full!\r\n");
return false;
}

Q->Size += 1;
Q->Rear = Succ(Q->Rear, Q);
*((Q->Element) + (Q->Rear)) = X;
return true;
}

ElementType Front(PtrToQueue Q)
{
ElementType WrongRet;
if (IsEmpty(Q))
{
memset(&WrongRet, 0, sizeof(ElementType));
return WrongRet;
}

return *(Q->Element + Q->Front);
}
bool Dequeue(PtrToQueue Q)
{
if (IsEmpty(Q))
{
printf("Empty queue!\r\n");
return false;
}

Q->Size--;
Q->Front = Succ(Q->Front, Q);
return true;
}

ElementType FontAndDequeue(PtrToQueue Q)
{
ElementType ret;
if (IsEmpty(Q))
{
memset(&ret, 0, sizeof(ElementType));
return ret;
}
ret = *(Q->Element + Q->Front);
Q->Size--;
Q->Front = Succ(Q->Front, Q);
return ret;
}

bool PrintAllElement(PtrToQueue Q)
{
uint16_t QueueSize = Q->Size;
for (uint16_t i = 0; i < QueueSize; i++)
{
printf("Num %d element is %c\r\n", i, *(Q->Element + (Q->Front + i) % Q->Capacity));
}
printf("******** End ********\r\n\n");
return true;
}

#ifndef __QUEUE_ARRAY_H_
#define __QUEUE_ARRAY_H_

#include <stdbool.h>
#include <stdint.h>
#include <malloc.h>
#include <stdbool.h>
#include <stdio.h>
#include <memory.h>

typedef union
{
char Ch;
uint16_t U16;
int16_t I16;
} ElementType;

typedef struct
{
ElementType *Element;
int32_t Front;
int32_t Rear;
uint16_t Size;
uint16_t Capacity;
} QueueType;

typedef QueueType *PtrToQueue;

PtrToQueue CreatQueue(uint32_t size);
bool DisposeQueue(PtrToQueue Q);
bool IsEmpty(PtrToQueue Q);
bool IsFull(PtrToQueue Q);
bool MakeEmpty(PtrToQueue Q);
bool Enqueue(PtrToQueue Q, ElementType X);
ElementType Front(PtrToQueue Q);
bool Dequeue(PtrToQueue Q);
ElementType FontAndDequeue(PtrToQueue Q);
bool PrintAllElement(PtrToQueue Q);

#endif