C 使用数组实现最大为5的固定大小队列

我想使用数组实现一个固定大小的队列

我下面的代码正在编译并成功运行，但在队列中插入或删除2或3次后终止。 可能这段代码有一些逻辑错误，我找不到它们

    #include<stdio.h>
    #include<string.h>
    struct queue {
      int contents[5];
      int front;
      int count;
    };

    void initQueue(struct queue * q);
    void enQueue(struct queue * q, int element);
    int deQueue(struct queue * q);
    void display( struct queue q);
    void printMenu();

    int main()
    {
        struct queue p;
        int data,ch, data1;
        initQueue(&p);
        do  {
        printMenu();    
        printf("Enter your choice\n");
        scanf("%d",&ch);
        switch(ch) {
          case 1:
            printf("Enter the element to be inserted/entered\n");
            scanf("%d",&data);
            enQueue(&p, data);
            break;
          case 2:
            data1 = deQueue(&p);
            if(data1 != -1000)
            printf("The deleted element is %d\n",data1);
            break;
          case 3:
            printf("The contents of the queue are");
            display(p);
            printf("\n");
            break;
          default:
            return 0;
        }
        } while(1);
        return 0;
    }

    void printMenu()
    {
        printf("Choice 1 : Enter element into Queue\n");
        printf("Choice 2 : Delete element from Queue\n");
        printf("Choice 3 : Display\n");
        printf("Any other choice : Exit\n");
    }

    void initQueue(struct queue * q) 
    {
      q->front=0;
      q->count=0;
    }

    void enQueue(struct queue * q, int element)
    {
      if(q->count<5)
      {
        q->contents[q->count]=element;
        q->count++;
        return;
      }
      else
      {
        printf("Queue is full\n");
      }
      return;
    }

    int deQueue(struct queue * q)
    {
      int item,i;
     if(q->front==q->count)
     {
       printf("Queue is empty\n");
       return (-1000);
      }
     else
     {
       item=q->contents[q->front];
       if(item!='\0')
       {
       for(i=q->front;i<q->count-1;i++)
       {
       q->contents[i]=q->contents[i+1];
      }
         q->count=q->count-1;
        return item;
       }
       else
       {
         printf("Queue is empty\n");
         return -1000;
       }
      }
    }

    void display( struct queue q)
    {
      int i;
      if(q.front==q.count)
     {
        printf(" {}");
      }
      else
      {
        for(i=q.front;i<q.count;i++)
        {
          printf(" %d",q.contents[i]);
        }
       }
    }

