栈和队列大概是数据结构里最"冤"的两个结构——概念简单到用一句话就能说清，但真到动手写的时候，十个里有六个会在循环队列的边界判断上翻车，剩下四个会在括号匹配的多重嵌套里绕晕。我当年带实验课的时候就发现，很多人链表写得飞起，一到栈和队列的实操就各种迷之操作：顺序栈的top指针到底指向栈顶元素还是栈顶的下一个位置？循环队列的队满条件为什么非要空出一个格子？这些细节课本上一笔带过，但实验里一个都躲不掉。

这篇内容就是围绕"栈和队列的基本操作"这个实验展开的，我会把顺序栈、链栈、循环队列、链队列这四种实现从头到尾拆一遍，包括每种结构的核心设计思路、关键边界条件的推导过程、完整可运行的代码实现，以及我在实际调试中踩过的那些坑。不管你是正在做这个实验的学生，还是想重新梳理一遍基础数据结构的开发者，应该都能从中找到有用的东西。代码以C语言为主，但思路是通用的，换成其他语言也一样。

1. 实验整体设计与结构选型思路

1.1 为什么栈和队列值得单独做一次实验

很多人觉得栈和队列太简单了，不就是后进先出和先进先出吗，有什么好实验的。但实际写代码的时候你会发现，这两个结构的"简单"是概念上的简单，实现上的细节一点都不少。栈的核心操作就push和pop两个，但顺序栈要考虑扩容，链栈要考虑内存管理；队列更麻烦，循环队列的队空队满判断、链队列的尾指针维护，每一个都是容易出bug的地方。

从教学设计的角度看，这个实验的目的不是让你记住栈是LIFO、队列是FIFO，而是训练三种能力：第一是对边界条件的敏感度，比如栈空时pop、队满时enqueue该怎么处理；第二是对指针操作的熟练度，链式结构的插入删除顺序不能乱；第三是对时间复杂度的直觉，知道为什么循环队列比普通顺序队列更优。

我在实际做这个实验的时候，建议把四种结构都实现一遍。不是因为它们都要用，而是因为对比着写，你才能真正理解每种结构的适用场景。顺序栈适合元素数量可预估的场景，链栈适合频繁变动的场景；循环队列解决了假溢出问题，链队列则没有容量限制。这些结论光看课本没感觉，自己写一遍代码就全明白了。

1.2 四种结构的选型对比

在动手之前，先把四种结构的特性拉通对比一下，这样你在实现的时候就知道每种结构要重点关注什么。

这张表里最关键的一列是"核心难点"。顺序栈的难点在于你要明确定义top指针的含义——它是指向栈顶元素本身，还是指向栈顶元素的下一个空位？这两种定义方式会导致所有操作的代码都不一样。我见过太多人写顺序栈的时候，push和pop用的不是同一套约定，结果就是程序跑起来看着对，一碰到边界就崩。

循环队列的难点更经典：如果直接用front == rear来判断队空，那队满的时候front也等于rear，两者冲突了。解决方案有三种——空出一个格子、加一个size计数器、加一个flag标记。这三种方案各有优劣，后面我会详细拆解。

链队列的难点在于尾指针的维护。出队的时候，如果队列中只有一个元素，出队后rear指针必须置空，否则rear就变成了野指针。这个细节很多人第一次写都会漏掉。

1.3 实验的整体模块划分

我建议把这个实验分成四个独立的模块来写，每个模块包含结构定义、初始化、核心操作和测试代码。这样组织的好处是每个模块可以独立编译运行，调试的时候不会互相干扰。

具体来说，每个模块需要实现以下内容：

• 结构定义：用typedef定义结构体，包括数据域和指针/索引域
• 初始化：分配内存或设置初始值
• 核心操作：栈的push/pop，队列的enqueue/dequeue
• 辅助操作：判空、判满、获取长度、遍历输出
• 测试代码：覆盖正常情况和所有边界情况

