数据结构实验题答案
数据结构与实训课后答案全集
第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所指结点的前驱。
数据结构实验报告答案
数据结构实验报告答案数据结构实验报告答案引言：数据结构是计算机科学中的重要概念，它涉及组织和管理数据的方法和技术。
在本次实验中，我们将研究和实践几种常见的数据结构，包括数组、链表、栈和队列。
通过这些实验，我们将深入理解数据结构的原理和应用。
一、数组数组是一种线性数据结构，它由一系列相同类型的元素组成。
数组的特点是可以通过索引来访问和修改元素，具有随机访问的能力。
在本次实验中，我们将实现一个简单的数组类，并进行一些基本操作，如插入、删除和查找。
首先，我们定义一个数组类，包含以下成员变量和方法：- size：数组的大小- elements：存储元素的数组- insert(index, element)：在指定位置插入元素- remove(index)：删除指定位置的元素- get(index)：获取指定位置的元素- search(element)：查找元素在数组中的位置通过实现上述方法，我们可以对数组进行各种操作。
例如，我们可以在数组的末尾插入一个元素，然后在指定位置删除一个元素。
我们还可以通过元素的值来查找其在数组中的位置。
二、链表链表是另一种常见的线性数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。
链表的特点是插入和删除操作的效率较高，但随机访问的效率较低。
在本次实验中，我们将实现一个简单的单向链表，并进行一些基本操作。
首先，我们定义一个节点类，包含以下成员变量和方法：- data：节点的数据元素- next：指向下一个节点的指针然后，我们定义一个链表类，包含以下成员变量和方法：- head：链表的头节点- insert(element)：在链表的末尾插入一个节点- remove(element)：删除链表中指定的节点- search(element)：查找链表中指定元素的节点通过实现上述方法，我们可以对链表进行各种操作。
例如，我们可以在链表的末尾插入一个节点，然后删除链表中指定的节点。
数据结构实验报告-答案.doc
数据结构实验报告-答案数据结构(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心得体会：本次实验使我们对链表的实质了解更加明确了，对链表的一些基本操作也更加熟练了。
数据结构实验答案
# 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)
国家开放大学《数据结构》课程实验报告(实验3 ——栈、队列、递归设计)参考答案
x=Pop(s); /*出栈*/
printf("%d ",x);
InQueue(sq,x); /*入队*/
}
printf("\n");
printf("(10)栈为%s,",(StackEmpty(s)?"空":"非空"));
printf("队列为%s\n",(QueueEmpty(sq)?"空":"非空"));
ElemType Pop(SeqStack *s); /*出栈*/
ElemType GetTop(SeqStack *s); /*取栈顶元素*/
void DispStack(SeqStack *s); /*依次输出从栈顶到栈底的元素*/
void DispBottom(SeqStack *s); /*输出栈底元素*/
} SeqQueue; /*定义顺序队列*/
void InitStack(SeqStack *s); /*初始化栈*/
int StackEmpty(SeqStack *s); /*判栈空*/
int StackFull(SeqStack *s); /*判栈满*/
void Push(SeqStack *s,ElemType x); /*进栈*/
sq=(SeqQueue *)malloc(sizeof(SeqQueue));
InitQueue(sq);
printf("(8)队列为%s\n",(QueueEmpty(sq)?"空":"非空"));
printf("(9)出栈/入队的元素依次为:");
数据结构(第4版)习题及实验参考答案数据结构复习资料完整版(c语言版)
数据结构（第4版）习题及实验参考答案数据结构复习资料完整版（c语言版）数据结构基础及深入及考试习题及实验参考答案见附录结论1、数据的逻辑结构是指数据元素之间的逻辑关系。
即从逻辑关系上描述数据，它与数据的存储无关，是独立于计算机的。
2、数据的物理结构亦称存储结构，是数据的逻辑结构在计算机存储器内的表示（或映像）。
它依赖于计算机。
存储结构可分为4大类：顺序、链式、索引、散列3、抽象数据类型：由用户定义，用以表示应用问题的数据模型。
它由基本的数据类型构成，并包括一组相关的服务（或称操作）。
它与数据类型实质上是一个概念，但其特征是使用与实现分离，实行封装和信息隐蔽（独立于计算机）。
4、算法：是对特定问题求解步骤的一种描述，它是指令的有限序列，是一系列输入转换为输出的计算步骤。
5、在数据结构中，从逻辑上可以把数据结构分成（C）A、动态结构和表态结构B、紧凑结构和非紧凑结构C、线性结构和非线性结构D、内部结构和外部结构6、算法的时间复杂度取决于（A）A、问题的规模B、待处理数据的初态C、问题的规模和待处理数据的初态线性表1、线性表的存储结构包括顺序存储结构和链式存储结构两种。
2、表长为n的顺序存储的线性表，当在任何位置上插入或删除一个元素的概率相等时，插入一个元素所需移动元素的平均次数为（E），删除一个元素需要移动的元素的个数为（A）。
A、(n-1)/2B、nC、n+1D、n-1E、n/2F、(n+1)/2G、(n-2)/23、“线性表的逻辑顺序与存储顺序总是一致的。
”这个结论是（B）A、正确的B、错误的C、不一定，与具体的结构有关4、线性表采用链式存储结构时，要求内存中可用存储单元的地址（D）A、必须是连续的B、部分地址必须是连续的C一定是不连续的D连续或不连续都可以5、带头结点的单链表为空的判定条件是（B）A、head==NULLB、head->ne某t==NULLC、head->ne某t=headD、head!=NULL6、不带头结点的单链表head为空的判定条件是（A）A、head==NULLB、head->ne某t==NULLC、head->ne某t=headD、head!=NULL7、非空的循环单链表head的尾结点P满足（C）A、p->ne某t==NULLB、p==NULLC、p->ne某t==headD、p==head8、在一个具有n个结点的有序单链表中插入一个新结点并仍然有序的时间复杂度是（B）A、O(1)B、O(n)C、O(n2)D、O(nlog2n)数据结构(第4版）习题及实验参考答案9、在一个单链表中，若删除p所指结点的后继结点，则执行（A）A、p->ne某t=p->ne某t->ne某t;B、p=p->ne某t;p->ne某t=p->ne某t->ne某t;C、p->ne某t=p->ne某t;D、p=p->ne某t->ne某t;10、在一个单链表中，若在p所指结点之后插入所指结点，则执行（B）A、->ne某t=p;p->ne某t=;B、->ne某t=p->ne某t;p->ne某t=;C、->ne某t=p->ne某t;p=;D、p->ne某t=;->ne某t=p;11、在一个单链表中，已知q是p的前趋结点，若在q和p之间插入结点，则执行（C）A、->ne某t=p->ne某t;p->ne某t=;B、p->ne某t=->ne某t;->ne某t=p;C、q->ne某t=;->ne某t=p;D、p->ne某t=;->ne某t=q;12、在线性结构中，第一个结点没有前趋结点，其余每个结点有且只有1个前趋结点。
桂电数据结构实验二叉树答案
桂电数据结构实验二叉树答案1. 对于一棵具有n个结点、度为4的树来说，_______________。
[单选题] *A. 树的高度至多是n-3(正确答案)B. 树的高度至多是n-4C. 第i层上至多有4*(i-1)个结点D. 至少在某一层上正好有4个结点2. 一棵完全二叉树上有1001个结点，其中叶子结点的个数是___________。
[单选题] *A. 250B. 501(正确答案)C. 254D. 5053. 在高度为h的完全二叉树中，______________________。
[单选题] *A. 度为0的结点都在第h层上B. 第i （1≤i≤ h）层上结点都是度为2的结点C. 第i （1≤i < h）层上有个结点(正确答案)D. 不存在度为1的结点4. 若二叉树的中序遍历序列是abcdef，且c为根结点，则________________。
[单选题] *A. 结点c有两个孩子(正确答案)B. 二叉树有两个度为0的结点C. 二叉树的高度为5D. 以上都不对5. 在任何一棵二叉树中，如果结点a有左孩子b和右孩子c，则在结点的先序序列、中序序列和后序序列中，___________。
[单选题] *A. 结点b一定在结点a的前面B. 结点a一定在结点c的前面C. 结点b一定在结点c的前面(正确答案)D. 结点a一定在结点b的前面6. 设n、m为一棵二叉树上的两个结点，在中序遍历时，n在m前的条件是___________。
[单选题] *A. n在m的右方B. n是m的祖先C. n在m的左方(正确答案)D. n是m的子孙7. 如果在一棵二叉树的先序序列、中序序列和后序序列中，结点a、b的位置都是a在前、b在后（形如…a…b…），则___________ 。
[单选题] *A. a、b可能是兄弟(正确答案)B. a可能是b的双亲C. a可能是b的孩子D. 不存在这样的二叉树8. 若一棵二叉树具有10个度为2的结点，5个度为1的结点，则度为0的结点个数是_________。
数据结构试题及答案(10套)
数据结构试题及答案(10套)数据结构试题及答案(10套)根据您的需求，我为您准备了10套数据结构试题及答案。
每套试题包含以下几个部分：选择题、填空题、编程题及答案解析。
下面是试题的具体内容：第一套试题：选择题：1. 在数据结构中，什么是栈？A. 先进先出（FIFO）的数据结构B. 后进先出（LIFO）的数据结构C. 随机访问的数据结构D. 无序排列的数据结构2. 以下哪种操作与队列的特性不相符？A. 入队操作B. 出队操作C. 查找操作D. 获取队首元素填空题：1. ______ 是一种动态集合，支持插入、删除和查找等操作。
2. 在二叉搜索树中，中序遍历的结果是________。
编程题：实现一个栈的数据结构，并包含以下操作：- push(x)：将元素 x 压入栈中- pop()：删除栈顶的元素并返回该元素- top()：获取栈顶元素的值- empty()：检查栈是否为空答案解析：选择题：B、C填空题：1. 集合 2. 升序序列编程题：略第二套试题：选择题：1. 以下哪个数据结构是一种广度优先搜索的应用？A. 栈B. 队列C. 堆D. 链表2. 在链表中，如果要删除一个节点，只给出该节点的指针，那么需要通过什么方式完成删除操作？A. 直接删除该节点B. 指向该节点的前一个节点的指针C. 指向该节点的后一个节点的指针D. 无法完成删除操作填空题：1. 树是一种________的数据结构。
2. 二叉树每个节点最多有______个子节点。
编程题：实现一个队列的数据结构，并包含以下操作：- enqueue(x)：将元素 x 入队- dequeue()：删除队首的元素并返回该元素- peek()：获取队首元素的值- is_empty()：检查队列是否为空答案解析：选择题：B、B填空题：1. 分层组织 2. 2编程题：略（以下部分省略）通过以上的题目，您可以对数据结构的知识点进行综合练习和复习。
每套试题包含了不同难度和类型的题目，能够帮助您全面了解和掌握数据结构的概念和操作。
数据结构实验报告 答案
数据结构实验报告答案一、实验目的本次数据结构实验的主要目的是通过实际编程和操作，深入理解和掌握常见的数据结构，如数组、链表、栈、队列、树和图等，并能够运用这些数据结构解决实际问题，提高编程能力和算法设计能力。
二、实验环境操作系统：Windows 10编程语言：C+＋开发工具：Visual Studio 2019三、实验内容1、数组操作定义一个整数数组，实现数组元素的输入、输出和查找功能。
对数组进行排序（选择排序、冒泡排序等），并输出排序后的数组。
2、链表操作构建一个单向链表，实现链表节点的插入、删除和遍历操作。
反转链表，并输出反转后的链表。
3、栈和队列操作用数组实现栈和队列的数据结构，实现入栈、出栈、入队、出队等基本操作。
利用栈实现表达式求值（中缀表达式转后缀表达式，然后计算后缀表达式的值）。
4、树的操作构建二叉树（可以采用顺序存储或链式存储），实现二叉树的前序、中序和后序遍历。
实现二叉树的查找、插入和删除节点操作。
5、图的操作用邻接矩阵或邻接表表示图，实现图的深度优先遍历和广度优先遍历。
求解图的最短路径（Dijkstra 算法或 Floyd 算法）。
四、实验步骤及代码实现1、数组操作｀｀｀cppinclude ＜iostream>using namespace std;／／数组输入函数void inputArray(int arr, int size) ｛cout ＜＜＂请输入＂＜＜ size ＜＜＂个整数：＂＜＜ endl; for （int i ＝ 0; i ＜ size; i+＋）｛cin ＞＞ arri;｝｝／／数组输出函数void outputArray(int arr, int size) ｛cout ＜＜＂数组元素为：＂＜＜ endl;for （int i ＝ 0; i ＜ size; i+＋）｛cout ＜＜ arri ＜＜＂＂；｝cout ＜＜ endl;｝／／数组查找函数int searchArray(int arr, int size, int target) ｛for （int i ＝ 0; i ＜ size; i+＋）｛if （arri ＝＝ target) ｛return i;｝｝return －1;｝／／选择排序函数void selectionSort(int arr, int size) ｛for （int i ＝ 0; i ＜ size 1; i+＋）｛int minIndex ＝ i;for （int j ＝ i ＋ 1; j ＜ size; j+＋）｛if （arrj ＜ arrminIndex) ｛minIndex ＝ j;｝｝if （minIndex!＝ i) ｛int temp ＝ arri;arri ＝ arrminIndex;arrminIndex ＝ temp;｝｝｝／／冒泡排序函数void bubbleSort(int arr, int size) ｛for （int i ＝ 0; i ＜ size 1; i+＋）｛for （int j ＝ 0; j ＜ size i 1; j+＋）｛if （arrj ＞ arrj ＋ 1) ｛int temp ＝ arrj;arrj ＝ arrj ＋ 1;arrj ＋ 1 ＝ temp;｝｝｝｝int main(）｛int size ＝ 10;inputArray(arr, size)；outputArray(arr, size)；int target ＝ 5;int result ＝ searchArray(arr, size, target)；if （result!＝－1) ｛cout ＜＜＂找到目标元素＂＜＜ target ＜＜＂，在数组中的索引为＂＜＜ result ＜＜ endl;｝ else ｛cout ＜＜＂未找到目标元素＂＜＜ target ＜＜ endl;｝selectionSort(arr, size)；outputArray(arr, size)；bubbleSort(arr, size)；outputArray(arr, size)；return 0;｝2、链表操作｀｀｀cppinclude ＜iostream>using namespace std;／／链表节点结构体struct ListNode ｛int data;ListNode next;ListNode(int x) ： data(x)， next(NULL) ｛｝｝；／／链表插入函数void insertNode(ListNode& head, int val) ｛ListNode newNode ＝ new ListNode(val)；if （head ＝＝ NULL) ｛head ＝ newNode;return;｝ListNode curr ＝ head;while （curr>next!＝ NULL) ｛curr ＝ curr>next;｝curr>next ＝ newNode;｝／／链表删除函数void deleteNode(ListNode& head, int val) ｛if （head ＝＝ NULL) ｛return;｝if （head>data ＝＝ val) ｛ListNode temp ＝ head;head ＝ head>next;delete temp;return;｝ListNode curr ＝ head;while （curr>next!＝ NULL ＆＆ curr>next>data!＝ val) ｛curr ＝ curr>next;｝if （curr>next!＝ NULL) ｛ListNode temp ＝ curr>next;curr>next ＝ curr>next>next;delete temp;｝｝／／链表遍历函数void traverseList(ListNode head) ｛ListNode curr ＝ head;while （curr!＝ NULL) ｛cout ＜＜ curr>data ＜＜＂＂；curr ＝ curr>next;｝cout ＜＜ endl;｝／／链表反转函数ListNode reverseList(ListNode head) ｛ListNode prev ＝ NULL;ListNode curr ＝ head;while （curr!＝ NULL) ｛ListNode nextTemp ＝ curr>next; curr>next ＝ prev;prev ＝ curr;curr ＝ nextTemp;｝return prev;｝int main(）｛ListNode head ＝ NULL;insertNode(head, 1)；insertNode(head, 2)；insertNode(head, 3)；insertNode(head, 4)；insertNode(head, 5)；traverseList(head)；deleteNode(head, 3)；traverseList(head)；ListNode reversedHead ＝ reverseList(head)；traverseList(reversedHead)；return 0;｝｀｀｀3、栈和队列操作｀｀｀cppinclude ＜iostream>using namespace std;／／用数组实现栈const int MAX_SIZE ＝ 100;class Stack ｛private:int arrMAX_SIZE;int top;public:Stack(）｛top ＝－1;｝／／入栈void push(int val) ｛if （top ＝＝ MAX_SIZE 1) ｛cout ＜＜＂栈已满，无法入栈" ＜＜ endl; return;｝arr+＋top ＝ val;｝／／出栈int pop(）｛if （top ＝＝－1) ｛cout ＜＜＂栈为空，无法出栈" ＜＜ endl; return －1;｝int val ＝ arrtop;top;return val;｝／／查看栈顶元素int peek(）｛if （top ＝＝－1) ｛cout ＜＜＂栈为空" ＜＜ endl;return －1;｝return arrtop;｝／／判断栈是否为空bool isEmpty(）｛return top ＝＝－1;｝｝；／／用数组实现队列class Queue ｛private:int arrMAX_SIZE;int front, rear;public:Queue(）｛front ＝ rear ＝－1;｝／／入队void enqueue(int val) ｛if （（rear ＋ 1) ％ MAX_SIZE ＝＝ front) ｛cout ＜＜＂队列已满，无法入队" ＜＜ endl; return;｝if （front ＝＝－1) ｛front ＝ 0;｝rear ＝（rear ＋ 1) ％ MAX_SIZE;arrrear ＝ val;｝／／出队int dequeue(）｛if （front ＝＝－1) ｛cout ＜＜＂队列为空，无法出队" ＜＜ endl; return －1;｝int val ＝ arrfront;if （front ＝＝ rear) ｛front ＝ rear ＝－1;｝ else ｛front ＝（front ＋ 1) ％ MAX_SIZE;｝return val;｝／／查看队头元素int peek(）｛if （front ＝＝－1) ｛cout ＜＜＂队列为空" ＜＜ endl;return －1;｝return arrfront;｝／／判断队列是否为空bool isEmpty(）｛return front ＝＝－1;｝｝；／／表达式求值函数int evaluateExpression(string expression) ｛Stack operandStack;Stack operatorStack;for （int i ＝ 0; i ＜ expressionlength(）； i+＋）｛char c ＝ expressioni;if （isdigit(c)）｛int operand ＝ 0;while （i ＜ expressionlength(）＆＆ isdigit(expressioni)）｛operand ＝ operand 10 ＋（expressioni+＋＇0'）；｝i;operandStackpush(operand)；｝ else if （c ＝＝＇＋＇｜｜ c ＝＝＇＇｜｜ c ＝＝＇＇｜｜ c ＝＝＇／＇）｛while （！operatorStackisEmpty(）＆＆precedence(operatorStackpeek(））＞＝ precedence(c)）｛int operand2 ＝ operandStackpop(）；int operand1 ＝ operandStackpop(）；char op ＝ operatorStackpop(）；int result ＝ performOperation(operand1, operand2, op)；operandStackpush(result)；｝operatorStackpush(c)；｝ else if （c ＝＝＇（＇）｛operatorStackpush(c)；｝ else if （c ＝＝＇）＇）｛while （operatorStackpeek(）！＝＇（＇）｛int operand2 ＝ operandStackpop(）；int operand1 ＝ operandStackpop(）；char op ＝ operatorStackpop(）；int result ＝ performOperation(operand1, operand2, op)；operandStackpush(result)；｝operatorStackpop(）；｝｝while （！operatorStackisEmpty(））｛int operand2 ＝ operandStackpop(）；int operand1 ＝ operandStackpop(）；char op ＝ operatorStackpop(）；int result ＝ performOperation(operand1, operand2, op)；operandStackpush(result)；｝return operandStackpop(）；｝／／运算符优先级函数int precedence(char op) ｛if （op ＝＝＇＋＇｜｜ op ＝＝＇＇）｛return 1;｝ else if （op ＝＝＇＇｜｜ op ＝＝＇／＇）｛return 2;｝return 0;｝／／运算函数int performOperation(int operand1, int operand2, char op) ｛switch （op) ｛case ＇＋＇：return operand1 ＋ operand2;case ＇＇：return operand1 operand2;case ＇＇：return operand1 operand2;case ＇／＇：if （operand2!＝ 0) ｛return operand1 ／ operand2;｝ else ｛cout ＜＜＂除数不能为 0" ＜＜ endl;return －1;｝｝return －1;｝int main(）｛Stack stack;stackpush(1)；stackpush(2)；stackpush(3)；cout ＜＜＂栈顶元素：＂＜＜ stackpeek(）＜＜ endl;cout ＜＜＂出栈元素：＂＜＜ stackpop(）＜＜ endl;cout ＜＜＂栈是否为空：＂＜＜（stackisEmpty(）？＂是" ：＂否"）＜＜ endl;Queue queue;queueenqueue(1)；queueenqueue(2)；queueenqueue(3)；cout ＜＜＂队头元素：＂＜＜ queuepeek(）＜＜ endl;cout ＜＜＂出队元素：＂＜＜ queuedequeue(）＜＜ endl;cout ＜＜＂队列是否为空：＂＜＜（queueisEmpty(）？＂是" ：＂否"）＜＜ endl;string expression ＝＂2+34"；int result ＝ evaluateExpression(expression)；cout ＜＜ expression ＜＜＂＝＂＜＜ result ＜＜ endl; return 0;｝｀｀｀4、树的操作｀｀｀cppinclude ＜iostream>using namespace std;／／二叉树节点结构体struct TreeNode ｛int val;TreeNode left;TreeNode right;TreeNode(int x) ： val(x)， left(NULL)， right(NULL) ｛｝｝；／／前序遍历函数void preOrderTraversal(TreeNode root) ｛return;｝cout ＜＜ root>val ＜＜＂＂；preOrderTraversal(root>left)；preOrderTraversal(root>right)；｝／／中序遍历函数void inOrderTraversal(TreeNode root) ｛if （root ＝＝ NULL) ｛return;｝inOrderTraversal(root>left)；cout ＜＜ root>val ＜＜＂＂；inOrderTraversal(root>right)；｝／／后序遍历函数void postOrderTraversal(TreeNode root) ｛return;｝postOrderTraversal(root>left)；postOrderTraversal(root>right)；cout ＜＜ root>val ＜＜＂＂；｝／／查找函数TreeNode searchBST(TreeNode root, int val) ｛if （root ＝＝ NULL ｜｜ root>val ＝＝ val) ｛return root;｝if （val ＜ root>val) ｛return searchBST(root>left, val)；｝ else ｛return searchBST(root>right, val)；｝｝／／插入函数TreeNode insertBST(TreeNode root, int val) ｛if （root ＝＝ NULL) ｛return new TreeNode(val)；｝if （val ＜ root>val) ｛root>left ＝ insertBST(root>left, val)；｝ else if （val ＞ root>val) ｛root>right ＝ insertBST(root>right, val)；｝return root;｝／／删除函数TreeNode deleteNodeBST(TreeNode root, int key) ｛if （root ＝＝ NULL) ｛return root;｝if （key ＜ root>val) ｛root>left ＝ deleteNodeBST(root>left, key)；｝ else if （key ＞ root>val) ｛root>right ＝ deleteNodeBST(root>right, key)；｝ else ｛if （root>left ＝＝ NULL) ｛TreeNode temp ＝ root>right;delete root;return temp;｝ else if （root>right ＝＝ NULL) ｛TreeNode temp ＝ root>left;delete root;return temp;｝TreeNode minNode ＝ root>right;while （minNode>left!＝ NULL) ｛minNode ＝ minNode>left;｝root>val ＝ minNode>val;root>right ＝ deleteNodeBST(root>right, minNode>val)；｝return root;｝int main(）｛TreeNode root ＝ new TreeNode(4)；root>left ＝ new TreeNode(2)；root>right ＝ new TreeNode(6)；root>left>left ＝ new TreeNode(1)；root>left>right ＝ new TreeNode(3)；root>right>left ＝ new TreeNode(5)；root>right>right ＝ new TreeNode(7)；cout ＜＜＂前序遍历：＂＜＜ endl; preOrderTraversal(root)；cout ＜＜ endl;cout ＜＜＂中序遍历：＂＜＜ endl; inOrderTraversal(root)；cout ＜＜ endl;cout ＜＜＂后序遍历：＂＜＜ endl; postOrderTraversal(root)；cout ＜＜ endl;int target ＝ 3;TreeNode foundNode ＝ searchBST(root, target)；if （foundNode!＝ NULL) ｛cout ＜＜＂找到目标节点＂＜＜ target ＜＜ endl;｝ else ｛cout ＜＜＂未找到目标节点＂＜＜ target ＜＜ endl;｝root ＝ insertBST(root, 8)；cout ＜＜＂插入节点 8 后的中序遍历：＂＜＜ endl; inOrderTraversal(root)；cout ＜＜ endl;root ＝ deleteNodeBST(root, 2)；cout ＜＜＂删除节点 2 后的中序遍历：。
数据结构完整题目及答案1
数据结构与算法实验报告目录实验一学生成绩分析程序 (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 门课的成绩信息。
(完整版)数据结构实验答案及解析
《数据结构》实验指导2013 / 2014 学年第 2学期姓名：______________学号：_________班级：______________指导教师：______________潍坊学院计算机工程学院2014预备实验 C语言的函数数组指针结构体知识一、实验目的1、复习C语言中函数、数组、指针和结构体的概念。
2、熟悉利用C语言进行程序设计的一般方法。
二、实验内容和要求1、调试程序：输出100以内所有的素数（用函数实现）。
#include<stdio.h>/*判断一个数是否为素数*/int isprime(int n){for(int m=2;m*m<=n;m++){if(n%m= =0) return 0;return 1;}/*输出100以内所有素数*/int main(){int i;for(i=2;i<100;i++)if(isprime(i)= =1) printf(“%4d”,i);return 0;}运行结果：2、调试程序：对一维数组中的元素进行逆序排列。
#include<stdio.h>#define N 10int main(){int a[N]={0,1,2,3,4,5,6,7,8,9},i,temp;printf(“the original Array is:\n ”);for(i=0;i<N;i++)printf(“%4d”,a[i]);for(i=0;i<N/2;i++){ /*交换数组元素使之逆序*/temp=a[i];a[i]=a[N-i-1];a[N-i-1]=temp;}printf(“\nthe changed Array is:\n”);for(i=0;i<N;i++)printf(“%4d”,a[i]);return 0;}运行结果：3、调试程序：在二维数组中，若某一位置上的元素在该行中最大，而在该列中最小，则该元素即为该二维数组的一个鞍点。
数据结构(图)习题与答案
一、单选题1、设有5个结点的无向图，该图至少应有_________条边才能确保是一个连通图。
A.7B.8C.6D.5正确答案：A2、设图G=(V,VR)，其中: V={A,B,C,D,G}，VR={(A,C),(A,D),( B,C),(B,D) ,(G,C),(B,G)}，则对应的图形为_________。
A.B.C.D.正确答案：C3、设某有向图中有n个顶点，则该有向图对应的邻接表中有_________个表头结点。
A.n-1B.n+2C.nD.n+1正确答案：C4、在一个无向图中所有顶点的度数之和等于所有边数的_________倍。
A.1B.2C.3D.1/2正确答案：B5、一个无向连通图的生成树是该连通图的_____。
A.极小连通子图B.强连通子图C.连通子图D.极大连通子图正确答案：A6、设某无向图中有n个顶点，则该无向图邻接矩阵的大小是_________。
A.n(n+1)/2B.（n-1）2C. n2D. （n+1）2正确答案：C7、设有n个顶点e条边的无向图，采用邻接矩阵作为物理结构，则删除与某顶点Vi 关联的所有边算法的时间复杂度为_________。
A.O(n2)B.O(n+e）C.O(n*e）正确答案：D8、设有n个顶点e条弧的有向图，采用邻接表作为物理结构，则求某顶点Vi度的算法的时间复杂度为_________。
A.O(n）B.O(n*e）C.O(n+e）D.O(n2)正确答案：C9、设无向图G=(V,E)和G'=(V',E')，如果G'是G的生成树，则下列说法中错误的是_____。
A.G'是G的连通分量B.G'是G的一个无环子图C.G'是G的极小连通子图且V=V'D.G'是G的子图正确答案：A10、设G是一个非连通的无向图，共有10条边，则该图至少有_____个顶点。
A.7B.6C.5D.8正确答案：B11、 n个顶点的有向图为强连通图时，至少含有________。
数据结构实验指导书及其答案pdf
引言概述正文内容
1.实验环境配置
1.1硬件要求
计算机硬件配置要求
操作系统要求
附加硬件设备要求（如虚拟机等）
1.2软件要求
编程语言要求（如C/C++、Java等）开发环境配置（如IDE、编译器等）1.3实验库和工具
实验需要使用的库文件和工具
如何获取和配置实验库和工具
2.实验内容介绍
2.1实验目标和背景
数据结构实验的作用和意义
实验背景和相关应用领域介绍
2.2实验概述
实验内容的大致流程和步骤
实验中可能遇到的问题和挑战
2.3实验要求
对学生实验流程和实验结果的要求
实验过程中需要注意的事项和技巧
3.实验步骤
3.1实验准备
配置实验环境
获取实验所需数据和文件
3.2实验具体步骤
根据实验要求将数据结构知识应用到具体问题中根据实验要求实现相应的算法和数据结构
3.3实验示例代码
提供示例代码以供学生参考和学习
解析示例代码中的关键步骤和实现细节
4.实验答案
4.1实验题目
实验题目及相关说明
确定实验的具体要求和目标
4.2实验答案解析
对实验答案的具体实现进行解析
对实验中可能遇到的问题和错误进行分析和解决4.3实验答案示例
提供实验答案的示例代码
解析实验答案中的关键实现步骤和说明
5.实验总结
5.1实验成果评估
对学生实验成果进行评估
分析实验结果的优点和不足
5.2实验心得
学生对本次实验的收获和感想
学生对未来实验的建议和展望
总结。
数据结构题库及答案Excel
数据结构题库及答案Excel1. 单链表的插入操作- 问题：请描述在单链表中插入一个新节点的步骤。
- 答案：首先确定插入位置，然后创建一个新节点。
将新节点的next指针指向原链表中该位置的节点。
接着，更新前一个节点的next指针指向新节点。
最后，如果插入位置是链表头部，则更新头指针。
2. 二叉树的遍历方法- 问题：请列举二叉树的三种基本遍历方法。
- 答案：前序遍历（根-左-右）、中序遍历（左-根-右）、后序遍历（左-右-根）。
3. 哈希表的冲突解决方法- 问题：在哈希表中，如何解决冲突？- 答案：常见的冲突解决方法有开放地址法（线性探测、二次探测、双重哈希）和链地址法。
4. 堆排序的基本原理- 问题：堆排序的基本原理是什么？- 答案：堆排序基于二叉堆数据结构，通过构建最大堆或最小堆，然后逐步将堆顶元素与堆尾元素交换，缩小堆的范围，最后得到有序序列。
5. 图的深度优先搜索（DFS）- 问题：请简述图的深度优先搜索（DFS）的基本思想。
- 答案：DFS从图的某个顶点开始，沿着邻接表的边尽可能深地搜索，直到无法继续为止，然后回溯到上一个顶点，继续搜索其他邻接顶点。
6. 快速排序算法的时间复杂度- 问题：快速排序算法的平均时间复杂度是多少？- 答案：快速排序算法的平均时间复杂度为O(n log n)。
7. 栈的后进先出（LIFO）特性- 问题：栈的后进先出特性是如何体现的？- 答案：栈的LIFO特性体现在元素的添加和删除操作都发生在栈顶，即最后添加的元素最先被删除。
8. 队列的先进先出（FIFO）特性- 问题：队列的先进先出特性是如何体现的？- 答案：队列的FIFO特性体现在元素的添加操作在队尾进行，而删除操作在队首进行，即最先添加的元素最先被删除。
9. 最小生成树的构造方法- 问题：请列举两种最小生成树的构造方法。
- 答案：普里姆（Prim）算法和克鲁斯卡尔（Kruskal）算法。
10. 动态规划的适用场景- 问题：动态规划适用于解决哪些类型的问题？- 答案：动态规划适用于具有重叠子问题和最优子结构特性的问题，如斐波那契数列、背包问题、最长公共子序列等。
太原理工数据结构实验答案
实验一线性表一．目的与要求本次实习的主要目的是为了使学生熟练掌握线性表的基本操作在顺序存储结构和链式存储结构上的实现，提高分析和解决问题的能力。
要求仔细阅读并理解下列例题，上机通过，并观察其结果，然后独立完成后面的实习题。
二．例题问题描述:用链表形式存储一个字符串，插入、删除某个字符，最后按正序、逆序两种方式输出字符串。
输入:初始字符串，插入位置，插入字符，删除字符。
输出:已建立链表（字符串），插入字符后链表，删除字符后链表，逆转后链表。
存储结构:采用链式存储结构算法的基本思想:建立链表当读入字符不是结束符时，给结点分配存储空间，写数据域，将新结点插到表尾；插入字符：根据读入的字符在链表中找插入位置，将新结点插入到该位置之前；删除字符：根据读入的删除字符在链表中找到被删结点后，将其从链表中删除；链表逆转：从链表的第一个结点开始对所有结点处理，将每个结点的前驱变为它的后继；打印链表：从链表的第一个结点开始，依次打印各[运行情况]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语言时就已经写过了，这里采用顺序表来存储数据。
华南农业大学数据结构上机答案实验
华南农业大学数据结构上机答案实验8583 顺序栈的基本操作时间限制:1000MS 内存限制:1000K提交次数:530 通过次数:212题型: 编程题语言: 无限制Description创建一个空的顺序栈，并实现栈的入栈、出栈、返回栈的长度、返回栈顶元素、栈的遍历等基本算法。
请将下#include<malloc.h>#include<stdio.h>#define OK 1#define ERROR 0#define STACK_INIT_SIZE 100 // 存储空间初始分配量#define STACKINCREMENT 10 // 存储空间分配增量typedef int SElemType; // 定义栈元素类型typedef int Status; // Status是函数的类型,其值是函数结果状态代码，如OK 等struct SqStack{SElemType *base; // 在栈构造之前和销毁之后，base的值为NULL SElemType *top; // 栈顶指针int stacksize; // 当前已分配的存储空间，以元素为单位}; // 顺序栈Status InitStack(SqStack &S){// 构造一个空栈S，该栈预定义大小为STACK_INIT_SIZE// 请补全代码S.base=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));if(!S.base) return ERROR;S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;}Status Push(SqStack &S,SElemType e){// 在栈S中插入元素e为新的栈顶元素// 请补全代码if(S.top-S.base>=S.stacksize){S.base=(SElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SEl emType));if(!S.base) return ERROR;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;}Status Pop(SqStack &S,SElemType &e){// 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR// 请补全代码if(S.top==S.base) return ERROR;e=*--S.top;return OK;}Status GetTop(SqStack S,SElemType &e){// 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR // 请补全代码if(S.top==S.base) return ERROR;e=*(S.top-1);return OK;}int StackLength(SqStack S){// 返回栈S的元素个数// 请补全代码return S.top-S.base;}Status StackTraverse(SqStack S){// 从栈顶到栈底依次输出栈中的每个元素SElemType *p = (SElemType *)malloc(sizeof(SElemType));p = S.top ; //请填空if(S.top==S.base)printf("The Stack is Empty!"); //请填空else{printf("The Stack is: ");p--;while(p>=S.base) //请填空{printf("%d ", *p);p--; //请填空}}printf("\n");return OK;}int main(){int a;SqStack S;SElemType x, e;if(InitStack(S)) // 判断顺序表是否创建成功，请填空{printf("A Stack Has Created.\n");}while(1){printf("1:Push \n2:Pop \n3:Get the Top \n4:Return the Length of the Stack\n5:Load the Stack\n0:Exit\nPlease choose:\n");scanf("%d",&a);switch(a){case 1: scanf("%d", &x);if(!Push(S,x)) printf("Push Error!\n"); // 判断Push是否合法，请填空else printf("The Element %d is Successfully Pushed!\n", x); break;case 2: if(!Pop(S,e)) printf("Pop Error!\n"); // 判断Pop是否合法，请填空else printf("The Element %d is Successfully Poped!\n", e); break;case 3: if(!GetTop(S,e))printf("Get Top Error!\n"); // 判断Get Top 是否合法，请填空else printf("The Top Element is %d!\n", e);break;case 4: printf("The Length of the Stack is %d!\n",StackLength(S)); //请填空break;case 5: StackTraverse(S); //请填空break;case 0: return 1;}}}8584 循环队列的基本操作时间限制:1000MS 内存限制:1000K提交次数:366 通过次数:157题型: 编程题语言: 无限制Description创建一个空的循环队列，并实现入队、出队、返回队列的长度、返回队头元素、队列的遍历等基本算法。
国家开放大学《数据结构》课程实验报告(实验2——线性表)参考答案
//在链表中删除最高分和最低分结点
for(q=head,p=head->next;p!=NULL;q=p,p=p->next)
{
if(p==pmin) { q->next=p->next; p=q; } //删除最低分结点
};
typedef struct pw PW;
//定义链表结点
struct node
{
PW data;
struct node * next;
};
typedef struct node NODE;
NODE *create(int n); //建立单链表
void input(NODE *s,int i); //输入第i个评委信息
（5）遍历链表，累加求和，计算总分及平均分，并输出相关信息。
完整程序
//实验1.1线性表的链接存储结构
#include
#include
#include
#define PWRS 5 //定义评委人数
//定义评委信息
struct pw
{
char name[8]; //姓名
short age; //年龄
float score; //评分
NODE *create(int n)
{
NODE *head,*p,*q;
inti;
p=(NODE*)malloc(sizeof(NODE));
head=p; q=p; p->next=NULL;
for(i=1; i<=n; i++)
{
p=(NODE*)malloc(sizeof(NODE));
《数据结构》实验报告二及其答案
《数据结构》实验报告二学校：班级：09软工A1学号：09XXXXX 姓名：XXX日期：2010 .04.08 程序名：L2311.CPP一、上机实验的问题和要求：单链表的查找、插入与删除。
设计算法，实现线性结构上的单链表的产生以及元素的查找、插入与删除。
具体实现要求：1.从键盘输入20个整数，产生带表头的单链表，并输入结点值。
2.从键盘输入1个整数，在单链表中查找该结点。
若找到，则显示“找到了”；否则，则显示“找不到”。
3.从键盘输入2个整数，一个表示欲插入的位置i，另一个表示欲插入的数值x，将x插入在对应位置上，输出单链表所有结点值，观察输出结果。
4.从键盘输入1个整数，表示欲删除结点的位置，输出单链表所有结点值，观察输出结果。
5.将单链表中值重复的结点删除，使所得的结果表中个结点值均不相同，输出单链表所有结点值，观察输出结果。
6.删除其中所有数据值为偶数的结点，输出单链表所有结点值，观察输出结果。
7.把单链表变成带表头结点的循环链表，输出循环单链表所有结点值，观察输出结果。
8.（★）将单链表分解成两个单链表A和B，使A链表中含有原链表中序号为奇数的元素，而B链表中含有原链表中序号为偶数的元素，且保持原来的相对顺序，分别输出单链表A和单链表B的所有结点值，观察输出结果。
二、程序设计的基本思想，原理和算法描述：（包括程序的结构，数据结构，输入/输出设计，符号名说明等）三、源程序及注释：#include <iostream.h>//单链表的定义：typedef int DataType; //DataType可以是任何相应的数据类型如int, float或char typedef struct node //结点类型定义{ DataType data; //结点的数据域struct node *next; //结点的指针域}ListNode,*LinkList;//typedef ListNode *LinkList;void main(){int i;DataType key,x;LinkList head;//ListNode *p;LinkList p;LinkList CreateList(void);void PrintList(LinkList head);LinkList LocateNode(LinkList head,DataType key);LinkList GetNode(LinkList head,int i);void InsertList(LinkList head,DataType x,int i);void DeleteList(LinkList head,int i);void DeleteManyList(LinkList head);void DeleteEvenList(LinkList head);void ChangeCircList(LinkList head);void PrintCircList(LinkList head);head=CreateList(); //建立单链表PrintList(head); //打印单链表cout<<"输入要查找的值:";cin>>key;p=LocateNode(head,key); //单链表查找cout<<"输入要查找的位置:";cin>>i;p=GetNode(head, i);cout<<"请输入欲插入元素的位置:";cin>>i;cout<<"请输入欲插入的元素(整数):";cin>>x;InsertList(head,x,i); //单链表插入PrintList(head); //打印单链表cout<<"请输入欲删除结点的位置:";cin>>i;DeleteList(head,i); //单链表删除PrintList(head); //打印单链表DeleteManyList(head); //删除重复值PrintList(head); //打印单链表DeleteEvenList(head); //删除偶数值PrintList(head); //打印单链表ChangeCircList(head); //修改为循环单链表PrintCircList(head); //打印循环单链表/*void DivideList(LinkList head,LinkList *A,LinkList *B);//分割成两个单链表DivideList(head, &A, &B);PrintList(A);PrintList(B);*/}//单链表的建立：LinkList CreateList(void){LinkList head,p,q;head=new ListNode;head->next=NULL;q=head;cout<<"输入20个整数(以空格分隔):";for(int i=0;i<20;i++){p=new ListNode;cin>>p->data;q->next=p;q=q->next;}q->next=NULL;return head;//在此插入必要的语句}//单链表的打印：void PrintList(LinkList head){LinkList L=head;cout<<"单链表打印:";while(L->next!=NULL){cout<<L->next->data<<" ";L=L->next;}cout<<endl;//在此插入必要的语句}//单链表的查找1：LinkList LocateNode(LinkList head,DataType key) {LinkList L=head;while(L->next!=NULL){{cout<<"找到了!\n";return L;}L=L->next;}cout<<"没找到!\n";return L;//在此插入必要的语句}//*单链表的查找2：LinkList GetNode(LinkList head,int i){LinkList L=head;for(int j=1;j<=i;j++){L=L->next;if(L->next==NULL){cout<<"<警告!您输入的节点位置不存在!>\n查找失败!\n";return L;}}if(i<=0){cout<<"<警告!您输入的节点位置不存在!>\n查找失败!\n";return L;}cout<<L->data;cout<<"找到了!\n";return L;}//单链表的插入：void InsertList(LinkList head,DataType x,int i){LinkList L=head,p;for(int j=1;j<i;j++){//if(L->next->next==NULL){cout<<"<警告!您输入的元素位置不存在,程序自动将数插到链表尾部!>\n";break;}L=L->next;}if(i<=0){cout<<"<警告!您输入的元素位置不存在,程序自动将数插到链表的头结的后面!>\n";}//L=L->next;p=new ListNode;p->data=x;p->next=L->next;L->next=p;//在此插入必要的语句}//单链表的删除：void DeleteList(LinkList head,int i){LinkList L=head;for(int j=1;j<i;j++){L=L->next;if(L->next==NULL){cout<<"<警告!您输入的节点位置不存在!>\n删除失败!\n";return;}}if(i<=0){cout<<"<警告!您输入的节点位置不存在!>\n删除失败!\n";return;}L->next=L->next->next;cout<<"删除成功!\n";//在此插入必要的语句}//删除单链表中重复值：void DeleteManyList(LinkList head){LinkList L=head,p;cout<<"删除链表中重复的元素\n";while(L->next!=NULL){p=L->next;while(p->next!=NULL){if(L->next->data==p->next->data)L->next=L->next->next;p=p->next;}L=L->next;}//在此插入必要的语句}//删除单链表中偶数值：void DeleteEvenList(LinkList head){LinkList L=head;cout<<"删除链表中的偶数值\n";do{if(L->next->data%2==0){if(L->next->next!=NULL)L->next=L->next->next;else{L->next=NULL;break;}}L=L->next;}while(L->next!=NULL);//在此插入必要的语句}//修改为循环单链表：void ChangeCircList(LinkList head){LinkList L=head;cout<<"修改为循环单链表\n";while(L->next!=NULL){L=L->next;}L->next=head;//在此插入必要的语句}//循环单链表的打印：void PrintCircList(LinkList head){LinkList L=head;cout<<"循环单链表打印:";while(L->next!=head){cout<<L->next->data<<" ";L=L->next;}cout<<endl;//在此插入必要的语句}/*//分割成两个单链表void DivideList(LinkList head,LinkList *A,LinkList *B); {//在此插入必要的语句}*/四、运行输出结果：五、调试和运行程序过程中产生的问题及采取的措施：当需要插入和删除的数值超过20时，如果不写：if(L->next==NULL){cout<<"<警告!您输入的节点位置不存在!>\n删除失败!\n";return;}那么就会不产生效果.六、对算法的程序的讨论、分析，改进设想，其它经验教训：七、对实验方式、组织、设备、题目的意见和建议：。
数据结构实验答案
实验一：以单链表表示集合，设计算法建立先后输入的两个集合的差。
说明：已知两个集合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、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验四.稀疏矩阵的三元组顺序表示方法及基本操作的实现（建立、输出、转置）并实现一个主菜单来实现。
#include<stdio.h>#define maxsize 50#define maxrow 10#define maxcol 10typedef struct {int i,j;int data;}triple;typedef struct {triple elem[maxsize+1];int mu,nu,tu;}tsmatrix;void createsmatrix (tsmatrix *t){t=(tsmatrix*)malloc(sizeof(tsmatrix));if(!t) exit(0); t->mu=0; t->nu=0; t->tu=0;}void transposesmatrix(tsmatrix m,tsmatrix*t){int q=1,col,p;t->mu=m.nu;t->nu=m.mu;t->tu=m.tu;if(t->tu){q=1;for(col=1;col<=m.nu;col++)for(p=1;p<=m.tu;++p)if(m.elem[p].j==col){t->elem[q].i=m.elem[p].j;t->elem[q].j=m.elem[p].i;t->elem[q].data=m.elem[p].data;++q;}}}void scanftsmatrix(tsmatrix *t){int count;printf("enter the nums of matrix's rows:\n");scanf("%d",&t->mu);printf("enter the nums of matrix's columns:\n");scanf("%d",&t->nu);printf("enter the nums of matrix's datas:\n");scanf("%d",&t->tu);for(count=1;count<=t->tu;count++){printf("enter the non-zero nums'row,column,data:\n");scanf("%d%d%d",&t->elem[count].i,&t->elem[count].j,&t->elem[count].data); }}/*void printftsmatrix(tsmatrix*t){int counter,col;printf("the xishu juzheng is :\n");for(counter=1;counter<=t->tu;){for(col=1;col<=t->nu;col++){if(t->elem[counter].j==col) {printf("%d\t",t->elem[counter].data);counter++;if(t->elem[counter].i==t->elem[counter-1].i) ;else if(col==t->nu) printf("\n");else {for(col++;col<=t->nu;col++)printf("*\t");printf("\n"); }}else printf("*\t");}}}*/void printftsmatrix(tsmatrix*t){int counter,a[maxrow][maxcol]={0},row,col;int*p;p=&a;printf("the sparse matrix is :\n");for(counter=1;counter<=t->tu;counter++){a[t->elem[counter].i-1][t->elem[counter].j-1]=t->elem[counter].data;}for(row=1;row<=t->mu;row++){for(col=1;col<=t->nu;col++){printf("%d\t",*p);p++;}printf("\n");p=p+maxcol-col+1;}}void main(){tsmatrix T,M;int x;char character/*zifu*/,n;createsmatrix(&T);scanftsmatrix(&T);while(character!='#'){printf("choice:1--transposesmatrix;2--printftsmatrix\n");printf("enter the num for your choice\n");scanf("%d",&x);switch(x){case 1:transposesmatrix(T,&M);printftsmatrix(&M);break;case 2:printftsmatrix(&T);break;}n=getchar();printf("enter one char'#' for your choice to quit:\n");scanf("%c",&character);getch();}}实验五树及二叉树实验1)按先序次序输入二叉树中结点的值，建立一棵以二叉链表作存储结构的二叉树，后按先序、中序、后序顺序分别遍历这棵二叉树。
2)编写一个求二叉树叶子结点数的算法。
3)交换左右孩子。
#include <stdio.h>#define NULL 0typedef struct bitnode{int data;struct bitnode *lchild, *rchild;}bitnode,*bitree;void createbitree(bitree *t){char ch,zifu;scanf("%c",&ch);zifu=getchar();if(ch=='#') *t=NULL;else{if(!((*t)=(bitree)malloc(sizeof(bitnode)))) ;/* if(!(*t=(bitnode*)malloc(sizeof(bitnode)))) ;*/(*t)->data=ch;printf("enter the lchild\n");createbitree(&((*t)->lchild));printf("enter the rchild\n");createbitree(&((*t)->rchild));}}void preorder(bitree *t){if(*t!=NULL){printf("%c\t",(*t)->data);preorder(&((*t)->lchild));preorder(&((*t)->rchild));}}void inorder(bitree *t){if(*t!=NULL){inorder(&((*t)->lchild));printf("%c\t",(*t)->data);inorder(&((*t)->rchild));}}void postorder(bitree *t){if(*t!=NULL){postorder(&((*t)->lchild));postorder(&((*t)->rchild));printf("%c\t",(*t)->data);}}int leafcount(bitree *t){int num,num1,num2;if(*t==NULL) num=0;else if(((*t)->lchild==NULL)&&((*t)->rchild==NULL)) num=1;else {num1=leafcount(&(*t)->lchild);num2=leafcount(&(*t)->rchild);num=num1+num2;}return num;}void changeleaf(bitree *t){bitree p,q;if(*t!=NULL){p=(*t)->rchild;(*t)->rchild=(*t)->lchild;(*t)->lchild=p;changeleaf(&((*t)->lchild));changeleaf(&((*t)->rchild));}}void instruction(void){printf("\nEnter your choice:\n""1 to preorder\n""2 to inorder\n""3 to postorder\n""4 to change the leaf\n""5 to leafcount\n""6 to end\n");}void main(){bitree t;int choice;printf("Enter the root of the tree\n");createbitree(&t);instruction();scanf("%d",&choice);while (choice!=6){switch (choice){case 1:printf("The perorder of the tree is:\n");preorder(&t);instruction();scanf("%d",&choice);break;case 2:printf("The ororder is:\n");inorder(&t);instruction();scanf("%d",&choice);break;case 3:printf("The postorder is:\n");postorder(&t);instruction();scanf("%d",&choice);break;case 5:printf("The leafs is %d\n",leafcount(&t));instruction();scanf("%d",&choice);break;case 4:changeleaf(&t);printf("After change the tree is:\n");preorder(&t);instruction();scanf("%d",&choice);break;default:printf("Error\n");break;}}printf("End of run\n");getch();}实验六1)建立无向图和有向图的邻接矩阵存储，计算顶点的度，并按要求输出图的基本信息。