c循环队列

 /*@file cyclequque.c*/
/*mingGW compiled ok*/
/*循环队列检验主程序 */

typedef int ElemType;
#include "allhead.h"
#include "quque.h"
#include "fun.h"

 

void main()
{
   Status j;
   int i=0,l;
   ElemType d;
   SqQueue Q;
   InitQueue(&Q);
   printf("1.初始化队列/n");
   for(i=1;i<=MAX_SIZE;i++)
   EnQueue(&Q,i);/*数据入队*/
   printf("2.队列data:");   
   QueueTraverse(Q,print);
   printf("3.队列空否:%u(1:空 0:否)/n",QueueEmpty(Q));
   printf("4.队列长度:%d/n",QueueLength(Q));

   printf("5.连续%d次由队头删除元素:/n",QueueLength(Q)-2);
   for(l=2;l<=QueueLength(Q);l++){  DeQueue(&Q,&d);  }  
   j=GetHead(Q,&d);
   if(j)   printf("6.队头元素为: %d/n",d);
   ClearQueue(&Q);
   printf("7.清空队列后, 队列空否?%u(1:空 0:否)/n",QueueEmpty(Q));
   DestroyQueue(&Q);  
 }

/**************************************************************/

运行结果：

1.初始化队列
2.队列data:1 2 3 4 5 6 7 8 9 10 11
3.队列空否:0(1:空 0:否)
4.队列长度:11
5.连续9次由队头删除元素:
6.队头元素为: 6
7.清空队列后, 队列空否?1(1:空 0:否)

 

/**************************************************************/
#include "allhead.h"
#include "fun.h"
省略它们，内容详见
http://blog.csdn.net/chinayaosir/archive/2008/09/20/2956091.aspx
/**************************************************************/

/*@file quque.h*/
/*mingGW compiled ok*/
/*数组构造循环队列*/
/*存储结构定义)*/
 #define MAX_SIZE 12 /* 最大队列长度+1 */
 typedef struct
 {
   ElemType *base; /* 初始化的动态分配存储空间 */
   int front; /* 头指针，若队列不空，指向队列头元素 */
   int rear; /* 尾指针，若队列不空，指向队列尾元素的下一个位置 */
 }SqQueue;

/*ADT LIST*/
/*循环队列的基本操作(9个) */
 void InitQueue(SqQueue *Q)
 { /* 构造一个空队列Q */
   (*Q).base=(ElemType *)malloc(MAX_SIZE*sizeof(ElemType));
   if(!(*Q).base) /* 存储分配失败 */
     exit(0);
   (*Q).front=(*Q).rear=0;
 }

 void DestroyQueue(SqQueue *Q)
 { /* 销毁队列Q，Q不再存在 */
   if((*Q).base)
     free((*Q).base);
   (*Q).base=NULL;
   (*Q).front=(*Q).rear=0;
 }

 void ClearQueue(SqQueue *Q)
 { /* 将Q清为空队列 */
   (*Q).front=(*Q).rear=0;
 }

 Status QueueEmpty(SqQueue Q)
 { /* 若队列Q为空队列，则返回TRUE；否则返回FALSE */
   if(Q.front==Q.rear) /* 队列空的标志 */
     return TRUE;
   else
     return FALSE;
 }

 int QueueLength(SqQueue Q)
 { /* 返回Q的元素个数，即队列的长度 */
   return(Q.rear-Q.front+MAX_SIZE)%MAX_SIZE;
 }

 Status GetHead(SqQueue Q,ElemType *e)
 { /* 若队列不空，则用e返回Q的队头元素，并返回OK；否则返回ERROR */
   if(Q.front==Q.rear) /* 队列空 */
     return ERROR;
   *e=Q.base[Q.front];
   return OK;
 }

 Status EnQueue(SqQueue *Q,ElemType e)
 { /* 插入元素e为Q的新的队尾元素 */
   if(((*Q).rear+1)%MAX_SIZE==(*Q).front) /* 队列满 */
     return ERROR;
   (*Q).base[(*Q).rear]=e;
   (*Q).rear=((*Q).rear+1)%MAX_SIZE;
   return OK;
 }

 Status DeQueue(SqQueue *Q,ElemType *e)
 { /* 若队列不空，则删除Q的队头元素，用e返回其值，并返回OK；否则返回ERROR */
   if((*Q).front==(*Q).rear) /* 队列空 */
     return ERROR;
   *e=(*Q).base[(*Q).front];
   (*Q).front=((*Q).front+1)%MAX_SIZE;
   return OK;
 }

 void QueueTraverse(SqQueue Q,void(*vi)(ElemType))
 { /* 从队头到队尾依次对队列Q中每个元素调用函数vi() */
   int i;
   i=Q.front;
   while(i!=Q.rear)
   {
     vi(Q.base[i]);
     i=(i+1)%MAX_SIZE;
   }
   printf("/n");
 }