测试代码这块我要多说一句。很多人写测试就是随便push几个数再pop几个数，看到输出对了就完事了。但真正能暴露bug的是边界测试：空栈pop、满栈push、循环队列绕圈、链队列删到只剩一个元素。这些场景才是实验真正要考察的东西。

2. 顺序栈的核心细节与实操要点

2.1 栈顶指针的两种定义方式及选择

顺序栈的实现第一个要决定的事情就是：top指针到底怎么定义。有两种主流方案：

方案A：top指向栈顶元素的下标，初始值为-1。栈空时top == -1，入栈时先top++再赋值，出栈时先取值再top--。

方案B：top指向栈顶元素的下一个空位，初始值为0。栈空时top == 0，入栈时先赋值再top++，出栈时先top--再取值。

这两种方案都能用，但绝对不能混用。我推荐用方案A，原因是判断栈空的条件更直观——top == -1一看就知道是空栈，而方案B的top == 0容易和"栈中有一个元素"混淆（方案B中栈中有一个元素时top == 1）。

用方案A定义结构体：

#define MAXSIZE 100 typedef struct { int data[MAXSIZE]; int top; // 栈顶元素下标，空栈时为-1 } SeqStack;

初始化就一行代码：

void InitStack(SeqStack *s) { s->top = -1; }

判空和判满也很直接：

int IsEmpty(SeqStack *s) { return s->top == -1; } int IsFull(SeqStack *s) { return s->top == MAXSIZE - 1; }

注意：如果你用的是方案B，那么判空是top == 0，判满是top == MAXSIZE，入栈出栈的代码顺序也要反过来。选定一种方案后就贯彻到底，不要在不同函数里用不同的约定。

2.2 入栈与出栈的完整实现

入栈操作需要先判满，再移动指针，最后赋值：

