diff --git a/期中测试.md b/期中测试.md
index c37dd1d..651263e 100644
--- a/期中测试.md
+++ b/期中测试.md
@@ -1,280 +1,285 @@
-若已知一个栈的入栈序列是1，2，3，…，n，其输出序列为p1，p2，p3，…，pn，若p1=n，则pi为
+# 期中测试试题📄
 
-- A.不确定
+## 选择题🔤
 
-- B.i
+1. 若已知一个栈的入栈序列是1，2，3，…，n，其输出序列为p1，p2，p3，…，pn，若p1=n，则pi为
 
-- C.n-i
+- [ ]  A.不确定
 
-- ==D.n-i+1== 
+- [ ]  B.i
 
-判定以 head 为头指针的不带头结点的单链表只有一个结点的条件是（ ）。
+- [ ]  C.n-i
 
-- ==A.head->next= =NULL==
+- [x]  D.n-i+1 
 
-- B.head!=NULL
+2. 判定以 head 为头指针的不带头结点的单链表只有一个结点的条件是（ ）。
 
-- C.head= =NULL
+- [x]  A.head->next= =NULL
 
-- D.head->next= =head
+- [ ]  B.head!=NULL
 
-- 对于顺序存储的长度为n的线性表，在第i个位置插入一个元素需要移动（ ）个元素。其中，0≤i＜n。
+- [ ]  C.head= =NULL
 
-- - A.i
+- [ ]  D.head->next= =head
 
-  - B.n-i-1
+3. 对于顺序存储的长度为n的线性表，在第i个位置插入一个元素需要移动（ ）个元素。其中，0≤i＜n。
 
-  - C.n-i+1
+- [ ] A.i
 
-  - ==D.n-i==
+- [ ]  B.n-i-1
 
-  - 允许对队列进行的操作有(  )。
+- [ ]  C.n-i+1
 
-  - - ==A.在队头元素之前插入元素==
+- [x]  D.n-i
 
-    - B.取出最近进队的元素
+4. 允许对队列进行的操作有()。
 
-    - C.删除队头元素
+- [x]  A.在队头元素之前插入元素
 
-    - D.对队列中的元素排序
+- [ ]  B.取出最近进队的元素
 
-    - 在班级信息管理表中，为了能按班级学号实现快速查询本班级学生信息的算法，采用（   ）更好。
+- [ ] C.删除队头元素
 
-    - - ==A.顺序表==
+- [ ] D.对队列中的元素排序
 
-      - B.链表 
+5. 在班级信息管理表中，为了能按班级学号实现快速查询本班级学生信息的算法，采用（ ）更好。
 
-      - 设某顺序表中第一个元素的地址是 Base ，每个结点占 m 个单元，则第 i 个结点的地址为（ ）。
+- [x] A.顺序表
 
-      - - A.Base+(i+1)∗m
+- [ ] B.链表 
 
-        - B.Base−i∗m
+6. 设某顺序表中第一个元素的地址是 Base ，每个结点占 m 个单元，则第 i 个结点的地址为（ ）。
 
-        - ==C.Base+(i−1)∗m==
+- [ ] A.Base+(i+1)∗m
 
-        - D.Base+i∗m
+- [ ] B.Base−i∗m
 
-栈在     中有所应用。
+- [x] C.Base+(i−1)∗m
 
-- ==A.前三个选项都有==
+- [ ] D.Base+i∗m
 
-- B.表达式求值
+7. 栈在____中有所应用。
 
-- C.递归调用
+- [x] A.前三个选项都有
 
-- D.函数调用
+- [ ] B.表达式求值
 
-若用一个大小为 6 的数组来实现循环队列，且当前 rear 和 front 的值分别为 0 和 3 ，当从队列中删除一个元素，再加入两个元素后， rear 和 front 的值分别为（ ）。
+- [ ] C.递归调用
 
-- A.1 和 4
+- [ ] D.函数调用
 
-- ==B.1 和 5==
+8. 若用一个大小为 6 的数组来实现循环队列，且当前 rear 和 front 的值分别为 0 和 3 ，当从队列中删除一个元素，再加入两个元素后， rear 和 front 的值分别为（ ）。
 
-- C.2 和 4
+- [ ] A.1 和 4
 
-- D.2 和 3
+- [x] B.1 和 5
 
-一个顺序表里已经有10个元素，最大容量是100，欲在顺序表中插入一个元素，则不合理的插入位置是（ ）。
+- [ ] C.2 和 4
 
-- ==A.15==
+- [ ] D.2 和 3
 
-- B.11
+9. 一个顺序表里已经有10个元素，最大容量是100，欲在顺序表中插入一个元素，则不合理的插入位置是（ ）。
 
-- C.5
+- [x] A.15
 
-- D.1
+- [ ] B.11
 
-判定以head为首指针的不带头结点的单链表为空的条件是（ ）。
+- [ ] C.5
 
-- ==A.head= =NULL==
+- [ ] D.1
 
-- B.head->next= =NULL
+10. 判定以head为首指针的不带头结点的单链表为空的条件是（ ）。
 
