1. Definición de la estructura de datos

typedef int QueueType;
typedef struct seqQueue {
    int MAXNUM;             // 队列中能存放的最大元素个数
    int front, rear;        // 队列的队首，队尾
    QueueType element[100]; // 存放连续空间的起始地址
} *SeqQueue;

2. Resumen del método

SeqQueue CreateSqlQueue(int maxNum); //创建空的顺序队列
int IsQueueEmpty(SeqQueue Q);   //判断顺序（环形）队列是否为空
int IsQueueFull(SeqQueue Q);    //判断顺序（环形）队列是否已满
int EnQueue(SeqQueue Q, QueueType x);   //入队
QueueType DeQueue(SeqQueue Q);          //出队
QueueType GetQueueFront(SeqQueue Q);    //取队首元素返回
int DestroyQueue(SeqQueue Q);   //销毁队列

3. Explicación detallada del método

// 创建空的顺序队列
SeqQueue CreateSqlQueue(int maxNum) {
    SeqQueue queue = (SeqQueue)malloc(sizeof(struct seqQueue));
    if (!maxNum)  return NULL;
    else {
        queue->MAXNUM = maxNum;
        queue->front = queue->rear = NULL;
        return queue;
    }
}
// 判断顺序（环形）队列是否为空
int IsQueueEmpty(SeqQueue Q) {
    // 若为空，返回值为1，否则返回值为0
    // 若队列不存在，则返回-1
    if (Q == NULL) return -1;
    else  return(Q->front == Q->rear);
}
// 判断顺序（环形）队列是否已满
int IsQueueFull(SeqQueue Q) {
    // 若已满，返回值为1，否则返回值为0
    return((Q->rear + 1) % Q->MAXNUM == Q->front);
}
// 入队
int EnQueue(SeqQueue Q, QueueType x) {
    // 若插入不成功，返回0；插入成功返回值为1
    if ((Q->rear + 1) % Q->MAXNUM == Q->front) return 0;
    else {
        Q->element[Q->rear] = x;
        Q->rear = (Q->rear + 1) % Q->MAXNUM;
        return 1;
    }
}
// 出队并返回删除元素
QueueType DeQueue(SeqQueue Q) {
    // 若队列为空，则返回-1
    if (Q->front == Q->rear) return -1;
    else {
        int del = Q->element[Q->front];
        Q->front = (Q->front + 1) % Q->MAXNUM;
        return del;
    }
}
// 取队首元素返回
QueueType GetQueueFront(SeqQueue Q){
    // 若队列为空，则返回-1
    if (Q->front == Q->rear) return -1;
    else  return(Q->element[Q->front]);
}
// 销毁队列，释放队列所占存储空间
int DestroyQueue(SeqQueue Q){
    // 返回销毁栈中现有数据元素的个数
    // 若待销毁的线性表不存在，则返回0
    if (Q->front == Q->rear) return 0;
}

4. Ejecución de resultados

El código del método principal es el siguiente:

int main() {
    SeqQueue Q = CreateSqlQueue(10);
    if (IsQueueEmpty(Q)) printf("当前队列为空");
    for (int i = 0; i < 10; i++) {
        EnQueue(Q, i);
    }
    printf("\nDeQueue方法: ");
    for (int i = 0; i < 5; i++) {
        printf("%d ", DeQueue(Q));
    }
    printf("\nGetQueueFront方法: %d ", GetQueueFront(Q));
    DestroyQueue(Q);
}

El resultado de la operación es el siguiente:

Utilice la cola para completar las siguientes funciones:

Supongamos que un banco tiene dos ventanillas comerciales, A y B, y la velocidad de procesamiento de la ventanilla A es el doble que la de la ventanilla B, es decir, después de que A ha procesado dos negocios, B solo ha procesado uno. Dada la secuencia de clientes del banco, genere la secuencia de clientes en orden de finalización comercial. Suponga que no se considera el intervalo de tiempo de llegada del cliente, y cuando las dos ventanas A y B terminan de procesar clientes al mismo tiempo, el cliente de la ventana A sale primero.
Ingrese una línea de números enteros, el primer número es el número total de clientes N (N<1000), seguido de N números enteros que representan el número de clientes, asumiendo que los clientes con números impares van a la ventana A para manejar el negocio y los clientes con números pares los números van a la ventana B Manejar el negocio.

Entrada de prueba: 2 1 3 9 4 11 13 15
Salida esperada: 1 3 2 9 11 4 13 15

el código se muestra a continuación:

void QueueDemo(int a[], int n) {
    SeqQueue A = CreateSqlQueue(n * 2);	//编号为奇数的顾客去A窗口 
    SeqQueue B = CreateSqlQueue(n * 2);	//编号为偶数的顾客去B窗口

    for (int i = 0; i < n; i++) {
        if (a[i] % 2)	EnQueue(A, a[i]);
        else EnQueue(B, a[i]);
    }
    printf("结果如下:");
    while (1) {
        for (int i = 0; i < 2; i++) {
            if (!IsQueueEmpty(A)) {
                printf("%d ", GetQueueFront(A));
                DeQueue(A);
            }
            else break;
        }
        if (!IsQueueEmpty(B)) {
            printf("%d ", GetQueueFront(B));
            DeQueue(B);
        }
        else break;
    }
}