数据结构上机考试题
数据结构考试试题及答案
数据结构一、单选题1. 计算机算法指的是（b ）。
A．程序B．问题求解步骤的描述C．调度方法D．排序方法2. 以下数据结构中，（a ）个是非线性数据结构。
A．树B．字符串C．队D．栈3. 对于顺序存储的线性表，访问元素和插入元素的时间复杂度分别为：（c ）。
A．O(n) O(n) B．O(n) O(1) C．O(1) O(n) D．O(1) O(1)4. 在单链表指针为p的结点之后插入指针为s的结点，正确的操作是（b ）。
A.p->next=s;s->next=p->nextB.s->next=p->next; p->next=sC.p->next=s;p->next=s->nextD.p->next=s->next; p->next=s5. n个顶点的有向图中,含有向边的数目最多为( d )A．n-1 B．n C．n(n-1)/2 D．n(n-1)6. 循环队列存储在数组A[0..m]中，则入队时的操作为（ d ）A．rear=rear+1 B．rear=(rear+1)mod(m-1)C．rear=(rear+1)mod m D．rear=(rear+1)mod(m+1)7. 字符串‟ababaabab‟的next函数为（d ）A.011232232B.012341234C.011122334D. 0112342348. 若一棵二叉树具有10个度为2的结点，5个度为1的结点，则度为0的结点个数为（ b ）A．9 B．11 C．15 D．不确定9. 设有数组A[i,j]，数组的每个元素长度为3字节，i的值为1到8，j的值为1到10，数组从内存首地址BA开始顺序存放，当以列为主序存放时，元素A[5,8]的首地址为（ b ）。
A．BA+141 B．BA+180 C．BA+222 D．BA+22510. n个顶点的带权无向连通图的最小生成树包含(b )个顶点A．n-1 B．nC．n/2 D．n+111．有关二叉树的下列说法正确的是（ b ）A．二叉树的度为2 B．一棵二叉树的度可以小于2C．二叉树中至少有一个结点的度为2 D．二叉树中任何一个结点的度都为212．关键路径是AOE网中（ a ）。
全国计算机等级考试(2级)上机考试题库及解析004
（1）下列数据结构中，属于非线性结构的是（）。
A）循环队列B）带链队列C）二叉树D）带链栈（2）下列数据结构中，能够按照“先进后出”原则存取数据的是（）。
A）循环队列B）栈C）队列D）二叉树（3）对于循环队列，下列叙述中正确的是（）。
A）队头指针是固定不变的B）队头指针一定大于队尾指针C）队头指针一定小于队尾指针D）队头指针可以大于队尾指针，也可以小于队尾指针（4）算法的空间复杂度是指（）。
A）算法在执行过程中所需要的计算机存储空间B）算法所处理的数据量C）算法程序中的语句或指令条数D）算法在执行过程中所需要的临时工作单元数（5）软件设计中划分模块的一个准则是（）。
A）低内聚低耦合B）高内聚低耦合C）低内聚高耦合D）高内聚高耦合（6）下列选项中不属于结构化程序设计原则的是（）。
A）可封装B）自顶向下C）模块化D）逐步求精（7）软件详细设计产生的图如下：该图是（）。
A）N-S图B）PAD图C）程序流程图D）E-R图（8）数据库管理系统是（）。
A）操作系统的一部分B）在操作系统支持下的系统软件C）一种编译系统D）一种操作系统（9）在E-R图中，用来表示实体联系的图形是（）。
A）椭圆形B）矩形C）菱形D）三角形（10）有三个关系R，S和T如下：其中关系T由关系R和S通过某种操作得到，该操作为（）。
A）选择B）投影C）交D）并（11）下列符号中可以用做C++标识符的是（）。
A）_radiusB）foo~barC）elseD）3room（12）下列各组类型声明符中，含义相同的一组是（）。
A）unsigned long int和longB）signed short int和shortC）unsigned short和shortD）short int和int（13）必须用一对大括号括起来的程序段是（）。
A）switch语句中的case标号语句B）if语句的分支C）循环语句的循环体D）函数的函数体（14）语句int *p = &k；定义了指针p，与这个语句等效的语句序列是（）。
数据结构上机考试题目及要求
数据结构上机实验考试标准一、评分标准：1.根据考试完成情况，参考平时上机情况评定优、良、中、及格、不及格5个档。
2.成绩分布比例近似为：优15%、良30%、中30%、及格20%、不及格<10%二、评分原则：1.充分参考平时实验完成情况，结合如下原则给出成绩；2.只完成第一题，成绩为良以下成绩（中、及格），若平时上机情况很好，可以考虑良好；3.两道题都完成，成绩为良及以上（优、良），根据完成质量和完成时间给成绩；4.如未完成任何程序，则不及格（根据平时成绩将不及格率控制在10%以下）；三、监考要求：1.考试前，要求学生检查电脑是否工作正常，如果不正常及时解决，待所有考生均可正常考试后再发布试题。
2.平时上机完成的程序可以在考试过程直接调用，在考试开始前复制到硬盘当中，考试过程中可以看教材。
3.考试开始后向学生分发考题的电子文档，同时宣读试题，学生可以通过网络或磁盘拷贝试题。
4.考试开始十五分钟之后把网络断开，学生不得再使用任何形式的磁盘。
5.程序检查时，记录其完成时间和完成情况。
除检查执行情况外，还要求学生对代码进行简要讲解，核实其对代码的理解情况和设计思想，两项均合格方视为试题完成。
6.完成考试的学生须关闭电脑立刻离开考场，考试成绩由教务办统一公布，负责教师不在考试现场公布成绩。
数据结构上机实验考试题目（2011年12月23日）题目1.设C={a1,b1,a2,b2,…,a n,b n}为一线性表，采用带头结点的单链表hc（hc为C链表的头指针）存放，设计一个算法，将其拆分为两个线性表（它们都用带头结点的单链表存放），使得：A={a1,a2,…,a n}，B={b n,b n-1,…,b1}。
[例] C链表为：C={1，2，3，4，5，6，7，8，9，10｝拆分后的A、B链表如下：A={1，3，5，7，9}，B={10，8，6，4，2}。
要求：算法的空间复杂度为O（1）。
即利用C链表原来的空间。
数据结构机考题库汇总
数据结构机考题库汇总1、在下列对顺序表进行的操作中，算法时间复杂度为O(1)的是（A）。
选项A）访问第i个元素的前驱（1i=n）选项B）在第i个元素之后插入一个新元素(1=i=n)选项C）删除第i个元素(1=i=n)选项D）对顺序表中元素进行排序顺序表是随机存取结构，选项A中实质是查找第i个结点和第i一1个结点，因此时间复杂度为O(1)；选项B和C插入和删除都需要移动元素，时间复杂度为O(n)；选项D是排序问题，时间复杂度是O(n)～O(n2)。
2、不带头结点的单链表head为空的判定条件是（A）。
选项A）head==NULL选项B）head-next==NULL选项C）head-next==head选项D）head!=NULL在不带头结点的单链表head中，head指向第一个元素结点，head=NULL表示该链表为空。
3、在一个长度为n的顺序表中，在第i个元素之前插入一个新元素时，需向后移动（B）个元素。
选项A）n-i选项B）n-i+1选项C）n-i-1选项D）ii之前共有(i-1)个元素,所以,需移动(n-(i-1))个元素。
4、某程序的时间复杂度为（3n+nlog2n+n2+8）,其数量级表示为（C）。
选项A）O(n)选项B）O(nlog2n)选项C）O(n2)选项D）O(log2n)5、在以下的叙述中，正确的是（C）。
选项A）线性表的顺序存储结构优于链表存储结构选项B）线性表的顺序存储结构适用于频繁插入删除数据元素的情况选项C）线性表的链表存储结构适用于频繁插入删除数据元素的情况选项D）线性表的链表存储结构优于顺序存储结构6、对一个具有n个元素的线性表，建立其单链表的时间复杂性为（A）。
选项A）O(n)选项B）O(1)选项C）O(n2)选项D）O(log2n)7、线性表链式存储结构的特点，哪个是错误的（C）。
选项A）逻辑上相邻的元素，其物理位置不一定相邻，元素之间的邻接关系由指针域指示选项B）链表是非随机存取存储结构，对链表的存取必须从头指针开始选项C）链表是一种动态存储结构，链表的结点可用free()申请和用malloc()释放。
数据结构试题及答案(十套)
一、单选题（每题 2 分，共20分）1.对一个算法的评价，不包括如下（B ）方面的内容。
A．健壮性和可读性B．并行性C．正确性D．时空复杂度2.在带有头结点的单链表HL中，要向表头插入一个由指针p指向的结点，则执行( )。
A. p->next=HL->next; HL->next=p;B. p->next=HL; HL=p;C. p->next=HL; p=HL;D. HL=p; p->next=HL;3.对线性表，在下列哪种情况下应当采用链表表示？( )A.经常需要随机地存取元素B.经常需要进行插入和删除操作C.表中元素需要占据一片连续的存储空间D.表中元素的个数不变4.一个栈的输入序列为1 2 3，则下列序列中不可能是栈的输出序列的是( C )A. 2 3 1B. 3 2 1C. 3 1 2D. 1 2 35.AOV网是一种（）。
A．有向图B．无向图C．无向无环图D．有向无环图6.采用开放定址法处理散列表的冲突时，其平均查找长度（）。
A．低于链接法处理冲突 B. 高于链接法处理冲突C．与链接法处理冲突相同D．高于二分查找7.若需要利用形参直接访问实参时，应将形参变量说明为（）参数。
A．值B．函数C．指针D．引用8.在稀疏矩阵的带行指针向量的链接存储中，每个单链表中的结点都具有相同的（）。
A．行号B．列号C．元素值D．非零元素个数9.快速排序在最坏情况下的时间复杂度为（）。
A．O(log2n) B．O(nlog2n)C．0(n) D．0(n2)10.从二叉搜索树中查找一个元素时，其时间复杂度大致为( )。
A. O(n)B. O(1)C. O(log2n)D. O(n2)二、运算题（每题 6 分，共24分）1.数据结构是指数据及其相互之间的______________。
当结点之间存在M对N （M：N）的联系时，称这种结构为_____________________。
数据结构上机考题
05信管《数据结构》上机考题（A卷）
学号：姓名：成绩：
试题：建立一个数据为整型的单链表L，然后将该链表中数据域值最小的那个结点移到链表的最前端。
要求与评分标准：
第一步：建立单链表（30分）
第二步：显示该单链表（10分）
第三步：查找链表中数据域值最小的结点，并将它移到链表的最前端（50分）第四步：显示该单链表，检查上述操作是否成功（10分）
05信管《数据结构》上机考题（B卷）
学号：姓名：成绩：
试题：在一个递增有序的顺序表中插入一个元素,使插入之后仍有序。
要求与评分标准：
第一步：建立一个递增有序的顺序表，注：可以在输入数据时按递增的顺序输入（30分）
第二步：显示该顺序表（10分）
第三步：在顺序表中找到合适的位置插入指定的元素,使插入之后仍有序（50分）第四步：显示该顺序表，检查上述操作是否成功（10分）
05信管《数据结构》上机考题（Ｃ卷）
学号：姓名：成绩：
试题：已知单链表L中的元素递增有序，请用高效的办法删除L中元素值大于mink且小于maxk的所有结点（注：mink和maxk由形参给出，它们与链表的数据域同类型且mink且小于maxk）
要求与评分标准：
第一步：建立递增有序的单链表Ｌ（30分）
第二步：显示该单链表（10分）
第三步：用高效的办法删除L中元素值大于mink且小于maxk的所有结点（50分）
第四步：显示该单链表，检查上述操作是否成功（10分）。
(完整word版)数据结构考试题5
要求：所有的题目的解答均写在答题纸上，需写清楚题目的序号。
每张答题纸都要写上姓名和学号。
一、单项选择题(每小题2分，共20小题，共计40分)1.某算法的空间复杂度为0(1),则。
A.该算法执行不需要任何辅助空间B.该算法执行所需辅助空间大小与问题规模n无关C.该算法执行不需要任何空间D.该算法执行所需全部空间大小与问题规模n无关2.在长度为n的顺序表中插入一个元素，对应算法的时间复杂度为。
A.0(1)B.O(log2n)C.0(n)D.0(n2)3.设线性表中有n个元素，以下运算中，在单链表上实现要比在顺序表上实现效率更高。
A.删除指定位置元素的后一个元素B.在最后一个元素的后面插入一个新元素C.顺序输出前k个元素D.交换第i个元素和第n-i+1个元素的值(i=1, 2,…，n)4.以下数据结构中元素之间为非线性关系的是。
A.栈B.队列C.线性表D.以上都不是5.若一个栈用数组data[1..n]存储，初始栈顶指针top为n+1,则以下元素x进栈的正确操作是。
A.top++;data[top]=x;B.data[top]=x;top++;C.top-- ;data[top]=x;D.data[top]=x;top --;6.若某循环队列有队首指针front和队尾指针rear,在队不满时进队操作仅会改变。
A.frontB.rearC.front 和rearD.以上都不队7.设循环队列中数组的下标是0〜N-1,其队头、队尾指针分别为f和r(f指向队首元素的前一位置，r指向队尾元素)，则其元素个数为。
A.r-fB.r-f-1C.(r-f)%N+1D.(r-f+N)%N8.设树T的度为4,其中度为1、2、3、4的结点个数分别为4、2、1、1,则T中的叶子结点个数是。
A.5B.6C.7D.89. 一棵哈夫曼树中共有199个结点，它用于多少个字符的编码。
A.99B.100C.101D.19910.设森林F中有4棵树，第1、2、3、4棵树的结点个数分别为a、b、c、d,将森林F转换为一颗二叉树B,则二叉树B根结点的左子树上的结点个数是。
数据结构上机实验
目录第1章绪论——上机实验题1解析实验题1.1求素数实验题1.2求一个正整数的各位数字之和实验题1.3求一个字符串是否为回文第2章线性表——上机实验题2解析实验题2.1实现顺序表各种基本运算的算法/*文件名:algo2-1.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 50typedef char ElemType;typedef struct{ElemType elem[MaxSize];int length;} SqList;void InitList(SqList *&L){L=(SqList *)malloc(sizeof(SqList));L->length=0;}void DestroyList(SqList *L){free(L);}int ListEmpty(SqList *L){return(L->length==0);}int ListLength(SqList *L){return(L->length);}void DispList(SqList *L){int i;if (ListEmpty(L)) return;for (i=0;i<L->length;i++)printf("%c",L->elem[i]);printf("\n");}int GetElem(SqList *L,int i,ElemType &e){if (i<1 || i>L->length)return 0;e=L->elem[i-1];return 1;}int LocateElem(SqList *L, ElemType e){int i=0;while (i<L->length && L->elem[i]!=e) i++;if (i>=L->length)return 0;elsereturn i+1;}int ListInsert(SqList *&L,int i,ElemType e){int j;if (i<1 || i>L->length+1)return 0;i--; /*将顺序表位序转化为elem下标*/for (j=L->length;j>i;j--) /*将elem[i]及后面元素后移一个位置*/L->elem[j]=L->elem[j-1];L->elem[i]=e;L->length++; /*顺序表长度增1*/return 1;}int ListDelete(SqList *&L,int i,ElemType &e){int j;if (i<1 || i>L->length)return 0;i--; /*将顺序表位序转化为elem下标*/e=L->elem[i];for (j=i;j<L->length-1;j++)L->elem[j]=L->elem[j+1];L->length--;return 1;}实验题2.2实现单链表各种基本运算的算法*文件名:algo2-2.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct LNode /*定义单链表结点类型*/{ElemType data;struct LNode *next;} LinkList;void InitList(LinkList *&L){L=(LinkList *)malloc(sizeof(LinkList)); /*创建头结点*/L->next=NULL;}void DestroyList(LinkList *&L){LinkList *p=L,*q=p->next;while (q!=NULL){free(p);p=q;q=p->next;}free(p);}int ListEmpty(LinkList *L){return(L->next==NULL);}int ListLength(LinkList *L){LinkList *p=L;int i=0;while (p->next!=NULL){i++;p=p->next;}return(i);}void DispList(LinkList *L){LinkList *p=L->next;while (p!=NULL){printf("%c",p->data);p=p->next;}printf("\n");}int GetElem(LinkList *L,int i,ElemType &e) {int j=0;LinkList *p=L;while (j<i && p!=NULL){j++;p=p->next;}if (p==NULL)return 0;else{e=p->data;return 1;}}int LocateElem(LinkList *L,ElemType e){LinkList *p=L->next;int n=1;while (p!=NULL && p->data!=e){p=p->next;n++;}if (p==NULL)return(0);elsereturn(n);}int ListInsert(LinkList *&L,int i,ElemType e)int j=0;LinkList *p=L,*s;while (j<i-1 && p!=NULL){j++;p=p->next;}if (p==NULL) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{s=(LinkList *)malloc(sizeof(LinkList)); /*创建新结点*s*/s->data=e;s->next=p->next; /*将*s插p->next=s;return 1;}}int ListDelete(LinkList *&L,int i,ElemType &e){int j=0;LinkList *p=L,*q;while (j<i-1 && p!=NULL){j++;p=p->next;}if (p==NULL) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{q=p->next; /*q指向要删除的结点*/p->next=q->next; /*从单链表中删除*q结点*/free(q); /*释放*q结点*/return 1;}}第3章栈和队列——上机实验题3解析实验题3.1实现顺序栈各种基本运算的算法*文件名:algo3-1.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 100typedef char ElemType;typedef struct{ElemType elem[MaxSize];int top; /*栈指针*/} SqStack;void InitStack(SqStack *&s){s=(SqStack *)malloc(sizeof(SqStack));s->top=-1;}void ClearStack(SqStack *&s){free(s);}int StackLength(SqStack *s){return(s->top+1);}int StackEmpty(SqStack *s){return(s->top==-1);}int Push(SqStack *&s,ElemType e){if (s->top==MaxSize-1)return 0;s->top++;s->elem[s->top]=e;return 1;}int Pop(SqStack *&s,ElemType &e){if (s->top==-1)return 0;e=s->elem[s->top];s->top--;return 1;int GetTop(SqStack *s,ElemType &e){if (s->top==-1)return 0;e=s->elem[s->top];return 1;}void DispStack(SqStack *s){int i;for (i=s->top;i>=0;i--)printf("%c ",s->elem[i]);printf("\n");}实验题3.2实现链栈各种基本运算的算法/*文件名:algo3-2.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct linknode{ElemType data; /*数据域*/struct linknode *next; /*指针域*/} LiStack;void InitStack(LiStack *&s){s=(LiStack *)malloc(sizeof(LiStack));s->next=NULL;}void ClearStack(LiStack *&s){LiStack *p=s->next;while (p!=NULL){free(s);s=p;p=p->next;}}int StackLength(LiStack *s){int i=0;LiStack *p;p=s->next;while (p!=NULL){i++;p=p->next;}return(i);}int StackEmpty(LiStack *s){return(s->next==NULL);}void Push(LiStack *&s,ElemType e){LiStack *p;p=(LiStack *)malloc(sizeof(LiStack));p->data=e;p->next=s->next; /*插入*p结点作为第一个数据结点*/s->next=p;}int Pop(LiStack *&s,ElemType &e){LiStack *p;if (s->next==NULL) /*栈空的情况*/return 0;p=s->next; /*p指向第一个数据结点*/e=p->data;s->next=p->next;free(p);return 1;}int GetTop(LiStack *s,ElemType &e){if (s->next==NULL) /*栈空的情况*/return 0;e=s->next->data;return 1;}void DispStack(LiStack *s){LiStack *p=s->next;while (p!=NULL){printf("%c ",p->data);p=p->next;}printf("\n");}实验题3.3实现顺序队列各种基本运算的算法/*文件名:algo3-3.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 5typedef char ElemType;typedef struct{ElemType elem[MaxSize];int front,rear; /*队首和队尾指针*/} SqQueue;void InitQueue(SqQueue *&q){q=(SqQueue *)malloc (sizeof(SqQueue));q->front=q->rear=0;}void ClearQueue(SqQueue *&q){free(q);}int QueueEmpty(SqQueue *q){return(q->front==q->rear);}int QueueLength(SqQueue *q){return (q->rear-q->front+MaxSize)%MaxSize; }int enQueue(SqQueue *&q,ElemType e){if ((q->rear+1)%MaxSize==q->front) /*队满*/return 0;q->rear=(q->rear+1)%MaxSize;q->elem[q->rear]=e;return 1;}int deQueue(SqQueue *&q,ElemType &e){if (q->front==q->rear) /*队空*/return 0;q->front=(q->front+1)%MaxSize;e=q->elem[q->front];return 1;}实验题3.4实现链队各种基本运算的算法/*文件名:algo3-4.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct qnode{ElemType data;struct qnode *next;} QNode;typedef struct{QNode *front;QNode *rear;} LiQueue;void InitQueue(LiQueue *&q){q=(LiQueue *)malloc(sizeof(LiQueue));q->front=q->rear=NULL;}void ClearQueue(LiQueue *&q){QNode *p=q->front,*r;if (p!=NULL) /*释放数据结点占用空间*/{r=p->next;while (r!=NULL){free(p);p=r;r=p->next;}}free(q); /*释放头结点占用空间*/ }int QueueLength(LiQueue *q){int n=0;QNode *p=q->front;while (p!=NULL){n++;p=p->next;}return(n);}int QueueEmpty(LiQueue *q){if (q->rear==NULL)return 1;elsereturn 0;}void enQueue(LiQueue *&q,ElemType e){QNode *s;s=(QNode *)malloc(sizeof(QNode));s->data=e;s->next=NULL;if (q->rear==NULL) /*若链队为空,则新结点是队首结点又是队尾结点*/q->front=q->rear=s;else{q->rear->next=s; /*将*s结点链到队尾,rear指向它*/q->rear=s;}}int deQueue(LiQueue *&q,ElemType &e){QNode *t;if (q->rear==NULL) /*队列为空*/return 0;if (q->front==q->rear) /*队列中只有一个结点时*/{t=q->front;q->front=q->rear=NULL;}else /*队列中有多个结点时*/{t=q->front;q->front=q->front->next;}e=t->data;free(t);return 1;}第4章串——上机实验题4解析实验题4.1实现顺序串各种基本运算的算法/*文件名:algo4-1.cpp*/#include <stdio.h>#define MaxSize 100 /*最多的字符个数*/typedef struct{ char ch[MaxSize]; /*定义可容纳MaxSize个字符的空间*/ int len; /*标记当前实际串长*/} SqString;void StrAssign(SqString &str,char cstr[]) /*str为引用型参数*/ {int i;for (i=0;cstr[i]!='\0';i++)str.ch[i]=cstr[i];str.len=i;}void StrCopy(SqString &s,SqString t) /*s为引用型参数*/ {int i;for (i=0;i<t.len;i++)s.ch[i]=t.ch[i];s.len=t.len;}int StrEqual(SqString s,SqString t){int same=1,i;if (s.len!=t.len) /*长度不相等时返回0*/same=0;else{for (i=0;i<s.len;i++)if (s.ch[i]!=t.ch[i]) /*有一个对应字符不相同时返回0*/same=0;}return same;}int StrLength(SqString s){return s.len;}SqString Concat(SqString s,SqString t){SqString str;int i;str.len=s.len+t.len;for (i=0;i<s.len;i++) /*将s.ch[0]～s.ch[s.len-1]复制到str*/ str.ch[i]=s.ch[i];for (i=0;i<t.len;i++) /*将t.ch[0]～t.ch[t.len-1]复制到str*/ str.ch[s.len+i]=t.ch[i];return str;}SqString SubStr(SqString s,int i,int j){SqString str;int k;str.len=0;if (i<=0 || i>s.len || j<0 || i+j-1>s.len){printf("参数不正确\n");return str; /*参数不正确时返回空串*/}for (k=i-1;k<i+j-1;k++) /*将s.ch[i]～s.ch[i+j]复制到str*/str.ch[k-i+1]=s.ch[k];str.len=j;return str;}SqString InsStr(SqString s1,int i,SqString s2){int j;SqString str;str.len=0;if (i<=0 || i>s1.len+1) /*参数不正确时返回空串*/{printf("参数不正确\n");return s1;}for (j=0;j<i-1;j++) /*将s1.ch[0]～s1.ch[i-2]复制到str*/str.ch[j]=s1.ch[j];for (j=0;j<s2.len;j++) /*将s2.ch[0]～s2.ch[s2.len-1]复制到str*/str.ch[i+j-1]=s2.ch[j];for (j=i-1;j<s1.len;j++) /*将s1.ch[i-1]～s.ch[s1.len-1]复制到str*/str.ch[s2.len+j]=s1.ch[j];str.len=s1.len+s2.len;return str;}SqString DelStr(SqString s,int i,int j){int k;SqString str;str.len=0;if (i<=0 || i>s.len || i+j>s.len+1) /*参数不正确时返回空串*/{printf("参数不正确\n");return str;}for (k=0;k<i-1;k++) /*将s.ch[0]～s.ch[i-2]复制到str*/str.ch[k]=s.ch[k];for (k=i+j-1;k<s.len;k++)/*将s.ch[i+j-1]～ch[s.len-1]复制到str*/ str.ch[k-j]=s.ch[k];str.len=s.len-j;return str;}SqString RepStr(SqString s,int i,int j,SqString t){int k;SqString str;str.len=0;if (i<=0 || i>s.len || i+j-1>s.len) /*参数不正确时返回空串*/ {printf("参数不正确\n");return str;}for (k=0;k<i-1;k++) /*将s.ch[0]～s.ch[i-2]复制到str*/str.ch[k]=s.ch[k];for (k=0;k<t.len;k++) /*将t.ch[0]～t.ch[t.len-1]复制到str*/str.ch[i+k-1]=t.ch[k];for (k=i+j-1;k<s.len;k++) /*将s.ch[i+j-1]～ch[s.len-1]复制到str*/str.ch[t.len+k-j]=s.ch[k];str.len=s.len-j+t.len;return str;}void DispStr(SqString str){int i;if (str.len>0){for (i=0;i<str.len;i++)printf("%c",str.ch[i]);printf("\n");}}实验题4.2实现链串各种基本运算的算法*文件名:algo4-2.cpp*/#include <stdio.h>#include <malloc.h>typedef struct snode{char data;struct snode *next;} LiString;void StrAssign(LiString *&s,char t[]){int i;LiString *r,*p;s=(LiString *)malloc(sizeof(LiString));s->next=NULL;r=s;for (i=0;t[i]!='\0';i++){p=(LiString *)malloc(sizeof(LiString));p->data=t[i];p->next=NULL;r->next=p;r=p;}}void StrCopy(LiString *&s,LiString *t){LiString *p=t->next,*q,*r;s=(LiString *)malloc(sizeof(LiString));s->next=NULL;s->next=NULL;r=s;while (p!=NULL) /*将t的所有结点复制到s*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}}int StrEqual(LiString *s,LiString *t){LiString *p=s->next,*q=t->next;while (p!=NULL && q!=NULL && p->data==q->data){p=p->next;q=q->next;}if (p==NULL && q==NULL)return 1;elsereturn 0;}int StrLength(LiString *s){int i=0;LiString *p=s->next;while (p!=NULL){i++;p=p->next;}return i;}LiString *Concat(LiString *s,LiString *t){LiString *str,*p=s->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;while (p!=NULL) /*将s的所有结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}p=t->next;while (p!=NULL) /*将t的所有结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *SubStr(LiString *s,int i,int j){int k;LiString *str,*p=s->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)) {printf("参数不正确\n");return str; /*参数不正确时返回空串*/ }for (k=0;k<i-1;k++)p=p->next;for (k=1;k<=j;k++) /*将s的第i个结点开始的j个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *InsStr(LiString *s,int i,LiString *t){int k;LiString *str,*p=s->next,*p1=t->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s)+1) /*参数不正确时返回空串*/{printf("参数不正确\n");return str;}for (k=1;k<i;k++) /*将s的前i个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}while (p1!=NULL) /*将t的所有结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p1->data;q->next=NULL;r->next=q;r=q;p1=p1->next;}while (p!=NULL) /*将*p及其后的结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *DelStr(LiString *s,int i,int j){int k;LiString *str,*p=s->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)) {printf("参数不正确\n");return str; /*参数不正确时返回空串*/ }for (k=0;k<i-1;k++) /*将s的前i-1个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}for (k=0;k<j;k++) /*让p沿next跳j个结点*/p=p->next;while (p!=NULL) /*将*p及其后的结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *RepStr(LiString *s,int i,int j,LiString *t){int k;LiString *str,*p=s->next,*p1=t->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)) {printf("参数不正确\n");return str; /*参数不正确时返回空串*/ }for (k=0;k<i-1;k++) /*将s的前i-1个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}for (k=0;k<j;k++) /*让p沿next跳j个结点*/p=p->next;while (p1!=NULL) /*将t的所有结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p1->data;q->next=NULL;r->next=q;r=q;p1=p1->next;}while (p!=NULL) /*将*p及其后的结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}void DispStr(LiString *s){LiString *p=s->next;while (p!=NULL){printf("%c",p->data);p=p->next;}printf("\n");}第5章数组和稀疏矩阵——上机实验题5解析实验题5.1求5×5阶螺旋方阵/*文件名:exp5-1.cpp*/#include <stdio.h>#define MaxLen 10void fun(int a[MaxLen][MaxLen],int n){int i,j,k=0,m;if (n%2==0) //m=én/2ùm=n/2;elsem=n/2+1;for (i=0;i<m;i++){for (j=i;j<n-i;j++){k++;a[i][j]=k;}for (j=i+1;j<n-i;j++){k++;a[j][n-i-1]=k;}for (j=n-i-2;j>=i;j--){k++;a[n-i-1][j]=k;}for (j=n-i-2;j>=i+1;j--){k++;a[j][i]=k;}}}void main(){int n,i,j;int a[MaxLen][MaxLen];printf("\n");printf("输入n(n<10):");scanf("%d",&n);fun(a,n);printf("%d阶数字方阵如下:\n",n);for (i=0;i<n;i++){for (j=0;j<n;j++)printf("%4d",a[i][j]);printf("\n");}printf("\n");}实验题5.2求一个矩阵的马鞍点/*文件名:exp5-2.cpp*/#include <stdio.h>#define M 4#define N 4void MinMax(int A[M][N]){int i,j,have=0;int min[M],max[N];for (i=0;i<M;i++) /*计算出每行的最小值元素,放入min[0..M-1]之中*/{min[i]=A[i][0];for (j=1;j<N;j++)if (A[i][j]<min[i])min[i]=A[i][j];}for (j=0;j<N;j++) /*计算出每列的最大值元素,放入max[0..N-1]之中*/{max[j]=A[0][j];for (i=1;i<M;i++)if (A[i][j]>max[j])max[j]=A[i][j];}for (i=0;i<M;i++)for (j=0;j<N;j++)if (min[i]==max[j]){printf(" A[%d,%d]=%d\n",i,j,A[i][j]); /*显示马鞍点*/have=1;}if (!have)printf("没有鞍点\n");}void main(){int i,j;int A[M][N]={{9, 7, 6, 8},{20,26,22,25},{28,36,25,30},{12,4, 2, 6}};printf("A矩阵:\n");for (i=0;i<M;i++){for (j=0;j<N;j++)printf("%4d",A[i][j]);printf("\n");}printf("A矩阵中的马鞍点:\n");MinMax(A); /*调用MinMax()找马鞍点*/}实验题5.3求两个对称矩阵之和与乘积/*文件名:exp5-3.cpp*/#include <stdio.h>#define n 4#define m 10int value(int a[],int i,int j){if (i>=j)return a[(i*(i-1))/2+j];elsereturn a[(j*(j-1))/2+i];}void madd(int a[],int b[],int c[n][n]){int i,j;for (i=0;i<n;i++)for (j=0;j<n;j++)c[i][j]=value(a,i,j)+value(b,i,j);}void mult(int a[],int b[],int c[n][n]){int i,j,k,s;for (i=0;i<n;i++)for (j=0;j<n;j++){s=0;for (k=0;k<n;k++)s=s+value(a,i,k)*value(b,k,j); c[i][j]=s;}}void disp1(int a[]){int i,j;for (i=0;i<n;i++){for (j=0;j<n;j++)printf("%4d",value(a,i,j));printf("\n");}}void disp2(int c[n][n]){int i,j;for (i=0;i<n;i++){for (j=0;j<n;j++)printf("%4d",c[i][j]);printf("\n");}}void main(){int a[m]={1,2,3,4,5,6,7,8,9,10};int b[m]={1,1,1,1,1,1,1,1,1,1};int c1[n][n],c2[n][n];madd(a,b,c1);mult(a,b,c2);printf("\n");printf("a矩阵:\n");disp1(a);printf("b矩阵:\n");disp1(b);printf("a+b:\n");disp2(c1);printf("a*b:\n");disp2(c2);printf("\n");}实验题5.4实现稀疏矩阵（采用三元组表示）的基本运算/*文件名:exp5-4.cpp*/#include <stdio.h>#define N 4typedef int ElemType;#define MaxSize 100 /*矩阵中非零元素最多个数*/ typedef struct{ int r; /*行号*/int c; /*列号*/ElemType d; /*元素值*/} TupNode; /*三元组定义*/typedef struct{ int rows; /*行数值*/int cols; /*列数值*/int nums; /*非零元素个数*/TupNode data[MaxSize];} TSMatrix; /*三元组顺序表定义*/void CreatMat(TSMatrix &t,ElemType A[N][N]){int i,j;t.rows=N;t.cols=N;t.nums=0;for (i=0;i<N;i++){for (j=0;j<N;j++)if (A[i][j]!=0){t.data[t.nums].r=i;t.data[t.nums].c=j;t.data[t.nums].d=A[i][j];t.nums++;}}}void DispMat(TSMatrix t){int i;if (t.nums<=0)return;printf("\t%d\t%d\t%d\n",t.rows,t.cols,t.nums);printf("\t------------------\n");for (i=0;i<t.nums;i++)printf("\t%d\t%d\t%d\n",t.data[i].r,t.data[i].c,t.data[i].d); }void TranMat(TSMatrix t,TSMatrix &tb){int p,q=0,v; /*q为tb.data的下标*/tb.rows=t.cols;tb.cols=t.rows;tb.nums=t.nums;if (t.nums!=0){for (v=0;v<t.cols;v++) /*tb.data[q]中的记录以c 域的次序排列*/for (p=0;p<t.nums;p++) /*p为t.data的下标*/if (t.data[p].c==v){tb.data[q].r=t.data[p].c;tb.data[q].c=t.data[p].r;tb.data[q].d=t.data[p].d;q++;}}}int MatAdd(TSMatrix a,TSMatrix b,TSMatrix &c){int i=0,j=0,k=0;ElemType v;if (a.rows!=b.rows || a.cols!=b.cols)return 0; /*行数或列数不等时不能进行相加运算*/c.rows=a.rows;c.cols=a.cols; /*c的行列数与a的相同*/while (i<a.nums && j<b.nums) /*处理a和b中的每个元素*/{if (a.data[i].r==b.data[j].r) /*行号相等时*/{if(a.data[i].c<b.data[j].c) /*a元素的列号小于b 元素的列号*/{c.data[k].r=a.data[i].r;/*将a元素添加到c中*/c.data[k].c=a.data[i].c;c.data[k].d=a.data[i].d;k++;i++;}else if (a.data[i].c>b.data[j].c)/*a元素的列号大于b元素的列号*/{c.data[k].r=b.data[j].r; /*将b元素添加到c中*/c.data[k].c=b.data[j].c;c.data[k].d=b.data[j].d;k++;j++;}else /*a元素的列号等于b元素的列号*/{v=a.data[i].d+b.data[j].d;if (v!=0) /*只将不为0的结果添加到c中*/{c.data[k].r=a.data[i].r;c.data[k].c=a.data[i].c;c.data[k].d=v;k++;}i++;j++;}}else if (a.data[i].r<b.data[j].r) /*a元素的行号小于b元素的行号*/{c.data[k].r=a.data[i].r; /*将a元素添加到c中*/c.data[k].c=a.data[i].c;c.data[k].d=a.data[i].d;k++;i++;}else /*a元素的行号大于b元素的行号*/{c.data[k].r=b.data[j].r; /*将b元素添加到c中*/c.data[k].c=b.data[j].c;c.data[k].d=b.data[j].d;k++;j++;}c.nums=k;}return 1;}int value(TSMatrix c,int i,int j){int k=0;while (k<c.nums && (c.data[k].r!=i || c.data[k].c!=j))k++;if (k<c.nums)return(c.data[k].d);elsereturn(0);}int MatMul(TSMatrix a,TSMatrix b,TSMatrix &c){int i,j,k,p=0;ElemType s;if (a.cols!=b.rows) /*a的列数不等于b的行数时不能进行相乘运算*/return 0;for (i=0;i<a.rows;i++)for (j=0;j<b.cols;j++){s=0;for (k=0;k<a.cols;k++)s=s+value(a,i,k)*value(b,k,j);if (s!=0) /*产生一个三元组元素*/{c.data[p].r=i;c.data[p].c=j;c.data[p].d=s;p++;}}c.rows=a.rows;c.cols=b.cols;c.nums=p;return 1;}void main(){ElemType a1[N][N]={{1,0,3,0},{0,1,0,0},{0,0,1,0},{0,0,1,1}};ElemType b1[N][N]={{3,0,0,0},{0,4,0,0},{0,0,1,0},{0,0,0,2}};TSMatrix a,b,c;CreatMat(a,a1);CreatMat(b,b1);printf("a的三元组:\n");DispMat(a);printf("b的三元组:\n");DispMat(b);printf("a转置为c\n");TranMat(a,c);printf("c的三元组:\n");DispMat(c);printf("c=a+b\n");MatAdd(a,b,c);printf("c的三元组:\n");DispMat(c);printf("c=a*b\n");MatMul(a,b,c);printf("c的三元组:\n");DispMat(c);}实验题5.5实现广义表的基本运算#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct lnode{ int tag; /*结点类型标识*/ union{ElemType data;struct lnode *sublist;}val;struct lnode *link; /*指向下一个元素*/} GLNode;extern GLNode *CreatGL(char *&s);extern void DispGL(GLNode *g);void Change(GLNode *&g,ElemType s,ElemType t) /*将广义表g中所有原子s 替换成t*/{if (g!=NULL){if (g->tag==1) /*子表的情况*/Change(g->val.sublist,s,t);else if (g->val.data==s) /*原子且data域值为s的情况*/g->val.data=t;Change(g->link,s,t);}}void Reverse(GLNode *&g) /*将广义表g所有元素逆置*/{GLNode *p,*q,*t;t=NULL;if (g!=NULL){p=g;while (p!=NULL) /*将同级的兄弟逆置*/{q=p->link;if (t==NULL){t=p;p->link=NULL;}else{p->link=t;t=p;}p=q;}g=t;p=g;while (p!=NULL){if (p->tag==1)Reverse(p->val.sublist);p=p->link;}}}int Same(GLNode *g1,GLNode *g2) /*判断两个广义表是否相同*/ {int s;if (g1==NULL && g2==NULL) /*均为NULL的情况*/return 1;else if ((g1==NULL && g2!=NULL) || (g1!=NULL && g2==NULL)) /*一个为NULL,另一不为NULL的情况*/return 0;else{s=1;while (g1!=NULL && g2!=NULL && s==1){if (g1->tag==1 && g2->tag==1)/*均为子表的情况*/s=Same(g1->val.sublist,g2->val.sublist);else if (g1->tag==0 && g2->tag==0)/*均为原子的情况*/{if (g1->val.data!=g2->val.data)s=0;}else /*一个为原子,另一为子表的情况*/s=0;g1=g1->link;g2=g2->link;}if (g1!=NULL || g2!=NULL) /*有一个子表尚未比较完时*/s=0;return s;}}ElemType MaxAtom(GLNode *g) /*求广义表g中最大的原子*/{ElemType m=0,m1; /*m赋初值0*/while (g!=NULL){if (g->tag==1) /*子表的情况*/{m1=MaxAtom(g->val.sublist); /*对子表递归调用*/if (m1>m) m=m1;}else{if (g->val.data>m) /*为原子时,进行原子比较*/m=g->val.data;}g=g->link;}return m;}void DelAtom(GLNode *&g,ElemType x) /*删除广义表g中的第一个为x原子*/{GLNode *p=g,*q,*pre;while (p!=NULL){q=p->link;if (p->tag==1) /*子表的情况*/DelAtom(p->val.sublist,x); /*对子表递归调用*/else{if (p->val.data==x) /*为原子时,进行原子比较*/{if (p==g)/*被删结点是本层的第1个结点*/{g=q;free(p); /*释放结pre=g;}else /*被删结{pre->link=q;free(p);}return;}}pre=p;p=q;}}void DelAtomAll(GLNode *&g,ElemType x) /*删除广义表g中的所有为x原子*/{GLNode *p=g,*q,*pre;while (p!=NULL){q=p->link;if (p->tag==1) /*子表的情况*/DelAtomAll(p->val.sublist,x); /*对子表递归调用*/else{if (p->val.data==x) /*为原子时,进行原子比较*/if (p==g)/*被删结点是本层的第1个结点*/{g=q;free(p); /*释放结pre=g;}else /*被删结{pre->link=q;free(p);}}pre=p;p=q;}}void PreOrder(GLNode *g) /*采用先根遍历g*/{if (g!=NULL){if (g->tag==0) /*为原子结点时*/printf("%c ",g->val.data);elsePreOrder(g->val.sublist); /*为子表时*/ PreOrder(g->link);}}void main(){GLNode *g1,*g2,*g3,*g4;char *str1="(a,(a),((a,b)),((a)),a)";char *str2="(a,(b),((c,d)),((e)),f)";char *str3="(a,(a,b),(a,b,c)))";char *str4="(a,(b),((c,d)),((e)),f)";g1=CreatGL(str1);printf("\n");printf(" 广义表g1:");DispGL(g1);printf("\n");printf(" 将广义表g1中所有'a'改为'b'\n");Change(g1,'a','b');printf(" 广义表g1:");DispGL(g1);printf("\n\n");g2=CreatGL(str2);printf(" 广义表g2:");DispGL(g2);printf("\n");printf(" 广义表g2中最大原子:%c\n",MaxAtom(g2));printf(" 将g2的元素逆置\n");Reverse(g2);printf(" 广义表g2:");DispGL(g2);printf("\n\n");printf(" 广义表g1和g2%s\n\n",(Same(g1,g2)?"相同":"不相同"));g3=CreatGL(str3);printf(" 广义表g3:");DispGL(g3);printf("\n");printf(" 删除广义表g3的第一个为'a'的原子\n");DelAtom(g3,'a');printf(" 广义表g3:");DispGL(g3);printf("\n\n");printf(" 删除广义表g3中的所有'a'原子\n");DelAtomAll(g3,'a');printf(" 广义表g3:");DispGL(g3);printf("\n\n");g4=CreatGL(str4);printf(" 广义表g4:");DispGL(g4);printf("\n");printf(" 采用先根遍历g4的结果:");PreOrder(g4);printf("\n\n");}。
数据结构试卷试卷及答案5套
数据结构试卷试1一、解释下列术语（每小题4分，共20分）1. 头指针2. 二叉排序树的定义3. 头结点4. 数据的逻辑结构5. 排序方法的稳定性二、选择填空（每小题2分，共20分）（在每小题的4 个备选答案中，选出一个正确的答案，多选少选均不得分）1. 在一个长度为n的顺序表中，在第i个元素（1≤i≤n+1）之前插入一个新元素时顺向后移动( ) 个元素A.n-iB. n-i+1C. n-i-1D.i2. 某个栈的输入序列为1，2，3，4，下面的四个序列中( )不可能是它的输出序列A.1,2,3,4B.2,3,4,1C. 4,3,2,1D.3,4, 1,23. 对二叉排序进行( )遍历可以得到结点的排序序列A.前序B.中序C. 后序D.按层次4．有64个结点的完全二叉树的深度为（）。
A 8B 7C 6D 55．折半查找法的时间复杂度是( )A.(n2)B.O(n)C. O(n㏒n)D. O(㏒n)6．A(1:5,1:6)的每个元素占5个单元，将其按行优先次序储存在起始地址为1000的连续的内存单元中，则元素A[5，5]的地址为（）。
A 1140B 1145C 1120D 11257. 有n个叶子结点的哈夫曼树的结点总数为（）。
A 不确定B 2nC 2n+1D 2n-18. 已知某二叉树的后序遍历序列是dabec, 中序遍历序列是debac, 则它的前遍历序列是（）。
A acbedB decabC deabcD cedba9．若循环队列用数组A(0:m-1)存放其元素值，已知其头、尾指针分别是f和r,则当前队列中的元素个数是（）。
A (r-f+m)mod mB r-f+1C r-f-1D r-f10. 一个二叉树的先序序列和后序序列正好相反，则该二叉树一定是（）的二叉树（树中结点个数大于1）。
A 空或只有一个结点B 高度等于其结点数C 任一结点无左孩子 D任一结点无右孩子三，判断题（每小题2分，对的打√，错的打×，共10分）1．若图G的最小生成树不唯一，则G的边数一定多于n-1，并且权值最小的边有多条（其中n为G的顶点数）。
数据结构考试题目及答案
数据结构考试题⽬及答案数据结构试题6⼀、单项选择题（每⼩题3分，共30分）1．设栈的输⼊序列是1、2、3、4，则______不可能是其出栈序列。
( )[A] 1234 [B] 2134 [C] 1432 [D] 43122．在⼀个具有n个结点的线性链表中查找某个结点，若查找成功，需要平均⽐较_____个结点。
( )[A] n [B] n/2 [C] (n+1)/2 [D] (n-1)/23．设每个字符占⼀个字节，⼆维数组A中每个元素有6个字符组成，其⾏下标从0到9，列下标从0到3，元素_____当A按⾏优先存储起始地址与当A按列优先存储的起始地址相同。
( )[A] A[3][0] [B] A[3][1] [C] A[3][2] [D] A[2][3]4．具有2000个结点的⾮空⼆叉树的最⼩深度为_______。
( )[A] 9 [B] 10 [C] 11 [D] 125．已知某⼆叉树的后根序列是dabec，中根序列是debac，则先根序列是_____。
( )[A] acbed [B] decab [C] deabc [D] cedba6. ⽆向图中所有边的数⽬等于所有顶点的度数之和的_____倍。
( )[A] 1 [B] 2 [C] 1/2 [D] 不⼀定7．递归函数F(n)=F(n-1)+n+1(n>1)的递归体是_______。
( )[A] F(0)=0 [B] F(1)=1 [C] F(n)=n+1 [D] F(n)=F(n-1)+n+18. 若需要在O(nlog2n)的时间内完成对n个元素的排序，且要求排序是稳定的,则可选择的排序⽅法是_______。
( )[A] 快速排序[B] 堆排序[C] 归并排序[D] 直接插⼊排序9．在对n个元素的序列进⾏排序时,堆排序所需要的附加存储空间是__。
( )[A] O(1) [B] O(log2n) [C] O(n) [D] O(n log2n)10．假定有K个关键字互为同义词，若⽤线性探查法把这K个关键字存⼊散列表中，则总的探查次数⾄少为______。
数据结构上机实验题
当涉及数据结构的上机实验题时，通常会涉及编程和算法的实践。
以下是一些可能的
上机实验题目：
1. 实现一个栈（Stack）数据结构，并编写基本的操作（入栈、出栈、获取栈顶元素等）。
2. 实现一个队列（Queue）数据结构，并编写基本的操作（入队、出队等）。
3. 实现一个链表（Linked List）数据结构，并编写插入、删除、查找等操作。
4. 实现一个二叉树（Binary Tree）数据结构，并编写遍历算法（前序、中序、后序遍历）。
5. 实现一个图（Graph）数据结构，并编写基本的图算法（深度优先搜索、广度优先搜索）。
6. 实现一个哈希表（Hash Table）数据结构，并编写插入、删除、查找等操作。
这些实验题目可以帮助学生加深对数据结构的理解，并通过编程实践来掌握数据结构
的基本操作和算法。
同时，这些实验也有助于提高学生的编程能力和解决问题的能力。
数据结构上机例题及答案
习题二⒉１描述以下四个概念的区别：头指针变量，头指针，头结点，首结点（第一个结点）。
解：头指针变量和头指针是指向链表中第一个结点（头结点或首结点）的指针；在首结点之前附设一个结点称为头结点；首结点是指链表中存储线性表中第一个数据元素的结点。
若单链表中附设头结点，则不管线性表是否为空，头指针均不为空，否则表示空表的链表的头指针为空。
2.2简述线性表的两种存储结构有哪些主要优缺点及各自使用的场合。
解：顺序存储是按索引直接存储数据元素，方便灵活，效率高，但插入、删除操作将引起元素移动，降低了效率；而链式存储的元素存储采用动态分配，利用率高，但须增设表示结点之间有序关系的指针域，存取数据元素不如顺序存储方便，但结点的插入和删除十分简单。
顺序存储适用于线性表中元素数量基本稳定，且很少进行插入和删除，但要求以最快的速度存取线性表中的元素的情况；而链式存储适用于频繁进行元素动态插入或删除操作的场合。
2.3 在头结点为h的单链表中，把值为b的结点s插入到值为a的结点之前，若不存在a，就把结点s插入到表尾。
Void insert(Lnode *h,int a,int b){Lnode *p,*q,*s;s=(Lnode*)malloc(sizeof(Lnode));s->data=b;p=h->next;while(p->data!=a&&p->next!=NULL){q=p;p=p->next;}if (p->data==a){q->next=s;s->next=p;}else{p->next=s;s->next=NULL;}}2.4 设计一个算法将一个带头结点的单链表A分解成两个带头结点的单链表A和B，使A中含有原链表中序号为奇数的元素，而B中含有原链表中序号为偶数的元素，并且保持元素原有的相对顺序。
Lnode *cf(Lnode *ha){Lnode *p,*q,*s,*hb;int t;p=ha->next;q=ha;t=0;hb=(Lnode*)malloc(sizeof(Lnode));s=hb;while(p->next!=NULL){if (t==0){q=p;p=p->next;t=1;}else{q->next=p->next;p->next=s->next; s->next=p; s=p;p=p->next; t=0;}}s->next=NULL;return (hb);}2.5设线性表中的数据元素是按值非递减有序排列的，试以不同的存储结构，编写一算法，将x插入到线性表的适当位置上，以保持线性表的有序性。
数据结构上机考核试题及答案
1、顺序表的插入与删除#define ListSize 10#define n 8#define Error printftypedef int DataType;typedef struct{DataType data[ListSize];int length;}seqlist;void deletelist(seqlist *L);void insertlist(seqlist *L);main(){seqlist *L=0;int i;char c;printf("请按递减顺序输入%d个整数:\n",n);for(i=0;i<n;i++)scanf("%d",&L->data[i]);L->length=n;printf("\n请选择:\n");printf("A----------------------插入------------------\n");printf("B----------------------删除------------------\n");printf("C----------------------退出------------------\n");scanf("\n%c",&c);while(c!='c'&&c!='C'){if(c=='A'||c=='a')insertlist(L);else deletelist(L);printf("当前顺序表中的数据是:\n");for(i=0;i<L->length;i++)printf("%3d",L->data[i]);printf("\n请再选择:\n");printf("A----------------------插入------------------\n");printf("B----------------------删除------------------\n");printf("C----------------------退出------------------\n");scanf("\n%c",&c);}}void insertlist(seqlist *L){int x,i,j;printf("\n请输入要插入的整数:");scanf("\n%d",&x);printf("\n在下面序列中插入%d\n",x);for(i=0;i<L->length;i++)printf("%3d",L->data[i]);i=0;while(i<L->length&&x<L->data[i])i++;if(i<0||i>L->length+1)Error("\n插入位置错误!\n");else if(L->length>=ListSize)Error("\n表溢出,无法插入!"); else if(x==L->data[i])printf("\n重复插入,不允许!\n");/*=========空白处1===========*/L->data[j+1]=l->data[j];L->data[i]=x;L->length++;/*======================*/}}void deletelist(seqlist *L){int x,i,j,num;printf("\n请输入要删除的整数:");scanf("\n%d",&x);printf("\n在下面序列中删除%d\n",x);for(i=0;i<L->length;i++)printf("%3d",L->data[i]);i=0;num=0;while(i<L->length&&x<L->data[i])i++;if(x!=L->data[i])Error("\n没找到要删除的整数!\n");else{num++;while(L->data[i+1]==x&&i<L->length-1){i++;num++;}printf("\n删除原表中从第%d个位置以后的%d个数据%d\n",i-num+1,num,x); for(j=i+1;j<=L->length-1;j++)/*=====请在下面填入相应的语句======*/L->data[j-num]=L->data[j];L->length=L->length-num;/*=====================*/}}2\ 单链表的插入与删除*/#include <stdio.h>#include <stdlib.h>#include <string.h>#define Error printf#define n 5typedef struct node{int data;struct node *next;}ListNode;typedef ListNode * LinkList;LinkList Createlinklist(void);void Insertlinklist(LinkList head);void Deletelinklist(LinkList head);void Outputlinklist(LinkList head);main(){LinkList head;char c;head=Createlinklist();printf("请选择:\n");printf("A--------------插入-----------------\n");printf("B--------------删除-----------------\n");while(c!='c'&&c!='C'){if(c=='A'||c=='a')Insertlinklist(head);else Deletelinklist(head);Outputlinklist(head);printf("\n请再选择:\n");printf("A--------------插入-----------------\n"); printf("B--------------删除-----------------\n"); printf("C--------------退出-----------------\n"); scanf("\n%c",&c);}}/*****************************/LinkList Createlinklist(){int x;LinkList head,s,r;head=(ListNode*)malloc(sizeof(ListNode));r=head;r->next=NULL;printf("请按递减顺序输入整数(输0 结束):\n"); scanf("%d",&x);while (x!=0){s=(ListNode*)malloc(sizeof(ListNode));s->data=x;s->next=r->next;r->next=s;r=s;scanf("\n%d",&x);}return head;}void Insertlinklist(LinkList head){int x;ListNode *p,*s;int i,j;printf("请输入要插入的整数:");scanf("%d",&x);p=head;j=0;while(p->next&&x<p->next->data){j++;p=p->next;}if(x==p->next->data)Error("重复插入,不允许!\n");else{s=(ListNode *)malloc(sizeof(ListNode));/*=====请在下面填入相应的语句===*/S->data=x;P->next=S;/*====================*/ }}void Deletelinklist(LinkList head){int x;ListNode *p,*r;int i,j;printf("请输入要删除的整数:");scanf("%d",&x);p=head;r=head->next;while(r&&x<r->data){ p=r;r=r->next;}if(r==NULL||x!=r->data)Error("没找到要删除的整数.\n");else{/*==========空白处2=========*/p->next=r->next;free(r);/*====================*/}}void Outputlinklist(LinkList head){ListNode *p;p=head->next;printf("当前链表中数据为:\n");while(p){printf("%6d",p->data);p=p->next;}}/*====数据结构上机考核试题3======*//* 栈的操作#define StackSize 10 #define Error printftypedef int DataType;typedef struct{DataType data[StackSize];int top;}SeqStack;void InitStack(SeqStack *s){s->top=0; }int StackEmpty(SeqStack *S){if (S->top==0)return 1;else return 0;}int StackFull(SeqStack *S){return S->top==StackSize;}void Push(SeqStack *S,DataType x){if(StackFull(S))Error("栈溢出!");/*==========空白处1============*/Else S->data[++(S->top)]=x;/*=====================*/}DataType Pop(SeqStack *S){If(StackEmpty(S))Error(“Stack underflow”);Else return S->data[--(S->top)];/*=========*/}void conversion(int N,int B);main(){int N,B;char ch;printf("进行数值转换请输入Y,退出请输入N:"); scanf("\n%c",&ch);while (ch=='Y'||ch=='y'){printf("请输入需要转换的十进制数:");scanf("%d",&N);printf("\n请输入想要转换的进制数(2,8or16):"); scanf("%d",&B);conversion(N,B);printf("继续转换请输入Y,退出请输入N:");scanf("\n%c",&ch); }}void conversion(int N,int B){ DataType i;SeqStack *S;InitStack(S);while(N){Push(S,N%B); N=N/B; }printf("转换的结果为:");while(!StackEmpty(S)){i=Pop(S);switch(i){case 10:printf("%c",'a');break;case 11:printf("%c",'b');break;case 12:printf("%c",'c');break;case 13:printf("%c",'d');break;case 14:printf("%c",'e');break;case 15:printf("%c",'f');break;default:printf("%d",i); }}printf("\n"); }/*==========数据结构上机考核试题4======*/ /* 队列的操作*/#include <stdio.h>#define QueueSize 100#define Error printftypedef char DataType;typedef struct{int front;int rear;int count;DataType data[QueueSize];}CirQueue;void InitQueue(CirQueue *Q){ Q->front=Q->rear=0;int QueueEmpty(CirQueue *Q){ return Q->count==0; }int QueueFull(CirQueue *Q){ return Q->count==QueueSize; }void EnQueue(CirQueue *Q,DataType x){ if(QueueFull(Q))Error("队列溢出!");e lse{ /*==========空白处1===========*/ Q->count++;Q->data[Q->rear]=x;Q->rear=(Q->rear+1)%QueueSize;/*=================*/ }} DataType DeQueue(CirQueue *Q) {DataType temp;if(QueueEmpty(Q))Error("队列下溢!");else{temp=Q->data[Q->front];/*============空白处2===========*/ Q->count--;Q->front=(q->front+1)%QueueSize;/*==============*/return temp;}}void Inputch(CirQueue *Q);void Outputch(CirQueue *Q);main(){ CirQueue *Q=0;char ch;printf("\n 继续进行请按Y,退出请按N:"); scanf("\n%c",&ch);while(ch=='Y'||ch=='y'){ InitQueue(Q);Inputch(Q);Outputch(Q);printf("\n 继续进行请按Y,退出请按N:"); scanf("\n%c",&ch); }}void Inputch(CirQueue *Q){ char ch;printf("\n 请输入字符串并以$为结束符:"); scanf("%c",&ch);while(ch!='$'){ EnQueue(Q,ch);scanf("%c",&ch); }}void Outputch(CirQueue *Q){ char ch;printf("你输入的字符串是:");while(!QueueEmpty(Q)){ch=DeQueue(Q);printf("%c",ch); }printf("\n"); }/*========数据结构上机考核试题5=====*/ /* 二叉树的遍历*/DataType data;struct node *lchild,*rchild;}BinTNode;typedef BinTNode *BinTree;int count;void CreateBinTree(BinTree *T);void Levelorder(BinTree T);main(){BinTree T;char ch1,ch2;printf("\n请选择:\n");ch1='y';while(ch1=='y'||ch1=='Y'){printf("\nA------------------二叉树建立-------------");printf("\nB------------------层次遍历---------------");printf("\nC------------------退出-------------------\n");scanf("\n%c",&ch2);switch(ch2){case 'a':case 'A':printf("请按先序输入建立二叉树存储的结点序列:\n"); CreateBinTree(&T);break;case 'b':case 'B':printf("该二叉树的层次遍历序列为:\n");Levelorder(T);break;case 'c':case 'C':ch1='n';break;default:ch1='n'; }}}void CreateBinTree(BinTree *T){char ch;scanf("\n%c",&ch);if(ch=='0') *T=NULL;else {*T=(BinTNode*)malloc(sizeof(BinTNode));(*T)->data=ch;CreateBinTree(&(*T)->lchild);CreateBinTree(&(*T)->rchild); }}void Levelorder(BinTree T){int i,j;BinTNode *q[20],*p;p=T;if(p!=NULL){i=1;q[i]=p;j=2;}while(i!=j){p=q[i];printf("%3c",p->data);/*==========空白处1==============*/if(p->lchild!=NULL){q[j]=p->lchild; j++;}if(p->rchild!=NULL){q[j]=p->rchild; j++;}i++;/*===========*/}}/*======数据结构上机考核试题6========*//* 求二叉树叶子结点个数*/DataType data;struct node *lchild,*rchild;}BinTNode;typedef BinTNode *BinTree;int count;void CreateBinTree(BinTree *T);void Leafnum(BinTree T);main(){BinTree T;char ch1,ch2;printf("\n请选择:\n");ch1='y';while(ch1=='y'||ch1=='Y'){printf("\nA------------------二叉树建立-------------");printf("\nB------------------求叶子结点个数---------");printf("\nC------------------退出-------------------\n");scanf("\n%c",&ch2);switch(ch2){case 'a':case 'A':printf("请按先序输入二叉树存储的结点序列:\n"); CreateBinTree(&T);break;case 'b':case 'B':count=0;Leafnum(T);printf("该二叉树有%d个叶子.\n",count);break;case 'c':case 'C':ch1='n';break;default:ch1='n';}}}void CreateBinTree(BinTree *T){ char ch;scanf("\n%c",&ch);if(ch=='0') *T=NULL;else {*T=(BinTNode*)malloc(sizeof(BinTNode));(*T)->data=ch;CreateBinTree(&(*T)->lchild);CreateBinTree(&(*T)->rchild); }}void Leafnum(BinTree T){ if(T){if(T->lchild==NULL&&T->rchild==NULL)/*=============空白处1==============*/ count++;Leafnum(T->lchild);Leafnum(T->rchild);/*==================*/}}/*========数据结构上机考核试题7======*//* 二分查找*/#include <stdio.h>#define n 10main(){int R[n],i,k,low,mid,high,m;char ch;printf("请按递增顺序输入10个整数:\n",n);for(i=0;i<n;i++)scanf("%d",&R[i]);printf("需要查找请输入Y,否则输入N:");scanf("\n%c",&ch);while(ch=='y'||ch=='Y'){printf("请输入要查找的整数:\n");scanf("\n%d",&k);low=0;high=n-1;m=0;while(low<=high){ /*========空白处1===========*//*=======请在下面填入相应的语句========*/mid=(low+high)/2;m++;if(R[mid]>k) high=mid-1;else if(R[mid]<k) low=mid+1;else break;/*=============*/ }if(low>high){printf("\n没找到!\n");printf("共进行了%d次比较.\n",m);if(R[mid]<k)mid++;printf("可将此数插入到第%d的位置上.\n",mid+1);}else {printf("\n要找的数据%d在第%d的位置上.\n",k,mid+1); printf("共进行了%d此比较.\n",m); }printf("\n继续查找请输入Y,否则输入N:\n");scanf("\n%c",&ch); }}/*=====数据结构上机考核试题8========*//* 直接插入排序*/#define NULL 0#define n 10#define Error printf#define FLASE 0#define TRUE 1#include <math.h>typedef int KeyType;typedef char InfoType;typedef struct{KeyType key;InfoType otherinfo;}RecType;typedef RecType Seqlist[n+1];int m,num;void main(){Seqlist S;int i;char ch1,ch2;printf("请输入10个待排序整数:\n");for(i=1;i<=n;i++)scanf("%d",&S[i].key);ch1='y';while(ch1=='y'||ch1=='Y'){printf("******************\n");printf("请选择:(0-2)\n");printf("1-----更新待排数据-------------------\n");printf("2--------直接插入排序----------------\n");printf("0-----退出------------------------\n");scanf("\n%c",&ch2);switch(ch2){case '1':printf("请输入10个更新数据(整数):\n");for(i=1;i<=n;i++)scanf("%d",&S[i].key);break;case '2':printf("请输入要输出第几趟结果:");scanf("\n%d",&m);for(i=1;i<=n;i++)R[i].key=S[i].key;Insertsort();break;case '0':ch1='n';break;default:ch1='n';}}}void Insertsort(){ int i,j,k;for(i=2;i<=n;i++){ if(R[i].key<R[i-1].key){ /*=========空白处1===========*/R[0]=R[i]; j=j-1;Do{R[j+1]=R[j]; j--; }/*==================*/while(R[0].key<R[j].key);R[j+1]=R[0]; }if(i-1==m){ printf("第%d趟结果是:",m);for(k=1;k<=n;k++)printf("%5d",R[k].key);printf("\n");printf("请输入还要输出第几趟结果,不想输出时请输入0):");scanf("\n%d",&m); } }printf("最终排序结果是:");printf("\n");}/*=====数据结构上机考核试题9========*//* 快速排序*/#define NULL 0#define n 10#define Error printf#define FLASE 0#define TRUE 1#include <math.h>typedef int KeyType;typedef char InfoType;typedef struct{KeyType key;InfoType otherinfo;}RecType;typedef RecType Seqlist[n+1];int m,num;Seqlist R;void Quicksort(int low,int high);int Partition(int i,int j);void main(){Seqlist S;int i;char ch1,ch2;printf("请输入10个待排序整数:\n");for(i=1;i<=n;i++)scanf("%d",&S[i].key);ch1='y';while(ch1=='y'||ch1=='Y'){printf("***********************\n");printf("请选择:(0-2)\n");printf("1---------更新待排序数据-----------------\n"); printf("2---------快速排序-----------------------\n"); printf("0-------------退出---------------------------\n"); scanf("\n%c",&ch2);switch(ch2){case '1':printf("请输入10个更新数据:\n");for(i=1;i<=n;i++)scanf("%d",&S[i].key);break;case '2':printf("请输入要输出第几趟结果:"); scanf("\n%d",&m);for(i=1;i<=n;i++)R[i].key=S[i].key;num=0;Quicksort(1,n);break;case '0':ch1='n';break;default:ch1='n'; }}}int Partition(int i,int j){ RecType pivot=R[i];while(i<j){/*==========空白处1===========*/{while(i<j&&r[j].key>=pivot.key) j--;if(i<j) R[i++]=R[j];while(i<j&&R[i].key<=pivot.key) i++;if(i<j) R[j--]=R[i]; }/*=================*/}R[i]=pivot;return i;}/*****************************/void Quicksort(int low,int high){int pivotpos ,k;if(low<high){pivotpos=Partition(low,high);num++;if(m==num){printf("第%d趟结果是: ",m);for(k=1;k<=n;k++)printf("%5d",R[k].key);printf("\n");printf("请输入还要输出第几趟结果,不想输出时请输入0):"); scanf("\n%d",&m);}Quicksort(low,pivotpos-1);Quicksort(pivotpos+1,high);}if(low==1&&high==n){printf("最终排序结果是:");for(k=1;k<=n;k++)printf("%5d",R[k].key);printf("\n");}}/*=======数据结构上机考核试题10========*//* 堆排序*//*下面有2处空白,空白处都标有醒目标记, */#define NULL 0#define n 10#define Error printf#define FLASE 0#define TRUE 1#include <math.h>typedef int KeyType;typedef char InfoType;typedef struct{KeyType key;InfoType otherinfo;}RecType;typedef RecType Seqlist[n+1];int m,num;Seqlist R;void Heapsort();void main(){Seqlist S;int i;char ch1,ch2;printf("请输入10个待排序整数:\n");for(i=1;i<=n;i++)scanf("%d",&S[i].key);ch1='y';while(ch1=='y'||ch1=='Y'){printf("********************************\n"); printf("请选择:(0-2)\n");printf("1----------更新待排序数据-----------\n"); printf("2---------堆排序-----------------------\n"); printf("0----------退出----------------------\n"); scanf("\n%c",&ch2);switch(ch2){case '1':printf("请输入10个更新数据:\n");for(i=1;i<=n;i++)scanf("%d",&S[i].key);break;case '2':printf("请输入要输出第几趟结果:"); scanf("\n%d",&m);for(i=1;i<=n;i++)R[i].key=S[i].key;Heapsort();break;case '0':ch1='n';break;default:ch1='n';}}}/********************************/void Heapify(int low,int high){int large;RecType temp=R[low];for(large=2*low;large<=high;large*=2){/*==========空白处1=========*//*=====请在下面填入相应的语句=====*/If(large<high&&R[large].key<R[large+1].key) large++;/*=================*/if(temp.key>=R[large].key)break;R[low]=R[large];low=large;}R[low]=temp;}/***********************/void BuildHeap(){int i;/*==========空白处2===========*//*===请在下面填入相应的建堆操作语句==*/for(i=n/2; i>0; i--)Heapify(i,n) ;/*================*/}/****************************/void Heapsort(){int i,k;BuildHeap();for(i=n;i>1;i--){R[0]=R[1];R[1]=R[i];R[i]=R[0];if(i==(n-m+1)){printf("第%d趟结果是:\n",m);for(k=1;k<=n;k++)printf("%5d",R[k].key);printf("\n");printf("请输入还想输出第几趟结果,不想输出时请输入0):"); scanf("\n%d",&m);}Heapify(1,i-1);}printf("最终排序结果是:\n");for(k=1;k<=n;k++)printf("%5d",R[k].key);printf("\n"); }1. 顺序表的插入与删除/*========空白处1========*/L->data[j+1]=l->data[j];L->data[i]=x;L->length++;/*====＝=空白处2===＝===*/L->data[j-num]=L->data[j];L->length=L->length-num;2．单链表的插入与删除/*=====空白处1==＝=*/S->data=x;S->next=P->next;P->next=S;/*====空白处2=====*/p->next=r->next;free(r);3. 栈的操作/*=======空白处1========*/Else S->data[++(S->top)]=x;/*=======空白处2========*/If(StackEmpty(S))Error(“Stack underflow”);Else return S->data[--(S->top)];4.队列的操作/*========空白处1========*/Q->count++;Q->data[Q->rear]=x;Q->rear=(Q->rear+1)%QueueSize;/*========空白处2========*/Q->count--;Q->front=(q->front+1)%QueueSize;5. 二叉树的遍历/*========空白处1========*/if(p->lchild!=NULL){q[j]=p->lchild; j++;} if(p->rchild!=NULL){q[j]=p->rchild; j++;} i++;6. 求二叉树叶子结点个数/*=======空白处1=======*/count++;Leafnum(T->lchild);Leafnum(T->rchild);7. 二分查找/*=======空白处1=======*/mid=(low+high)/2;m++;if(R[mid]>k) high=mid-1;else if(R[mid]<k) low=mid+1;else break;8. 直接插入排序/*=========空白处1=========*/R[0]=R[i]; j=j-1;Do{R[j+1]=R[j]; j--; }9. 快速排序/*=========空白处1========*/{while(i<j&&r[j].key>=pivot.key) j--;if(i<j) R[i++]=R[j];while(i<j&&R[i].key<=pivot.key) i++;if(i<j) R[j--]=R[i]; }10. 堆排序=========空白处1=========*/If(large<high&&R[large].key<R[large+1].key) large++; ========空白处2=========*/for(i=n/2; i>0; i--)Heapify(i,n) ;。
数据结构上机考试(含答案)
《数据结构》上机练习题1、设有两个有序序列，利用归并排序将它们排成有序表，并输出。
2、设有一有序序列，从键盘输入一个数，判别是否在序列中，如果在输出“YSE”；否则，将它插入到序列中使它仍然有序，并输出排序后的序列。
3、设有一有序序列，从键盘输入一个数，判别是否在序列中，如果不在，则输出“NO”，否则，将它从序列中删除它，并输出删除后的序列。
4、从键盘输入一组任意数据，建立一个有序链表，并从链头开始输出该链，使输出结果是有序的。
5、从键盘输入一组任意数据，建立一个包含所有输入数据的单向循环链表，并从链表的任意开始，依次输出该链表中的所有结点。
10、设有一个链表，（自己建立，数据从键盘输入），再从键盘输入一个数，判别是否在链表中，如果不在，则输出“NO“，否则，将它从链表中删除，并输出删除后的链表。
11、设有一个链表，（自己建立，数据从键盘输入），再从键盘输入一个数，判别是否在链表中，如果在输出“YSE”，否则，将它从插入到链头，并输出插入后的链表。
12、设有一个链表，（自己建立，数据从键盘输入），再从键盘输入一个数，判别是否在链表中，如果在输出“YSE”，否则，将它从插入到链尾，并输出插入后的链表。
13、编写栈的压栈push、弹栈pop函数，从键盘输入一组数据，逐个元素压入堆栈，然后再逐个从栈中弹出它们并输出。
14、编写栈的压栈push、弹栈pop函数，用它判别（）的匹配问题。
15、按类似先序遍历结果输入一序列，建立一棵二叉树（算法6、4），输出二叉树中序遍历的结果。
16、按类似先序遍历结果输入一序列，建立一棵二叉树（算法6、4），输出二叉树先序遍历的结果。
17、按类似先序遍历结果输入一序列，建立一棵二叉树（算法6、4），输出二叉树后序遍历的结果。
18、按类似先序遍历结果输入一序列，建立一棵二叉树（算法6、4），输出二叉树的总结点数。
19、按类似先序遍历结果输入一序列，建立一棵二叉树（算法6、4），输出二叉树叶子结点数。
数据结构上机实验题
思考与提高：
1.如果按由表尾至表头的次序输入数据元素，应如何建立顺序表。
{
Datatypestack[MAXNUM];
int top;
}SqStack;
/*初始化顺序栈函数*/
void InitStack(SqStack *p)
{q=(SqStack*)malloc(sizeof(SqStack) /*申请空间*/}
/*入栈函数*/
void Push(SqStack *p,Datatypex)
实现提示：
1.由于C语言的数组类型也有随机存取的特点，一维数组的机内表示就是顺序结构。因此，可用C语言的一维数组实现线性表的顺序存储。
在此，我们利用C语言的结构体类型定义顺序表：
#define MAXSIZE 1024
typedef int elemtype; /*线性表中存放整型元素*/
typedef struct
实验一线性表
实验目的：
1.熟悉C语言的上机环境，进一步掌握C语言的结构特点。
2.掌握线性表的顺序存储结构的定义及C语言实现。
3.掌握线性表的链式存储结构——单链表的定义及C语言实现。
4.掌握线性表在顺序存储结构即顺序表中的各种基本操作。
5.掌握线性表在链式存储结构——单链表中的各种基本操作。
实验内容：
printf("输入源点v1 : ");
scanf("%d",&v1); /*输入源点V1 */
数据结构上机考试试题(C++语言版)
数据结构上机考试试题（C++语言版）考试要求：本次考试共列考核试题4大题，考生可以在所列4个考核试题中任选3个小题（即可能只属于2个大题），作为上机考核试题。
考核原则：所选题目在上机编程调试通过后即为考核通过。
监考教师依据学生编程及调试通过与否情况给予考核成绩。
考核成绩评分标准：所选3个题目全部编写出程序并调试通过：优所选3个题目全部编写出程序，但只有2个上机调试通过：良所选3个题目全部编写出程序，但只有1个上机调试通过：及格所选3个题目全部编写出程序但都没有上机调试通过，或没有编写出全部程序：不及格。
考核时间：2小时。
考核试题：1、建立一个顺序方式存储的线性表，向表中输入若干元素后进行以下操作：（1）向线性表的表头、表尾或合适位置插入元素（2）对线性表按升序或降序输出2、建立一个动态链接方式存储的线性表，向表中输入若干元素后进行以下操作：（1）从单链表中查找指定元素（2）返回单链表中指定序号的结点值3、建立一个动态链接结构存储的二叉树，向这棵二叉树进行以下操作：（1）按任中序遍历次序输出二叉树中的所有结点（2）求二叉树的叶子数4、编写一个对整型数组A[n+1]中的A[1]至A[n]元素进行选择排序的算法，使得首先从待排序区间中选择出一个最大值并同最后一个元素交换，再从待排序区间中选择出一个最小值并同最第一个元素交换，反复进行直到待排序区间中元素的个数不超过1为止。
#include<iomanip.h>#include<stdlib.h>#include"linearlist1.h"//初始化线性表void InitList(LinearList& L, int ms){L.list=new ElemType[ms];if(!L.list) {cerr<<"Memory allocation failure!"<<endl;exit(1);}L.size=0;L.MaxSize=ms;}//清空线性表void ClearList(LinearList& L){L.size=0;}//求线性表长度int ListSize(LinearList& L){return L.size;}//检查线性表是否为空bool ListEmpty(LinearList& L){return L.size==0;}//检查线性表是否为满bool ListFull(LinearList& L){return L.size==L.MaxSize;}//遍历线性表void TraverList(LinearList& L){for(int i=0; i<L.size; i++) cout<<L.list[i]<<' ';cout<<endl;}//从线性表中查找元素bool FindList(LinearList& L, ElemType& item) {for(int i=0; i<L.size; i++)if(L.list[i]==item) {item=L.list[i];return true;}return false;}//更新线性表中的给定元素bool UpdateList(LinearList& L, const ElemType& item){for(int i=0; i<L.size; i++)if(L.list[i]==item) {L.list[i]=item;return true;}return false;}//向线性表的表头、表尾或合适位置插入元素bool InsertList(LinearList& L, const ElemType& item, int mark) {if(ListFull(L)) return false;if(mark>0) {for(int i=L.size-1; i>=0; i--)L.list[i+1]=L.list[i];L.list[0]=item;}else if(mark<0) L.list[L.size]=item;else {for(int i=0; i<L.size; i++)if(item<L.list[i]) break;for(int j=L.size-1; j>=i; j--)L.list[j+1]=L.list[j];L.list[i]=item;}L.size++;return true;}//从线性表中删除表头、表尾或等于给定值的元素bool DeleteList(LinearList& L, ElemType& item, int mark){if(ListEmpty(L)) return false;if(mark>0) {item=L.list[0];for(int i=1; i<L.size; i++)L.list[i-1]=L.list[i];}else if(mark<0) item=L.list[L.size-1];else { for(int i=0; i<L.size; i++)if(L.list[i]==item) break;if(i>=L.size)return false;else item=L.list[i];for(int j=i+1; j<L.size; j++)L.list[j-1]=L.list[j];}L.size--;return true;}//对线性表按升序或降序输出void OrderOutputList(LinearList& L, int mark){int* b=new int[L.size];int i,k;for(i=0; i<L.size; i++) b[i]=i;for(i=1; i<L.size; i++) {k=i-1;for(int j=i; j<L.size; j++) {if(mark==1 && L.list[b[j]]<L.list[b[k]]) k=j;if(mark!=1 && L.list[b[k]]<L.list[b[j]]) k=j;}if(k!=i-1) {int x=b[i-1]; b[i-1]=b[k]; b[k]=x;} }for(i=0; i<L.size; i++)cout<<L.list[b[i]]<<' ';cout<<endl;}#include<iomanip.h>const int ML=10;#include"linearlist1.h"//主文件listmain1.cppvoid main(){LinearList a;InitList(a,ML);int i;ElemType x;//依次向线性表a表尾插入5个整数元素cout<<"从键盘输入5个整数:";for(i=0; i<5; i++) {cin>>x;InsertList(a,x,-1);}//依次向线性表a表头插入2个整数元素cout<<"从键盘输入2个整数:";cin>>x; InsertList(a,x,1);cin>>x; InsertList(a,x,1);//按不同次序遍历输出线性表aTraverList(a);OrderOutputList(a,1);OrderOutputList(a,0);//把线性表a中的所有元素依次有序插入到一个新线性表b中"LinearList b;InitList(b,ML);for(i=0; i<a.size; i++)InsertList(b, a.list[i], 0);//输出线性表bTraverList(b);//从线性表a中分别删除表头、表尾、给定值元素if(DeleteList(a,x,1)) cout<<"Delete success!"<<endl;else cout<<"Delete fail!"<<endl;if(DeleteList(a,x,-1)) cout<<"Delete success!"<<endl;else cout<<"Delete fail!"<<endl;cout<<"从键盘上输入一个待删除的整数:";cin>>x;if(DeleteList(a,x,0)) cout<<"Delete success!"<<endl;else cout<<"Delete fail!"<<endl;//输出线性表aTraverList(a);}。
数据结构考试题及答案
数据结构考试题及答案数据结构考试题及答案一、单项选择题1.关系数据模型的三个组成部分中，不包括( C )A.完整性规则B.数据结构C.恢复D.数据操作2. 五种基本关系代数运算是 ( A )A. ∪，-，×，π和σB. ∪，-，∞，π和σC. ∪，∩，×，π和σD. ∪，∩，∞，π和σ3.公司中有多个部门和多名职员，每个职员只能属于一个部门，一个部门可以有多名职员，从部门到职员的联系类型是( D )A.多对多B.一对一C.多对一D.一对多4.关系代数表达式的优化策略中，首先要做的是( B )A.对文件进行预处理B.尽早执行选择运算C.执行笛卡儿积运算D.投影运算5.下列四项中，不属于关系数据库特点的是( D )A.数据冗余小B.数据独立性高C.数据共享性好D.多用户访问6. 下列聚合函数中不忽略空值 (null) 的是【 C 】A. SUM (列名)B. MAX (列名)C. COUNT ( * )D. AVG (列名)7．SQL语言中，修改表结构的语句是( D )。
A、CREATEB、SELECTC、UPDATED、ALTER8.下列四项中说法不正确的是（ C ）共四页第二页A.数据库减少了数据冗余B.数据库中的数据可以共享C.数据库避免了一切数据的重复D.数据库具有较高的数据独立性9．在关系数据库系统中，为了简化用户的查询操作，而又不增加数据的.存储空间，常用的方法是创建( C )A．另一个表（table） B. 游标（cursor） C. 视图（view）D.索引（index）10. 如果事务T获得了数据项Q上的排它锁，则T对Q （ C ）A.只能读不能写B.只能写不能读C. 既可读又可写D. 不能读不能写二.填空题1.数据库系统一般由数据库, _________, _应用系统_________, 数据库管理员和用户构成。
2.数据库的存储结构改变了，由数据库管理员对_________映像作相应改变，可以使_模式_与应用程序保持不变，从而保证了数据的物理独立性。
十套数据结构试题及答案
数据构造试卷〔一〕一、单项选择题〔每题 2 分，共20分〕1.栈和队列的共同特点是( a )。
A.只允许在端点处插入和删除元素B.都是先进后出C.都是先进先出D.没有共同点2.用链接方式存储的队列，在进展插入运算时( d ).A. 仅修改头指针B. 头、尾指针都要修改C. 仅修改尾指针D.头、尾指针可能都要修改3.以下数据构造中哪一个是非线性构造？( d )A. 队列B. 栈C. 线性表D. 二叉树4.设有一个二维数组A[m][n]，假设A[0][0]存放位置在644(10)，A[2][2]存放位置在676(10)，每个元素占一个空间，问A[3][3](10)存放在什么位置？脚注(10)表示用10进制表示。
cA．688 B．678 C．692 D．6965.树最适合用来表示( c )。
A.有序数据元素B.无序数据元素C.元素之间具有分支层次关系的数据D.元素之间无联系的数据6.二叉树的第k层的结点数最多为( d ).A．2k-1 B.2K+1 C.2K-1 D. 2k-17.假设有18个元素的有序表存放在一维数组A[19]中，第一个元素放A[1]中，现进展二分查找，那么查找A［3］的比拟序列的下标依次为( c d)A. 1，2，3B. 9，5，2，3C. 9，5，3D. 9，4，2，38.对n个记录的文件进展快速排序，所需要的辅助存储空间大致为 cA. O〔1〕B. O〔n〕C. O〔1og2n〕D. O〔n2〕9.对于线性表〔7，34，55，25，64，46，20，10〕进展散列存储时，假设选用H〔K〕=K %9作为散列函数，那么散列地址为1的元素有〔 c d〕个，A．1 B．2 C．3 D．410.设有6个结点的无向图，该图至少应有( a )条边才能确保是一个连通图。
二、填空题〔每空1分，共26分〕1.通常从四个方面评价算法的质量：____时间正确性_____、____占用内存_易读性____、____复杂度__强壮性___和_____准确度_ 高效率___。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
注意事项1. 考试时间2小时，13：00-15：00 2. 题目4选2 3. 所有题目均使用标准输入和标准输出3. 只提交源程序，文件后缀名只能是.C或.CPP 4. 源文件大小不能超过10K，否则会被当作恶意提交而扣分5. 严格按照题目要求输出，去掉不需要的提示信息或调试信息6. 在程序中不要使用fflush(stdin)函数，否则会导致结果错误另外注意：本次是模拟测试，上机时间是4个小时，我们考试时间从14点开始到17点30分结束。
同学视自己的能力，能做几道做几道。
哈夫曼树
时间限制: 100 second 内存限制: 100 Kb
描述
构造哈夫曼树（最优二叉树）
输入
输入n个结点每个结点的权值
输出
构造哈夫曼树（是最优二叉树）得到每个结点的哈夫曼编码
输入样例
23
186 64 13 22 32 103 21 15 47 57 1 5 32 20 57 63 15 1 48 51 80 23 8
输出样例
1( 186):00
2( 64):1001
3( 13):101100
4( 22):110010
5( 32):11100
6( 103):011
7( 21):110001
8( 15):101101
9( 47):11010
10( 57):0101
11( 1):101111000
12( 5):10111101
13( 32):11101
14( 20):110000
15( 57):1010
16( 63):1000
17( 15):101110
18( 1):101111001
19( 48):11011
20( 51):0100
21( 80):1111
22( 23):110011
23( 8):1011111
提示
输入第一行是结点数23 第二行是这几个结点的权值输出格式为结点号（权值）：哈夫曼编码
///////////////////////////////////////
计算huffman树WPL
时间限制: 5 second 内存限制: 100 Kb
描述
假设用于通信的电文由ｎ（4
输入
仅一组数据，分为两行输入；第１行为ｎ的值，第２行为ｎ（0
输出
一个整数，表示所构造哈夫曼树的带权路径长度（输出整数后换行）。
输入样例
8
7 19 2 6 32 3 21 10
输出样例
261
提示
Huffman树可以使用数组存储
//////////////////////////////////
求最小生成树的代价
时间限制: 5 second 内存限制: 100 Kb
描述
求无向网的最小生成树的代价。
输入
仅一组数据，输入数据第一行为两个正整数n和m，分别表示顶点数和边数。
后面紧跟m 行数据，每行数据是一条边的信息，包括三个数字，分别表示该边的两个顶点和边上的权值。
输出
输出得到的最小生成树的代价。
输入样例
8 11
1 2 3
1 4 5
1 6 18
2 4 7
2 5 6
3 5 10
3 8 20
4 6 15
4 7 11
5 7 8
5 8 12
输出样例
59
提示
每次找到最小生成树的一条边时累加其权值即可得到最小生成树的代价
///////////////////////////
判断堆栈出栈序列是否有效
时间限制: 5 second 内存限制: 100 Kb
描述
如果以序列“1,2,3,4”作为一个栈（初始为空）的输入，那么可得到输出序列“1,2,3,4”或“4,3,2,1”或“2,3,1,4”等等，但是肯定得不到输出序列“4,1,2,3”或“3,1,2,4”等等。
请编写一个程序，判断能否通过一个栈得到给定的输出序列。
输入
有多组数据；输入的第一行为整数n（1
输出
对于每一组数据，输出一个yes或no（表示能否通过栈得到该序列）。
输入样例
2
6
3 4 2 1 5 6
4
3 1 2 4
输出样例
yes
no
提示
根据栈的后进先出特性进行判断
////////////////////////////
约瑟夫环
时间限制: 5 second 内存限制: 100 Kb
描述
编号为1,2,...,n的n个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。
现在给定一个随机数m>0，从编号为1的人开始，按顺时针方向1开始顺序报数，报到m时停止。
报m的人出圈，同时留下他的密码作为新的m值，从他在顺时针方向上的下一个人开始，重新从1开始报数，如此下去，直至所有的人全部出圈为止。
输入
仅有一组数据，输入数据第一行为两个正整数n和m，分别表示人的个数及初始随机数，第二行为n个整数，表示每个人持有的密码
输出
在一行输出n个整数表示依次出圈人的编号，整数之间用空格分隔
输入样例
7 5
3 8 1 22
4 9 15
输出样例
5 2
6
7 4 3 1
提示
使用不带头节点的单循环链表
/////////////////////
根据二叉树的先序和中序列得到后序序列
时间限制: 5 second 内存限制: 100 Kb
描述
二叉树的每个节点用一个字符表示，如果知道二叉树的先序序列和中序序列则可以构造出一颗二叉树，进而可以得到该二叉树的后序序列
输入
仅一组数据，第一行为该二叉树的先序序列，第二行为该二叉树的中序遍历序列。
输出
输出该二叉树的后序遍历序列
输入样例
ABDGCEFH
DGBAECHF
输出样例
GDBEHFCA
提示
使用递归算法，根据先序序列找到树根，然后在中序序列中找到左右子树。
此题不一定需要把树建立起来，可以在递归同时就得到后序序列。
///////////////////////////
求无向图连通子图
时间限制: 5 second 内存限制: 100 Kb
描述
求无向图连通子图个数
输入
仅一组数据，输入数据第一行为两个正整数n（1
输出
输出由两行构成，第一行输出该图中连通子图的个数。
第二行按照升序输出每个连通子图中顶点个数。
输入样例
9 8
1 2
1 3
2 4
3 4
5 7
5 6
6 7
8 9
输出样例
3
2 3 4
提示
图的连通性以吐得遍历为基础，因此本题需要在图的遍历算法基础上实现
////////////////////////////////////
根据给定的关键字构造小顶堆，输出堆的中序遍历序列
时间限制: 5 second 内存限制: 100 Kb
描述
给出一组关键字（数字），根据这些关键字构造一个小顶堆，然后输出该小顶堆所对应的二叉树的中序遍历序列。
输入
仅一组数据，输入数据第一行为1个正整数n，表示关键字个数。
第2行为n个整数表示n 个关键字。
输出
在一行上输出由这些关键字构成的小顶堆所对应的中序遍历序列。
输入样例
9
49 38 65 97 76 13 27 18 20
输出样例
97 20 38 18 76 13 65 27 49
提示
堆是一个完全二叉树，可以用数组存储。