使用两个链栈来实现队列

可以使用两个链栈来实现队列，具体实现方式如下：

1. 定义两个链栈，分别称为“入栈”和“出栈”。
2. 入队操作时，将元素插入到“入栈”链栈的栈顶。
3. 出队操作时，首先判断“出栈”链栈是否为空。若为空，则将“入栈”链栈中的所有元素依次弹出并插入到“出栈”链栈中，然后再从“出栈”链栈中弹出栈顶元素作为队列的出队元素。若不为空，则直接从“出栈”链栈中弹出栈顶元素作为队列的出队元素。
4. 其他操作和队列的实现方式一致。

代码实现如下（使用C语言实现）：

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

// 定义链栈结点
typedef struct StackNode {
    int data;
    struct StackNode* next;
} StackNode;

// 定义链栈
typedef struct Stack {
    StackNode* top;
} Stack;

// 初始化链栈
void initStack(Stack* s) {
    s->top = NULL;
}

// 判断链栈是否为空
int isEmptyStack(Stack* s) {
    return s->top == NULL;
}

// 入栈操作
void pushStack(Stack* s, int data) {
    StackNode* node = (StackNode*)malloc(sizeof(StackNode));
    node->data = data;
    node->next = s->top;
    s->top = node;
}

// 出栈操作
int popStack(Stack* s) {
    if (isEmptyStack(s)) {
        printf("Error: stack is empty.\n");
        return -1;
    }
    StackNode* node = s->top;
    int data = node->data;
    s->top = node->next;
    free(node);
    return data;
}

// 获取栈顶元素
int peekStack(Stack* s) {
    if (isEmptyStack(s)) {
        printf("Error: stack is empty.\n");
        return -1;
    }
    return s->top->data;
}

// 定义队列结构
typedef struct Queue {
    Stack inStack;
    Stack outStack;
} Queue;

// 初始化队列
void initQueue(Queue* q) {
    initStack(&q->inStack);
    initStack(&q->outStack);
}

// 判断队列是否为空
int isEmptyQueue(Queue* q) {
    return isEmptyStack(&q->inStack) && isEmptyStack(&q->outStack);
}

// 入队操作
void enqueue(Queue* q, int data) {
    pushStack(&q->inStack, data);
}

// 出队操作
int dequeue(Queue* q) {
    if (isEmptyQueue(q)) {
        printf("Error: queue is empty.\n");
        return -1;
    }
    if (isEmptyStack(&q->outStack)) {
        while (!isEmptyStack(&q->inStack)) {
            int data = popStack(&q->inStack);
            pushStack(&q->outStack, data);
        }
    }
    return popStack(&q->outStack);
}

// 获取队列头部元素
int peekQueue(Queue* q) {
    if (isEmptyQueue(q)) {
        printf("Error: queue is empty.\n");
        return -1;
    }
    if (isEmptyStack(&q->outStack)) {
        while (!isEmptyStack(&q->inStack)) {
            int data = popStack(&q->inStack);
            pushStack(&q->outStack, data);
        }
    }
    return peekStack(&q->outStack);
}

// 测试
int main() {
    Queue q;
    initQueue(&q);
    enqueue(&q, 1);
    enqueue(&q, 2);
    enqueue(&q, 3);
    printf("%d\n", dequeue(&q)); // output: 1
    printf("%d\n", dequeue(&q)); // output: 2
    enqueue(&q, 4);
    printf("%d\n", dequeue(&q)); // output: 3
    printf("%d\n", dequeue(&q)); // output: 4
    printf("%d\n", dequeue(&q)); // output: Error: queue is empty.
    return 0;
}