1） 编程实现队列在两种存储结构中的基本操作（队列的初始化、判队列空、入队列、出队列）C语言

好的,我将为您介绍如何使用C语言实现队列在两种存储结构(顺序存储和链式存储)中的基本操作。

1. 顺序存储实现队列

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

#define MAXSIZE 100

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

// 初始化队列
void InitQueue(SqQueue *Q) {
    Q->front = Q->rear = 0;
}

// 判断队列是否为空
int QueueEmpty(SqQueue Q) {
    return Q.front == Q.rear;
}

// 入队操作
int EnQueue(SqQueue *Q, int x) {
    if (Q->rear == MAXSIZE) {
        printf("Queue overflow\n");
        return 0;
    }
    Q->data[Q->rear++] = x;
    return 1;
}

// 出队操作
int DeQueue(SqQueue *Q, int *x) {
    if (QueueEmpty(*Q)) {
        printf("Queue underflow\n");
        return 0;
    }
    *x = Q->data[Q->front++];
    return 1;
}

// 测试顺序存储队列
void TestSqQueue() {
    SqQueue Q;
    InitQueue(&Q);
    EnQueue(&Q, 1);
    EnQueue(&Q, 2);
    int x;
    DeQueue(&Q, &x);
    printf("Dequeued: %d\n", x);
}

2. 链式存储实现队列

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

typedef struct QNode {
    int data;
    struct QNode *next;
} QNode, *QueuePtr;

typedef struct {
    QueuePtr front;
    QueuePtr rear;
} LinkQueue;

// 初始化队列
void InitQueue(LinkQueue *Q) {
    Q->front = Q->rear = (QueuePtr)malloc(sizeof(QNode));
    Q->front->next = NULL;
}

// 判断队列是否为空
int QueueEmpty(LinkQueue Q) {
    return Q.front == Q.rear;
}

// 入队操作
void EnQueue(LinkQueue *Q, int x) {
    QueuePtr s = (QueuePtr)malloc(sizeof(QNode));
    s->data = x;
    s->next = NULL;
    Q->rear->next = s;
    Q->rear = s;
}

// 出队操作
int DeQueue(LinkQueue *Q, int *x) {
    if (QueueEmpty(*Q)) {
        printf("Queue underflow\n");
        return 0;
    }
    QueuePtr p = Q->front->next;
    *x = p->data;
    Q->front->next = p->next;
    if (Q->rear == p) {
        Q->rear = Q->front;
    }
    free(p);
    return 1;
}

// 测试链式存储队列
void TestLinkQueue() {
    LinkQueue Q;
    InitQueue(&Q);
    EnQueue(&Q, 1);
    EnQueue(&Q, 2);
    int x;
    DeQueue(&Q, &x);
    printf("Dequeued: %d\n", x);
}

这两种实现方式的区别主要在于存储结构的不同。顺序存储使用数组实现，而链式存储使用链表实现。顺序存储的优点是实现简单，但需要预先定义最大容量；链式存储的优点是可以动态分配内存，但实现相对复杂。