数据结构实验答案1
数据结构习题及答案 (1)
![数据结构习题及答案 (1)](https://img.taocdn.com/s3/m/a29f9c8b16fc700aba68fc2a.png)
第八章查找一、判断题1.用二分查找法对一个顺序表进行查找,这个顺序表可以是按各键值排好序的,也可以是没有按键值排好序的。
()2.哈希表的查找不用进行关键字的比较。
()3.哈希表的定义函数H(key)=key%p(p<=m)这种方法是直接定址法。
()4.装填因子α的值越大,就越不容易发生冲突。
( )5.选择hash函数的标准为:随机性好、均匀性好和尽量避免冲突。
( )参考答案:1、×2、×3、×4、×5、√二、填空题1.顺序查找法的平均查找长度为__________,二分查找法的平均查找长度为________,分块查找法(以顺序查找确定块)的平均查找长度为__________,分块查找法(以二分查找确定块〉的平均查找长度为_________,哈希表查找法采用链接法处理冲突时的平均查找长度为_________。
(n+1)/2;((n+1)*log2(n+1))/n-1;(s2+2s+n)/2s;log2(n/s+1)+s/2;1+α2.在各种查找方法中,平均查找长度与结点个数n无关的查法方法是_________哈希表查找3.二分查找的存储结构仅限于_________,且是__________。
顺序;有序的4.在分块查找方法中,首先查找__________,然后再查找相应的___________。
索引;块5.长度为255的表,采用分块查找法,每块的最佳长度是____________。
156.在散列函数H(key)=key%p中,p应取_______________。
小于表长的最大素数7.假设在有序线性表A[1..20]上进行二分查找,则比较一次查找成功的结点数为_________,则比较二次查找成功的结点数为__________,则比较三次查找成功的结点数为_________,则比较四次查找成功的结点数为________,则比较五次查找成功的结点数为_________,平均查找长度为_________。
数据结构与实训课后答案全集
![数据结构与实训课后答案全集](https://img.taocdn.com/s3/m/190501ff0242a8956bece42a.png)
第1章习题答案1. 填空题(1)在计算机中的存储映像(是逻辑结构在计算机中的实现或存储表示)数据元素的表示元素之间关系的表示数据元素。
(2)已经实现是一个概念分离分离(3)时、空效率指人对算法阅读理解的难易程度对于非法的输入数据,算法能给出相应的响应,而不是产生不可预料的后果。
(4)软硬件环境问题规模的(5)最坏(6)O(n4)O(n2)(7)时间复杂度(8)n 2)1(nn+O(n2)2. 判断题(1)×(2)×(3)√(4)√(5)√(6)√(7)×(8)×(9)×(10)×3. 简答题(1)略(见教材第3页的1.2数据结构的基本概念)(2)(a)n-1,O(n)(b)n-1 , O(n)(c)11* n+1, O(n)(n为初始值100)(d)⎣⎦n, O(n)(e)n , O(n)第2章习题及答案1、填空题(1)address+m*i(2)顺序顺序顺序链式存储链式存储(3)亦相邻不一定(4)n-i+1(5)0≤i≤la的长度-1≤j≤lb的长度-1 0≤k≤lc的长度-1(6)2)1(nn+插入的位置,节点数n(顺序表长度n)(7)其前驱O(n) O(1)(8)其前驱O(n) O(1)(9)p→next=p→next →next(10)head→next==Null head==Null head→next==head head==Null (11)head→next=head→next→next head=head→next(12)x=p→prior→data; p→prior→data=p→next→data; p→next→data=x; (13)p==head→prior(或p→next==head)2.判断题(1)×(2)√(3)×(4)×(5)×(6)×(7)√(8)×(9)×(10)×3.简答题(1)(2)在带头结点的单链表上,查找指针p所指结点的前驱。
数据结构(C++)第一次作业参考答案
![数据结构(C++)第一次作业参考答案](https://img.taocdn.com/s3/m/1c2a4a6d804d2b160b4ec030.png)
数据结构第一次作业数据结构第一次作业一.单项选择题(20分)( )1.已知一算术表达式的后缀形式为ABC *+DE-/,则其中缀形式为 _________。
a、(A+B *C)/(D-E)b、A+B*C /D-Ec、(A+B*C)/D-Ed、A+B*C/(D-E)( )2.若某链表中最常用的操作是在最后一个结点之后插入一个结点和删除第一个结点,则采用________存储方式最节省运算时间(假设链表仅设有一个first指针)。
a. 单链表b. 带头结点的双循环链表c. 单循环链表d. 双链表( )3.设一个栈的输入序列为A,B,C,D,则所得到的输出序列不可能是_______。
a. A,B,C,Db. D,C,B,Ac. A,C,D,Bd. D,A,B,C( )4.若线性表最常用的操作是存取第i个元素及其直接前驱的值,则采用_____存储方式节省时间。
a.顺序表 b.双链表 c.单循环链表 d.单链表( )5.若长度为n的线性表采用顺序存储结构,在其第i个位置插入一个新元素的算法的时间复杂度为_______。
(1≤i≤n+1)a、O(0)b、O(1)c、O(n)d、O(n2)( )6.若指针L指向一带头结点的循环单链表的头结点,该表为空表的条件是_______为真值;a. !( L -> link );b. L == (L -> link) -> link;c. L -> link;d. L == L -> link;( )7.用数组A[0..N-1]存放一个循环队列,一元素出队时,其队头指针front的修改方法是________:a. front = (front + 1) mod N;b. front = (front - 2)mod N;c. front = front + 1;d. front = front – 2;( )8.若用Head()和Tail()分别表示取广义表的表头和表尾,广义表A=(1,2,(3,4),(5,(6,7))),则Head(Tail(Head(Tail(Tail(A))))) 。
数据结构实验报告-答案.doc
![数据结构实验报告-答案.doc](https://img.taocdn.com/s3/m/9789183e960590c69fc3762d.png)
数据结构实验报告-答案数据结构(C语言版)实验报告专业班级学号姓名实验1实验题目:单链表的插入和删除实验目的:了解和掌握线性表的逻辑结构和链式存储结构,掌握单链表的基本算法及相关的时间性能分析。
实验要求:建立一个数据域定义为字符串的单链表,在链表中不允许有重复的字符串;根据输入的字符串,先找到相应的结点,后删除之。
实验主要步骤:1、分析、理解给出的示例程序。
2、调试程序,并设计输入数据(如:bat,cat,eat,fat,hat,jat,lat,mat,#),测试程序的如下功能:不允许重复字符串的插入;根据输入的字符串,找到相应的结点并删除。
3、修改程序:(1)增加插入结点的功能。
(2)将建立链表的方法改为头插入法。
程序代码:#include“stdio.h“#include“string.h“#include“stdlib.h“#include“ctype. h“typedefstructnode//定义结点{chardata[10];//结点的数据域为字符串structnode*next;//结点的指针域}ListNode;typedefListNode*LinkList;//自定义LinkList单链表类型LinkListCreatListR1();//函数,用尾插入法建立带头结点的单链表LinkListCreatList(void);//函数,用头插入法建立带头结点的单链表ListNode*LocateNode();//函数,按值查找结点voidDeleteList();//函数,删除指定值的结点voidprintlist();//函数,打印链表中的所有值voidDeleteAll();//函数,删除所有结点,释放内存ListNode*AddNode();//修改程序:增加节点。
用头插法,返回头指针//==========主函数==============voidmain(){charch[10],num[5];LinkListhead;head=C reatList();//用头插入法建立单链表,返回头指针printlist(head);//遍历链表输出其值printf(“Deletenode(y/n):“);//输入“y“或“n“去选择是否删除结点scanf(“%s“,num);if(strcmp(num,“y“)==0||strcmp(num,“Y“)==0){printf(“PleaseinputDelete_data:“);scanf(“%s“,ch);//输入要删除的字符串DeleteList(head,ch);printlist(head);}printf(“Addnode?(y/n):“);//输入“y“或“n“去选择是否增加结点scanf(“%s“,num);if(strcmp(num,“y“)==0||strcmp(num,“Y“)==0){head=A ddNode(head);}printlist(head);DeleteAll(head);//删除所有结点,释放内存}//==========用尾插入法建立带头结点的单链表===========LinkListCreatListR1(void){charch[10];LinkListhead=(Li nkList)malloc(sizeof(ListNode));//生成头结点ListNode*s,*r,*pp;r=head;r->next=NULL;printf(“Input#toend“);//输入“#“代表输入结束printf(“\nPleaseinputN ode_data:“);scanf(“%s“,ch);//输入各结点的字符串while(strcmp(ch,“#“)!=0){pp=LocateNode(head,ch);//按值查找结点,返回结点指针if(pp==NULL){//没有重复的字符串,插入到链表中s=(ListNode*)malloc(sizeof(ListNode));strcpy(s->data,ch);r->next=s;r=s; r->next=NULL;}printf(“Input#toend“);printf(“PleaseinputNode_data:“);scanf(“%s“,ch);}returnhead;//返回头指针}//==========用头插入法建立带头结点的单链表===========LinkListCreatList(void){charch[100];LinkListhead,p;head =(LinkList)malloc(sizeof(ListNode));head->next=NULL;while(1){printf(“Input#toend“);printf(“PleaseinputNode_data:“);scanf(“%s“,ch);if(strcmp (ch,“#“)){if(LocateNode(head,ch)==NULL){strcpy(head->data,ch);p=(Li nkList)malloc(sizeof(ListNode));p->next=head;head=p;}}elsebreak;}retu rnhead;}//==========按值查找结点,找到则返回该结点的位置,否则返回NULL==========ListNode*LocateNode(LinkListhead,char*key){List Node*p=head->next;//从开始结点比较while(p!=NULL//扫描下一个结点returnp;//若p=NULL则查找失败,否则p指向找到的值为key的结点}//==========修改程序:增加节点=======ListNode*AddNode(LinkListhead){charch[10];ListNode*s,*pp ;printf(“\nPleaseinputaNewNode_data:“);scanf(“%s“,ch);//输入各结点的字符串pp=LocateNode(head,ch);//按值查找结点,返回结点指针printf(“ok2\n“);if(pp==NULL){//没有重复的字符串,插入到链表中s=(ListNode*)malloc(sizeof(ListNode));strcpy(s->data,ch);printf(“ok3\n“);s->next=head->next;head->next=s;}returnhead;}//==========删除带头结点的单链表中的指定结点=======voidDeleteList(LinkListhead,char*key){ListNode*p,*r,*q=hea d;p=LocateNode(head,key);//按key值查找结点的if(p==NULL){//若没有找到结点,退出printf(“positionerror”);exit(0);}while(q->next!=p)//p 为要删除的结点,q为p的前结点q=q->next;r=q->next;q->next=r->next;free(r);//释放结点}//===========打印链表=======voidprintlist(LinkListhead){ListNode*p=head->next;//从开始结点打印while(p){printf(“%s,“,p->data);p=p->next;}printf(“\n“);}//==========删除所有结点,释放空间===========voidDeleteAll(LinkListhead){ListNode*p=head,*r;while( p->next){r=p->next;free(p);p=r;}free(p);}实验结果:Input#toendPleaseinputNode_data:batInput#toendPleaseinputNode_data: catInput#toendPleaseinputNode_data:eatInput#toendPleaseinputNode_da ta:fatInput#toendPleaseinputNode_data:hatInput#toendPleaseinputNode_ data:jatInput#toendPleaseinputNode_data:latInput#toendPleaseinputNode _data:matInput#toendPleaseinputNode_data:#mat,lat,jat,hat,fat,eat,cat,bat ,Deletenode(y/n):yPleaseinputDelete_data:hatmat,lat,jat,fat,eat,cat,bat,Ins ertnode(y/n):yPleaseinputInsert_data:putposition:5mat,lat,jat,fat,eat,put,c at,bat,请按任意键继续...示意图:latjathatfateatcatbatmatNULLheadlatjathatfateatcatbatmatheadlatjatfateat putcatbatmatheadNULLNULL心得体会:本次实验使我们对链表的实质了解更加明确了,对链表的一些基本操作也更加熟练了。
数据结构实验答案
![数据结构实验答案](https://img.taocdn.com/s3/m/24d9f319964bcf84b9d57b90.png)
# include
# define maxnum 20
typedef int DataType ;
typedef struct
{ DataType data[maxnum] ;
int length ;
}SeqList ;
int MergeQL(SeqList la , SeqList lb , SeqList *lc)
实验一 线性表的顺序存储实验
一,实验目的
1,掌握用Visual C++6.0上机调试顺序表的基本方法
2,掌握顺序表的基本操作,插入,删除,查找,以及有序顺序表的合并等算法的实现
二,实验内容
1,顺序表基本操作的实现
[问题描述] 当我们要在顺序表的第i个位置上插入一个元素时,必须先将顺序表中第i个元素之后的所有元素依次后移一个位置,以便腾空一个位置,再把新元素插入到该位置.若是欲删除第i个元素时,也必须把第i个元素之后的所有元素前移一个位置.
ListNode *s,*r; /*工作指针*/
r=head; /*尾指针初值也指向头结点*/
while((ch=getchar())!='\n')
{
s=(ListNode *)malloc(sizeof(ListNode));
s->data=ch;
r->next=s;
r=s;
}
(*L)->next=NULL;
}
int List_Length(ListNode *L )
{
int n=0;ListNode *p=L->next;
while(p!=NULL)
数据结构线性表答案 (1)
![数据结构线性表答案 (1)](https://img.taocdn.com/s3/m/e64648c0a21614791611284f.png)
第一章线性表2.1 描述以下三个概念的区别:头指针,头结点,首元结点(第一个元素结点)。
解:头指针是指向链表中第一个结点的指针。
首元结点是指链表中存储第一个数据元素的结点。
头结点是在首元结点之前附设的一个结点,该结点不存储数据元素,其指针域指向首元结点,其作用主要是为了方便对链表的操作。
它可以对空表、非空表以及首元结点的操作进行统一处理。
2.2 填空题。
解:(1) 在顺序表中插入或删除一个元素,需要平均移动表中一半元素,具体移动的元素个数与元素在表中的位置有关。
(2) 顺序表中逻辑上相邻的元素的物理位置必定紧邻。
单链表中逻辑上相邻的元素的物理位置不一定紧邻。
(3) 在单链表中,除了首元结点外,任一结点的存储位置由其前驱结点的链域的值指示。
(4) 在单链表中设置头结点的作用是插入和删除首元结点时不用进行特殊处理。
2.3 在什么情况下用顺序表比链表好?解:当线性表的数据元素在物理位置上是连续存储的时候,用顺序表比用链表好,其特点是可以进行随机存取。
2.4 对以下单链表分别执行下列各程序段,并画出结果示意图。
解:2.5 画出执行下列各行语句后各指针及链表的示意图。
L=(LinkList)malloc(sizeof(LNode)); P=L; for(i=1;i<=4;i++){P->next=(LinkList)malloc(sizeof(LNode)); P=P->next; P->data=i*2-1;}P->next=NULL;for(i=4;i>=1;i--) Ins_LinkList(L,i+1,i*2); for(i=1;i<=3;i++) Del_LinkList(L,i);解:2.6 已知L是无表头结点的单链表,且P结点既不是首元结点,也不是尾元结点,试从下列提供的答案中选择合适的语句序列。
a. 在P结点后插入S结点的语句序列是__________________。
数据结构习题参考答案
![数据结构习题参考答案](https://img.taocdn.com/s3/m/38ee0384fc0a79563c1ec5da50e2524de518d03c.png)
数据结构习题参考答案一、栈和队列1. 栈是一种具有后进先出(Last In First Out)特性的线性数据结构。
常用方法:- push(x): 将元素x压入栈顶;- pop(): 弹出栈顶元素;- top(): 返回栈顶元素;- isEmpty(): 判断栈是否为空;例题解答:(1)题目描述:使用栈实现队列的功能。
解答:使用两个栈,一个用于入队操作,一个用于出队操作。
入队操作:直接将元素压入入队栈中;出队操作:如果出队栈为空,则将入队栈的元素逐个弹出并压入出队栈,此时出队栈的栈顶元素即为要弹出的元素。
复杂度分析:入队操作的时间复杂度为O(1),出队操作的平均时间复杂度为O(1)。
(2)题目描述:判断括号序列是否合法,即括号是否完全匹配。
解答:使用栈来处理括号序列,遇到左括号则入栈,遇到右括号则与栈顶元素进行匹配,如果匹配成功则继续处理剩余字符,如果不匹配则判定为非法序列。
算法步骤:- 初始化一个空栈;- 从左到右遍历括号序列,对于每个字符执行以下操作:- 如果是左括号,则将其入栈;- 如果是右括号,则将其与栈顶元素进行匹配:- 如果栈为空,则判定为非法序列;- 如果栈顶元素与当前字符匹配,则将栈顶元素出栈,继续处理剩余字符;- 如果栈顶元素与当前字符不匹配,则判定为非法序列。
- 遍历结束后,如果栈为空,则括号序列合法;否则,括号序列非法。
复杂度分析:时间复杂度为O(n),其中n为括号序列的长度。
2. 队列是一种具有先进先出(First In First Out)特性的线性数据结构。
常用方法:- enqueue(x): 将元素x入队;- dequeue(): 出队并返回队首元素;- getFront(): 返回队首元素;- isEmpty(): 判断队列是否为空;例题解答:(1)题目描述:使用队列实现栈的功能。
解答:使用两个队列,一个用于入栈操作,一个用于出栈操作。
入栈操作:直接将元素入队入栈队列中;出栈操作:如果出栈队列为空,则将入栈队列的元素逐个出队并入队出栈队列,此时出栈队列的队首元素即为要出栈的元素。
数据结构课后习题答案1--7
![数据结构课后习题答案1--7](https://img.taocdn.com/s3/m/7eec891dabea998fcc22bcd126fff705cc175c3e.png)
数据结构课后习题答案1--7题目1:请你设计一个栈数据结构,使其具备以下功能:可以在O(1)的时间复杂度内获取栈的最小元素。
解答1:要实现在O(1)的时间复杂度内获取栈的最小元素,可以使用两个栈来实现。
一个栈用来保存原始数据,另一个栈用来保存当前栈的最小元素。
具体实现如下:1. 初始化两个栈:stack和min_stack,其中stack用于保存所有元素,min_stack用于保存当前栈中的最小元素。
2. 插入元素时,先将元素插入stack中,然后判断插入的元素是否比min_stack的栈顶元素小,如果是,则将元素也插入到min_stack中;如果不是,则将min_stack的栈顶元素再次插入到min_stack中。
3. 删除元素时,分别从stack和min_stack中弹出栈顶元素。
这样,min_stack的栈顶元素始终是stack中的最小元素。
题目2:请你设计一个队列数据结构,使其具备以下功能:可以在O(1)的时间复杂度内获取队列的最大元素。
解答2:要实现在O(1)的时间复杂度内获取队列的最大元素,可以使用两个队列来实现。
一个队列用来保存原始数据,另一个队列用来保存当前队列的最大元素。
具体实现如下:1. 初始化两个队列:queue和max_queue,其中queue用于保存所有元素,max_queue用于保存当前队列中的最大元素。
2. 插入元素时,先将元素插入queue中,然后判断插入的元素是否比max_queue的队尾元素大,如果是,则将元素也插入到max_queue的队尾;如果不是,则将max_queue中所有比插入元素小的元素都弹出,再将插入元素插入到max_queue的队尾。
3. 删除元素时,分别从queue和max_queue中弹出队头元素。
这样,max_queue的队头元素始终是queue中的最大元素。
题目3:请你设计一个栈数据结构,使其除了具有常规的入栈和出栈功能外,还具备以下功能:能够在O(1)的时间复杂度内获取栈中的最大元素。
数据结构第一章答案
![数据结构第一章答案](https://img.taocdn.com/s3/m/dd2c5583dc88d0d233d4b14e852458fb770b388f.png)
习题一1.1有下列几种用二元组表示的数据结构,试画出它们分别对应的图形表示(当出现多个关系时,对每个关系画出相应的结构图),并指出它们分别属于何种结构。
1.A=(K,R) 其中K={a1,a2,a3,…,a n}R={}2.B=(K,R),其中K={a,b,c,d,e,f,g,h}R={<a,b>,<b,c>,<c,d>,<d,e>,<e,f>,<f,g>,<g,h>}3.C=(K,R),其中K={a,b,c,d,e,f,g,h}R={<d,b>,<d,g>,<b,a>,<b,c>,<g,e>,<g,h>,<e,f>}4.D=(K,R),其中K={1,2,3,4,5,6}R={(1,2),(2,3),(2,4),(3,4),(3,5),(3,6),(4,5),(4,6)} 5.E=(K,R),其中K={48,25,64,57,82,36,75,43}R={r1,r2,r3}r1={<48,25>,<25,64>,<64,57>,<57,82>,<82,36>,<36,75>,<75,43>}r2={<48,25>,<48,64>,<64,57>,<64,82>,<25,36>,<82,75>,<36,43>}r3={<25,36>,<36,43>,<43,48>,<48,57>,<57,64>,<64,75>,<75,82>} 解:⑴是集合结构;⑵是线性结构;⑶⑷是树型结构;⑸散列结构1.2用C语言函数编写下列每一个算法,并分别求出它们的时间复杂度。
数据结构完整题目及答案1
![数据结构完整题目及答案1](https://img.taocdn.com/s3/m/ed513437ee06eff9aef80792.png)
数据结构与算法实验报告目录实验一学生成绩分析程序 (4)1.1 上机实验的问题和要求(需求分析): (4)1.2 程序设计的基本思想,原理和算法描述: (4)1.3 调试和运行程序过程中产生的问题及采取的措施: (4)1.4 运行输出结果: (4)1.5 源程序及注释: (5)实验二线性表的基本操作 (8)2.1 上机实验的问题和要求(需求分析): (8)2.2 程序设计的基本思想,原理和算法描述: (8)2.3 调试和运行程序过程中产生的问题及采取的措施: (8)2.4 运行输出结果: (8)2.5 源程序及注释: (8)实验三链表的基本操作 (11)3.1 上机实验的问题和要求(需求分析): (11)3.2 程序设计的基本思想,原理和算法描述: (11)3.3 调试和运行程序过程中产生的问题及采取的措施: (11)3.4 运行输出结果: (11)3.5 源程序及注释: (11)实验四单链表综合实验 (14)4.1 上机实验的问题和要求(需求分析): (14)4.2 程序设计的基本思想,原理和算法描述: (14)4.3 调试和运行程序过程中产生的问题及采取的措施: (14)4.4 运行输出结果: (14)4.5 源程序及注释: (14)实验五串 (19)5.1 上机实验的问题和要求(需求分析): (19)5.2 程序设计的基本思想,原理和算法描述: (19)5.3 调试和运行程序过程中产生的问题及采取的措施: (19)5.4 运行输出结果: (19)5.5 源程序及注释: (21)实验六循环队列的实现与运算 (22)6.1 上机实验的问题和要求(需求分析): (22)6.2 程序设计的基本思想,原理和算法描述: (22)6.3 调试和运行程序过程中产生的问题及采取的措施: (22)6.4 运行输出结果: (22)6.5 源程序及注释: (23)实验七栈子系统 (26)7.1 上机实验的问题和要求(需求分析): (26)7.2 程序设计的基本思想,原理和算法描述: (26)7.3 调试和运行程序过程中产生的问题及采取的措施: (26)7.4 运行输出结果: (26)7.5 源程序及注释: (28)实验八树 (36)8.1 上机实验的问题和要求(需求分析): (36)8.2 程序设计的基本思想,原理和算法描述: (39)8.3 调试和运行程序过程中产生的问题及采取的措施: (39)8.4 运行输出结果: (39)8.5 源程序及注释: (41)实验九建立哈夫曼树与哈夫曼树与码 (50)9.1 上机实验的问题和要求(需求分析): (50)9.2 程序设计的基本思想,原理和算法描述: (50)9.3 调试和运行程序过程中产生的问题及采取的措施: (50)9.4 运行输出结果: (50)9.5 源程序及注释: (50)实验十图 (53)10.1 上机实验的问题和要求(需求分析): (53)10.2 程序设计的基本思想,原理和算法描述: (53)10.3 调试和运行程序过程中产生的问题及采取的措施: (53)10.4 运行输出结果: (53)10.5 源程序及注释: (53)实验一学生成绩分析程序一、上机实验的问题和要求(需求分析):【题目】设一个班有10个学生,每个学生有学号,以及数学、物理、英语、语文、体育 5 门课的成绩信息。
数据结构习题答案一
![数据结构习题答案一](https://img.taocdn.com/s3/m/723e2b89680203d8ce2f24dc.png)
数据结构习题答案一评论:0 条查看:40 次zjw313014322发表于2009-04-21 16:25一、选择题1. 下面说法错误的是 C 。
(1)算法原地工作的含义是指不需要任何额外的辅助空间。
(2)在相同的规模n下,复杂度O(n)的撒在时间上总是优于复杂度O(2n)的算法。
(3)所谓时间复杂度是指最坏情况下,估算算法执行时间的一个上界。
(4)同一个算法,实现语言的级别越高,执行效率越低。
A、(1)B、(1)(2)C、(1)(4)D、(3)2. 一个递归算法必须包括 B 。
A、递归部分B、终止条件和递归部分C、迭代部分D、终止条件和迭代部分3. 数据的 C 包括查找、插入、删除、更新、排序等操作类型。
A、存储结构B、逻辑结构C、基本运算D、算法描述4. 在数据结构中,从逻辑上可以把数据结构分成 C 。
A、动态结构和静态结构B、紧凑结构和非紧凑结构C、线性结构和非线性结构D、内部结构和外部结构5. 与数据元素本身的形式、内容、相对位置、个数无关的是数据的 C 。
A、存储结构B、存储实现C、逻辑结构D、运算实现6. 通常要求同一逻辑结构中的所有数据元素具有相同的特性,这意味着 B 。
A、数据具有同一特点B、不仅数据元素所包含的数据项的个数要相同,而且对应数据项的类型要一致C、每个数据元素都一样D、数据元素所包含的数据项的个数要相等7. 以下说法正确的是 D 。
A、数据元素是数据的最小单位B、数据项是数据的基本单位C、数据结构是带有结构的各数据项的集合D、一些表面上很不相同的数据可以有相同的逻辑结构8. 以下说法错误的是 A 。
A、程序设计的实质是数据处理B、数据的逻辑结构是数据的组织形式,基本运算规定了数据的基本操作方式C、运算实现是完成运算功能的算法或这些算法的设计D、数据处理方式总是与数据的某种相应表示形式相联系,反之亦然9. 下列程序段的时间复杂度为 B 。
x=n;y=0;while (x>=(y+1)*(y+1))y=y+1;A、O(n)B、O(n1/2)C、O(1)D、O(n2)10. 下列叙述中有关好的编程风格的正确描述是 C 。
数据结构实验答案1
![数据结构实验答案1](https://img.taocdn.com/s3/m/4925677c3a3567ec102de2bd960590c69ec3d8c1.png)
数据结构实验答案1重庆文理学院软件工程学院实验报告册专业:_____软件工程__ _班级:_____软件工程2班__ _学号:_____201258014054 ___姓名:_____周贵宇___________课程名称:___ 数据结构 _指导教师:_____胡章平__________2013年 06 月 25 日实验序号 1 实验名称实验一线性表基本操作实验地点S-C1303 实验日期2013年04月22日实验内容1.编程实现在顺序存储的有序表中插入一个元素(数据类型为整型)。
2.编程实现把顺序表中从i个元素开始的k个元素删除(数据类型为整型)。
3.编程序实现将单链表的数据逆置,即将原表的数据(a1,a2….an)变成(an,…..a2,a1)。
(单链表的数据域数据类型为一结构体,包括学生的部分信息:学号,姓名,年龄)实验过程及步骤1.#include#include#include#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0#define ElemType int#define MAXSIZE 100 /*此处的宏定义常量表示线性表可能达到的最大长度*/typedef struct{ ElemType elem[MAXSIZE]; /*线性表占用的数组空间*/ int last; /*记录线性表中最后一个元素在数组elem[ ]中的位置(下标值),空表置为-1*/}SeqList;#include "common.h"#include "seqlist.h"void px(SeqList *A,int j);void main(){ SeqList *l;int p,q,r;int i;l=(SeqList*)malloc(sizeof(SeqList));printf("请输入线性表的长度:");scanf("%d",&r);l->last = r-1;printf("请输入线性表的各元素值:\n");for(i=0; i<=l->last; i++){scanf("%d",&l->elem[i]);}px(l,i);printf("请输入要插入的值:\n");scanf("%d",&l->elem[i]);i++;px(l,i);l->last++;for(i=0; i<=l->last; i++){ printf("%d ",l->elem[i]);}printf("\n");}void px(SeqList *A,int j){ int i,temp,k;for(i=0;i<j;i++)< p="">{ for(k=0;k<j-1;k++)< p="">{if(A->elem[i]elem[k]){temp=A->elem[i];A->elem[i]=A->elem[k];A->elem[k]=temp;}}}}2.#include#include#include#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0#define ElemType int#define MAXSIZE 100 /*此处的宏定义常量表示线性表可能达到的最大长度*/typedef struct{ ElemType elem[MAXSIZE]; /*线性表占用的数组空间*/ int last; /*记录线性表中最后一个元素在数组elem[ ]中的位置(下标值),空表置为-1*/}SeqList;#include "common.h"#include "seqlist.h"void px(SeqList *A,int j);int DelList(SeqList *L,int i,SeqList *e,int j)/*在顺序表L中删除第i个数据元素,并用指针参数e返回其值。
数据结构实验报告答案1
![数据结构实验报告答案1](https://img.taocdn.com/s3/m/3ba1983ea8114431b90dd8d4.png)
(此文档为word格式,下载后您可任意编辑修改!)《数据结构与算法分析》课程设计内容体系主要内容《数据结构课程设计》课程,可使学生深化理解书本知识,致力于用学过的理论知识和上机取得的实践经验,解决具体、复杂的实际问题,培养软件工作者所需的动手能力、独立解决问题的能力。
该课程设计侧重软件设计的综合训练,包括问题分析、总体结构设计、用户界面设计、程序设计基本技能和技巧、多人合作,以至一整套软件工作规范的训练和科学作风的培养。
一、课程设计要求学生必须仔细阅读《数据结构与算法分析》课程设计方案,认真主动完成课程设计的要求。
有问题及时主动通过各种方式与教师联系沟通。
学生要发挥自主学习的能力,充分利用时间,安排好课程设计的时间计划,并在课程设计过程中不断检测自己的计划完成情况,及时的向教师汇报。
课程设计按照教学要求需要两周时间完成,两周中每天(按每周5天)至少要上3-4小时的机来调试C语言设计的程序,总共至少要上机调试程序30小时。
二、数据结构课程设计的具体内容本次课程设计完成如下模块(共9个模块,学生可以在其中至少挑选6个功能块完成,但有**号的模块是必须要选择的)(1)运动会分数统计**任务:参加运动会有n个学校,学校编号为1……n。
比赛分成m个男子项目,和w个女子项目。
项目编号为男子1……m,女子m+1……m+w。
不同的项目取前五名或前三名积分;取前五名的积分分别为:7、5、3、2、1,前三名的积分分别为:5、3、2;哪些取前五名或前三名由学生自己设定。
(m<=20,n<=20)功能要求:可以输入各个项目的前三名或前五名的成绩;●能统计各学校总分;●可以按学校编号、学校总分、男女团体总分排序输出;●可以按学校编号查询学校某个项目的情况;可以按项目编号查询取得前三或前五名的学校。
规定:输入数据形式和范围:20以内的整数(如果做得更好可以输入学校的名称,运动项目的名称)输出形式:有中文提示,各学校分数为整形界面要求:有合理的提示,每个功能可以设立菜单,根据提示,可以完成相关的功能要求。
太原理工数据结构实验答案
![太原理工数据结构实验答案](https://img.taocdn.com/s3/m/df48a6ccbb4cf7ec4afed086.png)
实验一线性表一.目的与要求本次实习的主要目的是为了使学生熟练掌握线性表的基本操作在顺序存储结构和链式存储结构上的实现,提高分析和解决问题的能力。
要求仔细阅读并理解下列例题,上机通过,并观察其结果,然后独立完成后面的实习题。
二.例题问题描述:用链表形式存储一个字符串,插入、删除某个字符,最后按正序、逆序两种方式输出字符串。
输入:初始字符串,插入位置,插入字符,删除字符。
输出:已建立链表(字符串),插入字符后链表,删除字符后链表,逆转后链表。
存储结构:采用链式存储结构算法的基本思想:建立链表当读入字符不是结束符时,给结点分配存储空间,写数据域,将新结点插到表尾;插入字符:根据读入的字符在链表中找插入位置,将新结点插入到该位置之前;删除字符:根据读入的删除字符在链表中找到被删结点后,将其从链表中删除;链表逆转:从链表的第一个结点开始对所有结点处理,将每个结点的前驱变为它的后继;打印链表:从链表的第一个结点开始,依次打印各[运行情况]Input a linktable(a string):abcde↙Build link is :abcdePlease input a char you want to insert after:b↙Please input a char you want to insert:c↙After p insert y,link is:abccdePlease input a char you want to delete:e↙after delete p,link is:abccdOpsite result is :dccba如图显示:实习题:问题描述:设顺序表A中的数据元素递增有序,试写一程序,将x插入到顺序表的适当位置上,使该表仍然有序。
输入:插入前的顺序表,插入的数,插入后的顺序表输出:插入前的顺序表,插入的数,插入后的顺序表存储结构:顺序表存储数据算法基本思想:其实这个题在学C语言时就已经写过了,这里采用顺序表来存储数据。
数据结构习题及答案-第1章 绪论
![数据结构习题及答案-第1章 绪论](https://img.taocdn.com/s3/m/3c467d128762caaedc33d466.png)
第1章绪论一、选择题1. 算法的计算量的大小称为计算的()。
【北京邮电大学2000 二、3 (20/8分)】A.效率 B. 复杂性 C. 现实性 D. 难度2. 算法的时间复杂度取决于()【中科院计算所 1998 二、1 (2分)】A.问题的规模 B. 待处理数据的初态 C. A和B3.计算机算法指的是(1),它必须具备(2)这三个特性。
(1) A.计算方法 B. 排序方法 C. 解决问题的步骤序列 D. 调度方法(2) A.可执行性、可移植性、可扩充性 B. 可执行性、确定性、有穷性C. 确定性、有穷性、稳定性D. 易读性、稳定性、安全性【南京理工大学 1999 一、1(2分)【武汉交通科技大学 1996 一、1( 4分)】4.一个算法应该是()。
【中山大学 1998 二、1(2分)】A.程序 B.问题求解步骤的描述 C.要满足五个基本特性 D.A和C.5. 下面关于算法说法错误的是()【南京理工大学 2000 一、1(1.5分)】A.算法最终必须由计算机程序实现B.为解决某问题的算法同为该问题编写的程序含义是相同的C. 算法的可行性是指指令不能有二义性D. 以上几个都是错误的6. 下面说法错误的是()【南京理工大学 2000 一、2 (1.5分)】(1)算法原地工作的含义是指不需要任何额外的辅助空间(2)在相同的规模n下,复杂度O(n)的算法在时间上总是优于复杂度O(2n)的算法(3)所谓时间复杂度是指最坏情况下,估算算法执行时间的一个上界(4)同一个算法,实现语言的级别越高,执行效率就越低A.(1) B.(1),(2) C.(1),(4) D.(3)7.从逻辑上可以把数据结构分为()两大类。
【武汉交通科技大学 1996 一、4(2分)】A.动态结构、静态结构 B.顺序结构、链式结构C.线性结构、非线性结构 D.初等结构、构造型结构8.以下与数据的存储结构无关的术语是()。
【北方交通大学 2000 二、1(2分)】A.循环队列 B. 链表 C. 哈希表 D. 栈9.以下数据结构中,哪一个是线性结构()?【北方交通大学 2001 一、1(2分)】A.广义表 B. 二叉树 C. 稀疏矩阵 D. 串10.以下那一个术语与数据的存储结构无关?()【北方交通大学 2001 一、2(2分)】A.栈 B. 哈希表 C. 线索树 D. 双向链表11.在下面的程序段中,对x的赋值语句的频度为()【北京工商大学 2001 一、10(3分)】FOR i:=1 TO n DOFOR j:=1 TO n DOx:=x+1;A. O(2n) B.O(n) C.O(n2) D.O(log2n)12.程序段 FOR i:=n-1 DOWNTO 1 DOFOR j:=1 TO i DOIF A[j]>A[j+1]THEN A[j]与A[j+1]对换;其中 n为正整数,则最后一行的语句频度在最坏情况下是()A. O(n)B. O(nlogn)C. O(n3)D. O(n2) 【南京理工大学1998一、1(2分)】13.以下哪个数据结构不是多型数据类型()【中山大学 1999 一、3(1分)】A.栈 B.广义表 C.有向图 D.字符串14.以下数据结构中,()是非线性数据结构【中山大学 1999 一、4】A.树 B.字符串 C.队 D.栈15. 下列数据中,()是非线性数据结构。
数据结构-结课实验带答案
![数据结构-结课实验带答案](https://img.taocdn.com/s3/m/0bb62c65f6ec4afe04a1b0717fd5360cba1a8dcd.png)
数据结构-结课实验带答案线性表一、顺序表建立_新1、定义顺序表存储结构2、初始化顺序表为空(InitList_Sq)3、输入顺序表数据(CreateList_Sq)4、遍历(输出)顺序表数据(TraverseList_Sq)5、销毁顺序表数据(DestroyList_Sq)例如:输入元素个数和数据如下:55 3 8 7 9程序输出为:5,3,8,7,9二、单链表的建立-前插法_新1、定义单链表存储结构2、初始化一个空的单链表L(InitList_L)3、用前插法创建单链表数据(CreateList_F)4、遍历(输出)单链表表数据(TraverseList_L)5、销毁单链表表数据(DestroyList_L)例如:输入单链表结点个数和数据如下:59 7 8 3 5程序输出为:5,3,8,7,9三、单链表的建立-后插法_ 新1、定义单链表存储结构2、初始化一个空的单链表L(InitList_L)3、用后插法创建单链表数据(CreateList_L)4、遍历单链表表数据(TraverseList_L)5、销毁单链表表数据(DestroyList_L)例如:输入元素个数和数据如下:55 3 8 7 9程序输出为:5,3,8,7,9四、顺序表的插入_新1、定义插入函数(ListInsert_Sq)2、在主函数中遍历输出插入前线性表中的元素3、在主函数中输入插入元素的位置和数据信息4、显示插入后的顺序表数据信息(TraverseList_Sq)例如:输入元素个数和数据如下:55 3 8 7 9插入元素的位置和值为:26程序输出为:5,3,8,7,9 //在输入插入位置和值之前遍历输出的线性表中的数据元素5,6,3,8,7,9模板如下:#include#includeusing namespace std;#define MAXSIZE 100#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef int ElemType;typedef struct {ElemType *elem; //指向数据元素的基地址int length; //线性表的当前长度}SqList;Status InitList_Sq(SqList *L){ //构造一个空的顺序表L}Status CreateList_Sq(SqList &L,int n){}//在此处定义顺序表插入函数ListInsert_Sqvoid TraverseList_Sq(SqList &L){}void DestroyList_Sq(SqList &L){}int main(){SqList L;int i,n,e;InitList_Sq(&L);//提示:输入元素个数:cin>>n;CreateList_Sq(L,n);TraverseList_Sq(L); //遍历输出插入前线性表数据元素//提示:在顺序表中输入新元素插入的位置和数据:cin>>i>>e;//在此处编写ListInsert_Sq函数的调用语句TraverseList_Sq(L);DestroyList_Sq(L);return 0;}五、顺序表的查找—按值进行查找_新1、定义按值查找函数(GetElem_Sq)2、在主函数中遍历输出查找前线性表中的元素3、在主函数中输入待查元素4、显示待查找元素的位置例如:输入顺序表元素个数和数据如下:55 3 8 7 9输入的待查找元素为:3程序输出结果有:5,3,8,7,9 //在查找之前遍历输出线性表中的数据元素2 //待查元素在线性表中的位置六、顺序表的查找—按序号进行查找_新1、定义按序查找函数(GetElem_Sq)2、在主函数中遍历输出查找之前线性表中的元素2、在主函数中输入待查元素在顺序表中的位序3、显示查找后的数据例如:输入顺序表元素个数和数据如下:55 3 8 7 9输入查找元素的位序为:2程序输出结果为:5,3,8,7,9 //在调用查找函数之前遍历输出的线性表中的数据元素3 //输出的待查元素的位序七、单链表的插入_新1、定义插入函数(ListInsert_L)2、在主函数中输出插入新结点之前单链表中的结点信息(TraverseList_L)3、在主函数中输入插入结点的位置和数据信息4、显示插入后的单链表数据信息(TraverseList_L)例如:输入单链表结点个数和数据如下:55 3 8 7 9结点插入的位置和值为:26程序输出为:5,3,8,7,9 // 插入新结点之前输出的单链表中的结点信息5,6,3,8,7,9 //插入新结点之后输出的单链表中的结点信息模板如下:#includeusing namespace std;#define MAXSIZE 100#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef int ElemType;typedef struct LNode {ElemType data; //结点的数据域struct LNode *next; //结点的指针域} LNode, *LinkList; //LinkList为指向结构体LNode的指针类型Status InitList_L(LinkList &L){//构造一个空的单链表L}void CreateList_L(LinkList &L,int n){}//在此处定义单链表的插入函数ListInsert_Lvoid TraverseList_L(LinkList L)//依次输出单链表里的每个元素{}Status DestroyList_L(LinkList &L){}int main(){LinkList L; //用LinkList L;替换,与#include "LinkList.h"配合int n,i;ElemType e;InitList_L(L);//提示:请输入单链表的结点个数:cin>>n;CreateList_L(L,n);TraverseList_L(L);//提示:在单链表中输入结点插入的位置和数据:cin>>i>>e;//在此处调用单链表的插入函数TraverseList_L(L);DestroyList_L(L);return 0;}八、顺序表删除_新1、定义删除函数(ListDelete_Sq)2、在主函数中遍历输出插入前线性表中的元素3、在主函数中输入被删元素的位置4、显示删除后的线性表元素例如:输入顺序表元素个数和数据如下:55 3 8 7 9输入被删元素的位置:2程序输出结果为:5,3,8,7,9 //删除元素之前输出的线性表中的数据元素3 //输出的被删除元素5,8,7,9 //输出删除元素之后线性表中的数据元素九、单链表的查找-按序号查找_新1、定义按序查找函数(GetElem_Sq)2、在主函数中输出插入新结点之前单链表中的结点信息(TraverseList_L)3、在主函数中输入待查元素在单链表中的位序4、显示查找后的数据例如:输入单链表结点个数和数据如下:55 3 8 7 9输入查找结点的位序为:2程序输出结果为:5,3,8,7,9 // 插入新结点之前输出的单链表中的结点信息3 //输出该位置上的结点信息十、单链表结点的删除_ 新1、定义删除函数(ListDelete_L2、在主函数中遍历输出删除前单链表中的结点信息3、在主函数中输入被删结点的位置4、显示删除后的单链表的结点信息例如:输入单链表结点个数和数据如下:55 3 8 7 9输入被删结点的位置:2程序输出结果为:5,3,8,7,9 //删除结点之前遍历输出的单链表中的结点信息3 //输出被删除结点的结点信息5,8,7,9 //删除结点之后遍历输出的单链表中的结点信息十一、线性表的合并_新假设利用两个线性表LA和LB分别表示两个集合A和B,现要求一个新的集合A=A∪B,例如,设LA=(7 5 3 11 ),LB=(2 6 3),合并后LA=(7 5 3 11 2 6)1、定义线性表的顺序存储结构2、初始化线性表(InitList_Sq)3、创建线性表(CreateList_Sq)4、定义线性表的合并函数(unionList_Sq),将存在于线性表LB 中而不存在于线性表LA中的数据元素插入到线性表LA中,(在合并函数中,还将包含对函数ListLengtht_Sq、ListInsert_Sq、LocateElem_Sq和GetElem_Sq的调用)5、在主函数中输入两个线性表LA,LB,调用合并函数6、遍历合并后的线性表LA,并输出数据(TraverseList_Sq)例如:输入线性表LA的元素个数和数据如下:47 5 3 11输入有序表LB的元素个数和数据如下:32 6 3输出为:7,5,3,11 //输出线性表LA的数据元素2,6,3 //输出线性表LB的数据元素7,5,3,11,2,6 //输出合并后的线性表LA的数据元素十二、有序表的合并_新已知线性表LA 和LB中的数据元素按值非递减有序排列,现要求将LA和LB归并为一个新的线性表LC,且LC中的数据元素仍按值非递减有序排列.1、定义有序表合并函数(MergeList_Sq),将两个非递减的有序表LA和LB合并为一个新的有序表LC,且LC中的数据元素仍按值非递减有序排列(在合并函数中,还将包含对ListLengtht_Sq、ListInsert_Sq和LocateElem_Sq的调用)2、在主函数中输出LA表的数据元素(TraverseList_Sq)3、在主函数中输出LB表的数据元素(TraverseList_Sq)4、在主函数中输入两个非递减的有序表LA,LB,调用合并函数5、遍历合并后的有序表LC,并输出数据(TraverseList_Sq)例如:输入有序表LA的元素个数和数据如下:42 5 8 9输入有序表LB的元素个数和数据如下:63 4 8 10 12 20输出为:2,5,8,9 //输出LA表的数据元素3,4,8,10,12,20 //输出LB表的数据元素2,3,4,5,8,8,9,10,12,20 //输出合并后的LC表的数据元素十三、有序链表的合并_新已知线性表LA 和LB中的数据元素按值非递减有序排列,现要求将LA和LB归并为一个新的线性表LC,且LC中的数据元素仍按值非递减有序排列.1、用后插法创建单链表数据(CreateList_L)2、定义遍历函数输出单链表数据(TraverseList_L)3、定义有序链表合并函数(MergeList_L),将两个非递减的有序链表LA和LB合并为一个新的有序链表LC,且LC中的结点元素仍按值非递减有序排列4、在主函数中输出LA和LB表的结点信息(TraverseList_L)5、在主函数中调用合并函数(MergeList_L)6、遍历合并后的有序链表LC,并输出结点信息(TraverseList_L)例如:输入有序链表LA的结点个数和数据如下:42 5 8 9输入有序链表LB的结点个数和数据如下:63 4 8 10 12 20输出为:2,5,8,9 //输出LA表的结点信息3,4,8,10,12,20 //输出LB表的结点信息2,3,4,5,8,8,9,10,12,20 //输出合并后的LC表的结点信息栈和队列一、顺序栈的建立1.定义顺序栈的存储结构2.初始化顺序栈为空栈(InitStack_Sq)3.输入要入栈的元素个数n4.向顺序栈中压入n个元素(Push_Sq)5.将顺序栈中的元素从栈顶到栈底依次输出(StackTraverse_Sq)6.销毁顺序栈(DestroyStack_Sq)例如:54 35 10 99 10 5 3 4 //遍历输出时最后一个元素后有一个空格二、顺序栈的入栈1.定义顺序栈入栈函数(Push_Sq)2.输入要入栈的元素个数n3.向顺序栈中压入n个元素4.将顺序栈中的元素从栈顶到栈底依次输出(StackTraverse_Sq)5.销毁顺序栈(DestroyStack_Sq)例如:56 2 8 10 99 10 8 2 6 //遍历输出时最后一个元素后有一个空格模板如下:#include#includeusing namespace std;#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef int SElemType;#define MAXSIZE 100typedef struct{SElemType *base;SElemType *top;int stacksize;}SqStack;Status InitStack_Sq(SqStack &S) { }void DestroyStack_Sq(SqStack &S) { }//在此处定义入栈函数Push_Sqvoid StackTraverse_Sq(SqStack S) { }int main(){SqStack S;InitStack_Sq(S);int n;SElemType e;cin>>n;for(int i=1;i<=n;i++){cin>>e;//此处调用入栈函数}StackTraverse_Sq(S);DestroyStack_Sq(S);return 0;}三、顺序栈的出栈1.定义顺序栈出栈函数(Pop_Sq)2.定义求顺序栈栈长函数(StackLength_Sq)3.输入要入栈的元素个数n4.向顺序栈中压入n个元素5.将顺序栈中的元素从栈顶到栈底依次输出(StackTraverse_Sq)6.销毁顺序栈(DestroyStack_Sq)例如:42 4 6 88 6 4 2 //遍历输出时最后一个元素后有一个空格46 4 2 //遍历输出时最后一个元素后有一个空格83四、顺序栈栈顶元素的获取1.定义获取顺序栈栈顶元素函数(GetTop_Sq)2.输入要入栈的元素个数n3.向顺序栈中压入n个元素4.将顺序栈中的元素从栈顶到栈底依次输出(StackTraverse_Sq)5.获取栈顶元素6.输出栈顶元素7.销毁顺序栈(DestroyStack_Sq)例如:42 4 6 88 6 4 2 //遍历输出时最后一个元素后有一个空格8五、链栈的建立1.定义链栈的结点存储结构2.初始化链栈为空栈(InitStack_Link)3.输入要入栈的元素个数n4.向链栈中压入n个元素(Push_Link)5.从栈顶到栈底遍历链栈数据(StackTraverse_Link)6.销毁链栈(DestroyStack_Link)54 35 10 99 10 5 3 4 //遍历输出时最后一个元素后有一个空格六、链栈的入栈1.定义链栈的入栈函数(Push_Link)2.输入要入栈的元素个数n3.向栈中压入n个元素4.将链栈中的元素从栈顶到栈底依次输出(StackTraverse_Link)5.销毁链栈(DestroyStack_Link)例如:51 2 3 4 55 4 3 2 1 //遍历输出时最后一个元素后有一个空格模板如下:#includeusing namespace std;#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef int SElemType;#define MAXSIZE 100typedef struct StackNode{SElemType data;struct StackNode *next;}StackNode,*LinkStack;Status InitStack_Link(LinkStack &S) {}void DestroyStack_Link(LinkStack &S) {}bool StackEmpty_Link(LinkStack S) {}//此处定义入栈函数Push_Linkvoid StackTraverse_Link(LinkStack S) {}int main(){LinkStack S;int n;SElemType e;InitStack_Link(S);cin>>n;for(int i=1;i<=n;i++){cin>>e;//此处调用入栈函数}StackTraverse_Link(S);DestroyStack_Link(S);return 0;}七、链栈的出栈1.定义求栈长函数(StackLength_Link)2.定义出栈函数(Pop_Link)3.输入要入栈的元素个数n4.向栈中压入n个元素(Push_Link)5.将栈中的元素从栈顶到栈底依次输出(StackTraverse_Link)6.输出栈长7.执行出栈操作8.将栈中的元素从栈顶到栈底依次输出9.输出出栈元素10.输出栈长11.销毁链栈(DestroyStack_Link)例如:51 2 3 4 55 4 3 2 1 //遍历输出时最后一个元素后有一个空格54 3 2 1 //遍历输出时最后一个元素后有一个空格54八、链栈栈顶元素的获取1.定义获取栈顶元素函数(GetT op_Link)2.输入要入栈的元素个数n3.向栈中压入n个元素(Push_Link)4.将栈中的元素从栈顶到栈底依次输出(StackTraverse_Link)5.获取栈顶元素6.输出栈顶元素7.销毁链栈(DestroyStack_Link)例如:42 4 6 88 6 4 2 //遍历输出时最后一个元素后有一个空格8九、循环队列的建立1.定义循环队列的存储结构2.初始化循环队列为空队列(InitQueue_Sq)3.输入要入队的元素个数n4.向循环队列中输入n个元素(EnQueue_Sq)5.将循环队列中的元素从队头至队尾依次输出(StackQueue_Sq)6.销毁循环队列(DestroyQueue_Sq)例如:51 2 3 4 51 2 3 4 5 //遍历输出时最后一个元素后有一个空格十、循环队列的入队1.定义循环队列入队函数(EnQueue_Sq)2.输入要入队的元素个数n3.向循环队列中输入n个元素4.将循环队列中的元素从队头至队尾依次输出(StackQueue_Sq)5.销毁循环队列(DestroyQueue_Sq)例如:56 2 8 10 96 2 8 10 9 //遍历输出时最后一个元素后有一个空格模板如下:#include#includeusing namespace std;#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef int QElemType;#define MAXSIZE 100typedef struct{QElemType *base;int front;int rear;}SqQueue;Status InitQueue_Sq(SqQueue &Q) {}void DestroyQueue_Sq(SqQueue &Q) {}//此处定义入队函数EnQueue_Sqvoid QueueTraverse_Sq(SqQueue Q) {}int main(){SqQueue Q;QElemType e;InitQueue_Sq(Q);int n;cin>>n;for(int i=1;i<=n;i++){cin>>e;//此处调用入队函数}QueueTraverse_Sq(Q);DestroyQueue_Sq(Q);return 0;}十一、循环队列的出队1.定义求循环队列队长函数(QueueLength_Sq)2.定义循环队列的出队函数(DeQueue_Sq)3.输入要入队的元素个数n4.向循环队列中输入n个元素5.将循环队列中的元素从队头至队尾依次输出(StackQueue_Sq)6.输出队长7.执行出队操作8.将循环队列中的元素从队头至队尾依次输出9.输出出队元素10.输出队长11.销毁循环队列(DestroyQueue_Sq)例如:51 2 3 4 51 2 3 4 5 //遍历输出时最后一个元素后有一个空格52 3 4 5 //遍历输出时最后一个元素后有一个空格14十二、循环队列队头元素的获取1.定义获取循环队列队头元素函数(GetHead_Sq)2.输入要入队的元素个数n3.向循环队列中输入n个元素4.将循环队列中的元素从队头至队尾依次输出5.获取栈顶元素6.将循环队列中的元素从队头至队尾依次输出7.销毁循环队列例如:52 4 6 8 102 4 6 8 10 //遍历输出时最后一个元素后有一个空格2十三、链队列的建立1.定义链队列的存储结构2.初始化链队列为空队列(InitQueue_Link)3.输入要入队的元素个数n4.向链队列中输入n个元素(EnQueue_Link)5.将链队列中的元素从队头至队尾依次输出(StackQueue_Link)6.销毁链队列(DestroyQueue_Link)例如:51 2 3 4 51 2 3 4 5 //遍历输出时最后一个元素后有一个空格十四、链队列的入队1.定义链队列入队函数(EnQueue_Link)2.输入要入队的元素个数n3.向链队列中输入n个元素4.将链队列中的元素从队头至队尾依次输出(StackQueue_Link)5.销链队列(DestroyQueue_Link)例如:56 2 8 10 96 2 8 10 9 //遍历输出时最后一个元素后有一个空格模板如下:#include#includeusing namespace std;#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef int QElemType;#define MAXSIZE 100typedef struct QNode{QElemType data;struct QNode *next;}QNode,*QueuePtr;typedef struct{QueuePtr front;QueuePtr rear;}LinkQueue;Status InitQueue_Link(LinkQueue &Q){}void DestroyQueue_Link(LinkQueue &Q){}//此处定义入队函数EnQueue_Linkvoid QueueTraverse_Link(LinkQueue Q){}int main(){LinkQueue Q;QElemType e;InitQueue_Link(Q);int n;cin>>n;for(int i=1;i<=n;i++){cin>>e;//此处调用入队函数}QueueTraverse_Link(Q);DestroyQueue_Link(Q);return 0;}十五、链队列的出队1.定义求链队列队长函数(QueueLength_Link)2.定义链队列的出队函数(DeQueue_Link)3.输入要入队的元素个数n4.向链队列中输入n个元素5.将链队列中的元素从队头至队尾依次输出(StackQueue_Link)6.输出队长7.执行出队操作8.将链队列中的元素从队头至队尾依次输出9.输出出队元素10.输出队长11.销毁链队列(DestroyQueue_Link)例如:51 2 3 4 51 2 3 4 5 //遍历输出时最后一个元素后有一个空格52 3 4 5 //遍历输出时最后一个元素后有一个空格14十六、链队列队头元素的获取1.定义获取链队列队头元素函数(GetHead_Link)2.输入要入队的元素个数n3.向链队列中输入n个元素4.将链队列中的元素从队头至队尾依次输出5.获取栈顶元素6.将链队列中的元素从队头至队尾依次输出7.销毁链队列例如:52 4 6 8 102 4 6 8 10 //遍历输出时最后一个元素后有一个空格2十七、栈的应用将十进制数n,转换成八进制。
数据结构实验答案
![数据结构实验答案](https://img.taocdn.com/s3/m/5746bd382af90242a895e55b.png)
实验一:以单链表表示集合,设计算法建立先后输入的两个集合的差。
说明:已知两个集合A和B,集合A-B中包含所有属于集合A而不属于集合B 的元素。
步骤:1.首先建立A和B的单链表2.然后对集合B中的每个元素x,在A中查找,若存在和x相同的元素,则从该链表中删除。
3.打印A-B,进行验证。
实验二:建立一个二叉树,并进行先序和中序遍历。
(递归和非递归算法)步骤1.补充元素0建立一个满二叉树,存储到一维数组2.利用递归算法建立二叉树,注意零的元素处置3.进行递归、非递归的中序和先序遍历。
打印结果。
实验三:先从键盘输入26个字母生成无序数组,对数组排序后,再从键盘输入一个字符进行折半查找。
实验四:为一个图(maxnode=20)建立一个邻接表、编写深度遍历和广度遍历算法并给出遍历结果。
实验一答案:#include<stdio.h>typedef struct linknode{int data;struct linknode *next;} node;node *creatlist(){node *head,*r,*s;int x;head=(node*)malloc(sizeof(node));r=head;printf("input int and end with \n");scanf("%d",&x);while(x!=0){s=(node*)malloc(sizeof(node));s->data=x;r->next=s;s->next=NULL;r=s;scanf("%d",&x);}r->next=NULL;s=head;head=head->next;free(s);return(head);}void subs(){node *p,*p1,*p2,*q,*heada,*headb;heada=creatlist();headb=creatlist();p=heada;p1=p;while(p!=NULL){q=headb;while(q->data!=p->data && q!=NULL) q=q->next; if(q!=NULL){if(p==heada){heada=heada->next;p1=heada;}else if(p->next==NULL) p1->next=NULL;else p1->next=p->next;p2=p->next;p->next=NULL;free(p);p=p2;}else{p1=p;p=p->next;}}p=heada;if(p==NULL)printf("kong\n");elseprintf(" A - B \n");while(p!=NULL){printf("%d\n",p->data);p=p->next;}}main(){subs();}实验二答案://程序目的建立二叉树,同时对他进行先序排列。
数据结构练习1
![数据结构练习1](https://img.taocdn.com/s3/m/ef718bde81eb6294dd88d0d233d4b14e85243e20.png)
1.在一个具有n个单元的顺序栈中,假定以地址低端(即0单元)作为栈底,以top作为栈顶指针,当做出栈处理时,top变化为:【正确答案: C】A top不变B top=0C top--D top++得分:0.002.经过以下运算后,x的值是:InitStack (s); Push(s, a); Push(s, b); Pop(s, x); GetTop(s,x) 【正确答案: A】A aB 0C bD 1得分:0.003.元素A、B、C、D依次进栈后,栈顶元素是:【正确答案: B】A CB DC BD A得分:0.004.在带头节点的单链表L为空的判定条件是:【正确答案: A】A L->NEXT==NULLB L!=NULLC L->NEXT==LD L==NULL得分:0.005.将两个长度为n、m的递增有序表归并成一个有序顺序表,其最少的比较次数是(MIN表示取最小值):【正确答案: B】A nB MIN(m, n)C mD 不确定得分:0.006.如果最常用的操作时取第i个元素及前驱元素,则下列存储方式最节省时间是:【正确答案: A】A 顺序表B 循环单链表C 双链表D 单链表得分:0.007.线性表的顺序存储结构和链式存储结构相比,优点是:【正确答案: D】A 所有的操作算法实现简单B 便于插入和删除C 节省存储空间D 便于随机存取得分:0.008.最不合适用做链队的不带头节点的链表是:【正确答案: B】A 以上都不合适B 只带队首节点指针的非循环单链表C 只带队尾节点指针的循环双链表D 只带队首节点指针的循环双链表得分:0.009.带表头结点的双循环链表L为空表的条件是:【正确答案: C】A L->prior==NULLB L==NULLC L->next==LD L->next->prior==NULL得分:0.0010.在某线性表最常用的操作是在尾元素之后插入一个元素和删除第一个元素。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
重庆文理学院软件工程学院实验报告册专业:_____软件工程__ _班级:_____软件工程2班__ _学号:_____201258014054 ___姓名:_____周贵宇___________课程名称:___ 数据结构 _指导教师:_____胡章平__________2013年 06 月 25 日{ ElemType elem[MAXSIZE]; /*线性表占用的数组空间*/ int last; /*记录线性表中最后一个元素在数组elem[ ]中的位置(下标值),空表置为-1*/}SeqList;#include "common.h"#include "seqlist.h"void px(SeqList *A,int j);void main(){ SeqList *l;int p,q,r;int i;l=(SeqList*)malloc(sizeof(SeqList));printf("请输入线性表的长度:");scanf("%d",&r);l->last = r-1;printf("请输入线性表的各元素值:\n");for(i=0; i<=l->last; i++){scanf("%d",&l->elem[i]);}px(l,i);printf("请输入要插入的值:\n");scanf("%d",&l->elem[i]);i++;px(l,i);l->last++;for(i=0; i<=l->last; i++){ printf("%d ",l->elem[i]);}printf("\n");}void px(SeqList *A,int j){ int i,temp,k;for(i=0;i<j;i++){ for(k=0;k<j-1;k++){if(A->elem[i]<A->elem[k]){temp=A->elem[i];A->elem[i]=A->elem[k];A->elem[k]=temp;}}}}2.#include <stdio.h>#include <stdlib.h>#include <malloc.h>#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0#define ElemType int#define MAXSIZE 100 /*此处的宏定义常量表示线性表可能达到的最大长度*/typedef struct{ ElemType elem[MAXSIZE]; /*线性表占用的数组空间*/ int last; /*记录线性表中最后一个元素在数组elem[ ]中的位置(下标值),空表置为-1*/}SeqList;#include "common.h"#include "seqlist.h"void px(SeqList *A,int j);int DelList(SeqList *L,int i,SeqList *e,int j)/*在顺序表L中删除第i个数据元素,并用指针参数e返回其值。
i 的合法取值为1≤i≤st+1 */{ int k,a,b,c;if((i<1)||(i>L->last+2)){ printf("删除位置不合法!");return(ERROR);}if(j>L->last-i){ printf("删除位置不合法!");return(ERROR);}for(b=0,a=i-1;a<i+j-1;b++,a++){ e->elem[b]=L->elem[a];}e->last=b; /* 将删除的元素存放到e所指向的变量中*/for(k=i;k+j-1<=L->last;k++){ L->elem[k-1]=L->elem[k+j-1]; }/*将后面的元素依次前移*/L->last=L->last-j;printf("删除的元素值为:");for(c=0;c<b;c++){ printf("%d ",e->elem[c]);}printf("\n");return(OK);}void main(){ SeqList *l,*q;int p,r;int i,j,m;l = (SeqList*)malloc(sizeof(SeqList));q = (SeqList*)malloc(sizeof(SeqList));printf("请输入线性表的长度:");scanf("%d",&r);l->last = r-1;printf("请输入线性表的各元素值:\n");for(i=0; i<=l->last; i++){ scanf("%d",&l->elem[i]);}px(l,i);for(i=0;i<=r-1;i++){printf("%d ",l->elem[i]);}printf("\n");printf("请输入要删除的元素位置(位置+个数):\n"); scanf("%d%d",&p,&j);m=DelList(l,p,q,j);if(m==0){printf("无法删除");exit(0);}else if(m==1){ printf("线性表内余下元素为:\n");for(i=0;i<=r-j-1;i++){printf("%d ",l->elem[i]);}printf("\n");}}void px(SeqList *A,int j){ int i,temp,k;for(i=0;i<j;i++){ for(k=0;k<j-1;k++){if(A->elem[i]<A->elem[k]){temp=A->elem[i];A->elem[i]=A->elem[k];A->elem[k]=temp;}}}printf("排序完成!");}3.#include <stdio.h>#include <stdlib.h>#include <string.h>/*#define ElemType char*/typedef struct Node /*结点类型定义*/{ int num;char name[10];int age;struct Node * next;}Node, *LinkList; /* LinkList为结构指针类型*/LinkList CreateFromTail()/*通过键盘输入表中元素值,利用尾插法建单链表,并返回该单链表头指针L*/{ LinkList L;Node *r, *s;int a;char b[10];int c;int flag =1; /*设置一个标志,初值为1,当输入"-1"时,flag 为0,建表结束*/L=(Node * )malloc(sizeof(Node));L->next=NULL; /*为头结点分配存储空间,建立空的单链表L*/r=L; /*r指针动态指向链表的当前表尾,以便于做尾插入,其初值指向头结点*//*循环输入表中元素值,将建立新结点s插入表尾*/printf("输入学生的信息:\n");printf("学号姓名年龄\n");while(flag){ scanf("%d",&a);if(a==-1)flag=0;else{ scanf("%s%d",b,&c);s=(Node*)malloc(sizeof(Node));s->num=a;strcpy(s->name,b);s->age=c;r->next=s;r=s;}} r->next=NULL;return L;}void ReverseList(LinkList L){ Node *p,*q;p=L->next;L->next=NULL;while(p!=NULL){ q=p->next; /*q指针保留p->next得值*/ p->next=L->next;L->next=p; /*将p结点头插入到单链表L中*/p=q; /*p指向下一个要插入的结点*/ }}void main(){ LinkList l;Node *p;printf("请输入链表数据,以-1结束!\n");l = CreateFromTail();printf("输入的单链表为:\n");p = l->next;while(p!=NULL){ printf("%d %s %d\n",p->num,p->name,p->age);p=p->next;}ReverseList(l);printf("逆置后的单链表为:\n");p = l->next;while(p!=NULL){ printf("%d %s %d\n",p->num,p->name,p->age);p=p->next;}}实验结果及分析1.实验结果:实验分析:我做了三次实验,分别插入数列前,中,后的数字,实验证明代码没有错误,能正常运行、排序、输出。
存在的问题:我不明白为什么我写的是降序排序,计算机运行后就是升序排序了。
希望老师能帮我修改一下。
2.实验结果实验分析:我通过三次实验(正常删除、删除个数超出、删除位置不正确)证明代码的正确性。