数据结构(c语言版期中练习题)
数据结构期中考试试卷
数据结构期中考试试卷一、选择题（每题2分，共20分）1. 在数据结构中，线性结构的特点是什么？A. 元素之间存在一对一关系B. 元素之间存在一对多关系C. 元素之间存在多对多关系D. 元素之间存在一对一或多对多关系2. 以下哪个算法不是排序算法？A. 快速排序B. 归并排序C. 深度优先搜索D. 堆排序3. 在二叉树中，度为2的节点最多有多少个子节点？A. 1B. 2C. 3D. 44. 哈希表解决冲突的方法不包括以下哪一项？A. 分离链接法B. 开放寻址法C. 链地址法D. 树形结构法5. 以下哪个不是图的遍历算法？A. 深度优先搜索B. 广度优先搜索C. 动态规划D. 克鲁斯卡尔算法6. 栈的特点是？A. 后进先出B. 先进后出C. 先进先出D. 后进后出7. 以下哪个不是二叉搜索树的性质？A. 左子树上所有节点的值小于它的根节点的值B. 右子树上所有节点的值大于它的根节点的值C. 左子树和右子树都是二叉搜索树D. 所有节点的值都相等8. 在数据库中，索引的作用是什么？A. 增加数据存储空间B. 提高数据检索效率C. 降低数据插入速度D. 减少数据存储量9. 以下哪个不是图的存储结构？A. 邻接矩阵B. 邻接表C. 树形结构D. 边列表10. 递归算法的基本思想是什么？A. 将问题分解为更小的子问题B. 重复执行相同的操作C. 将问题转化为非递归形式D. 避免使用循环结构二、填空题（每题2分，共20分）1. 在数据结构中，______是一种特殊的线性表，只允许在一端进行插入和删除操作。
2. 排序算法中，______排序的时间复杂度为O(n^2)，适用于小规模数据的排序。
3. 在图的表示中，______矩阵可以有效地表示稠密图。
4. 哈希表中，______是指两个关键字通过哈希函数得到同一个哈希地址。
5. 栈和队列的主要区别在于，栈是______，而队列是先进先出。
6. 二叉树的遍历方式包括前序遍历、中序遍历和______遍历。
数据结构试卷(期中考试)
第页/共 页 《数据结构》期中考试试卷一、选择题（每题2分，共40分）1．组成数据的基本单位是【 】。
A ．数据项B ．数据类型C ．数据元素D ．数据变量 2．线性表采用链式存储时，结点的存储地址【 】。
A ．必须是不连续的 B ．连续与否均可C ．必须是连续的D ．和头结点的存储地址相连续3. 有一个含头结点的单链表，头指针为head ，判断其是否为空的条件为【 】。
A ．head==NULL B ． head->next==NULL C ．head->next==head D ．head!=NULL 4．算法分析的目的是【 】。
A ．辨别数据结构的合理性B ．评价算法的效率C ．研究算法中输入与输出的关系D ．鉴别算法的可读性5．已知指针p 所指结点不是尾结点，若在*p 之后插入结点*s ，则应执行下列哪一个操作？【 】。
A. s->next = p ； p-> next = s ；B. s-> next = p-> next ； p-> next = s ；C. s-> next = p-> next ； p = s ；D. p-> next = s ； s-> next = p ； 6．若进栈序列为1，2，3，4，5，6，且进栈和出栈可以穿插进行，则可 能出现的出栈序列为【 】。
A ．3，2，6，1，4，5B ．5，6，4，2，3，1C ．1，2，5，3，4，6D ．3，4，2，1，6，5 7．一个元素进入队列的时间复杂度是【 】。
A O(1)B O(n)C O(n 2)D O(log 2n) 8．数组A[1..5,1..6]的每个元素占5个单元，将其按行优先次序存储在起始地址为1000的连续的内存单元中，则元素A[5,5]的地址为【 】。
A 1140 B 1145 C 1120 D 1125 9．链表不具有的特点是【 】。
数据结构期中考试题
数据结构期中考试题一、选择题1. 数据结构是（）的研究。
A. 算法B. 数据C. 硬件D. 软件2. 下列哪种数据结构在插入和删除操作时效率较高？A. 数组B. 链表C. 栈D. 队列3. 以下哪种数据结构使用了先进先出（FIFO）的策略？A. 栈B. 队列C. 链表D. 数组4. 在二叉树中，每个节点最多可以有几个子节点？A. 0B. 1C. 2D. 35. 以下哪种数据结构在查找操作时效率较高？A. 数组B. 链表C. 栈D. 二叉树二、简答题1. 请简要介绍栈（Stack）和队列（Queue）的特点及应用场景。
2. 请解释树（Tree）和图（Graph）的区别，并给出它们各自的应用场景。
3. 请描述二叉树（Binary Tree）的特点并给出一个示例图。
4. 请简要介绍哈希表（Hash Table）的原理及其在实际应用中的优势。
三、编程题1. 设计一个栈，使得它具有以下功能：- push(val)：将元素val压入栈中。
- pop()：弹出栈顶元素，并返回弹出的元素。
- getMin()：返回栈中最小的元素。
2. 设计一个队列，使得它具有以下功能：- push(val)：将元素val插入队列中。
- pop()：移除并返回队列头部的元素。
- peek()：返回队列头部的元素。
- empty()：检查队列是否为空。
四、综合题某公司需要设计一个学生信息管理系统，主要功能包括添加学生信息、查询学生信息、删除学生信息以及修改学生信息。
请使用合适的数据结构和算法来实现该系统，并说明你的选择理由。
总结：通过本次期中考试题，我们从选择题、简答题到编程题，对数据结构的基本知识和应用有了更深入的了解。
数据结构在计算机科学中扮演着重要的角色，合理的选择和运用数据结构可以提高程序的效率和性能。
希望大家能够加强对数据结构的学习和应用，为解决实际问题提供更有效的解决方案。
数据结构期中考试题
一、单项选择题（每小题3分，共30分）1、线性结构是数据元素之间存在的一种_______。
A、一对多关系B、多对多关系C、多对一关系D、一对一关系2、以下数据结构中，哪一个不是线性结构（）A．生成树 B. 顺序栈 C. 单链表 D. 循环队列3、设n是偶数，则运行下列程序段的时间复杂度为（）。
x=100;for(p=2;p<=n;p++)for(q=2*i;q<=n;q++)x=(x+1)*3;A．O(1) B.O(n) C.O(n2) D.O(lbn)4、若频繁地对线性表进行插入和删除操作，该线性表应该采用——存储结构。
A、散列B、顺序C、链式D、索引5、在非空双向循环链表中由q所指的链结点后面插入一个由p所指的链结点的动作依次为：p->llink=Q；p->rlink=q->rlink;q->rlink=p；_______.(空白处为一条赋值语句) A、q->llink=p B、q->rlink->llink=pC、p->rlink->llink=pD、p->llink->llink=p6、设循环队列的结构是：const int Maxsize=100;typedef int Data Type;typedef struct {Data Type data[Maxsize];Int front, rear;} Queue;若有一个Queue类型的队列Q，试问判断队列满的条件应是下列哪一个语句（）A 、Q.front= = Q.rear; B、 Q.front - Q.rear= = Maxsize;C、Q.front + Q.rear= = Maxsize;D、 Q.front= = (Q.rear+1)% Maxsize;7、已知L是一个不带表头的单链表, 在表首插入结点*p的操作是（）。
A. p = L; p->next = L;B. p->next = L; p = L;C. p->next = L; L = p;D. L = p; p->next= L;8、下面关于串的叙述中，哪一个是不正确的？( )A．串是字符的有限序列 B.空串是由空格构成的串C．模式匹配是串的一种重要运算 D．串既可以采用顺序存储，也可以采用链式存储9、若进栈序列为1，2，3，4，5，6，且进栈和出栈可以穿插进行，则可能出现的出栈序列为( )。
数据结构期中考试试题及答案
一、单项选择题(本题总分 20分，每题 2分)在每小题列出的四个选项中只有 一个选项是符合题目要求的，请将正确选项前的字母。
1.若结点的存储地址与其关键字之间存在某种映射关系，则称这种存储结构为( D ) 。
A.顺序表 B.链表 C.索引表 D.散列表采用排除法，顺序表存储位置表示数据元素的顺序关系，跟关键字无法；链表的地址是动态分配的；索引表是 按数据元素的关键字排序所得，它的数据元素是没有规律的2.在长度为 n 的顺序表的第 i(1≤i ≤n+1)个位置上插入一个元素，元素的移动次数为( A ) 。
A.n -i+1B.n -iC.iD.i -1代入计算法，我们知道在 i=n+1 时不需要移动元素3.若一棵二叉树的先序遍历序列为 a,b,c ，则由 abc 三个结点构成的二叉树个数为( B ) 。
A.4B.5C.6D.74.三维数组 A[4][5][6]按行优先存储方法存储在内存中，若每个元素占 2 个存储单元，且数组中第一个元素的存 储地址为 130，则元素 A[3][4][5]的存储地址为(B A.370B .368C .366) 。
D.372Loc(3,4,5)=loc(0,0,0)+(3*5*6+4*6+5)*2=130+119*2=368;5.高度为 h 的二叉树（仅含根结点的二叉树高度为 1）的结点最少是多少( D) 。
A. h+1B. 2hC. 2h －1D. h二叉树性质 26. 将两个各有 n 个元素的有序表归并成一个有序表，其最多的比较次数是( A. nB.n+1 C. 2n-1D. n-17. 已知一算术表达式的中缀形式为 A ＋B *C -D/E ，后缀形式为 ABC *+DE/-，其前缀形式为( C) 。
A )。
A. -+A*BC/DE C. -+*ABC/DEB. –A+B*CD/E D. –A+B*C/DE根据中缀和后缀表达式可画出表达树如下：- + /A* D EBC故前缀表达式为：-+A*BC/DE数据结构期中考试8．下面图示的顺序存储结构表示的二叉树是（ A ）。
数据结构期中考试试题及答案
2014-2015学年第二学期《数据结构与算法》期中考试学号：姓名：一、写语句1.设单链表结点指针域为next，试写出删除链表中指针p所指结点的直接后继的C语言语句。
2.设单链表中某指针p所指结点（即p结点）的数据域为data，链指针域为next，请写出在p结点之前插入s结点的操作3. 设双向循环链表中结点的数据域、前驱和后继指针域分别为data,pre和next,试写出在指针p 所指结点之前插入s结点的C语言描述语句。
4. 一线性表存储在带头结点的双向循环链表中，L为头指针。
如下算法：（1）说明该算法的功能。
（2）在空缺处填写相应的语句。
void unknown (BNODETP *L){ …p=L->next; q=p->next; r=q->next；while (q!=L){ while (p!=L) && (p->data>q->data) p=p->prior；q->prior->next=r；(1) ______；q->next=p->next；q->prior=p；(2) ______；(3) ______；q=r；p=q->prior；(4) ______；} }二、写算法1．设有一个正整数序列组成的有序单链表（按递增次序有序，且允许有相等的整数存在），试编写能实现下列功能的算法：（要求用最少的时间和最小的空间）(1)确定在序列中比正整数x大的数有几个（相同的数只计算一次，如序列{20,20,17,16,15,15,11,10,8,7,7,5,4}中比10大的数有5个）；(2) 在单链表将比正整数x小的数按递减次序排列；(3) 将正整数（比）x大的偶数从单链表中删除。
2. 设键盘输入n个英语单词，输入格式为n, w1, w2, …,wn,其中n表示随后输入英语单词个数，试编一程序，建立一个单向链表，实现：（1）如果单词重复出现，则只在链表上保留一个。
数据结构期中考试试卷
数据结构期中考试试卷一、选择题（每题2分，共20分）1. 在数据结构中，线性表是按照什么顺序排列的元素集合？A. 任意顺序B. 无序C. 有序D. 线性2. 链表与数组相比，其主要优点是什么？A. 节省空间B. 访问速度快C. 插入和删除操作灵活D. 内存分配简单3. 栈（Stack）是一种遵循什么原则的数据结构？A. 先进先出B. 先进后出C. 后进先出D. 后进后出4. 哈希表解决冲突最常用的方法是？A. 链接法B. 替换法C. 线性探测法D. 二次探测法5. 树和二叉树的主要区别是什么？A. 树的节点数可以比二叉树多B. 树的节点可以有多个子节点C. 树的节点可以没有子节点D. 树的节点可以有左子节点和右子节点6. 什么是二叉搜索树（BST）？A. 所有左子节点的值小于根节点的值B. 所有右子节点的值大于根节点的值C. 所有左子节点的值大于根节点的值D. A和B都正确7. 图的邻接矩阵表示法适用于哪种类型的图？A. 稠密图B. 稀疏图C. 有向图D. 无向图8. 排序算法的时间复杂度为O(n^2)的算法有哪些？A. 选择排序B. 冒泡排序C. 插入排序D. 所有以上9. 什么是递归？A. 函数调用自身B. 函数调用其他函数C. 循环结构D. 条件语句10. 动态规划主要用于解决什么问题？A. 排序问题B. 查找问题C. 优化问题D. 数据存储问题二、简答题（每题5分，共20分）1. 请简述链表和数组的区别。
2. 解释什么是图的深度优先搜索（DFS）。
3. 什么是二叉堆？请简述其性质。
4. 描述快速排序算法的基本思想。
三、编程题（每题15分，共30分）1. 编写一个函数，实现单链表的反转。
2. 编写一个函数，实现二叉树的前序遍历。
四、算法设计题（每题15分，共30分）1. 设计一个算法，用于在无序数组中找到第k小的元素。
2. 设计一个算法，实现最小生成树的克鲁斯卡尔算法。
五、综合应用题（10分）假设你正在开发一个在线图书管理系统，请设计一个数据结构来存储书籍信息，并实现以下功能：- 添加新书- 删除书籍- 查找特定书籍- 列出所有书籍请提供数据结构的设计思路和相应的伪代码。
数据结构期中考试试题答案c语言版本
R @ - * ( +
S 1 0 3 2 1 +
R@ - *
S 1 0 3 2 1 + * - 3 1
R@ + ( -
S 1 0 3 2 1 + * - 3 1 - 2
R@ + /
S 1 0 3 2 1 + * - 3 1 - 2 / +
R
S 1 0 3 2 1 + * - 3 1 - 2 / + @ \0
3．在带附加表头的循环双向链表中， 表头附加结点 的 左 指针域指向最后一个结点，最后一个结点的 右 指针域指向 表头附加 结点。
4．在以HL为表头指针的带附加结点的单链表和循环单链表中，链表为空的条件分别为
HL->next==NULL 和 HL==HL->next 。
5．在由数组a中元素结点构成的单链表中，删除下标为i的结点后，需要把该结点插入到空闲表的表头，具体操作为 a[i].next=a[1].next 、 a[1].next=i 。
8．一个广义表中的元素分为 单 元素和 表 元素两类。
9．广义表A=((a,(b,(),c),((d),e)))的长度为 1 ，深度为 4 。
10．向一个顺序栈插入一个元素时，首先应 top++ ，然后再将待插入元素 放入栈顶位置 。
11．对于队列，应在 队尾 进行插入，在 队首 进行删除。
12．中缀表达式2+7/(4-1)所对应的后缀表达式为 2 7 4 1 - / + @ 。
数据结构期中考试试题答案
一、 单选题（每小题2分，共8分）
1.在一个长度为n的线性表中顺序查找值为x的元素时，查找成功时的平均查找长度（即x同元素的平均比较次数，假定查找每个元素的概率都相等）为 C 。
数据结构期中考试
数据结构期中考试考试内容：把本学期中重要的程序合并在一个源程序中，通过菜单按钮选择调用不同的功能。
具体要求：请模仿C语言课本P81页中的方法，编写一个菜单。
需要合并的程序包括：1. 顺序存储下实现的线性表基本操作（见ds-sqlist）2. 链式存储下实现的线性表基本操作(见ds-slink)3. 将X插入到一个有序(从小到大排序)的线性表(顺序存储结构)的适当位置上，并保持线性表的有序性。
(见实验报告三，第3题)4. 顺序结构线性表的就地逆置算法（见实验报告四，第3题的第1小问）5. 顺序存储下实现的栈基本操作(见ds-sqstack)6. 链式存储下实现的栈基本操作(ds-linkstack)7. 判断输入字符串是否为“序列1&序列2”形式的回文(见实验报告五，第4题)8. 顺序存储下实现的队列基本操作见(ds-sqqueue)9. 链式存储下实现的队列基本操作见(ds-linkqueue)同学们写的菜单可以有如下形式：#include <stdio.h>#include <stdlib.h>#include <string.h>#define MaxLen 100 /*顺序表的容量*/typedef char ElemType;typedef struct{ int data[MaxLen]; /*存放顺序表的元素*/int length; /*顺序表的实际长度*/}sqList;void InitList(sqList *L) /*初始化线性表*/{L->length=0;}int GetLen(sqList *L) /*求线性表长度*/{return L->length;}int GetElem(sqList *L,int i) /*求线性表中第i个元素*/{if (i<1 || i>L->length) /*无效的i值*/{ printf("error");exit(1);}return L->data[i-1];}int Locate(sqList *L,int x) /*按值查找*/{int i=0;while(i<L->length && L->data[i]!=x) /*查找值为x的第1个结点*/ i++;if (i<L->length)return(i+1); /*未找到*/elsereturn(0);}void InsElem(sqList *L,int i,int x) /*插入元素*/{ int j;if(i<1||i>L->length+1) /*无效的参数i*/{printf("error");exit(1);}if(L->length==MaxLen){printf("overflow!");exit(1);}for(j=L->length;j>=i;j--) /*将位置为i的结点及之后的结点后移*/ L->data[j]=L->data[j-1];L->data[i-1]=x; /*在位置i处放入x*/ L->length++; /*线性表长度增1*/}void DelElem(sqList *L,int i) /*删除元素*/{int j;if (i<1 || i>L->length){printf("不存在第%d个元素!",i);exit(0);} /*无效的参数i*/for (j=i;j<=L->length-1;j++) /*将位置为i的结点之后的结点前移*/ L->data[j-1]=L->data[j];L->length--; /*线性表长度减1*/}void DispList(sqList *L) /*输出线性表*/{int i;for (i=1;i<=L->length;i++)printf("%d ",L->data[i-1]);printf("\n");}void reverlist(sqList *L,int *p) /*将顺序存储结构的基本线性表就地逆置*/ {int i,t;p=L->data;for(i=0;i<= L->length-1-i;i++){ t=L->data[i];L->data[i]=L->data[L->length-1-i];L->data[L->length-1-i]=t;}}typedef struct LNode{int data; /*数据域*/struct LNode *next; /*指针域*/} LNode,*LinkList;LNode *head;void InitList(LinkList *L) /*L为二级指针*/{*L=(LNode *)malloc(sizeof(LNode)); /*创建头结点*L*/ (*L)->next=NULL;}int GetLength(LinkList L) /*求线性表的长度*/{int num=0;LNode *p;p=L->next;while (p!=NULL){num++;p=p->next;}return num;}LNode *GetElem(LinkList L,int i) /*求线性表中第i个元素*/ {LNode *p; int pos=1;p=L->next;if (i<1 || i>GetLength(L)) exit(1); /*i参数不正确,返回*/while (pos<i) /*从第1个结点开始找,查找第i个结点*/{p=p->next;pos++;}return p; /*返回位置*/}LNode *Locate(LinkList L,int x) /*按值查找*/{ LNode *p;p=L->next;while (p!=NULL && p->data!=x) /*从第1个结点开始查找data域为x的结点*/ p=p->next;return p;}void InsElem(LinkList L,int i,int x) /*插入结点*/{LNode *p,*q,*s;int pos=1;p=L;if (i<1 || i>GetLength(L)+1) exit(1); /*i参数不正确,插入失败,退出*/s=(LNode *)malloc(sizeof(LNode)); /*创建data域为x的结点*/s->data=x;while (pos<=i) /*从头结点开始找,查找第i-1个结点*/{ q=p;p=p->next;pos++;}s->next=q->next; /*将*s的next域指向*p的下一个结点(即第i个结点)*/q->next=s; /*将*q的next域指向*s,这样*s变成第i个结点*/}void DelElem(LinkList L,int i) /*删除结点*/{int pos=1;LNode *q=L,*p;if (i<1 || i>GetLength(L)) {printf("error\n"); exit(1);} /*i参数不正确,插入失败,退出*/while (pos<i) /*从头结点开始,查找第i-1个结点,由q指向它*/{ q=q->next;pos++;}p=q->next; /*由p指向第i个结点*/q->next=p->next; /*将*q的next指向*p之后结点,即从链表中删除第i个结点*/ free(p); /*释放第i个结点占用的空间*/}void DispList(LinkList L) /*输出单链表*/{LNode *p;p=L->next;while (p!=NULL){printf("%4d ",p->data);p=p->next;}printf("\n");}typedef struct{ElemType data[MaxLen ]; /*保存栈中元素*/int top; /*栈指针*/} STACK;void InitStack(STACK *s){s->top=-1;}int Push(STACK *S, ElemType x) /*进栈运算,st为引用型参数*/{if (S->top==MaxLen -1){ /*栈满*/printf("\n Stack is full!");return 0;} /*栈不满*/S->top++;S->data[S->top]=x;return 1;}int Empty(STACK *S) /*判断栈空运算*/{return(S->top==-1?1:0);}int Pop(STACK *S,ElemType *x) /*出栈运算,st和x为引用型参数*/ {if (Empty(S)){ /*栈空*/printf("\n Stack is free!");return 0;}/*栈不空*/*x=S->data[S->top];S->top--;return 1;}int GetTop(STACK *S,ElemType *x) /*取栈顶元素,x为引用型参数*/ {if (Empty(S)){ /*栈空*/printf("\n Stack is free!");return 0;}*x=S->data[S->top];return 1;}typedef struct snode{ElemType data; /*存储结点数据*/struct snode *next; /*指针域*/} LinkSTACK;void InitStack(LinkSTACK **top) /*ls为引用型参数*/{*top=(LinkSTACK *)malloc(sizeof(LinkSTACK));(*top)->next=NULL;}int Push(LinkSTACK **top,ElemType x) /*进栈运算,ls为引用型参数*/ {LinkSTACK *s;s=(LinkSTACK *)malloc(sizeof(LinkSTACK));s->data=x;s->next=(*top)->next;(*top)->next=s;return 1;}int Empty(LinkSTACK **top) /*判断栈空运算*/{return ((*top)->next==NULL?1:0);}int Pop(LinkSTACK **top,ElemType *x) /*出栈运算,ls为引用型参数*/ {LinkSTACK *s;if (Empty(top)){ /*栈空,下溢出*/printf("\n Stack is free!");return 0;}s=(*top)->next;*x=s->data;(*top)->next=s->next;free(s);return 1;}int GetTop(LinkSTACK **top,ElemType *x) /*取栈顶元素运算*/ {if (Empty(top)){ /*栈空,下溢出*/printf("\n Stack is free!");return 0;}*x=(*top)->next->data;return 1;}typedef struct{ElemType data[MaxLen]; /*保存队中元素*/int front,rear; /*队头和队尾指针*/} SqQueue;void InitQueue(SqQueue *SQ) /*qu为引用型参数*/{SQ->rear=SQ->front=0; /*指针初始化*/}int EnQueue(SqQueue *SQ,ElemType x) /*入队运算,qu为引用型参数*/ {if ((SQ->rear+1)%MaxLen==SQ->front) /*队满*/{printf("\n Queue is full!");return 0;}SQ->rear=(SQ->rear+1)%MaxLen; /*队尾指针进1*/SQ->data[SQ->rear]=x;return 1;}int Empty(SqQueue *SQ) /*判断队空运算*/{return (SQ->rear==SQ->front)?1:0;}int OutQueue(SqQueue *SQ,ElemType *x) /*出队运算,qu和x为引用型参数*/ {if(Empty(SQ)){printf("\n Queue is free!");return 0;}SQ->front=(SQ->front+1)%MaxLen; /*队头指针进1*/*x=SQ->data[SQ->front];return 1;}int GetHead(SqQueue *SQ,ElemType *x) /*取队头元素运算,x为引用型参数*/ {if(Empty(SQ)){printf("\n Queue is free!");return 0;}*x=SQ->data[(SQ->front+1)%MaxLen];return 1;}typedef struct qnode{ElemType data;struct qnode *next;} QTYPE; /*链队中结点的类型*/typedef struct qptr{QTYPE *front,*rear;} SQUEUE; /*链队类型*/void InitQueue(SQUEUE *LQ) /*LQ为指针型参数*/{QTYPE *p;p=(QTYPE *)malloc(sizeof(QTYPE));p->next=NULL;LQ->rear=LQ->front=p; /*初始情况*/}int EnQueue(SQUEUE *LQ,ElemType x) /*入队运算,lLQ为指针型参数数*/{QTYPE *s;s=(QTYPE *)malloc(sizeof(QTYPE)); /*创建新结点，插入到链队的末尾*/ s->data=x;s->next=LQ->rear->next;LQ->rear->next=s;LQ->rear=s;return 1;}int Empty(SQUEUE *LQ) /*判断队空运算*/{return (LQ->front==LQ->rear?1:0);}int OutQueue(SQUEUE *LQ,ElemType *x) /*出队运算,LQ和x为指针型参数参数*/ {QTYPE *p;if(Empty(LQ)){printf("\n Queue is free!");return 0;}p=LQ->front->next;*x=p->data;LQ->front->next=p->next;if(LQ->front->next==NULL)LQ->rear=LQ->front;free(p);return 1;}int GetHead(SQUEUE *LQ,ElemType *x) /*取队头元素运算,LQ和x为指针型参数*/ {if(Empty(LQ)){printf("\n Queue is free!");return 0;}*x=LQ->front->next->data;return 1;}void main(){int select;while(1){printf(" 欢迎使用数据结构程序演示系统！\n\n");printf("********************************************************\n");printf("* 请选择演示程序：*\n");printf("* 1.顺序存储的线性表*\n");printf("* 2.链式存储的线性表*\n");printf("* 3.有序线性表中插入元素并保持有序*\n");printf("* 4.顺序结构线性表的就地逆置算法*\n");printf("* 5.顺序存储下实现的栈基本操作*\n");printf("* 6.链式存储下实现的栈基本操作*\n");printf("* 7.判断输入字符串是否为序列1&序列2形式的回文*\n");printf("* 8.顺序存储下实现的队列基本操作*\n");printf("* 9.链式存储下实现的队列基本操作*\n");printf("* 10.谢谢使用，退出本系统*\n");INPUT:printf("********************************************************\n");printf(" 请选择功能1-9 \n");scanf("%d",&select);if(select==10)break;if(select>=11||select<=0){ printf("***输入有误，请重新输入功能1-9:***\n");goto INPUT;}switch(select){case 1:{ int i;int e;sqList *L;L=(sqList *)malloc(sizeof(sqList));InitList(L); /*初始化顺序表sq*/InsElem(L,1,1); /*插入元素*/InsElem(L,2,2);InsElem(L,3,3);InsElem(L,4,4);InsElem(L,5,5);InsElem(L,6,6);printf("线性表:");DispList(L);printf("长度:%d\n",GetLen(L));i=3;printf("第%d个元素:%d\n",i,GetElem(L,i));e=5;printf("元素%d是第%d个元素\n",e,Locate(L,e));i=4;printf("删除第%d个元素\n",i);DelElem(L,i);printf("线性表:");DispList(L);}break;case 2:{int i;int x;LinkList L;InitList(&L); /*初始化顺序表sq*/InsElem(L,1,1); /*插入元素*/InsElem(L,2,7);InsElem(L,3,9);InsElem(L,4,23);InsElem(L,5,56);InsElem(L,6,87);printf("线性表:");DispList(L);printf("长度:%d\n",GetLength(L));i=3;printf("第%d个元素:%d\n",i,*GetElem(L,i));x=56;printf("元素%d的地址是%d\n",x,Locate(L,x));i=4;printf("删除第%d个元素\n",i);DelElem(L,i);printf("线性表:");DispList(L);}break;case 3: {int i,n,x;sqList *L;L=(sqList *)malloc(sizeof(sqList));InitList(L); /*初始化顺序表sq*/InsElem(L,1,1); /*插入元素*/InsElem(L,2,2);InsElem(L,3,3);InsElem(L,4,4);InsElem(L,5,5);InsElem(L,6,6);scanf("%d",&x);for(i=0;i<=GetLen(L)-1;i++)if(x>=L->data[i]) n=i+2;InsElem(L,x,n);printf("%d插入后线性表:",x);DispList(L);}break;case 4:{int j; sqList *L;L=(sqList *)malloc(sizeof(sqList));L->length=0;printf("please input 10 data\n");for(j=0;j<10;j++) /*创建初始基本线性表*/ {scanf("%d",&L->data[j]);L->length++;}printf("the sqlist is:\n");for(j=0;j<10;j++) /*将创建成功的基本线性表输出*/printf("%4d",L->data[j]);printf("\n\n");reverlist(L,L->data ); /*将基本线性表逆置*/printf("the result is:\n\n");for(j=0;j<10;j++) /*将逆置后的基本线性表输出*/printf("%4d",L->data[j]);printf("\n\n");}break;case 5: {STACK st;ElemType e;InitStack(&st);printf("栈%s\n",(Empty(&st)==1?"空":"不空"));printf("a进栈\n");Push(&st,'a');printf("b进栈\n");Push(&st,'b');printf("c进栈\n");Push(&st,'c');printf("d进栈\n");Push(&st,'d');printf("栈%s\n",(Empty(&st)==1?"空":"不空"));GetTop(&st,&e);printf("栈顶元素:%c\n",e);printf("出栈次序:");while (!Empty(&st)){Pop(&st,&e);printf("%c ",e);}printf("\n");}break;case 6: {LinkSTACK *top;ElemType e;InitStack(&top);printf("栈%s\n",(Empty(&top)==1?"空":"不空"));printf("a进栈\n");Push(&top,'a');printf("b进栈\n");Push(&top,'b');printf("c进栈\n");Push(&top,'c');printf("d进栈\n");Push(&top,'d');printf("栈%s\n",(Empty(&top)==1?"空":"不空"));GetTop(&top,&e);printf("栈顶元素:%c\n",e);printf("出栈次序:");while (!Empty(&top)){Pop(&top,&e);printf("%c ",e);}printf("\n");}break;case 7:{ char b[100],a[100];int i,j;STACK st1;ElemType e;InitStack(&st1);printf("栈%s\n",(Empty(&st1)==1?"空":"不空"));scanf("%s",a);j=strlen(a);for(i=0;i<j;i++)Push(&st1,a[i]);printf("栈%s\n",(Empty(&st1)==1?"空":"不空")); Pop(&st1,&e);b[0]=e;for(i=0;b[i]!='&';){i++;Pop(&st1,&e);b[i]=e;}for(i=(j-2)/2,Pop(&st1,&e);i>0;i--,Pop(&st1,&e)){if(b[i]!=e)printf("error");else printf("YES!");}}break;case 8:{SqQueue qu;ElemType e;InitQueue(&qu);printf("队%s\n",(Empty(&qu)==1?"空":"不空"));printf("a进队\n");EnQueue(&qu,'a');printf("b进队\n");EnQueue(&qu,'b');printf("c进队\n");EnQueue(&qu,'c');printf("d进队\n");EnQueue(&qu,'d');printf("队%s\n",(Empty(&qu)==1?"空":"不空"));GetHead(&qu,&e);printf("队头元素:%c\n",e);printf("出队次序:");while (!Empty(&qu)){OutQueue(&qu,&e);printf("%c ",e);}printf("\n");}break;case 9:{SQUEUE LQ;ElemType e;InitQueue(&LQ);printf("队%s\n",(Empty(&LQ)==1?"空":"不空"));printf("a进队\n");EnQueue(&LQ,'a');printf("b进队\n");EnQueue(&LQ,'b');printf("c进队\n");EnQueue(&LQ,'c');printf("d进队\n");EnQueue(&LQ,'d');printf("队%s\n",(Empty(&LQ)==1?"空":"不空"));GetHead(&LQ,&e);printf("队头元素:%c\n",e);printf("出队次序:");while (!Empty(&LQ)){OutQueue(&LQ,&e);printf("%c ",e);}printf("\n");} break;default:break;//当按10时执行该语句退出while循环，结束程序}//switch}//while}//main菜单部分功能的编写可参考下面的代码，其它函数以及case后面的语句请补充完整：运行结果：一.三．五．七．八．九．提交方式：登录网络教学综合平台，选择“数据结构”课程，把包括“源程序”和“程序运行结果截屏（多个）”上传（或粘贴）到网络教学平台->课程作业->期中考试综合设计实验下。
《数据结构》期中题库及答案
一、判断题：1、线性表的逻辑顺序与物理顺序总是一致的。
( )2、线性表的顺序存储表示优于链式存储表示。
( )3、线性表若采用链式存储表示时所有结点之间的存储单元地址可连续可不连续。
( )4、二维数组是其数组元素为线性表的线性表。
( )5、每种数据结构都应具备三种基本运算：插入、删除和搜索。
( )6、数据结构概念包括数据之间的逻辑结构，数据在计算机中的存储方式和数据的运算三个方面。
( )7、线性表中的每个结点最多只有一个前驱和一个后继。
（）8、线性的数据结构可以顺序存储，也可以链接存储。
非线性的数据结构只能链接存储。
（）9、栈和队列逻辑上都是线性表。
（）10、单链表从任何一个结点出发，都能访问到所有结点（）11、删除二叉排序树中一个结点，再重新插入上去，一定能得到原来的二叉排序树。
（）12、快速排序是排序算法中最快的一种。
（）13、多维数组是向量的推广。
（）14、一般树和二叉树的结点数目都可以为0。
（）15、直接选择排序是一种不稳定的排序方法。
（）16、98、对一个堆按层次遍历，不一定能得到一个有序序列。
（）17、在只有度为0和度为k的结点的k叉树中，设度为0的结点有n0个，度为k的结点有nk个，则有n0=nk+1。
（）18、折半搜索只适用与有序表，包括有序的顺序表和有序的链表。
（）19、堆栈在数据中的存储原则是先进先出。
（）20、队列在数据中的存储原则是后进先出。
（）21、用相邻矩阵表示图所用的存储空间大小与图的边数成正比。
（）22、哈夫曼树一定是满二叉树。
（）23、程序是用计算机语言表述的算法。
（）24、线性表的顺序存储结构是通过数据元素的存储地址直接反映数据元素的逻辑关系。
（）25、用一组地址连续的存储单元存放的元素一定构成线性表。
（）26、堆栈、队列和数组的逻辑结构都是线性表结构。
（）27、给定一组权值，可以唯一构造出一棵哈夫曼树。
（）28、只有在初始数据为逆序时，冒泡排序所执行的比较次数最多。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
一、判断题。
1．通常由数据的逻辑结构和存储结构组成了一个数据结构。
X 运算集合
2．一个长度为n的顺序表中，将第i个位置（1≤i≤n）的元素删除，需要移动n次元素。
X n-i
3．串是每个结点都由一个字符组成的线性表。
O
4．顺序存储方式只能用于线性表。
X
5．函数StrLength(“abc”)的值为3。
O
6．链表的逻辑顺序与存储顺序总是一致的。
X
7．Strcat(s1,s2)和Strcat(s2,s1)的结果是相同的，都是将串s1和串s2联接起来。
X
8．栈是允许在表的一端进行插入和删除的线性表。
O
9．链表是一种随机存储结构。
X
10．线性表中的每个结点最多只有一个直接前驱和一个直接后继。
O
11．栈和队列是一种非线性数据结构。
X
12．顺序表结构适宜于进行顺序存取，而链表适宜于进行随机存取。
X
13．链表中插入运算的平均时间复杂度是O(n)。
O
14．队列的特点是后进先出。
X
15．线性表的顺序存储表示优于链式存储表示。
X
16．一个栈的输入序列是12345，则栈的输出序列不可能是12345。
X
17．顺序表的特点是逻辑上相邻的结点其在存储结构上的位置亦相邻。
O
18．算法与程序相同，只是说法不同，两者无区别。
X
19．单链表从任何一个结点出发，都能访问到所有结点。
X
二、选择题。
1．组成数据的基本单位是 C 。
A、数据项
B、数据类型
C、数据元素
D、数据变量
2．设单链表中指针p指向结点m，若要删除m之后的结点（若存在），则需要修改指针的操作为D。
A、p->next=p;
B、p=p->next;
C、p=p->next->next;
D、p->next=p->next->next;
3．设a1、a2、a3为3个结点，整数P0，3，4代表地址，则如下的链式存储结构称为 B
P0 3 4
P0→→→
（Ａ）循环单链表（Ｂ）单链表（Ｃ）双向循环链表（Ｄ）双向链表
4．判定一队列q（最多元素为n，头尾指针分别为front和rear）为满队列的条件是B。
A、q.rear – q.front= =n-1
B、q.rear – q.front = =n
C、q.rear= =QU.front
D、q.rear – q.front +1
5．算法分析的目的是C。
A) 找出数据结构的合理性B) 研究算法中的输入和输出的关系
C) 分析算法的效率以求改进D) 分析算法的易懂性和文档性
6、带头结点的单循环链表head为空的判定条件是B。
A、head= =NULL
B、head->next= =head
C、head->next= =NULL
D、head!=NULL
7．线性表若采用顺序存储结构时，要求内存中可用存储单元的地址C。
A、一定是不连续的
B、连续或不连续都可以
C、必须是连续的
D、部分地址必须是连续的
12．串的长度是指 B 。
A、串中所含不同字母的个数
B、串中所含字符的个数
C、串中所含不同字符的个数
D、串中所含非空格字符的个数
13．设串s1=″that∪is∪a∪cook″，s2=″book″，则SubStr(s1,11,Strlen (s2), Sub)得到的Sub是B。
（’∪’表示空格字符）
A、″thi s∪is∪a∪″
B、″cook″
C、″coo″
D、″book″
14．链式存储的存储结构所占存储空间 A 。
A、分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针
B、只有一部分，存放结点值
C、只有一部分，存储表示结点间关系的指针
D、分两部分，一部分存放结点值，另一部分存放结点所占单元数
15．循环队列sq用base指针指示的一片连续地址空间（大小为maxsize）存放其元素值，已知其头尾指针分别是front和rear，则当前队列中的元素个数是A。
A、(sq.rear-sq.front+maxsize)% maxsize
B、sq.rear-sq.front+1
C、sq.rear-sq.front-1
D、sq.rear-sq.front
16．计算机算法必须具备输入、输出和 B 等5个特性。
A) 可行性、可移植性和可扩充性B) 可行性、确定性和有穷性
C) 确定性、有穷性和稳定性D) 易读性、稳定性和安全性
17．判定一个栈S（最多元素为maxsize）为满的条件是D。
A、S.top!=-1
B、S.top==-1
C、S.top!=maxsize-1
D、S.top==maxsize-1
18．有六个元素6,5,4,3,2,1顺序入栈， C 不是合法的出栈序列。
A. 5 4 3 6 1 2
B. 4 5 3 1 2 6
C. 3 4 6 5 2 1
D. 2 3 4 1 5 6
20．在单链表中设置头结点的作用是A。
A、使空表和非空表处理一致
B、可以节省存储空间
C、可以减小时间复杂度
D、为了增加链表长度
21．线性结构中，元素之间存在 A 的关系。
A、一对一
B、一对多
C、多对多
D、不确定
22．在n个结点的顺序表中，算法的时间复杂度是O（1）的操作是： A 。
A、访问第i个结点（1≤i≤n）和求第i个结点的直接前驱（2≤i≤n）
B、在第i个结点后插入一个新结点（1≤i≤n）
C、删除第i个结点（1≤i≤n）
D、将n个结点从小到大排序
23．线性表Ｌ在 B 情况下适用于使用链式结构实现。
A、需经常修改Ｌ中的结点值
B、需不断对Ｌ进行删除插入
C、Ｌ中含有大量的结点
D、Ｌ中结点结构复杂
24．设计一个判别表达式中左、右括号是否配对出现的算法，采用 D 数据结构最佳。
（A）线性表的顺序存储结构（B）线性表的链式存储结构
（C）队列（D）栈
27．线性表（a1,a2,…,an）以链接方式存储时，访问第i位置元素的时间复杂度为 C 。
A、O(i)
B、O(1)
C、O(n)
D、O(i-1)
29．队列操作的原则是 A 。
A、先进先出
B、后进先出
C、只能进行插入
D、只能进行删除30．下面关于串的叙述中， B 是不正确的。
A、串是字符的有限序列
B、空串是由空格构成的串
C、求子串是串的一种重要运算
D、串既可以采用顺序存储，也可以采用链式存储31．从供选择的答案中，选出最确切的解答，把相应编号填入对应的栏内。
设有4个数据元素a1、a2、a3和a4，对他们分别进行栈操作或队操作。
在进栈或进队操作时，按a1、a2、a3、a4次序每次进入一个元素。
假设栈或队的初始状态都是空。
现要进行的栈操作是进栈两次，出栈一次，再进栈两次，出栈一次；这时，第一次出栈得到的元素是①，第二次出栈得到的元素是②；类似地，考虑对这4个数据元素进行的队操作是进队两次，出队一次，再进队两次，出队一次；这时，第一次出队得到的元素是③，第二次出队得到的元素是④。
经操作后，最后在栈中或队中的元素还有⑤个。
供选择的答案：
A、a1
B、a2
C、a3
D、a4
E、1
F、2
G、3
H、0
答：①、②、③、④、⑤分别为B 、D、 A 、 C 、 F
三、填空题。
1、Index (“DA TASTRUCTURE”,”STR”)＝ 5 。
2、两个串相等的充分必要条件是长度相等〔2〕和〔各个对应位置的字符都相等〕。
3、在具有n个单元的循环队列，队满时共有N 个元素。
4、在队列中进行插入的一端为队尾〔5〕，删除的一端为对头〔6〕。
5、数据的存储结构可用四种基本的存储方法表示，它们分别是〔7〕循序、〔8链式、
索引存储、散列存储。
6、串是数据元素都是〔9〕字符的线性表。
7、一个算法的效率可分为（10）时间效率和空间(11) 效率。
8、在n个结点的单链表中要删除已知结点*p，需找到它的直接前驱〔12〕，其时间复杂度为O(n) 〔13〕。
9、〔14〕零个字符的串称为空串，〔15〕仅有空格组成的串
称为空白串。
11、常见数据的逻辑结构有集合(18) 、线性结构〔19〕、树结构〔20〕和〔21〕图或网结构。
12、线性表是具有（22）相同数据类型的数据元素组成的有限〔23〕序列。
13、在线性结构中有唯一的一个无直接前驱的结点称为开始节点〔24〕和唯一的一个无直接后继的结点称为〔25〕终端节点。