-- C.head!=NULL
+- [x] A.head= =NULL
 
-- D.head->next= =head
+- [ ] B.head->next= =NULL
 
-- 线性表是（ ）。
+- [ ] C.head!=NULL
 
-- - ==A.一个有限序列，可以为空==
+- [ ] D.head->next= =head
 
-  - B.一个有限序列，不可以为空
+11. 线性表是（ ）。
 
-  - C.一个无限序列，不可以为空
+- [x] A.一个有限序列，可以为空
 
-  - D.一个无限序列，可以为空
+- [ ] B.一个有限序列，不可以为空
 
-  - 一个顺序表里已经有 5 个元素，最大容量是 100 ，现插入 2 个元素，删除 3 个元素，该顺序表的长度是（ ）。
+- [ ] C.一个无限序列，不可以为空
 
-  - - A.5
+- [ ] D.一个无限序列，可以为空
 
-    - ==B.4==
+12. 一个顺序表里已经有 5 个元素，最大容量是 100 ，现插入 2 个元素，删除 3 个元素，该顺序表的长度是（ ）。
 
-    - C.不确定
+- [ ] A.5
 
-    - D.1
+- [x] B.4
 
-    - 下面关于串的的叙述中，     是不正确的。
+- [ ] C.不确定
 
-    - - A.模式匹配是串的一种重要运算
+- [ ] D.1
 
-      - B.串既可以采用顺序存储，也可以采用链式存储
+13. 下面关于串的的叙述中， 是不正确的。
 
-      - ==C.空串是由空格构成的串==
+- [ ] A.模式匹配是串的一种重要运算
 
-      - D.串是字符的有限序列
+- [ ] B.串既可以采用顺序存储，也可以采用链式存储
 
-      - 能够满足快速完成插入和删除运算的线性表存储结构是（ ）。
+- [x] C.空串是由空格构成的串
 
-      - - A.散列存储
+- [ ] D.串是字符的有限序列
 
-        - ==B.链式存储==
+14. 能够满足快速完成插入和删除运算的线性表存储结构是（ ）。
 
-        - C.有序存储
+- [ ] A.散列存储
 
-        - D.顺序存储
+- [x] B.链式存储
 
-        - 设进栈次序为ABCDE，（ ）是不可能得到的出栈序列。
+- [ ] C.有序存储
 
-        - - A.ABCDE
+- [ ] D.顺序存储
 
-          - ==B.EABCD==
+15. 设进栈次序为ABCDE，（ ）是不可能得到的出栈序列。
 
-          - C.BCDEA
+- [ ] A.ABCDE
 
-          - D.EDCBA
+- [x] B.EABCD
 
-          - 铁路进行列车调度时，常把站台设计成栈式结构，若进站的六辆列车顺序为：1，2，3，4，5，6， 不能出栈序列是（ ）。
+- [ ] C.BCDEA
 
-          - - A.1 2 3 4 5 6
+- [ ] D.EDCBA
 
-            - B.3 2 5 6 4 1
+16. 铁路进行列车调度时，常把站台设计成栈式结构，若进站的六辆列车顺序为：1，2，3，4，5，6， 不能出栈序列是（ ）。
 
-            - C.1 3 5 4 2 6
+- [ ] A.1 2 3 4 5 6
 
-            - ==D.4 3 5 6 1 2==
+- [ ] B.3 2 5 6 4 1
 
-            - 在数据结构中，从逻辑上可以把数据结构分成
+- [ ] C.1 3 5 4 2 6
 
-            - - A.线性结构和非线性结构
+- [x] D.4 3 5 6 1 2
 
-              - ==B.动态结构和静态结构==
+17. 在数据结构中，从逻辑上可以把数据结构分成
 
-              - C.内部结构和外部结构
+- [ ] A.线性结构和非线性结构
 
-              - D.紧凑结构和非紧凑结构
+- [x] B.动态结构和静态结构
 
-              - 线性表的顺序存储最适合于实现（ ）运算。
+- [ ] C.内部结构和外部结构
 
-              - - A.查找
+- [ ] D.紧凑结构和非紧凑结构
 
-                - B.插入
+18. 线性表的顺序存储最适合于实现（ ）运算。
 
-                - ==C.由下标定位==
+- [ ] A.查找
 
-                - D.删除
+- [ ] B.插入
 
-                - 顺序表中第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的地址是
+- [x] C.由下标定位
 
-                - - A.110
+- [ ] D.删除
 
-                  - B.100
+19. 顺序表中第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的地址是
 
-                  - ==C.108==
+- [ ] A.110
 
-                  - D.120
+- [ ] B.100
 
-                  - 在一个单链表中，若删除p所指结点的后续结点，则执行（ ）。
+- [x] C.108
 
-                  - - A.p=p->next->next
+- [ ] D.120
 
-                    - B.p->next=p->next
+20. 在一个单链表中，若删除p所指结点的后续结点，则执行（ ）。
 
-                    - C.p=p->next;p->next=p->next->next
+- [ ] A.p=p->next->next
 
