本题要求实现一个普通顺序队列。 当输入1 2 3 -1时，输出为1 2 3 。 当输入为1 2 3 4 5 6 7 8 9 10 11 -1时，输出为 queue is full! 1 2 3 4 5 6 7 8 9 10 请填空。

### 回答1：
队列的实现代码如下：

#include <stdio.h>
#define MAXSIZE 10

typedef struct {
    int data[MAXSIZE];
    int front, rear;
} Queue;

void init(Queue *q) {
    q->front = q->rear = ;
}

int isEmpty(Queue *q) {
    return q->front == q->rear;
}

int isFull(Queue *q) {
    return (q->rear + 1) % MAXSIZE == q->front;
}

int enQueue(Queue *q, int x) {
    if (isFull(q)) {
        return ;
    }
    q->data[q->   

### 回答2：
实现一个普通顺序队列，需要定义队列结构体和相关的操作函数。队列结构体中应包含队列元素信息和相关的队列变量信息，如队列长度、队列头尾指针等。

以下是实现一个普通顺序队列的步骤：

1. 定义队列结构体

typedef struct{
    int* data;    // 队列数组
    int front;    // 队首指针
    int rear;     // 队尾指针
    int capacity; // 队列容量
}Queue;

2. 定义初始化队列函数

void initQueue(Queue* q, int capacity) {
    // 初始化队列，设置队列容量和队列指针
    q->data = (int*)malloc(capacity * sizeof(int));
    q->front = 0;
    q->rear = -1;
    q->capacity = capacity;
}

3. 定义判断队列是否为空的函数

int isEmpty(Queue* q) {
    // 如果队首指针大于队尾指针，说明队列为空
    return (q->rear < q->front);
}

4. 定义判断队列是否已满的函数

int isFull(Queue* q) {
    // 如果队尾指针到达队列容量-1，说明队列已满
    return (q->rear == q->capacity - 1);
}

5. 定义入队函数

void enqueue(Queue* q, int x) {
    if(isFull(q)) {
        printf("queue is full!\n");
        exit(1);  // 如果队列已满，直接退出程序
    }
    // 队尾指针加1并添加元素
    q->rear += 1;
    q->data[q->rear] = x;
}

6. 定义出队函数

int dequeue(Queue* q) {
    if(isEmpty(q)) {
        printf("queue is empty!\n");
        exit(1);  // 如果队列为空，直接退出程序
    }
    // 队首指针加1并返回元素
    int res = q->data[q->front];
    q->front += 1;
    return res;
}

7. 定义测试函数

int main() {
    Queue q;
    initQueue(&q, 10);
    
    int num;
    while(1) {
        scanf("%d", &num);
        if(num == -1) break;
        enqueue(&q, num);
    }
    
    while(!isEmpty(&q)) {
        printf("%d ", dequeue(&q));
    }
    
    return 0;
}

根据题目要求，当输入1 2 3 -1时，输出为1 2 3，当输入为1 2 3 4 5 6 7 8 9 10 11 -1时，输出为queue is full! 1 2 3 4 5 6 7 8 9 10。

因此，当输入为1 2 3 -1时，程序运行结果为：

1 2 3

当输入为1 2 3 4 5 6 7 8 9 10 11 -1时，程序运行结果为：

queue is full!
1 2 3 4 5 6 7 8 9 10   

### 回答3：
题目要求实现一个普通顺序队列，顺序队列是一种先进先出的线性数据结构，支持插入和删除操作。在这个问题中，输入一系列的数字，直到输入-1为止，要求将这些数字按顺序插入到队列中，并在队列已满时返回"queue is full!"的提示，最终输出队列中所有元素。

实现普通顺序队列需要用到数组和两个指针：队首指针front和队尾指针rear。队首指针指向队列中第一个元素，队尾指针指向队列中最后一个元素的下一个位置。当队列为空时，front和rear指向同一个位置，当队列已满时，rear的下一个位置等于front。

以下是实现这个问题的示例代码：

#include<iostream>
using namespace std;

const int MAXSIZE = 10; //队列最大长度
int queue[MAXSIZE]; //定义队列数组
int front = 0, rear = 0; //队首和队尾指针

//插入元素到队尾
void enqueue(int x) {
if ((rear+1)%MAXSIZE == front) {
cout << "queue is full!" << endl;
return;
}
queue[rear] = x;
rear = (rear+1)%MAXSIZE;
}

//删除队首元素
void dequeue() {
if (front == rear) {
cout << "queue is empty!" << endl;
return;
}
cout << queue[front] << " ";
front = (front+1)%MAXSIZE;
}

int main() {
int x;
while (cin >> x && x != -1) {
enqueue(x);
}
while (front != rear) {
dequeue();
}
return 0;
}

以上代码中，enqueue(x)函数用于将元素x插入到队尾，若队列已满则返回"queue is full!"。dequeue()函数用于删除队首元素并输出，若队列为空则返回"queue is empty!"。在主函数中，首先读入所有数据并插入到队列中，然后不断删除队首元素并输出，直到队列为空。

运行示例1：输入1 2 3 -1，输出1 2 3

运行示例2：输入1 2 3 4 5 6 7 8 9 10 11 -1，输出queue is full! 1 2 3 4 5 6 7 8 9 10