// 入队操作 void enqueue(Queue* q, int element) { if (isFull(q)) { printf("队列已满，无法插入元素！\n"); return; } q->s1.data[++q->s1.top1] = element; }

这段代码是一个队列数据结构的入队操作，使用了两个栈来实现队列的功能。具体实现是：元素进入栈1的栈顶，当需要出队时，将栈1中的元素全部出栈并进入栈2，栈2的栈顶元素即为队列头部元素，出队后将栈2中的元素重新压入栈1中。

其中，isFull(q)函数用于判断队列是否已满，防止队列溢出。

此代码中的实现方式是栈1用于入队，栈2用于出队。还有一种实现方式是栈1用于出队，栈2用于入队。两种方式的实现原理和时间复杂度都是一样的。

相关问题

采用顺序存储实现循环队列的初始化入队出队操作

循环队列是一种队列，它可以在数组中循环使用空间，实现队列的基本操作包括初始化、入队和出队。下面是使用顺序存储实现循环队列的初始化、入队和出队操作的示例代码。

#define MAXSIZE 100  // 循环队列的最大长度

typedef struct {
    int data[MAXSIZE];  // 数组存储元素
    int front;  // 队头指针
    int rear;  // 队尾指针
} Queue;

// 初始化循环队列
void initQueue(Queue *q) {
    q->front = 0;
    q->rear = 0;
}

// 判断循环队列是否为空
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 element) {
    if (isFull(q)) {
        printf("Queue is full.\n");
        return 0;
    }
    q->data[q->rear] = element;
    q->rear = (q->rear + 1) % MAXSIZE;
    return 1;
}

// 出队操作
int deQueue(Queue *q, int *element) {
    if (isEmpty(q)) {
        printf("Queue is empty.\n");
        return 0;
    }
    *element = q->data[q->front];
    q->front = (q->front + 1) % MAXSIZE;
    return 1;
}

上述代码中，循环队列使用数组存储元素，队头指针和队尾指针分别指向队头和队尾元素在数组中的位置。初始化操作将队头和队尾指针都指向数组的第一个元素，判断队列是否为空的方法是队头指针和队尾指针是否相等，判断队列是否已满的方法是队尾指针加1后对数组长度取模是否等于队头指针。

入队操作将元素放入队尾指针所指向的位置，然后将队尾指针加1，如果队尾指针超过了数组的长度，则将其置为0，实现循环使用空间的效果。如果队列已满，则返回0表示入队失败。

出队操作将队头指针所指向的元素取出，然后将队头指针加1，同样如果队头指针超过了数组的长度，则将其置为0，实现循环使用空间的效果。如果队列为空，则返回0表示出队失败。

（1）定义存储整数的循环队列和链队列。 （2）编写初始化/创建、入队和出队操作的算法。 （3）设计菜单，以选择菜单方式进行操作，并实现上述算法。

1. 循环队列和链队列是两种不同的队列数据结构，用于存储一系列元素，支持先进先出的操作方式。

循环队列是一种基于数组实现的队列，其特点是头尾相接，形成一个环形结构。当队列满时，新的元素将无法入队；当队列为空时，无法出队。循环队列可以通过取模运算实现队头和队尾的循环操作。

链队列是一种基于链表实现的队列，其特点是队头和队尾分别指向链表的头和尾节点。入队操作在链表尾部插入新节点，出队操作则删除链表头部节点。

2. 下面是循环队列和链队列的初始化/创建、入队和出队操作的算法：

（1）循环队列的初始化/创建、入队和出队操作算法：

#define MAX_SIZE 100

typedef struct {
    int data[MAX_SIZE];
    int front;  // 队头指针
    int rear;   // 队尾指针
} CircularQueue;

// 初始化循环队列
void initCircularQueue(CircularQueue *Q) {
    Q->front = Q->rear = 0;
}

// 入队操作
void enQueue(CircularQueue *Q, int x) {
    if ((Q->rear + 1) % MAX_SIZE == Q->front) {
        printf("Queue is full.\n");
        return;
    }
    Q->data[Q->rear] = x;
    Q->rear = (Q->rear + 1) % MAX_SIZE;
}

// 出队操作
int deQueue(CircularQueue *Q) {
    if (Q->front == Q->rear) {
        printf("Queue is empty.\n");
        return -1;
    }
    int x = Q->data[Q->front];
    Q->front = (Q->front + 1) % MAX_SIZE;
    return x;
}

（2）链队列的初始化/创建、入队和出队操作算法：

typedef struct Node {
    int data;
    struct Node *next;
} Node;

typedef struct {
    Node *front;  // 队头指针
    Node *rear;   // 队尾指针
} LinkedQueue;

// 初始化链队列
void initLinkedQueue(LinkedQueue *Q) {
    Q->front = Q->rear = NULL;
}

// 入队操作
void enQueue(LinkedQueue *Q, int x) {
    Node *newNode = (Node *)malloc(sizeof(Node));
    newNode->data = x;
    newNode->next = NULL;
    if (Q->rear == NULL) {
        Q->front = Q->rear = newNode;
    } else {
        Q->rear->next = newNode;
        Q->rear = newNode;
    }
}

// 出队操作
int deQueue(LinkedQueue *Q) {
    if (Q->front == NULL) {
        printf("Queue is empty.\n");
        return -1;
    }
    int x = Q->front->data;
    Node *temp = Q->front;
    Q->front = Q->front->next;
    if (Q->front == NULL) {
        Q->rear = NULL;
    }
    free(temp);
    return x;
}

3. 下面是一个简单的菜单，用于选择队列操作：

#include <stdio.h>

int main() {
    int choice, x;
    CircularQueue Q1;
    LinkedQueue Q2;
    initCircularQueue(&Q1);
    initLinkedQueue(&Q2);
    while (1) {
        printf("1. Enqueue\n");
        printf("2. Dequeue\n");
        printf("3. Exit\n");
        printf("Enter your choice: ");
        scanf("%d", &choice);
        switch (choice) {
            case 1:
                printf("Enter the element to be enqueued: ");
                scanf("%d", &x);
                enQueue(&Q1, x);
                enQueue(&Q2, x);
                break;
            case 2:
                printf("Dequeued element from circular queue is %d.\n", deQueue(&Q1));
                printf("Dequeued element from linked queue is %d.\n", deQueue(&Q2));
                break;
            case 3:
                printf("Exiting...\n");
                return 0;
            default:
                printf("Invalid choice.\n");
        }
    }
}