int Push(SeqStack *s, int value) { if (IsFull(s)) { return 0; // 栈满，入栈失败 } s->top++; s->data[s->top] = value; return 1; }

出栈操作需要先判空，再取值，最后移动指针：

int Pop(SeqStack *s, int *value) { if (IsEmpty(s)) { return 0; // 栈空，出栈失败 } *value = s->data[s->top]; s->top--; return 1; }

这里有一个设计决策：出栈时是否要清空原位置的数据？答案是不需要。因为top指针已经减了，那个位置的数据虽然还在内存里，但逻辑上已经不属于栈了，下次入栈会被覆盖。手动清空反而多此一举。

取栈顶元素和出栈的区别在于，取栈顶不移动top指针：

int GetTop(SeqStack *s, int *value) { if (IsEmpty(s)) { return 0; } *value = s->data[s->top]; return 1; }

2.3 顺序栈的扩容策略

固定大小的顺序栈在实际使用中很容易溢出。如果要支持动态扩容，需要把数组改成动态分配的指针，并记录当前容量：

typedef struct { int *data; int top; int capacity; } DynStack; void InitDynStack(DynStack *s, int initCap) { s->data = (int *)malloc(sizeof(int) * initCap); s->top = -1; s->capacity = initCap; } int PushDyn(DynStack *s, int value) { if (s->top == s->capacity - 1) { int newCap = s->capacity * 2; int *newData = (int *)realloc(s->data, sizeof(int) * newCap); if (newData == NULL) { return 0; } s->data = newData; s->capacity = newCap; } s->top++; s->data[s->top] = value; return 1; }

扩容策略选择翻倍而不是每次加固定值，原因是翻倍能让均摊时间复杂度保持在O(1)。如果每次只加1，那n次入栈的总操作次数是1+2+...+n = O(n²)，均摊下来每次是O(n)，性能差很多。

实操心得：扩容时用realloc而不是malloc+memcpy+free，因为realloc在可能的情况下会原地扩展，避免了一次完整的数据拷贝。但要注意realloc失败时返回NULL，原来的指针仍然有效，所以不能直接s->data = realloc(s->data, ...)，必须用临时指针接一下。

3. 链栈的实现与指针操作要点

3.1 链栈的结构设计与初始化

链栈用单链表实现，栈顶放在链表头部。为什么放头部？因为头部的插入和删除都是O(1)，而尾部插入是O(1)但删除是O(n)。栈的核心操作是push和pop，都在同一端进行，所以放在头部最合适。

typedef struct StackNode { int data; struct StackNode *next; } StackNode; typedef struct { StackNode *top; // 栈顶指针 int count; // 元素个数 } LinkedStack;

初始化时top置空，count置零：

void InitLinkedStack(LinkedStack *s) { s->top = NULL; s->count = 0; }

这里我加了一个count字段来记录元素个数，因为链栈判空虽然可以用top == NULL，但获取长度需要遍历整个链表，加个计数器能以O(1)的时间获取长度。这是一个典型的空间换时间策略。

3.2 链栈入栈出栈的指针操作

入栈就是头插法：

int LinkedPush(LinkedStack *s, int value) { StackNode *newNode = (StackNode *)malloc(sizeof(StackNode)); if (newNode == NULL) { return 0; } newNode->data = value; newNode->next = s->top; s->top = newNode; s->count++; return 1; }

这三行指针操作的顺序不能乱：先让新节点的next指向当前栈顶，再更新栈顶指针指向新节点。如果反过来先更新了top，那原来的栈顶就找不到了，整条链就断了。

出栈操作：

int LinkedPop(LinkedStack *s, int *value) { if (s->top == NULL) { return 0; } StackNode *temp = s->top; *value = temp->data; s->top = temp->next; free(temp); s->count--; return 1; }

出栈时必须先用一个临时指针保存栈顶节点，再更新top，最后free临时指针。不能直接free(s->top)然后再访问s->top->next，因为free之后那块内存已经不属于你了。

常见错误：有些人在出栈时写成free(s->top); s->top = s->top->next;这是典型的use-after-free，free之后s->top指向的内存已经被回收，再访问它的next字段是未定义行为。编译器可能不报错，但运行时可能崩溃或者产生随机结果。

3.3 链栈与顺序栈的对比实测

我在同一台机器上对两种栈做了简单的性能对比测试，入栈和出栈各执行100万次：

从数据可以看出，顺序栈在性能上全面优于链栈，主要原因是数组的连续内存访问缓存命中率高，而链表的节点分散在堆上，每次访问都可能触发缓存未命中。链栈的优势在于不需要预先分配固定大小的内存，也不会因为扩容导致性能抖动。

所以选型建议很明确：如果能预估元素数量上限，用顺序栈；如果元素数量波动很大或者内存碎片化严重，用链栈。实际工程中顺序栈的使用频率远高于链栈。

4. 循环队列的边界判断与实现细节

4.1 循环队列的队空队满判断方案

循环队列最核心的问题就是：front == rear既可以表示队空也可以表示队满，怎么区分？三种主流方案：

方案一：牺牲一个存储单元。队列最多存MAXSIZE-1个元素，队空条件是front == rear，队满条件是(rear + 1) % MAXSIZE == front。

方案二：加size计数器。维护一个size变量记录当前元素个数，队空是size == 0，队满是size == MAXSIZE。

方案三：加flag标记。维护一个flag标记最后一次操作是入队还是出队，队空是front == rear && flag == 0，队满是front == rear && flag == 1。

三种方案对比：

我推荐方案一或方案二。方案一代码最简洁，适合考试和教学场景；方案二空间利用率最高，适合实际工程。方案三的flag逻辑容易搞混，不太推荐。

4.2 基于牺牲单元的循环队列实现

#define QUEUE_MAX 100 typedef struct { int data[QUEUE_MAX]; int front; // 队头元素下标 int rear; // 队尾元素的下一个位置 } CircularQueue; void InitQueue(CircularQueue *q) { q->front = 0; q->rear = 0; } int IsQueueEmpty(CircularQueue *q) { return q->front == q->rear; } int IsQueueFull(CircularQueue *q) { return (q->rear + 1) % QUEUE_MAX == q->front; } int Enqueue(CircularQueue *q, int value) { if (IsQueueFull(q)) { return 0; } q->data[q->rear] = value; q->rear = (q->rear + 1) % QUEUE_MAX; return 1; } int Dequeue(CircularQueue *q, int *value) { if (IsQueueEmpty(q)) { return 0; } *value = q->data[q->front]; q->front = (q->front + 1) % QUEUE_MAX; return 1; }

这里rear的定义是"队尾元素的下一个位置"，也就是说data[rear]是下一个可以存放新元素的位置。入队时先存值再移动rear，出队时先取值再移动front。

队列中元素个数的计算公式是：

int QueueLength(CircularQueue *q) { return (q->rear - q->front + QUEUE_MAX) % QUEUE_MAX; }

这个公式要理解清楚：当rear > front时，长度就是rear - front；当rear < front时（说明绕了一圈），长度是rear - front + QUEUE_MAX。两种情况合并起来就是(rear - front + QUEUE_MAX) % QUEUE_MAX。

4.3 循环队列的绕圈测试与验证

循环队列最容易出bug的地方就是绕圈。我设计了一个测试用例来验证：队列容量为5（实际最多存4个元素），依次入队1、2、3、4，然后出队1、2，再入队5、6，此时队列中应该是3、4、5、6。

void TestCircularQueue() { CircularQueue q; InitQueue(&q); // 入队1,2,3,4 for (int i = 1; i <= 4; i++) { Enqueue(&q, i); } printf("入队4个元素后，队列长度：%d\n", QueueLength(&q)); // 应为4 // 出队1,2 int val; Dequeue(&q, &val); printf("出队：%d\n", val); // 1 Dequeue(&q, &val); printf("出队：%d\n", val); // 2 // 入队5,6 Enqueue(&q, 5); Enqueue(&q, 6); printf("再入队2个元素后，队列长度：%d\n", QueueLength(&q)); // 应为4 // 全部出队 while (!IsQueueEmpty(&q)) { Dequeue(&q, &val); printf("%d ", val); // 应为3 4 5 6 } printf("\n"); }

这个测试的关键在于验证rear指针绕过数组末尾后能正确回到前面。如果取模运算写错了，比如漏掉了% QUEUE_MAX，那rear就会一直增大，最终数组越界。

实操心得：调试循环队列的时候，建议在每次入队出队后打印front、rear和队列长度。这样一旦发现异常，能立刻定位是哪一步出了问题。我当年就是靠这个方法发现自己的队满判断写成了(rear + 1) % QUEUE_MAX == front，但实际应该是(rear + 1) % QUEUE_MAX == front，看起来一样但优先级搞错了。

5. 链队列的实现与尾指针维护

5.1 带头结点的链队列设计

链队列用单链表实现，需要同时维护队头指针和队尾指针。为了简化操作，通常会加一个头结点（哨兵节点），这样队头出队和队尾入队的代码可以统一处理，不需要单独判断队列是否为空。

typedef struct QueueNode { int data; struct QueueNode *next; } QueueNode; typedef struct { QueueNode *front; // 队头指针，指向头结点 QueueNode *rear; // 队尾指针，指向最后一个节点 } LinkedQueue;

初始化时创建一个头结点，front和rear都指向它：

void InitLinkedQueue(LinkedQueue *q) { q->front = (QueueNode *)malloc(sizeof(QueueNode)); q->front->next = NULL; q->rear = q->front; }

带头结点的好处是：入队时不需要判断队列是否为空，直接q->rear->next = newNode; q->rear = newNode;就行。出队时也不需要特殊处理，因为front始终指向头结点，真正的队头元素是front->next。

5.2 入队与出队的完整实现

入队操作：

int LinkedEnqueue(LinkedQueue *q, int value) { QueueNode *newNode = (QueueNode *)malloc(sizeof(QueueNode)); if (newNode == NULL) { return 0; } newNode->data = value; newNode->next = NULL; q->rear->next = newNode; q->rear = newNode; return 1; }

入队的指针操作顺序：先把新节点接到队尾后面，再更新rear指针。如果先更新rear，那原来的队尾就找不到了。

出队操作：

int LinkedDequeue(LinkedQueue *q, int *value) { if (q->front == q->rear) { return 0; // 队列为空 } QueueNode *temp = q->front->next; *value = temp->data; q->front->next = temp->next; // 关键：如果出队的是最后一个元素，需要把rear重新指向头结点 if (q->rear == temp) { q->rear = q->front; } free(temp); return 1; }

出队操作里最关键的一步就是那个if判断。如果队列中只有一个元素，出队后队列变为空，此时rear还指向被free掉的节点，就成了野指针。下次入队时q->rear->next就会访问已释放的内存，程序直接崩溃。

常见错误：很多人写链队列出队时会漏掉rear指针的更新。这个bug的隐蔽性在于，如果队列中始终有多个元素，程序看起来完全正常。只有当队列被清空后再入队时才会崩溃。所以测试的时候一定要覆盖"出队到空再入队"这个场景。

5.3 链队列的销毁与内存管理

链队列使用完毕后需要释放所有节点的内存，包括头结点：

void DestroyLinkedQueue(LinkedQueue *q) { QueueNode *p = q->front; while (p != NULL) { QueueNode *temp = p; p = p->next; free(temp); } q->front = NULL; q->rear = NULL; }

销毁的时候从头结点开始逐个释放，注意先用temp保存当前节点，再移动p，最后free(temp)。顺序反了就会use-after-free。

6. 栈和队列的经典应用场景

6.1 用栈实现括号匹配

括号匹配是栈最经典的应用。思路很简单：遇到左括号就入栈，遇到右括号就看栈顶是不是对应的左括号，是就出栈，不是就匹配失败。最后如果栈为空，说明全部匹配。

int BracketMatch(const char *str) { SeqStack s; InitStack(&s); for (int i = 0; str[i] != '\0'; i++) { char c = str[i]; if (c == '(' || c == '[' || c == '{') { Push(&s, c); } else if (c == ')' || c == ']' || c == '}') { if (IsEmpty(&s)) { return 0; // 右括号多余 } int top; Pop(&s, &top); if ((c == ')' && top != '(') || (c == ']' && top != '[') || (c == '}' && top != '{')) { return 0; // 括号类型不匹配 } } } return IsEmpty(&s); // 栈空说明全部匹配 }

这个算法的时间复杂度是O(n)，空间复杂度最坏情况下也是O(n)（全是左括号的情况）。测试用例要覆盖：正常匹配、左括号多余、右括号多余、类型不匹配、空字符串、只有括号没有其他字符等情况。

6.2 用队列实现层次遍历

队列在树的层次遍历中非常有用。思路是：根节点入队，然后循环出队一个节点并访问，同时把它的左右子节点入队，直到队列为空。

typedef struct TreeNode { int data; struct TreeNode *left; struct TreeNode *right; } TreeNode; void LevelOrder(TreeNode *root) { if (root == NULL) return; LinkedQueue q; InitLinkedQueue(&q); LinkedEnqueue(&q, (int)root); // 这里简化处理，实际应存指针 while (!IsQueueEmpty(&q)) { int val; LinkedDequeue(&q, &val); TreeNode *node = (TreeNode *)val; printf("%d ", node->data); if (node->left) LinkedEnqueue(&q, (int)node->left); if (node->right) LinkedEnqueue(&q, (int)node->right); } }

实际写的时候队列应该存TreeNode而不是int，我这里为了复用之前的链队列代码做了简化。真正实现的时候建议单独定义一个存指针的队列结构，或者用void做泛型。

6.3 两个栈实现一个队列

这是一个经典的面试题。思路是：一个栈做入队栈（inStack），一个栈做出队栈（outStack）。入队时直接压入inStack；出队时如果outStack不为空，直接从outStack弹出；如果outStack为空，把inStack的所有元素依次弹出并压入outStack，再从outStack弹出。

typedef struct { SeqStack inStack; SeqStack outStack; } QueueByTwoStacks; void InitQueueByTwoStacks(QueueByTwoStacks *q) { InitStack(&q->inStack); InitStack(&q->outStack); } int EnqueueByTwoStacks(QueueByTwoStacks *q, int value) { return Push(&q->inStack, value); } int DequeueByTwoStacks(QueueByTwoStacks *q, int *value) { if (IsEmpty(&q->outStack)) { while (!IsEmpty(&q->inStack)) { int temp; Pop(&q->inStack, &temp); Push(&q->outStack, temp); } } return Pop(&q->outStack, value); }

这个实现的均摊时间复杂度是O(1)。虽然单次出队可能触发O(n)的转移操作，但每个元素最多被转移一次，所以均摊下来每次操作是O(1)。

7. 常见问题与排查技巧实录

7.1 边界条件速查表

下面这张表整理了栈和队列实现中最容易出错的边界条件，建议在写代码前先过一遍：

7.2 调试技巧与工具使用

调试栈和队列的代码，我总结了几个实用的技巧：

打印中间状态。在每次操作后打印关键变量，比如顺序栈的top值、循环队列的front和rear值。这样能直观地看到指针的移动是否符合预期。

画图辅助。在纸上画出数组或链表的结构，手动模拟每一步操作。特别是循环队列的绕圈，画图比在脑子里想要清楚得多。

单元测试覆盖边界。每个操作至少测试三种情况：正常情况、边界情况（空/满）、连续操作后的情况。比如循环队列要测试绕圈后的入队出队。

用assert做断言。在关键位置加assert，比如入队后assert(QueueLength(&q) > 0)，出队后assert(QueueLength(&q) >= 0)。断言失败会直接告诉你哪一行出了问题。

7.3 我踩过的那些坑

坑一：循环队列的取模运算优先级。我写过q->rear = q->rear + 1 % QUEUE_MAX，看起来没问题，实际上%的优先级高于+，所以等价于q->rear = q->rear + (1 % QUEUE_MAX)，也就是q->rear = q->rear + 1，根本没有取模。正确写法是q->rear = (q->rear + 1) % QUEUE_MAX。

坑二：链栈出栈时的free顺序。我写过free(s->top); s->top = s->top->next;，free之后访问s->top->next是未定义行为。正确做法是先用临时指针保存，再free。

坑三：循环队列判满条件搞反。队满条件是(rear + 1) % MAXSIZE == front，不是(rear + 1) % MAXSIZE == front + 1。我当年考试的时候就在这里丢过分。

坑四：链队列出队后忘记更新rear。这个bug最隐蔽，因为队列中有多个元素时程序完全正常，只有清空后再入队才会崩溃。我调了整整一个下午才找到。

坑五：顺序栈扩容时realloc失败处理。s->data = realloc(s->data, newSize)如果失败，原来的s->data就丢了，内存泄漏。正确做法是用临时指针接realloc的返回值，判断非空后再赋值。

7.4 性能优化建议

如果你的实验要求做性能对比，这里有几个优化方向：

顺序栈的扩容因子选择2倍而不是1.5倍，因为2倍可以用位运算代替乘法，速度更快。循环队列的取模运算如果MAXSIZE是2的幂，可以用& (MAXSIZE - 1)代替% MAXSIZE，因为位运算比取模快得多。链队列可以考虑用内存池预分配节点，减少malloc/free的开销。

不过对于实验级别的代码，这些优化不是必须的。先把功能写对，再考虑性能。我见过太多人功能还没跑通就开始优化，结果bug越调越多。

8. 实验代码的组织与测试建议

8.1 文件组织方式

我建议把代码分成头文件和源文件，每个结构一个模块：

stack_seq.h / stack_seq.c -- 顺序栈 stack_linked.h / stack_linked.c -- 链栈 queue_circular.h / queue_circular.c -- 循环队列 queue_linked.h / queue_linked.c -- 链队列 main.c -- 测试入口

头文件放结构定义和函数声明，源文件放函数实现。这样组织的好处是修改一个模块不会影响其他模块，编译的时候也可以单独编译。

如果你用的是单文件提交，那就把每个结构用注释分隔开，保持逻辑清晰。但不管哪种方式，函数命名要有规律，比如顺序栈的函数统一用SeqStack前缀，链栈用LinkedStack前缀，避免命名冲突。

8.2 测试用例设计

测试用例要覆盖以下几类：

基本功能测试。每个操作至少测试一次正常流程，验证输入输出是否符合预期。

边界测试。空栈pop、满栈push、空队列dequeue、满队列enqueue，验证错误处理是否正确。

连续操作测试。连续入栈出栈多次，验证指针维护是否正确。循环队列要测试绕圈，链队列要测试清空后重新入队。

混合操作测试。入队出队交替进行，模拟真实使用场景。

我通常会在main函数里写一个测试菜单，让用户可以交互式地选择操作。这样调试的时候比较方便，也能直观地看到每一步的结果。

void TestMenu() { SeqStack s; InitStack(&s); int choice, value; while (1) { printf("\n1.入栈 2.出栈 3.取栈顶 4.判空 5.退出\n"); printf("请选择："); scanf("%d", &choice); switch (choice) { case 1: printf("输入入栈值："); scanf("%d", &value); if (Push(&s, value)) { printf("入栈成功\n"); } else { printf("栈满，入栈失败\n"); } break; case 2: if (Pop(&s, &value)) { printf("出栈：%d\n", value); } else { printf("栈空，出栈失败\n"); } break; // ... 其他case } } }

这种交互式测试的好处是你可以手动构造各种边界场景，比自动化测试更灵活。缺点是每次都要手动输入，效率低。实际做实验的时候可以两种方式结合，先用交互式测试调通功能，再写自动化测试批量验证。

8.3 实验报告撰写要点

如果你需要提交实验报告，我建议重点写清楚以下几个部分：

结构设计说明。解释你为什么选择这种结构，top/front/rear指针的定义是什么，初始值是多少。这部分是老师最看重的，因为它体现了你对结构的理解。

关键代码分析。不要贴全部代码，只贴核心操作的代码，并加上注释说明每一步的意图。特别是边界判断和指针操作的部分，要解释为什么这么写。

测试结果与分析。列出你测试了哪些场景，每个场景的输入和输出是什么，是否发现了问题。如果发现了bug，写清楚bug的原因和修复方法，这比只写"测试通过"要有价值得多。

复杂度分析。分析每个操作的时间复杂度和空间复杂度，最好能给出推导过程。比如循环队列的入队出队都是O(1)，因为只涉及常数次指针移动和取模运算。

心得体会。写你在实验过程中遇到的困难和解决方法，这是实验报告中最有个人特色的部分。不要写"通过这次实验我学到了很多"这种空话，要写具体的收获，比如"我一开始把循环队列的队满条件写错了，后来通过画图分析才理解为什么要牺牲一个存储单元"。

这个实验看起来简单，但真正把四种结构都写对、把所有边界都处理好，还是需要花不少时间的。我的建议是先画图理清思路再写代码，写完一个模块就测试一个模块，不要全部写完再一起调。调试的时候善用打印和断言，能省很多时间。最后，代码写完之后放一放，第二天再回来看一遍，往往能发现前一天没注意到的问题。