用C填充队列

更正，现在可以了，谢谢大家

好的，现在我已将主文件更新为
main.c

#包括“queue.h”
int main（）{
int i；
int*dataPtr；
整数；
队列*编号；
numbers=createQueue（）；
printf（“请输入您想要知道的10个数字的总和和平均值。\n”）；
对于（i=0；i<10；i++）{
printf（“编号%d:，i+1”）；
scanf（“%d”和编号）；
*dataPtr=数字；
排队（数字、数据PTR）；
}
系统（“暂停”）；
返回0；
}

但是我的程序在运行时崩溃了
有人知道为什么会这样吗

原创帖子

我不知道如何用C语言填写用户输入的队列。有人能给我指出正确的方向吗

队列.h:

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

//Queue ADT Type Definitions
        typedef struct node{
                void* dataPtr;
                struct node* next;
        } QUEUE_NODE;

        typedef struct{
                QUEUE_NODE* front;
                QUEUE_NODE* rear;
                int count;
        } QUEUE;

//Prototype Declarations      
        QUEUE* createQueue (void);
        QUEUE* destroyQueue (QUEUE* queue);

        bool dequeue        (QUEUE* queue, void** itemPtr);
        bool enqueue        (QUEUE* queue, void*  itemPtr);
        bool queueFront     (QUEUE* queue, void** itemPtr);
        bool queueRear      (QUEUE* queue, void** itemPtr);
        int  queueCount     (QUEUE* queue);

        bool emptyQueue     (QUEUE* queue);
        bool fullQueue      (QUEUE* queue);
//End of Queue ADT definitions

#包括
#包括
#包括
//队列ADT类型定义
类型定义结构节点{
void*dataPtr；
结构节点*下一步；
}队列节点；
类型定义结构{
队列节点*前端；
队列节点*后部；
整数计数；
}排队；
//原型声明
队列*createQueue（void）；
队列*销毁队列（队列*队列）；
bool出列（队列*队列，无效**itemPtr）；
bool排队（队列*队列，无效*项目PTR）；
bool queueFront（队列*队列，无效**itemPtr）；
bool queueRear（队列*队列，无效**itemPtr）；
int queueCount（队列*队列）；
bool emptyQueue（队列*队列）；
bool fullQueue（队列*队列）；
//队列结束ADT定义

队列.c

#include <stdio.h>
#include <stdlib.h>
#include "queue.h"
QUEUE* createQueue (void){
       QUEUE* queue;

       queue = (QUEUE*) malloc (sizeof (queue));
       if (queue){
          queue->front  = NULL;
          queue->rear   = NULL;
          queue->count  = 0;
       }
       return queue;
}

bool enqueue (QUEUE* queue, void* itemPtr){
     QUEUE_NODE* newPtr;

     if(!(newPtr = (QUEUE_NODE*)malloc(sizeof(QUEUE_NODE))))
                 return false;

     newPtr->dataPtr    = itemPtr;
     newPtr->next       = NULL;

     if (queue->count == 0)
         queue->front = newPtr;
     else
         queue->rear->next = newPtr;

     (queue->count)++;
     queue->rear = newPtr;
     return true;
}

bool dequeue (QUEUE* queue, void** itemPtr){
     QUEUE_NODE* deleteLoc;

     if (!queue->count)
        return false;

     *itemPtr  = queue->front->dataPtr;
     deleteLoc = queue->front;
     if(queue->count == 1)
         queue->rear  = queue->front = NULL;
     else
         queue->front = queue->front->next;
     (queue->count)--;
     free (deleteLoc);

     return true;
}

bool queueFront (QUEUE* queue, void** itemPtr){
     if (!queue->count)
        return false;
     else{
          *itemPtr = queue->front->dataPtr;
          return true;
     }
}

bool queueRear (QUEUE* queue, void** itemPtr){
     if (!queue->count)
        return true;
     else{
          *itemPtr = queue->rear->dataPtr;
          return false;
     }
}

bool emptyQueue (QUEUE* queue){
     return (queue->count == 0);
}

