单片机的 FIFO循环队列实现

//////////////////////////////////////////////////////////
// 文件：config.h
//////////////////////////////////////////////////////////
#ifndef __CONFIG_H 
#define __CONFIG_H
//这一段无需改动
//This segment should not be modified
#ifndef TRUE
#define TRUE  1
#endif
#ifndef FALSE
#define FALSE 0
#endif
typedef unsigned char  uint8;
typedef signed   char  int8;
typedef unsigned short uint16;
typedef signed   short int16;
typedef unsigned int   uint32;
typedef signed   int   int32;
typedef float          fp32;

#include "FIFOQUEUE.h"
#endif

//////////////////////////////////////////////////////////
// 文件：FIFOQUEUE.h
//////////////////////////////////////////////////////////
#ifndef _FIFOQUEUE_H
#define _FIFOQUEUE_H
#define ElemType       uint8
#define QueueSize      20 //fifo队列的大小
#define QueueFull      0  //fifo满置0
#define QueueEmpty     1  //FIFO空置1
#define QueueOperateOk 2  //队列操作完成 赋值为2
struct FifoQueue
{
    uint16 front;     //队列头
    uint16 rear;        //队列尾
    uint16 count;       //队列计数
    ElemType dat[QueueSize];
};
//Queue Initalize
extern void QueueInit(struct FifoQueue *Queue);
// Queue In
extern uint8 QueueIn(struct FifoQueue *Queue,ElemType sdat);
// Queue Out
extern uint8 QueueOut(struct FifoQueue *Queue,ElemType *sdat);
#endif

//////////////////////////////////////////////////////////
// 文件：FIFOQUEUE.C
//////////////////////////////////////////////////////////
#include "config.h"
//Queue Init
void QueueInit(struct FifoQueue *Queue)
{
    Queue->front = Queue->rear;//初始化时队列头队列首相连
    Queue->count = 0;   //队列计数为0
}

// Queue In
uint8 QueueIn(struct FifoQueue *Queue,ElemType sdat) //数据进入队列
{
    if((Queue->front == Queue->rear) && (Queue->count == QueueSize))
    {                    // full //判断如果队列满了
        return QueueFull;    //返回队列满的标志
    }else
    {                    // in
        Queue->dat[Queue->rear] = sdat;
        Queue->rear = (Queue->rear + 1) % QueueSize;
        Queue->count = Queue->count + 1;
        return QueueOperateOk;
    }
}

// Queue Out
uint8 QueueOut(struct FifoQueue *Queue,ElemType *sdat)
{
    if((Queue->front == Queue->rear) && (Queue->count == 0))
    {                    // empty
        return QueueEmpty;
    }else
    {                    // out
        *sdat = Queue->dat[Queue->front];
        Queue->front = (Queue->front + 1) % QueueSize;
        Queue->count = Queue->count - 1;
        return QueueOperateOk;
    }
}

//////////////////////////////////////////////////////////
// 文件：Main.C
//////////////////////////////////////////////////////////
#include <reg52.h>
#include "config.h"
void main(void)
{
    struct FifoQueue MyQueue;
    ElemType sh;
    uint8 i;
    QueueInit(&MyQueue);
    while(1)
    {
        for(i = 0;i < 30;i++)
        {
            if(QueueIn(&MyQueue,i) == QueueFull) break;
        }
        for(i = 0;i < 30;i++)
        {
            if(QueueOut(&MyQueue,&sh) == QueueEmpty) break;
        }
    }
    while(1);
}

//=====ADT Queue的表示与实现===== 
//-----单链队列——队列的链式存储结构----- 
typedef struct QNode{ 
    QElemType   data; 
    struct QNode  *next; 
}QNode, *QueuePtr;
typedef struct{ 
    QueuePtr front;  //对头指针 
    QueuePtr rear;  //队尾指针 
}LinkQueue；
//-----基本操作的函数原型说明（几个易错常考的）----- 
Status GetHead(LinkQueue Q, QElemType &e) 
   //若队列不空，则用e返回Q的对头元素，并返回OK；否则返回ERROR 
Status EnQueue(LinkQueue &Q, QElemType e) 
    //插入元素e为Q的新的队尾元素 
Status DeQueue(LinkQueue &Q, QElemType &e) 
    //若队列不空，则删除Q的对头元素，用e返回其值，并返回OK； 
    //否则返回ERROR

//-----循环队列———队列的顺序存储结构----- 
#define MAXQSIZE 100   //最大队列长度 
typedef struct
{
    QElemType *base;  //初始化的动态非配存储空间 
    int front;        //头指针，若队列不空，指向队列的头元素 
    int rear;         //尾指针，若队列不空，指向队列尾元素的下一个位置 
}SqQueue;
 
//-----循环队列的基本操作的算法描述----- 
Status InitQueue(SqQueue &Q)
{
    //构造一个空队列Q 
    Q.base=(ElemType *)malloc(MAXQSIZE*sizeof(ElemType)); 
    if(!Q.base) exit (OVERFLOW);  // 存储分配失败
    Q.front=Q.rear=0; 
    return OK; 
}
int QueueLength(SqQueue Q){ 
    //返回Q的元素个数，即队列的长度 
    return (Q.rear-Q.front+MAXQSIZE) % MAXQSIZE; 
}
Status EnQueue(SqQueue &Q, QElemType e)
{
    //插入元素e为Q的新的队尾元素 
    if((Q.rear+1) % MAXQSIZE == Q.front) return ERROR;  // 队列满
    Q.base[Q.rear]=e; 
    Q.rear=(Q.rear+1) % MAXQSIZE; 
    return OK; 
}
Status DeQueue(SqQueue &Q, QElemType &e)
{
    //若队列不空，则删除Q的对头元素，用e返回其值，并返回OK； 
    //否则返回ERROR 
    if(Q.front==Q.rear)  return ERROR; 
    e=Q.base[Q.front]; 
    Q.front=(Q.front+1) % MAXQSIZE; 
    return OK; 
}