队列

#include<stdio.h>
#include<stdlib.h>
#define QUEUE_INIT_SIZE 10
#define OVERFLLOW 1
#define ERROR 0
#define OK 1
#define STACKINCREMENT 10
#define TURE 1
#define FALSE 0

typedef int elemtype;

typedef struct queue Squ;

struct queue {

    elemtype front;  

    elemtype *value;

    elemtype rear;
};

 void InitQueue(Squ *q)
{
    
     q->value=(elemtype *)malloc(QUEUE_INIT_SIZE * sizeof(elemtype));
     if(q->value == NULL) {
         exit(OVERFLLOW);
     }
     q->front = 0;
     q->rear = 0;
}

/*
 *   clear stack if have clear return ok--1;
 */

int ClearQueue(Squ *q)
{
    
     Squ *p=q;
     if( p->front == p->rear ) {
         *p->value=0;
         return OK;
     }
     while(p->front != p->rear) {
         *p->value=0;
         p->front++;
     }
     *p->value=0;
     return OK;
}

/*
 *   if stack is exist but empty return ture ,else return false;
 */

int EmptyQueue(Squ q)
{
    if(q.front == q.rear ) {
        return FALSE;
    } else {
        return TURE;
    }
}

/*
 *  if stack is empty StackLength return 0,else return its length;
 */

int QueueLength(Squ q)
{
    Squ *p=&q;
    int count=0;

    if(p->front == p->rear) {
        return count;
    }
    while(p->front != p->rear) {
        count++;
        p->front++;
    }
    return count;
}

/*
 *  if stack is exist ,return its top member;
 */

int  GetTop(Squ q,elemtype *value)
{
     Squ *p=&q;
     int i=0;
     if(p->front == p->rear) {
         return ERROR;
     } else {
          while(p->front != p->rear) {
              p->front ++;
              p->value[i++];
          }
          *value=p->value[i];
          return TURE;
       }
}
/*
 *   push member into stack;
 */   
int EnQueue(Squ *q,elemtype *value)
{
     if( (q->rear+1) % QUEUE_INIT_SIZE == q->front) {
          printf("the queue is full/n");
          return ERROR;
     } else {
           q->value[q->rear] = *value;
           q->rear=(q->rear+1) % QUEUE_INIT_SIZE;
       }
     return OK;
}  
/*
 * Pop a member from stack,if success return ture,else return false;
 */

int OutQueue(Squ *q,elemtype *value)
{
    if(q->front == q->rear) {
        printf("no data/n");
        return FALSE;
    } else {
          *value=q->value[q->front];
          q->front=(q->front+1) % QUEUE_INIT_SIZE;
      }
    return TURE;
}

/*
 * Destroy the stack,if stack not exist return error,else destroy it
 * and return ture;
 */

int DestroyQueue(Squ *q)
{  
     free(q->value);
     return TURE;
}

  
int main()
{
   elemtype value;
   Squ Queue;
   int i;
   InitQueue(&Queue);
 /*  GetTop(*Queue,&value);
   printf("%d/n",value);
   printf("the queue length is: %d/n",QueueLength(*Queue));
  */
   printf("please input value/n");
   scanf("%d",&value);
   while(value != 0 ) {
       EnQueue(&Queue,&value);
    //   GetTop(Queue,&value);
    //   printf("the top value is:%d/n",value);
       printf("the queue length is:%d/n",QueueLength(Queue));  
       if(! EmptyQueue(Queue)){
           printf("queue is free/n");
        } else {
              printf("queue is not free/n");
          }
       printf("please input value/n");
       scanf("%d",&value);
   }
   //ClearQueue(Queue);
 /*  GetTop(Queue,&value);
   printf("value=:%d/n",value);*/
   printf("please input value!/n");
   scanf("%d",&value);
   while(value !=  0 ) {
       OutQueue(&Queue,&value); 
       printf("%d/n",value);
       printf("the queue length is=:%d/n",QueueLength(Queue));
      
       printf("please input value!/n");
       scanf("%d",&value);
   }
/*
   if(! EmptyQueue(Queue)){
        printf("queue is free/n");
   } else {
         printf("queue is not free/n");
     }

   if(! DestroyQueue(&Queue) ) {
       printf("destroy queue unsuccess/n");
   }  else {
          printf("destroy queue success/n");
      }*/
   return 0;
}