bool fullQueue(QUEUE* queue){
     QUEUE_NODE* temp;

     temp = (QUEUE_NODE*)malloc(sizeof(*(queue->rear)));
     if (temp){
               free (temp);
               return true;
               }
     return false;
}

int queueCount(QUEUE* queue){
    return queue->count;
}

QUEUE * destroyQueue (QUEUE* queue){
      QUEUE_NODE* deletePtr;

      if (queue){
                 while (queue->front != NULL){
                       free (queue->front->dataPtr);
                       deletePtr = queue->front;
                       queue->front = queue->front->next;
                       free(deletePtr);
                 }
                 free (queue);
      }
      return NULL;
}

main.c
#include <stdio.h>
#include <stdlib.h>
#include "queue.h"

int main(){
    int number;
    int *dataPtr;
    QUEUE* numbers;
    numbers = createQueue ();

    printf("Please enter the 10 numbers you want to know the sum and average of.\n");

    for (int i = 0, i < 10; i++){
        if (!(dataPtr = (int*) malloc (sizeof (int))))
           printf("Overflow trying to fill queues.\n"), exit(100);




  system("Pause");
  return 0;

}

#包括
#包括
#包括“queue.h”
队列*创建队列（无效）{
队列*队列；
队列=（队列*）malloc（sizeof（队列））；
如果（队列）{
队列->前端=空；
队列->后方=空；
队列->计数=0；
}
返回队列；
}
bool排队（队列*队列，无效*项目PTR）{
队列_节点*newPtr；
if（！（newPtr=（队列节点*）malloc（sizeof（队列节点）））
返回false；
newPtr->dataPtr=itemPtr；
newPtr->next=NULL；
如果（队列->计数==0）
队列->前端=newPtr；
其他的
队列->后方->下一步=newPtr；
（队列->计数）+；
队列->后方=newPtr；
返回true；
}
bool出列（队列*队列，无效**itemPtr）{
队列_节点*deleteLoc；
如果（！队列->计数）
返回false；
*itemPtr=queue->front->dataPtr；
deleteLoc=队列->前端；
如果（队列->计数==1）
队列->后=队列->前=空；
其他的
队列->前方=队列->前方->下一步；
（队列->计数）--；
免费（deleteLoc）；
返回true；
}
bool queueFront（队列*队列，无效**itemPtr）{
如果（！队列->计数）
返回false；
否则{
*itemPtr=queue->front->dataPtr；
返回true；
}
}
布尔队列后部（队列*队列，无效**itemPtr）{
如果（！队列->计数）
返回true；
否则{
*itemPtr=队列->后方->数据PTR；
返回false；
}
}
bool emptyQueue（队列*队列）{
返回（队列->计数==0）；
}
bool fullQueue（队列*队列）{
队列_节点*temp；
temp=（队列节点*）malloc（sizeof（*（队列->后部））；
如果（临时）{
免费（临时）；
返回true；
}
返回false；
}
int queueCount（队列*队列）{
返回队列->计数；
}
队列*销毁队列（队列*队列）{
队列_节点*deletePtr；
如果（队列）{
while（队列->前端！=NULL）{
空闲（队列->前端->数据PTR）；
deletePtr=队列->前端；
队列->前方=队列->前方->下一步；
免费（删除PTR）；
}
免费（排队）；
}
返回NULL；
}
main.c
#包括
#包括
#包括“queue.h”
int main（）{
整数；
int*dataPtr；
队列*编号；
numbers=createQueue（）；
printf（“请输入您想要知道的10个数字的总和和平均值。\n”）；
对于（int i=0，i<10；i++）{
如果（！（dataPtr=（int*）malloc（sizeof（int）））
printf（“溢出试图填充队列。\n”），退出（100）；
系统（“暂停”）；
返回0；
}

根据您的评论判断，我假设问题状态如下

接受来自用户的数字值输入序列，并用结果填充队列

为此，您需要：

• 循环输入直到满足某种终止条件（问题状态可能表示使用什么），如果不选择不可能为数据错误的东西（因为预期输入是数字的，考虑使用像“Q”这样的字母来停止输入）。
• 对于每个输入，获取它（从键盘，从文件？你不说），检查它是否是终止条件，如果不是，转换为数值
• 将结果排队

如果不更清楚地定义问题，更好地指出你所处的困境，我将帮上大忙

---

您正在使用的队列似乎是作为一个链表实现的，因此您可以手动遍历列表以非破坏性地访问内容。这打破了抽象，但效果很好

---

使用

ptr=queueFront（）

获取指向第一个节点的指针，然后每次要移动到下一个节点时都使用

ptr=ptr->next

。要访问单个节点的有效负载，请获取

ptr->dataPtr

并取消引用（即跟随指针）。

我认为您正在寻找gets（）或ssscanf从控制台获取用户输入的函数。队列代码看起来不错，您只需要从控制台获取整数，然后使用队列函数执行操作。

您已将该界面发布到通用队列工具。在我看来，它是一个非常合理的队列工具。该工具

#include <stdio.h>
#include <stdlib.h>
#include "queue.h"
QUEUE* createQueue (void){
       QUEUE* queue;

       queue = (QUEUE*) malloc (sizeof (queue));
       if (queue){
          queue->front  = NULL;
          queue->rear   = NULL;
          queue->count  = 0;
       }
       return queue;
}

bool enqueue (QUEUE* queue, void* itemPtr){
     QUEUE_NODE* newPtr;

     if(!(newPtr = (QUEUE_NODE*)malloc(sizeof(QUEUE_NODE))))
                 return false;

     newPtr->dataPtr    = itemPtr;
     newPtr->next       = NULL;

     if (queue->count == 0)
         queue->front = newPtr;
     else
         queue->rear->next = newPtr;

     (queue->count)++;
     queue->rear = newPtr;
     return true;
}

bool dequeue (QUEUE* queue, void** itemPtr){
     QUEUE_NODE* deleteLoc;

     if (!queue->count)
        return false;

     *itemPtr  = queue->front->dataPtr;
     deleteLoc = queue->front;
     if(queue->count == 1)
         queue->rear  = queue->front = NULL;
     else
         queue->front = queue->front->next;
     (queue->count)--;
     free (deleteLoc);

     return true;
}

bool queueFront (QUEUE* queue, void** itemPtr){
     if (!queue->count)
        return false;
     else{
          *itemPtr = queue->front->dataPtr;
          return true;
     }
}

bool queueRear (QUEUE* queue, void** itemPtr){
     if (!queue->count)
        return true;
     else{
          *itemPtr = queue->rear->dataPtr;
          return false;
     }
}

bool emptyQueue (QUEUE* queue){
     return (queue->count == 0);
}

bool fullQueue(QUEUE* queue){
     QUEUE_NODE* temp;

     temp = (QUEUE_NODE*)malloc(sizeof(*(queue->rear)));
     if (temp){
               free (temp);
               return true;
               }
     return false;
}

int queueCount(QUEUE* queue){
    return queue->count;
}

QUEUE * destroyQueue (QUEUE* queue){
      QUEUE_NODE* deletePtr;

      if (queue){
                 while (queue->front != NULL){
                       free (queue->front->dataPtr);
                       deletePtr = queue->front;
                       queue->front = queue->front->next;
                       free(deletePtr);
                 }
                 free (queue);
      }
      return NULL;
}

main.c
#include <stdio.h>
#include <stdlib.h>
#include "queue.h"

int main(){
    int number;
    int *dataPtr;
    QUEUE* numbers;
    numbers = createQueue ();

    printf("Please enter the 10 numbers you want to know the sum and average of.\n");

    for (int i = 0, i < 10; i++){
        if (!(dataPtr = (int*) malloc (sizeof (int))))
           printf("Overflow trying to fill queues.\n"), exit(100);




  system("Pause");
  return 0;

}

gets(number);

scanf("%d", &number);

    scanf("%d", &number);
    dataPtr = malloc(sizeof(int));
    *dataPtr = number;