队列基本操作实验报告

队列基本操作实验报告
一、实验目的
本次实验的主要目的是通过编写队列的基本操作，掌握队列数据结构的基本原理及其应用。

二、实验内容
1. 队列的定义和基本操作
队列是一种先进先出（FIFO）的线性数据结构，它只允许在队尾插入元素，在队头删除元素。

队列的基本操作包括：入队（enqueue）、出队（dequeue）、获取队头元素（getFront）、获取队列长度（getSize）等。

2. 队列的顺序存储结构
顺序存储结构是指用数组来存储队列中的元素，其中需要维护两个指针：front指向队头元素，rear指向下一个待插入位置。

当rear等于数组长度时，需要进行循环，即将rear置为0。

3. 队列的链式存储结构
链式存储结构是指用链表来存储队列中的元素，其中每个节点包含一
个数据域和一个指针域。

head指向链表头节点，tail指向链表尾节点。

4. 实验流程
(1) 编写顺序存储结构下的队列基本操作函数。

(2) 编写链式存储结构下的队列基本操作函数。

(3) 分别测试两种存储方式下各个函数是否正确实现。

三、实验步骤
1. 顺序存储结构下的队列基本操作函数
(1) 定义队列结构体和初始化函数。

typedef struct {
int *data;
int front, rear;
int maxSize;
} SeqQueue;
SeqQueue* initSeqQueue(int maxSize) {
SeqQueue *q = (SeqQueue*)malloc(sizeof(SeqQueue));
q->data = (int*)malloc(sizeof(int) * maxSize);
q->front = q->rear = 0;
q->maxSize = maxSize;
return q;
}
(2) 实现入队操作。

bool enqueue(SeqQueue *q, int x) {
if ((q->rear + 1) % q->maxSize == q->front) return false; // 队满
q->data[q->rear] = x;
q->rear = (q->rear + 1) % q->maxSize; // 循环
return true;
}
(3) 实现出队操作。

bool dequeue(SeqQueue *q) {
if (q->front == q->rear) return false; // 队空
q->front = (q->front + 1) % q->maxSize; // 循环
return true;
}
(4) 实现获取队头元素操作。

int getFront(SeqQueue *q) {
if (q->front == q->rear) return -1; // 队空
return q->data[q->front];
}
(5) 实现获取队列长度操作。

int getSize(SeqQueue *q) {
return (q->rear - q->front + q->maxSize) % q ->maxSize; }
2. 链式存储结构下的队列基本操作函数
(1) 定义链表节点结构体和初始化函数。

typedef struct Node {
int data;
struct Node *next;
} ListNode;
typedef struct {
ListNode *head, *tail;
int size;
} LinkedQueue;
LinkedQueue* initLinkedQueue() {
LinkedQueue *q =
(LinkedQueue*)malloc(sizeof(LinkedQueue));
q->head = q->tail = NULL;
q->size = 0;
return q;
}
(2) 实现入队操作。

void enqueue(LinkedQueue *q, int x) {
ListNode *node = (ListNode*)malloc(sizeof(ListNode)); node->data = x;
node->next = NULL;
if (q->tail == NULL) {
q->head = q->tail = node; // 队列为空，直接插入 } else {
q->tail->next = node; // 插入到队尾
q->tail = node; // 更新队尾指针
}
++q->size; // 更新队列长度
}
(3) 实现出队操作。

void dequeue(LinkedQueue *q) {
if (q->head == NULL) return; // 队空
ListNode *tmp = q->head; // 记录头节点
if (q->head == q->tail) { // 只有一个节点
q->head = q -> tail= NULL;
} else {
q -> head= tmp -> next; // 头指针后移一位
}
free(tmp); // 释放原头节点
--q -> size; // 更新队列长度
}
(4) 实现获取队头元素操作。

int getFront(LinkedQueue *q) {
if (q->head == NULL) return -1; // 队空
return q->head->data;
}
(5) 实现获取队列长度操作。

int getSize(LinkedQueue *q) {
return q->size;
}
四、实验结果
经过测试，两种存储方式下的队列基本操作函数均能正确实现。

五、实验总结
通过本次实验，我深刻理解了队列数据结构的原理和应用。

在编写代码的过程中，我发现顺序存储结构下需要进行循环，而链式存储结构下则不需要，这是两种存储方式的区别之一。

此外，在编写代码时还要注意边界条件的判断，避免出现越界等问题。

通过不断练习和掌握
基本操作函数的实现方法，我相信我能更好地应用队列数据结构解决实际问题。