-                    - ==D.p-next=p->next->next==
+- [ ] B.p->next=p->next
 
-                    - 数组S[M]存储一个栈，top为栈顶指针。如果条件top= =-1表示栈空，在栈不空的情况下，栈顶元素为（ ）。
+- [ ] C.p=p->next;p->next=p->next->next
 
-                    - - A.S[++top]
+- [x] D.p-next=p->next->next
 
-                      - B.S[top-1]
+21. 数组S[M]存储一个栈，top为栈顶指针。如果条件top= =-1表示栈空，在栈不空的情况下，栈顶元素为（ ）。
 
-                      - C.S[top+1]
+- [ ] A.S[++top]
 
-                      - ==D.S[top]==
+- [ ] B.S[top-1]
 
-                      - 对于链接存储的存储结构所占存储空间，以下选项描述正确的是（ ）。
+- [ ] C.S[top+1]
 
-                      - - ==A.分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针==
+- [x] D.S[top]
 
-                        - B.分两部分，一部分存放结点值，另一部分存放结点所占单元数
+22. 对于链接存储的存储结构所占存储空间，以下选项描述正确的是（ ）。
 
-                        - C.只有一部分，存储表示结点间关系的指针
+- [x] A.分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针
 
-                        - D.只有一部分，存放结点值
+- [ ] B.分两部分，一部分存放结点值，另一部分存放结点所占单元数
 
-                        - 已知last指向单链表的尾结点，将 s 所指结点加在表尾，以下选项描述正确的是（ ）。
+- [ ] C.只有一部分，存储表示结点间关系的指针
 
-                        - - ==A.s->next=last, last->next=NULL,last=s;==
+- [ ] D.只有一部分，存放结点值
 
-                          - B.last->next=s,s->next=NULL,last=s;
+23. 已知last指向单链表的尾结点，将 s 所指结点加在表尾，以下选项描述正确的是（ ）。
 
-                          - C.s->next=NULL, last->next=s, s=last;
+- [x] A.s->next=last, last->next=NULL,last=s;
 
-                          - D.s->next=s,last=s,last->next=NULL;
+- [ ] B.last->next=s,s->next=NULL,last=s;
 
-                          - 对于一个头指针为head的带头结点的单链表，判定该表为空表的条件是（ ）。
+- [ ] C.s->next=NULL, last->next=s, s=last;
 
-                          - - A.head→next==head
+- [ ] D.s->next=s,last=s,last->next=NULL;
 
-                            - B.head==NULL
+24. 对于一个头指针为head的带头结点的单链表，判定该表为空表的条件是（ ）。
 
-                            - C.head!=NULL 
+- [ ] A.head→next==head
 
-                            - ==D.head→next==NULL==
+- [ ] B.head==NULL
 
-                            - 线性表Ｌ在     情况下适用于使用链式结构实现。  
+- [ ] C.head!=NULL 
 
-                            - - A.L中结点结构复杂
+- [x] D.head→next==NULL
 
-                              - ==B.需不断对L进行删除插入==
+25. 线性表Ｌ在 情况下适用于使用链式结构实现。
 
-                              - C.需经常修改L中的结点值
+- [ ] A.L中结点结构复杂
 
-                              - D.L中含有大量的结点
+- [x] B.需不断对L进行删除插入
 
-                              - 循环队列存储在数组A[0..m]中，则入队时的操作为
+- [ ] C.需经常修改L中的结点值
 
-                              - - A.rear=rear+1
+- [ ] D.L中含有大量的结点
 
-                                - ==B.rear=(rear+1)%(m+1)==
+26. 循环队列存储在数组A[0..m]中，则入队时的操作为
 
-                                - C.rear=(rear+1)%(m-1)
+- [ ] A.rear=rear+1
 
-                                - D.rear=(rear+1)%m
+- [x] B.rear=(rear+1)%(m+1)
 
-在某个线性链表中在p节点后插入节点x，若s为指向插入节点x的指针，则指针修改语句为s->next=p->next 和什么？
+- [ ] C.rear=(rear+1)%(m-1)
+
+- [ ] D.rear=(rear+1)%m
+
+## 填空题🈳
+
+27. 在某个线性链表中在p节点后插入节点x，若s为指向插入节点x的指针，则指针修改语句为s->next=p->next 和什么？
 
 ```c
 p->next=s;
 ```
 
-线性表中元素的存储可以使用顺序表和       。
+28. 线性表中元素的存储可以使用顺序表和 。
 
 ```中文（简体）
 链表
 ```
 
-数据结构中数据的关系通常有集合、      、树形结构、图状结构和网状结构。
+29. 数据结构中数据的关系通常有集合、、树形结构、图状结构和网状结构。
 
 ```中文（简体）
 数组
 ```
 
-循环队列Q中判断队满的条件为           (最大空间MAXQSIZE、队头指针Q.front,队尾指针Q.rear)。
+30. 循环队列Q中判断队满的条件为 (最大空间MAXQSIZE、队头指针Q.front,队尾指针Q.rear)。
 
 ```c
 (Q.rear+1)%MAXQSIZE==Q.front;
 ```
-