#包括
#包括
结构队列{
int内容[5]；
内锋；
整数计数；
};
void initQueue（结构队列*q）；
void队列（结构队列*q，int元素）；
int-deQueue（结构队列*q）；
无效显示（结构队列q）；
作废打印菜单（）；
int main（）
{
结构队列p；
int数据，ch，data1；
初始化队列（&p）；
做{
打印菜单（）；
printf（“输入您的选择\n”）；
scanf（“%d”和“ch”）；
开关（ch）{
案例1：
printf（“输入要插入/输入的元素\n”）；
scanf（“%d”和数据）；
排队（&p，数据）；
打破
案例2：
数据1=出列（&p）；
如果（数据1！=-1000）
printf（“删除的元素是%d\n”，数据1）；
打破
案例3：
printf（“队列的内容为”）；
显示器（p）；
printf（“\n”）；
打破
违约：
返回0；
}
}而(1),；
返回0；
}
无效打印菜单（）
{
printf（“选项1：将元素输入队列\n”）；
printf（“选项2：从队列中删除元素\n”）；
printf（“选项3：显示”）；
printf（“任何其他选择：退出”）；
}
void initQueue（结构队列*q）
{
q->front=0；
q->count=0；
}
void队列（结构队列*q，int元素）
{
如果（q->countcontents[q->count]=元素；
q->count++；
返回；
}
其他的
{
printf（“队列已满\n”）；
}
返回；
}
int出列（结构队列*q）
{
int项目，i；
如果（q->front==q->count）
{
printf（“队列为空\n”）；
返回（-1000）；
}
其他的
{
项目=q->内容[q->前端]；
如果（项目！=“\0”）
{
对于（i=q->front；icount-1；i++）
{
q->contents[i]=q->contents[i+1]；
}
q->count=q->count-1；
退货项目；
}
其他的
{
printf（“队列为空\n”）；
返回-1000；
}
}
}
无效显示（结构队列q）
{
int i；
if（q.front==q.count）
{
printf（“{}”）；
}
其他的
{
对于（i=q.front；i来说，您似乎混淆了使用N元素数组实现“环形缓冲区”的两种方法

经典的方法是在前面和后面的元素上保留索引，但缺点是浪费一个元素，因为相同的条件
front==back
意味着0或N个元素

另一个是前端索引和计数器。在这种情况下，最后一个元素位于索引
（前端+计数-1）%N

因此，比较出列函数中的
front
和
count
没有意义。您应该将
count
与0进行比较。
此代码可能有效。请尝试此操作

 #include<stdio.h>
#include<string.h>
struct queue {
  int contents[5];
  int front;
  int count;
} ;

void initQueue(struct queue * q);
void enQueue(struct queue * q, int element);
int deQueue(struct queue * q);
void display( struct queue q);
void printMenu();

int main()
{
    struct queue p;
    int data,ch, data1;
    initQueue(&p);
    do {
    printMenu();    
    printf("Enter your choice\n");
    scanf("%d",&ch);
    switch(ch) {
      case 1:
        printf("Enter the element to be inserted/entered\n");
        scanf("%d",&data);
        enQueue(&p, data);
        break;
      case 2:
        data1 = deQueue(&p);
        if(data1 != -1000)
        printf("The deleted element is %d\n",data1);
        break;
      case 3:
        printf("The contents of the queue are");
        display(p);
        printf("\n");
        break;
      default:
        return 0;
    }
    } while(1);
    return 0;
}


void printMenu()
{
    printf("Choice 1 : Enter element into Queue\n");
    printf("Choice 2 : Delete element from Queue\n");
    printf("Choice 3 : Display\n");
    printf("Any other choice : Exit\n");
}

void initQueue(struct queue * q) 
{
  q->front=0;
  q->count=0;
}

void enQueue(struct queue * q, int element)
{
  int index;
  index=(q->count+q->front)%5;
  if(index==q->front&&q->count!=0)
    printf("Queue is full\n");
  else
  {
      q->count++;
    q->contents[index]=element;
  }
}

int deQueue(struct queue * q)
{
  int elem;
  if(q->count==0)
  {
   printf("Queue is empty\n");
    return (-1000);
  }
  elem=q->contents[q->front];
  q->count--;
  q->front=(q->front+1)%5;
  return elem;
}

void display( struct queue q)
{
  int i,index;
  if(q.count==0)
    printf(" {}");
  else
  {
      for(index=q.front,i=1;i<=q.count;i++,index++)
        printf(" %d",q.contents[index%5]);
  }

}

#包括
#包括
结构队列{
int内容[5]；
内锋；
整数计数；
} ;
void initQueue（结构队列*q）；
void队列（结构队列*q，int元素）；
int-deQueue（结构队列*q）；
无效显示（结构队列q）；
作废打印菜单（）；
int main（）
{
结构队列p；
int数据，ch，data1；
初始化队列（&p）；
做{
打印菜单（）；
printf（“输入您的选择\n”）；
scanf（“%d”和“ch”）；
开关（ch）{
案例1：
printf（“输入要插入/输入的元素\n”）；
scanf（“%d”和数据）；
排队（&p，数据）；
打破
案例2：
数据1=出列（&p）；
如果（数据1！=-1000）
printf（“删除的元素是%d\n”，数据1）；
打破
案例3：
printf（“队列的内容为”）；
显示器（p）；
printf（“\n”）；
打破
违约：
返回0；
}
}而(1),；
返回0；
}
无效打印菜单（）
{
printf（“选项1：将元素输入队列\n”）；
printf（“选项2：从队列中删除元素\n”）；
printf（“选项3：显示”）；
printf（“任何其他选择：退出”）；
}
void initQueue（结构队列*q）
{
q->front=0；
q->count=0；
}
void队列（结构队列*q，int元素）
{
整数指数；
索引=（q->计数+q->前面）%5；
如果（索引==q->front&&q->count！=0）
printf（“队列已满\n”）；
其他的
{
q->count++；
q->contents[索引]=元素；
}
}
int出列（结构队列*q）
{
内因；
如果（q->count==0）
{
printf（“队列为空\n”）；
返回（-1000）；
}
elem=q->contents[q->front]；
q->计数--；
q->front=（q->front+1）%5；
返回元素；
}
无效显示（结构队列q）
{
int i，索引；
如果（q.count==0）
printf（“{}”）；
其他的
{
对于（索引=q.front，i=1；i
#包括
#包括
结构队列{
int内容[5]；
内锋；
整数计数；
} ;
void initQueue（结构队列*q）；
void队列（结构队列*q，int元素）；
int-deQueue（结构队列*q）；
无效显示（结构队列q）；
作废打印菜单（）；
int main（）
{
结构队列p；
int数据，ch，data1；
初始化队列（&p）；
做{
打印菜单（）；
printf（“输入您的选择\n”）；
scanf（“%d”和“ch”）；
开关（ch）{
案例1：
printf（“输入要插入/输入的元素\n”）；
scanf（“%d”和数据）；
排队（&p，数据）；
打破
案例2：
数据1=出列（&p）；
如果（数据1！=-1000）
printf（“删除的元素是%d\n”，数据1）；
打破
案例3：
printf（“队列的内容为”）；
显示器（p）；
printf（“\n”）；
打破
违约：
返回0；
}
}而(1),；
返回0；
}
无效打印菜单（）
{
printf（“选项1：将元素输入队列\n”）；
printf（“选项2：从队列中删除元素\n”）；
printf(
 #include<stdio.h>
#include<string.h>
struct queue {
  int contents[5];
  int front;
  int count;
} ;

void initQueue(struct queue * q);
void enQueue(struct queue * q, int element);
int deQueue(struct queue * q);
void display( struct queue q);
void printMenu();

int main()
{
    struct queue p;
    int data,ch, data1;
    initQueue(&p);
    do {
    printMenu();    
    printf("Enter your choice\n");
    scanf("%d",&ch);
    switch(ch) {
      case 1:
        printf("Enter the element to be inserted/entered\n");
        scanf("%d",&data);
        enQueue(&p, data);
        break;
      case 2:
        data1 = deQueue(&p);
        if(data1 != -1000)
        printf("The deleted element is %d\n",data1);
        break;
      case 3:
        printf("The contents of the queue are");
        display(p);
        printf("\n");
        break;
      default:
        return 0;
    }
    } while(1);
    return 0;
}


void printMenu()
{
    printf("Choice 1 : Enter element into Queue\n");
    printf("Choice 2 : Delete element from Queue\n");
    printf("Choice 3 : Display\n");
    printf("Any other choice : Exit\n");
}

void initQueue(struct queue * q) 
{
  q->front=0;
  q->count=0;
}

void enQueue(struct queue * q, int element)
{
  int index;
  index=(q->count+q->front)%5;
  if(index==q->front&&q->count!=0)
    printf("Queue is full\n");
  else
  {
      q->count++;
    q->contents[index]=element;
  }
}

int deQueue(struct queue * q)
{
  int elem;
  if(q->count==0)
  {
   printf("Queue is empty\n");
    return (-1000);
  }
  elem=q->contents[q->front];
  q->count--;
  q->front=(q->front+1)%5;
  return elem;
}

void display( struct queue q)
{
  int i,index;
  if(q.count==0)
    printf(" {}");
  else
  {
      for(index=q.front,i=1;i<=q.count;i++,index++)
        printf(" %d",q.contents[index%5]);
  }

}