淮阴工学院c++实验报告实验八结构和链表
数据结构C语言版 实验报告
数据结构C语言版实验报告一、实验目的本次实验旨在通过使用 C 语言实现常见的数据结构，加深对数据结构基本概念、原理和操作的理解，提高编程能力和解决实际问题的能力。
二、实验环境操作系统：Windows 10编程环境：Visual Studio 2019编程语言：C 语言三、实验内容1、线性表顺序表的实现与操作链表的实现与操作2、栈和队列栈的实现与应用（表达式求值）队列的实现与应用（模拟排队）3、树和二叉树二叉树的遍历（前序、中序、后序）二叉搜索树的实现与操作4、图图的存储结构（邻接矩阵、邻接表）图的遍历（深度优先搜索、广度优先搜索）四、实验步骤及结果1、线性表顺序表的实现与操作定义顺序表的数据结构，包括数组和表的长度。
实现顺序表的初始化、插入、删除、查找等操作。
测试顺序表的各种操作，输出操作结果。
｀｀｀cinclude ＜stdioh>include ＜stdlibh>define MAX_SIZE 100typedef struct ｛int dataMAX_SIZE;int length;｝ SeqList;／／初始化顺序表void initList(SeqList L) ｛L>length ＝ 0;｝／／插入元素到顺序表int insertList(SeqList L, int pos, int element) ｛if （L>length ＞＝ MAX_SIZE ｜｜ pos ＜ 0 ｜｜ pos ＞ L>length) ｛return 0;｝for （int i ＝ L>length 1; i ＞＝ pos; i) ｛L>datai ＋ 1 ＝ L>datai;｝L>datapos ＝ element;L>length+＋；return 1;｝／／删除顺序表中的元素int deleteList(SeqList L, int pos) ｛if （pos ＜ 0 ｜｜ pos ＞＝ L>length) ｛return 0;｝for （int i ＝ pos; i ＜ L>length 1; i+＋）｛L>datai ＝ L>datai ＋ 1;｝L>length;return 1;｝／／查找顺序表中的元素int searchList(SeqList L, int element) ｛for （int i ＝ 0; i ＜ Llength; i+＋）｛if （Ldatai ＝＝ element) ｛return i;｝｝return －1;｝int main(）｛SeqList L;initList(＆L)；insertList(＆L, 0, 10)；insertList(＆L, 1, 20)；insertList(＆L, 2, 30)；printf(＂顺序表元素: ＂）；for （int i ＝ 0; i ＜ Llength; i+＋）｛printf(＂％d ＂， Ldatai)；｝printf(＂＼n"）；int pos ＝ searchList(L, 20)；if （pos!＝－1) ｛printf(＂元素 20 在顺序表中的位置: ％d\n"， pos)；｝ else ｛printf(＂顺序表中未找到元素 20\n"）；｝deleteList(＆L, 1)；printf(＂删除元素后的顺序表元素: ＂）；for （int i ＝ 0; i ＜ Llength; i+＋）｛printf(＂％d ＂， Ldatai)；｝printf(＂＼n"）；return 0;｝｀｀｀实验结果：成功实现顺序表的初始化、插入、删除、查找等操作，输出结果符合预期。
数据结构实验实训报告范文
一、实验目的1. 理解并掌握数据结构的基本概念和常用算法。
2. 学会使用C语言实现线性表、栈、队列、树和图等基本数据结构。
3. 培养动手实践能力，提高编程水平。
二、实验内容1. 线性表（1）顺序表（2）链表2. 栈（1）顺序栈（2）链栈3. 队列（1）顺序队列（2）链队列4. 树（1）二叉树（2）二叉搜索树5. 图（1）邻接矩阵表示法（2）邻接表表示法三、实验环境1. 操作系统：Windows 102. 编程语言：C语言3. 编译器：Visual Studio 20194. 实验软件：C语言开发环境四、实验步骤1. 线性表（1）顺序表1）定义顺序表结构体2）实现顺序表的初始化、插入、删除、查找等基本操作3）编写测试程序，验证顺序表的基本操作（2）链表1）定义链表结构体2）实现链表的创建、插入、删除、查找等基本操作3）编写测试程序，验证链表的基本操作2. 栈（1）顺序栈1）定义顺序栈结构体2）实现顺序栈的初始化、入栈、出栈、判空等基本操作3）编写测试程序，验证顺序栈的基本操作（2）链栈1）定义链栈结构体2）实现链栈的初始化、入栈、出栈、判空等基本操作3）编写测试程序，验证链栈的基本操作3. 队列（1）顺序队列1）定义顺序队列结构体2）实现顺序队列的初始化、入队、出队、判空等基本操作3）编写测试程序，验证顺序队列的基本操作（2）链队列1）定义链队列结构体2）实现链队列的初始化、入队、出队、判空等基本操作3）编写测试程序，验证链队列的基本操作4. 树（1）二叉树1）定义二叉树结构体2）实现二叉树的创建、遍历、查找等基本操作3）编写测试程序，验证二叉树的基本操作（2）二叉搜索树1）定义二叉搜索树结构体2）实现二叉搜索树的创建、遍历、查找等基本操作3）编写测试程序，验证二叉搜索树的基本操作5. 图（1）邻接矩阵表示法1）定义邻接矩阵结构体2）实现图的创建、添加边、删除边、遍历等基本操作3）编写测试程序，验证邻接矩阵表示法的基本操作（2）邻接表表示法1）定义邻接表结构体2）实现图的创建、添加边、删除边、遍历等基本操作3）编写测试程序，验证邻接表表示法的基本操作五、实验结果与分析1. 线性表（1）顺序表实验结果表明，顺序表的基本操作实现正确，测试程序运行稳定。
数据结构第八次 实验
淮海工学院计算机科学系实验报告书课程名：《数据结构》题目：查找、排序的应用实验班级：软件111学号：姓名：排序、查找的应用实验报告要求1目的与要求:1）查找、排序是日常数据处理过程中经常要进行的操作和运算，掌握其算法与应用对于提高学生数据处理能力和综合应用能力显得十分重要。
2）本次实验前，要求同学完整理解有关排序和查找的相关算法和基本思想以及种算法使用的数据存储结构；3）利用C或C++语言独立完成本次实验内容或题目，程序具有良好的交互性（以菜单形式列出实验排序和显示命令，并可进行交互操作）和实用性；4）本次实验为实验成绩评定主要验收内容之一，希望同学们认真对待，并按时完成实验任务；5）本次实验为综合性实验，请于2012年12月23日按时提交实验报告（纸质报告每班10份）；6）下周开始数据结构课程设计，务必按时提交实验报告，任何同学不得拖延。
2 实验内容或题目题目：对记录序列（查找表）：{287，109，063，930，589，184，505，269,008，083}分别实现如下操作：1)分别使用直接插入排序、冒泡排序、快速排序、简单选择排序、堆排序（可选）、链式基数排序算法对纪录序列进行排序，并显示排序结果；2)对上述纪录列表排好序，然后对其进行折半查找或顺序查找；3 实验步骤与源程序#include <iostream.h>#include <stdlib.h>//清屏函数#include <malloc.h>//malloc#include <conio.h>//getch函数#define MAXSIZE 20#define OK 1#define TRUE 1#define FALSE 0typedef int KeyType;//整型typedef struct{KeyType key;}RecordType;typedef struct{RecordType r[MAXSIZE+1];int length;}RecordList;void initrecord(RecordList * l)//还原输入序列{ //287，109，063，930，589，184，505，269,008，083 l->r[1].key=287;l->r[2].key=109;l->r[3].key=63;l->r[4].key=930;l->r[5].key=589;l->r[6].key=184;l->r[7].key=505;l->r[8].key=269;l->r[9].key=8;l->r[10].key=83;}int Create(RecordList *l){int k;for(int i=1;i<=l->length;i++){ cout<<"请输入第"<<i<<"个记录";cin>>k;l->r[i].key=k;}cout<<"打印表"<<endl;for(int z=1;z<=l->length;z++)cout<<l->r[z].key<<" ";return OK;}//创建顺序表void InsSort(RecordList * l)//直接插入排序{int j;for(int i=2;i<=l->length;i++){l->r[0].key=l->r[i].key;j=i-1;while(l->r[0].key<l->r[j].key){l->r[j+1].key =l->r[j].key ;j=j-1;l->r[j+1].key=l->r[0].key;}cout<<"打印表";for(int m=1;m<=l->length;m++)cout<<l->r[m].key<<" ";cout<<endl;}void BubbleSort(RecordList * l)//冒泡排序{int i,j,x;int change=TRUE;for(i=1;i<=l->length && change;++i){change=FALSE;for(j=1;j<=l->length-i;++j)if(l->r[j].key>l->r[j+1].key){x=l->r[j].key;l->r[j].key=l->r[j+1].key ;l->r[j+1].key=x;change=TRUE;}}cout<<"打印表";for(int m=1;m<=l->length;m++)cout<<l->r[m].key<<" ";cout<<endl;}int QKPass(RecordList * l,int left,int right) //一次快速排序{int x=l->r[left].key;int low=left;int high=right;while(low<high){while(low<high && l->r[high].key >=x)high--;if(low<high){l->r[low].key =l->r[high].key ;low++;while(low<high && l->r[low].key<x)low++;if(low<high){l->r[high].key=l->r[low].key;high--;}}l->r[low].key=x;return low;}void QKSort(RecordList *l,int low,int high) //快速排序{int pos;if(low<=high){pos=QKPass(l,low,high);QKSort(l,low,pos-1);QKSort(l,pos+1,high);}}void SelectSort(RecordList *l)//简单选择排序{int n=l->length;for(int i=1;i<=n-1;++i){int k;k=i;for(int j=i+1;j<=n;++j)if(l->r[j].key<l->r[k].key)k=j;if(k!=i){int x;x=l->r[i].key;l->r[i].key=l->r[k].key;l->r[k].key=x;}}cout<<"打印表";for(int m=1;m<=l->length;m++)cout<<l->r[m].key<<" ";cout<<endl;}int SeqSearch(RecordList *l){int k;cout<<"顺序查找请输入你要查找的值";cin>>k;int i;l->r[0].key=k;i=l->length;while(l->r[i].key!=k)i--;return (i);}//基于顺序结构的查找法int BinSrch(RecordList *l){int low=1,high=l->length;int k;cout<<"折半查找请输入你要查找的值";cin>>k;int mid;while(low<=high){mid=(low+high)/2;if(k==l->r[mid].key)return (mid);else if(k<l->r[mid].key)high=mid-1;elselow=mid+1;}return (0);}//折半查找void main(){int f=1;int m;int e;char s;int locate1;//顺序查找返回值int locate2;//折半查找返回值RecordList *l;l=(RecordList*)malloc(sizeof(RecordList));l->length=10;//表长//287，109，063，930，589，184，505，269,008，083while(f){system("CLS");cout<<"你想实现什么功能?"<<endl;cout<<" ---------------------"<<endl;cout<<" 1顺序表的创建 "<<endl;cout<<" 2直接插入排序 "<<endl;cout<<" 3冒泡排序 "<<endl;cout<<" 4快速排序 "<<endl;cout<<" 5简单选择排序 "<<endl;cout<<" 6顺序查找 "<<endl;cout<<" 7折半查找 "<<endl;cout<<" ---------------------"<<endl;cout<<"输入操作序号："<<endl;cin>>s;switch(s){case '1':Create(l);cout<<"构造顺序表成功!"<<endl;getch();break;case '2':InsSort(l);getch();break;case '3':cout<<"进行还原："<<endl;initrecord(l);for( e=1;e<=l->length;e++)cout<<l->r[e].key<<" ";cout<<endl;getch();BubbleSort(l);getch();break;case '4':cout<<"进行还原："<<endl;initrecord(l);for( e=1;e<=l->length;e++)cout<<l->r[e].key<<" ";cout<<endl;QKSort(l,1,10);getch();cout<<"打印表";for( m=1;m<=l->length;m++)cout<<l->r[m].key<<" ";cout<<endl;getch();break;case '5':cout<<"进行还原："<<endl;initrecord(l);for( e=1;e<=l->length;e++)cout<<l->r[e].key<<" ";cout<<endl;getch();SelectSort(l);getch();break;case '6':locate1=SeqSearch(l);cout<<"在表中的位置是"<<locate1<<endl;getch();break;case '7':locate2=BinSrch(l);cout<<"在表中的位置是"<<locate2<<endl;getch();break;}}}//注意getch函数的应用4 测试数据与实验结果（可以抓图粘贴）5 结果分析与实验体会每次做实验都会发现不足，这次实验就发现对8进制数处理的困难，对指针的运用不到位，传值和传址理解不透。
c语言链表实验报告
c语言链表实验报告C语言链表实验报告引言：链表是一种常见的数据结构，它在计算机科学中有着广泛的应用。
通过链表，我们可以动态地存储和操作数据，实现各种复杂的算法和数据结构。
本实验旨在通过使用C语言，实现一个简单的链表结构，并演示其基本操作和应用。
一、链表的定义和基本概念链表是由一系列节点组成的数据结构，每个节点包含数据和指向下一个节点的指针。
相比于数组，链表具有动态性，可以根据需要动态地分配和释放内存空间。
链表的基本概念包括头节点、尾节点、节点插入和节点删除等。
二、链表的实现1. 定义节点结构体在C语言中，我们可以通过定义结构体来表示链表的节点。
结构体中包含一个数据成员和一个指向下一个节点的指针成员。
2. 创建链表为了创建一个链表，我们首先需要定义一个头节点，并将其指针指向NULL。
然后，通过动态分配内存，创建其他节点，并将它们按照一定的顺序链接起来。
3. 插入节点链表的插入操作可以在链表的任意位置进行。
我们可以在头节点之后或者指定节点之后插入新的节点。
插入操作的关键是修改指针的指向，使得新节点能够正确地链接到链表中。
4. 删除节点链表的删除操作可以删除链表中的任意节点。
删除操作的关键是修改指针的指向，使得被删除节点的前一个节点和后一个节点能够正确地链接起来，并释放被删除节点的内存空间。
三、链表的应用链表作为一种常见的数据结构，有着广泛的应用。
以下是链表的一些常见应用场景：1. 队列和栈链表可以用来实现队列和栈这两种常见的数据结构。
通过在链表的头部或尾部进行插入和删除操作，可以实现队列和栈的基本功能。
2. 图的表示在图的表示中，链表可以用来表示图的邻接表。
每个顶点对应一个链表，链表中存储该顶点的邻接点。
通过链表的插入和删除操作，可以方便地修改图的结构。
3. 文件系统在文件系统中，链表可以用来表示文件的目录结构。
每个目录对应一个链表，链表中存储该目录下的文件和子目录。
通过链表的插入和删除操作，可以方便地管理文件和目录。
数据结构顺序表链表试验报告
数据结构顺序表链表试验报告数据结构试验报告一、引言数据结构是计算机科学中非常重要的一个概念，它用于组织和存储数据，以便能够高效地进行检索和操作。
顺序表和链表是两种常见的数据结构，它们在实际应用中都有各自的优势和局限性。
本报告将对顺序表和链表进行试验比较，以评估它们在不同场景下的性能和适合性。
二、实验目的本次试验的目的是比较顺序表和链表在插入、删除和查找操作上的性能差异，并分析其时间复杂度和空间复杂度。
通过实验结果，可以对不同场景下选择合适的数据结构提供参考。
三、实验内容1. 顺序表实验a. 创建一个包含100个元素的顺序表；b. 在表尾插入一个元素；c. 在表头插入一个元素；d. 在表的中间位置插入一个元素；e. 删除表尾的一个元素；f. 删除表头的一个元素；g. 删除表的中间位置的一个元素；h. 查找一个元素；i. 遍历整个顺序表。
2. 链表实验a. 创建一个包含100个节点的链表；b. 在链表尾部插入一个节点；c. 在链表头部插入一个节点；d. 在链表的中间位置插入一个节点；e. 删除链表尾部的一个节点；f. 删除链表头部的一个节点；g. 删除链表的中间位置的一个节点；h. 查找一个节点；i. 遍历整个链表。
四、实验结果与分析1. 顺序表实验结果a. 在表尾插入一个元素的平均时间为0.1ms；b. 在表头插入一个元素的平均时间为0.2ms；c. 在表的中间位置插入一个元素的平均时间为0.5ms；d. 删除表尾的一个元素的平均时间为0.1ms；e. 删除表头的一个元素的平均时间为0.2ms；f. 删除表的中间位置的一个元素的平均时间为0.5ms；g. 查找一个元素的平均时间为1ms；h. 遍历整个顺序表的平均时间为10ms。
2. 链表实验结果a. 在链表尾部插入一个节点的平均时间为0.2ms；b. 在链表头部插入一个节点的平均时间为0.1ms；c. 在链表的中间位置插入一个节点的平均时间为0.5ms；d. 删除链表尾部的一个节点的平均时间为0.2ms；e. 删除链表头部的一个节点的平均时间为0.1ms；f. 删除链表的中间位置的一个节点的平均时间为0.5ms；g. 查找一个节点的平均时间为2ms；h. 遍历整个链表的平均时间为5ms。
数据结构链表实训心得体会总结
数据结构链表实训心得体会总结当在某些事情上我们有很深的体会时，就很有必要写一篇心得体会，通过写心得体会，可以帮助我们总结积累经验。
那么心得体会怎么写才恰当呢？以下我给大家整理了一些优质的心得体会范文，希望对大家能够有所帮助。
最新数据结构链表实训心得体会总结一一、实验名称：测量平均速度二、实验目的：1.学会用实验的方法测出小车在斜坡各段的平均速度，验证小车在斜坡滑下是前半程快还是后半程快。
2巩固刻度尺和秒表的使用。
三、实验原理：v=s/t四、实验器材：停表、木板、小车、刻度尺、金属片、木块五、需要测量的物理量：路程s和时间t六、实验步骤：1.将木块的一端用木块垫起，使它保持很小的坡度。
2.将小车放在斜面顶端，金属片放在斜面底端，用刻度尺测出小车通过的路程s1.用停表测量通过这段路程所用的时间t1、3.根据测得的s1、t1.利用公式v1=s1/t1算出小车通过斜面全程的平均速度v1、4.将金属片移至斜面中部，重复上述过程，进行第二次测量。
5.利用s1—s2=s3.t1—t2=t3.求出v3、6.收集数据的表格：路程s1=s2=s3=s1-s2=运动时间平均速度t1=t2=t3=t1-t2=v1=v2=v3=八、结论：小车在半程运动的速度快。
（填前或后）最新数据结构链表实训心得体会总结二职责：1.负责mysql数据库的备份、恢复、监控、迁移等日常运维工作。
2.负责mysql性能的调优，保证数据库安全、稳定、高效运行。
3.制定和改进应急预案、策略和流程，提高服务运行质量。
4.与产品开发团队紧密配合，规划、设计、评审和优化数据库设计方案。
5.数据库新技术的研究，适应快速发展的互联网业务场景。
任职要求：1、5年mysql数据库维护经验，熟悉mysql故障排查、性能优化、备份与恢复、容灾等技术。
2、负责mysql数据库日常管理和维护，对现有数据系统的稳定性、高可用性、扩展性的相关保障工作;3、负责性能监控和调优，能够对业务需求和事故及时响应，调整数据库设计建议;4、负责审核新业务上线的数据库代码审核与部署;5、能够进行数据库引擎、sql语句和读写分离的优化分析/设计，并具有高并发下读写分离维护经验;6、熟悉 redis/memcache/mongodb等nosql数据库优先;7、熟悉linuX运维管理，熟悉shell或python一种脚本语言开发优先。
链表实验报告
链表实验报告一、实验目的链表是一种常见的数据结构，本次实验的主要目的是深入理解链表的概念、原理和操作，通过实际编程实现链表的创建、插入、删除、遍历等基本操作，掌握链表在数据存储和处理中的应用，提高对数据结构的理解和编程能力。
二、实验环境本次实验使用的编程语言为 C 语言，开发工具为 Visual Studio Code。
三、实验原理链表是一种动态的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。
链表的优点是可以灵活地进行插入和删除操作，不需要像数组那样移动大量的数据。
链表分为单向链表、双向链表和循环链表等。
单向链表只有一个指向下一个节点的指针，双向链表有指向前一个节点和后一个节点的指针，循环链表的尾节点指向头节点，形成一个环形结构。
四、实验步骤1、单向链表的创建定义链表节点结构体，包含数据域和指针域。
编写创建链表的函数，通过动态分配内存创建链表节点，并将节点连接起来。
2、单向链表的插入操作实现头部插入、尾部插入和中间插入的函数。
在插入时，需要处理指针的更新，确保链表的连接正确。
3、单向链表的删除操作编写删除指定节点的函数。
删除节点时，要释放被删除节点的内存，并更新相邻节点的指针。
4、单向链表的遍历实现遍历链表并打印节点数据的函数。
5、双向链表的创建与操作类似于单向链表，定义双向链表节点结构体，并实现创建、插入、删除和遍历的函数。
注意双向链表中指针的更新方式与单向链表的不同。
6、循环链表的创建与操作定义循环链表节点结构体，创建循环链表。
实现循环链表的插入、删除和遍历操作，处理好尾节点与头节点的连接。
五、实验结果与分析1、单向链表成功创建了单向链表，并能够正确进行头部、尾部和中间的插入操作。
删除操作也能准确删除指定节点，并释放内存。
遍历输出的结果与预期相符。
2、双向链表双向链表的创建和各种操作都能正常执行，指针的更新没有出现错误。
在双向链表中，插入和删除操作的效率相对单向链表有所提高，因为可以直接通过前向指针进行操作。
C语言程序设计实训报告 链表操作
实验链表实验报告
实验链表实验报告一、实验目的本次实验的主要目的是深入理解链表这种数据结构的概念、特点和操作方法，并通过实际编程实现来提高对链表的应用能力。
二、实验环境本次实验使用的编程语言为C+＋，开发工具为Visual Studio 2019。
三、实验原理链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。
与数组不同，链表的内存分配是动态的，并且可以方便地进行插入和删除操作，而不需要移动大量的元素。
链表分为单向链表、双向链表和循环链表等多种类型。
在本次实验中，我们主要实现单向链表。
单向链表的节点结构通常包含数据域和指针域。
数据域用于存储节点的数据，指针域用于指向下一个节点。
通过遍历链表的指针，可以访问链表中的每个节点。
四、实验内容1、链表节点的定义｀｀｀cppstruct ListNode ｛int data;ListNode next;ListNode(int x) ： data(x)， next(NULL) ｛｝｝；｀｀｀2、链表的创建｀｀｀cppListNode createList(）｛ListNode head ＝ NULL;ListNode tail ＝ NULL;int num;cout ＜＜＂请输入链表中的数字（输入－1 结束）：＂；cin ＞＞ num;while （num!＝－1) ｛ListNode newNode ＝ new ListNode(num)；if （head ＝＝ NULL) ｛head ＝ newNode;tail ＝ newNode;｝ else ｛tail>next ＝ newNode;tail ＝ newNode;｝cin ＞＞ num;｝return head;｝｀｀｀3、链表的遍历｀｀｀cppvoid traverseList(ListNode head) ｛ListNode curr ＝ head;while （curr!＝ NULL) ｛cout ＜＜ curr>data ＜＜＂＂；curr ＝ curr>next;｝cout ＜＜ endl;｝｀｀｀4、链表的插入｀｀｀cppvoid insertNode(ListNode& head, int position, int value) ｛ListNode newNode ＝ new ListNode(value)；if （position ＝＝ 0) ｛newNode>next ＝ head;head ＝ newNode;return;｝ListNode curr ＝ head;int count ＝ 0;while （curr!＝ NULL ＆＆ count ＜ position 1) ｛curr ＝ curr>next;count+＋；｝if （curr ＝＝ NULL) ｛cout ＜＜＂插入位置超出链表长度" ＜＜ endl; return;｝newNode>next ＝ curr>next;curr>next ＝ newNode;｝｀｀｀5、链表的删除｀｀｀cppvoid deleteNode(ListNode& head, int position) ｛if （head ＝＝ NULL) ｛cout ＜＜＂链表为空，无法删除" ＜＜ endl; return;｝if （position ＝＝ 0) ｛ListNode temp ＝ head;head ＝ head>next;delete temp;return;｝ListNode curr ＝ head;ListNode prev ＝ NULL;int count ＝ 0;while （curr!＝ NULL ＆＆ count ＜ position) ｛prev ＝ curr;curr ＝ curr>next;count+＋；｝if （curr ＝＝ NULL) ｛cout ＜＜＂删除位置超出链表长度" ＜＜ endl; return;｝prev>next ＝ curr>next;delete curr;｝｀｀｀五、实验结果通过对上述链表操作函数的调用，我们成功地创建、遍历、插入和删除了链表中的节点。
C语言程序设计第八次实验报告(绝对有效!!)
第八次上机实验报告（结构体、共用体）一、实验目的：（1）掌握结构体类型、结构体变量的定义与使用。
（2）掌握结构体数组的定义与使用。
（3）学会使用结构体变量指针的定义与使用。
（4）掌握链表的概念，学会对链表进行建立、遍历、删除、查找操作。
（5）了解共用体的概念，进一步复习指针的内容。
二、实验题目：（1）根据以下学生情况表，编制一个C程序，分别用选择法和冒泡法对该学生情况表按成绩从低到高进行排序处理并输出。
具体要求：（a）程序中，输入、输出和两种排序功能模块分别用自定义函数形式实现。
（b）在主函数中定义一个结构体数组和结构体指针数组，其中结构体数组用以存放学生表的信息，结构体指针数组中的每一个指针元素分别指向结构体数组的个元素，利用指针数组实现排序可避免结构体数组元素交换移动，节省排序时间。
（c）在主函数中通过调用输入、输出和两种排序函数，实现首先输入数据，然后输出排序前学生的情况，再输出排序后的学生结果，格式如图所示（不要求输出表格线）。
程序：#include<stdio.h>#define N 5typedef struct student{int num;char name[16];char sex;int age;double grade;} stu;int output(stu *a[],int n){int i;printf("学生情况表\n");printf("学号\t姓名\t性别\t年龄\t成绩\n");for(i=0;i<n;i++)printf("%d\t%s\t%c\t%d\t%lf\n",a[i]->num,a[i]->name,a[i]->sex ,a[i]->age,a[i]->grade);return 0;}int input(stu *a[],int n)int i;printf("输入%d个学生的信息（学号姓名性别年龄成绩）：\n",n);for(i=0;i<n;i++)scanf("%d%s%s%d%lf",&(a[i]->num),a[i]->name,&(a[i]->s ex),&(a[i]->age),&(a[i]->grade));return 0;}int bubblesort(stu *a[],int n){int i,j;stu *tmp;for(i=0;i<n-1;i++)for(j=0;j<n-i-1;j++){if (a[j]->grade < a[j+1]->grade){tmp=a[j];a[j]=a[j+1];a[j+1]=tmp;}}return 0;}int selectsort(stu *a[],int n){int i,j,k;stu *tmp;for(i=0;i<n-1;i++){k=i;for(j=i+1;j<n;j++)if(a[j]->grade > a[k]->grade) k=j;if(k!=i){tmp=a[k];a[k]=a[i];a[i]=tmp;}}return 0;}int main(){int i,flag;stu p[N],*q[N];for(i=0;i<N;i++)q[i]=&p[i];input(q,N);output(q,N);printf("选择排列方式（1）冒泡排序法（2）选择排序法:\n");scanf("%d",flag);if(flag==1)bubblesort(q,N);else if(flag==2)selectsort(q,N);else printf("choice error!!");output(q,N);return 0;}新程序：#include<stdio.h>struct person{int num;char name[7];char sex;int age;float grade;}p[5],*q[5],*s,**t;void input(struct person p[]){int i;for(i=0;i<=4;i++)scanf("%d%s%1s%d%f",&(p[i].num),p[i].name,&(p[i].sex),&(p[ i].age),&(p[i].grade));}struct person **bubblesort(struct person p[],struct person *q[],struct person *s) {int j,i;for(i=0;i<4;i++)for(j=0;j<4-i;j++)if(p[j].grade>p[j+1].grade){s=q[j];q[j]=q[j+1];q[j+1]=s;}return(q);}void output(struct person **q){int i;for(i=0;i<=4;i++)printf("%d\t%s\t%c\t%d\t%f\n",(*(q+i))->num,(*(q+i))->name,(*(q+ i))->sex,(*(q+i))->age,(*(q+i))->grade);}int main(){int w;for(w=0;w<=4;w++)q[w]=&p[w];s=NULL;printf("input the information of students:\n");input(p);t=bubblesort(p,q,s);printf("\nnum name sex age grade\n");output(t);return 0;}（2）链表基本操作。
c课程设计链表实验报告
c课程设计链表实验报告一、教学目标本节课的教学目标是让学生掌握链表的基本概念和操作，包括链表的定义、节点的结构、链表的创建、插入、删除和遍历等操作。
通过本节课的学习，学生应该能够理解链表的工作原理，熟练使用链表进行数据存储和操作，并能够编写相应的程序实现链表功能。
具体来说，知识目标包括：1.了解链表的定义和特点；2.掌握链表的基本操作及其时间复杂度；3.理解链表在数据存储和处理中的应用场景。
技能目标包括：1.能够使用编程语言实现链表的创建、插入、删除和遍历等基本操作；2.能够分析链表程序的正确性和性能；3.能够运用链表解决实际问题，如实现一个简单的链表排序算法。
情感态度价值观目标包括：1.培养学生的逻辑思维能力和问题解决能力；2.激发学生对计算机科学和编程的兴趣；3.培养学生的团队合作意识和代码规范意识。
二、教学内容本节课的教学内容主要包括链表的基本概念和操作。
具体安排如下：1.链表的定义和特点：介绍链表的概念、节点结构以及链表的两种类型（单向链表和双向链表）；2.链表的创建：讲解如何创建一个链表，包括初始化节点和链接节点的方法；3.链表的插入操作：介绍如何在链表中插入一个新节点，包括头插法和中插法的实现；4.链表的删除操作：讲解如何删除链表中的一个节点，包括头删法和中删法的实现；5.链表的遍历操作：介绍如何遍历链表，实现链表中各个节点的访问和打印；6.链表的应用场景：举例说明链表在实际编程中的应用，如链表排序算法。
三、教学方法为了达到本节课的教学目标，将采用以下教学方法：1.讲授法：讲解链表的基本概念和原理，引导学生理解链表的工作方式；2.案例分析法：通过分析典型链表程序，让学生掌握链表的操作方法和技巧；3.实验法：让学生动手编写链表程序，培养学生的实际编程能力和问题解决能力；4.讨论法：学生进行小组讨论，分享学习心得和编程经验，提高学生的团队合作意识。
四、教学资源为了支持本节课的教学内容和教学方法的实施，将准备以下教学资源：1.教材：《数据结构与算法》；2.参考书：《链表：原理与实现》；3.多媒体资料：PPT课件、链表操作视频教程；4.实验设备：计算机、编程环境。
数据结构课程设计实践报告
淮阴工学院实践报告数据结构课程设计设计题目：纸牌游戏系别：江淮学院专业：计算机科学与技术班级：计算机3111学生姓名: 卞玲玲学号:********** 起止日期:2012年12月24日~2013年1月6日指导教师：寇海洲、龚乐君摘要：纸牌游戏是一副或多幅纸牌提供娱乐的牌戏，是大家熟知的益智游戏。
早期的纸牌大部分为数码牌，中国的玩法通常是高点数胜低点数，或以特殊组合牌型取胜，此二原则仍为两大牌戏派别中论计胜负的标准。
而在当今社会，纸牌游戏已成为高雅的社交与智力活动，是我们娱乐休闲的方式之一，所以在游戏之余，我们不但要学会怎么玩纸牌游戏，而且更要尝试去做一种纸牌游戏。
关键词：纸牌游戏，翻牌，流程图，数据结构，C语言目录1需求分析 (4)1.1课题设计目的 (4)1.2课程设计任务 (4)2 概要设计 (4)2.1设计思路 (4)2.2设计流程 (4)2.2.1主要步骤 (4)2.2.2流程图 (5)3 详细设计 (5)3.1定义单链表结点 (5)3.2.主要函数功能 (5)3.2.1创建链表函数 (5)3.2.2创建翻牌函数 (6)3.2.3输出结果函数 (7)3.3主函数 (7)4 调试与操作说明 (8)5 总结 (10)6 致谢 (11)参考文献 (11)附录 (12)1需求分析1.1课题设计目的纸牌游戏是一种休闲娱乐方式，通过与《数据结构》课程的联系，设计一段完整的程序，开发一种新的游戏玩法，使学生在掌握数据结构的同时，懂得怎样去开发，去实际应用所学到的知识。
1.2课程设计任务：编号为1-52 张牌，正面向上，从第2张开始，以2为基数，是2的倍数的牌翻一次，直到最后一张牌；然后，从第3张开始，以3为基数，是3的倍数的牌翻一次，直到最后一张牌；然后…从第4张开始，以4 为基数，是4的倍数的牌翻一次，直到最后一张牌；...再依次5的倍数的牌翻一次，6 的，7的直到以52为基数的翻过，输出：这时正面向上的牌有哪些？2概要设计2.1 设计思路编号为1的牌没有进行翻牌，所以仍然是正面向上，当从第二个编号开始的每张牌每次遇到是其倍数时，都会相应的翻一次，比如24，第一次它是2的倍数时要从正面翻到背面，当进行到3时，就又要从背面翻回来，而到4时还要在翻，以此类推，到6.8.12…它都要来回的翻。
数据结构（C语言版）实验报告.doc
数据结构（C语言版）实验报告.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"typedef struct node{//定义结点char data[10]; // 结点的数据域为字符串struct node *next; // 结点的指针域}ListNode;typedef ListNode * LinkList; LinkList CreatListR1(); // 自定义LinkList 单链表类型// 函数，用尾插入法建立带头结点的单链表LinkList CreatList(void); ListNode *LocateNode(); //函数，用头插入法建立带头结点的单链表// 函数，按值查找结点void DeleteList(); // 函数，删除指定值的结点void printlist(); void DeleteAll(); //函数，打印链表中的所有值//函数，删除所有结点，释放存ListNode * AddNode(); // 修改程序：增加节点。
C语言链表实验报告
链表实验报告一、实验名称链表操作的实现--学生信息库的构建二、实验目的（1）理解单链表的存储结构及基本操作的定义（2）掌握单链表存储基本操作（3）学会设计实验数据验证程序【实验仪器及环境】计算机 Window XP操作系统三、实验内容1、建立一个学生成绩信息（学号，姓名，成绩）的单链表，按学号排序2、对链表进行插入、删除、遍历、修改操作。
3、对链表进行读取（读文件）、存储（写文件）四、实验要求（1）给出终结报告（包括设计过程，程序）-打印版（2）对程序进行答辩五、实验过程、详细内容1、概念及过程中需要调用的函数（1）链表的概念结点定义结构的递归定义struct stud_node{int num;char name[20];int score;struct stud_node *next;};（2）链表的建立1、手动输入struct stud_node*Create_Stu_Doc(){struct stud_node *head,*p;int num,score;char name[20];int size=sizeof(struct stud_node);【链表建立流程图】2、从文件中直接获取 先建立一个(3)链表的遍历（4（5）删除结点（6）动态储存分配函数malloc （） void *malloc(unsigned size)①在内存的动态存储区中分配一连续空间，其长度为size②若申请成功，则返回一个指向所分配内存空间的起始地址的指针 ③若申请不成功，则返回NULL （值为0） ④返回值类型：(void *) ·通用指针的一个重要用途·将malloc 的返回值转换到特定指针类型，赋给一个指针【链表建立流程图】ptrptrptr->numptr->score ptr=ptr->nexthead pt rs s->next = ptr->next ptr->next = s 先连后断 ptr2=ptr1->nextptr1->next=ptr2->nextfree （ptr2）（7）动态储存释放函数free（）当某个动态分配的存储块不再用时，要及时将它释放void free(void *ptr)释放由动态存储分配函数申请到的整块内存空间，ptr为指向要释放空间的首地址。
链表实验报告
C语言实验报告实验目的：链表的基本操作添加，删除，排序#include <iostream.h>#include <string.h>#include <stdlib.h>struct StuNode{char ID[10];char Name[10];int Height;StuNode *next;};typedef StuNode stulist;void Addafter (stulist * list,char * id,char * name,int height){if(!list||!id) return;StuNode *p=new StuNode;strcpy(p->ID,id);strcpy(p->Name,name);p->Height=height;StuNode *q=list;while(q->next){q=q->next;}q->next=p;p->next=NULL;}void ShowNode(stulist * list){cout<<"现有数据是："<<endl;StuNode *p=list->next;while(p){cout<<p->ID<<" "<<p->Name<<" "<<p->Height<<endl;p=p->next;}cout<<endl<<"*************************************"<<endl; }void Insert (stulist * list){char Beid[10]="2014002";char id[10]="1112223";char name[10]="狗蛋";int height=177;if(!list||!id) return;StuNode *p=new StuNode;strcpy(p->ID,id);strcpy(p->Name,name);p->Height=height;StuNode *q=list;while(strcmp(q->ID,Beid)!=0){q=q->next;}p->next=q->next;q->next=p;}void Delete(stulist * list){char id[10]="2014001";StuNode *q=list;StuNode *d=q->next;while(strcmp(d->ID,id)!=0){q=q->next;d=d->next;}q->next=d->next;delete d;}void main(){stulist list_1;list_1.next=NULL;char name[10],id[10];int height;Addafter(&list_1,"2014001","张三",175);Addafter(&list_1,"2014002","李四",180);Addafter(&list_1,"2014003","王二",173);Addafter(&list_1,"2014004","麻子",179);ShowNode(&list_1);cout<<"现在添加马六"<<endl;Addafter(&list_1,"2014999","马六",180);ShowNode(&list_1);cout<<"现在把狗蛋插入到李四后面"<<endl;Insert(&list_1);ShowNode(&list_1);cout<<"现在删除张三"<<endl;Delete(&list_1);ShowNode(&list_1);}实验总结：通过学习链表的操作，让知道了C语言和C++是有着紧密联系的，让我能更加熟练了数组，指针，结构体等一些基本的c++语言知识，而且知道了怎么添加修改和排序的一些方法。
链表的基本操作实验报告
《数据结构》实验报告学号1445203105 姓名王胜博班级软件5班成绩实验名称实验三链表的基本操作是否原创是一、实验要求编程实现链表下教材第二章定义的线性表的基本操作，最好用菜单形式对应各个操作，使其编程一个完整的小软件。
二、实验目的通过该实验，深入理解链表的逻辑结构、物理结构等概念，掌握链表基本操作的编程实现，熟练掌握C语言中指针的操作。
和实验2对比，掌握线性结构两种不同存储方式的区别。
三、设计思想用函数执行各个功能，随机插入元素四、主要源代码#include<stdio.h>#include<stdlib.h>#include<time.h>typedef int ElemType;typedef struct Node{ElemType data;struct Node *next;}Node, *LinkList;void InitList(LinkList *L){*L=(LinkList)malloc(sizeof(Node));if(!(*L))printf("存储分配失败\n");(*L)->next=NULL;}void DestroyList(LinkList L){LinkList p;while(L){p=L->next;free(L);L=p;}}int ListLength(LinkList L){LinkList p;int i=0;p=L->next;while(p){i++;p=p->next;}return i;}int GetElem(LinkList L,int i,ElemType &e){ LinkList p;p=L->next;int j=1;while(p&&j<i){p=p->next;++j;}e=p->data;return e;}int GetElemLo(LinkList L,int i,ElemType &e){ LinkList p;p=L->next;int j=1;while(p->data!=i&&j<=ListLength(L)){p=p->next;++j;}e=j;return e;}void FindPre(LinkList L,int x){LinkList p;p=L;if(p->next->data==x){printf("第一个元素没有前驱\n");}else{while(p->next){if(p->next->data==x){printf("%d的前驱结点是:%d\n",x,p->data);break;}else{p=p->next;}}}}void FindNext(LinkList L,int x){LinkList p;p=L->next;while(p){if(p->data==x){printf("%d的后继结点是:%d\n",x,p->next->data);break;}else{p=p->next;}if(p->next==NULL){printf("最后一个元素没有后继\n");break;}}}void LinkInset_L(LinkList &L,int i,ElemType e){ LinkList p;p=L;int j=0;while(p&&j<i-1){p=p->next;++j;}if(!p||j>i-1)printf("i小于1或者i大于表长加1\n");LinkList s;s=(LinkList)malloc(sizeof (Node));s->data=e;s->next=p->next;p->next=s;}void ListDelete_L(LinkList &L,int i,ElemType &e){ LinkList p,q;p=L;int j=0;while(p->next && j<i-1){p=p->next;++j;}if(!p->next ||j>i-1)printf("删除位置不合理\n");q=p->next;p->next=q->next;e=q->data;free(q);printf("已删除的元素是:%d\n",e);}void visit(ElemType e){printf("%d,",e);}void ListTraverse(LinkList L){LinkList p=L->next;while(p){visit(p->data);p=p->next;}printf("\n");}void CreatListTail(LinkList *L,int n){LinkList p,r;int i;srand(time(0));*L=(LinkList)malloc(sizeof(Node));r=*L;for(i=0;i<n;i++){p=(Node *)malloc(sizeof(Node));p->data=rand()%100+1;r->next=p;r=p;}r->next=NULL;}int main(){LinkList L;int opp;printf("可执行的操作有:\n");printf("1.初始化或重置链表\n");printf("2.随机插入元素\n");printf("3.显示链表中数据元素个数\n");printf("4.输出所输入的链表元素\n");printf("5.所指位序的元素值\n");printf("6.链表已存在元素的位序\n");printf("7.请输入元素，求直接前驱\n");printf("8.请输入元素，求直接后继\n");printf("9.在第i个位置插入元素\n");printf("10.删除第i个元素\n");printf("11.销毁链表\n");printf("12.退出\n");printf("\n");printf("请输入你的选择:\n");do{scanf("%d",&opp);switch(opp){case 1:{InitList(&L);printf("链表已初始化\n");printf("下一步操作:");break;}case 2:{int n;printf("输入插入元素个数:");scanf("%d",&n);CreatListTail(&L,n);printf("下一步操作:");break;}case 3:{printf("链表中元素的个数是:%d\n",ListLength(L));printf("下一步操作:");break;}case 4:{ListTraverse(L);printf("下一步操作:");break;}case 5:{int m,e;printf("输入要取元素的位置:");scanf("%d",&m);if(m>ListLength(L)){printf("输入有误\n");}else{GetElem(L,m,e);printf("该元素是:%d\n",e);}printf("下一步操作:");break;}case 6:{int i,e;printf("输入要取的元素:");scanf("%d",&i);GetElemLo(L,i,e);printf("该元素的位置是:%d\n",e);printf("下一步操作:");break;}case 7:{int x;printf("要求哪个元素的前驱？");scanf("%d",&x);FindPre(L,x);printf("下一步操作:");break;}case 8:{int x;printf("要求哪个元素的后继？");scanf("%d",&x);FindNext(L,x);printf("下一步操作:");break;}case 9:{int i,e;printf("在哪个位置插入元素?");scanf("%d",&i);if(i>ListLength(L))printf("输入有误\n");else{printf("插入的新元素是:");scanf("%d",&e);LinkInset_L(L,i,e);printf("新链表:");ListTraverse(L);}printf("下一步操作:");break;}case 10:{int i,e;printf("要删除哪个位置的元素？");scanf("%d",&i);if(i>ListLength(L))printf("输入有误\n");else{ListDelete_L(L,i,e);printf("新链表:");ListTraverse(L);}printf("下一步操作:");break;}case 11:{DestroyList(L);printf("链表已销毁!\n");printf("下一步操作:");break;}case 12:{printf("谢谢使用\n");break;}default:{printf("输入错误，请重新输入\n");break;}}}while(opp!=12);return 0;}五、调试与测试数据六、实验总结。
结构与联合实验实验报告
结构与联合实验实验报告一、实验目的本次实验旨在深入研究和比较结构（Struct）与联合（Union）在数据存储和操作方面的特性，分析它们在不同场景下的优势和适用范围，为程序设计中合理选择数据结构提供依据。
二、实验原理（一）结构（Struct）结构是一种用户自定义的数据类型，它可以将不同类型的数据组合在一起，形成一个逻辑上相关的整体。
结构中的成员按照定义的顺序依次存储在内存中，每个成员都有自己独立的存储空间。
（二）联合（Union）联合也是一种用户自定义的数据类型，但与结构不同的是，联合的所有成员共享同一块内存空间。
在同一时刻，只有一个成员的值是有效的。
三、实验设备和环境（一）硬件设备计算机一台，配置如下：处理器：＿____内存：＿____硬盘：＿____（二）软件环境操作系统：＿____编程语言：＿____编译器：＿____四、实验步骤（一）定义结构和联合类型｀｀｀cstruct Student ｛int id;char name50;float score;｝；union Data ｛int num;float value;char str20;｝；｀｀｀（二）创建结构和联合变量并进行初始化｀｀｀cstruct Student stu1 ＝｛101, ＂张三"， 855}；union Data data1 ＝｛123}；｀｀｀（三）访问结构和联合成员｀｀｀cprintf(＂学生学号：％d\n"， stu1id)；printf(＂联合中的数值：％d\n"， data1num)；｀｀｀（四）修改结构和联合成员的值｀｀｀cstu1score ＝ 900;data1value ＝ 314;｀｀｀（五）比较结构和联合的内存占用｀｀｀cprintf(＂结构的大小：％lu\n"， sizeof(struct Student)）；printf(＂联合的大小：％lu\n"， sizeof(union Data)）；｀｀｀五、实验结果与分析（一）访问和修改成员在访问和修改结构成员时，可以直接通过成员名进行操作，非常直观和方便。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验八结构体与链表一、实验目的和要求1．掌握结构体类型、结构体变量的基本概念；2．掌握结构体指针、结构体数组的应用；3．掌握链表的基本概念；4．掌握链表的基本操作与应用，包括建立链表、遍历链表、插入结点、删除结点、查找结点等。
二、相关知识点1．结构体类型：定义：struct 结构类型名{数据类型数据项1;数据类型数据项2;…………………….数据类型数据项n;}2．结构体变量：1．定义：（1）间接定义法──先定义结构类型、再定义结构变量struct 结构类型名结构变量；（2）直接定义法──在定义结构类型的同时定义结构变量struct 结构类型名{………}结构变量表；2．结构变量的初始化与引用：（1）如：struct std_info student={"000102","张三","男",{1980,9,20}};（2）结构变量的引用规则，对于结构变量，要通过成员运算符“.”，逐个访问其成员即结构变量.成员3．结构体指针：（1）使用指向结构变量的指针来访问结构变量的各个成员。
struct std_info *p_std=&student（2）使用指向结构数组的指针来访问结构数组struct std_info *p_std=student;4．结构体数组结构数组的每一个元素，都是结构类型数据，均包含结构类型的所有成员。
struct std_info student[3]={{“000102”, “张三”,“男”,{1980,9,20}},{“000105”,“李四”,“男”,{1980,8,15}},{“000112”, “王五”,“女”,{1980,3,10}}};5．链表的基本操作与应用：（1）建立链表：创建静态链表，创建动态链表（2）访问链表（3）插入结点（4）删除结点（5）查找结点（6）链表的释放。
三、实验内容1.定义一个学生成绩结构体类型，包含“学号”、“姓名”、“性别”、“年龄”、“班级”、“英语”、“数学”、“物理”、“总分”、“名次”等信息。
编写6个函数分别用于：（1）使用结构体数组，输入全班10名学生的上述信息；（2）计算每一个学生的总分、平均分；（3）计算每一门课程的平均分；（4）查找成绩有不及格的学生信息；（5）按学生成绩总分降序排序；（6）输出全班学生的学号、总分及名次。
（1）思路分析：先定义结构体，调用函数putinfor实现输入，调用函数sum_avg实现计算每一个学生的总分、平均分；调用函数course_avg实现计算每一门课程的平均分；调用函数findstu实现查找成绩有不及格的学生信息；调用函数sequence实现按学生成绩总分降序排序；调用函数display实现输出全班学生的学号、总分及名次。
（2）源代码：#include <iostream.h>#include <stdio.h>#define N 3struct stu_score{char num[10];char name[6];char sex[2];int age;char classes[4];float english;float math;float physics;float sum;float avg;int mingci;};void putinfor(stu_score score[]);void sum_avg(struct stu_score score[]);void course_avg(struct stu_score score[]);void findstu(struct stu_score score[]);void sequence(struct stu_score score[]);void display(struct stu_score score[]);void main(){ struct stu_score stu[N];putinfor(stu);sum_avg(stu);course_avg(stu);findstu(stu);sequence(stu);display(stu);}void putinfor(stu_score score[]){for(int i=0;i<N;i++){cout<<"请输入第"<<i+1<<"个学生的学号："<<endl;gets(score[i].num);cout<<"请输入第"<<i+1<<"个学生的姓名："<<endl;gets(score[i].name);cout<<"请输入第"<<i+1<<"个学生的性别："<<endl;gets(score[i].sex);cout<<"请输入第"<<i+1<<"个学生的年龄："<<endl;cin>>score[i].age;cout<<"请输入第"<<i+1<<"个学生的班级："<<endl;gets(score[i].classes);cout<<"请输入第"<<i+1<<"个学生的英语成绩："<<endl;cin>>score[i].english;cout<<"请输入第"<<i+1<<"个学生的数学成绩："<<endl;cin>>score[i].math;cout<<"请输入第"<<i+1<<"个学生的物理成绩："<<endl;cin>>score[i].physics;}}void sum_avg(struct stu_score score[]){for(int i=0;i<N;i++){score[i].sum=score[i].english+score[i].math+score[i].physics; score[i].avg=score[i].sum/3;}}void course_avg(struct stu_score score[]){float eng_avg,math_avg,phy_avg;float eng_sum=0,math_sum=0,phy_sum=0;for(int i=0;i<N;i++){eng_sum=eng_sum+score[i].english;math_sum=math_sum+score[i].math;phy_sum=phy_sum+score[i].physics;}eng_avg=eng_sum/N;math_avg=math_sum/N;phy_avg=phy_sum/N;cout<<"英语的平均分为："<<eng_avg<<endl;cout<<"数学的平均分为："<<math_avg<<endl;cout<<"物理的平均分为："<<phy_avg<<endl;}void findstu(struct stu_score score[]){for(int i=0;i<N;i++)if(score[i].english<60||score[i].math<60||score[i].physics<60)cout<<"第"<<i+1<<"个学生有不及格课程,其学号和姓名为："<<score[i].num<<""<<score[i].name<<endl;}void sequence(struct stu_score score[]){struct stu_score temp;for(int i=0;i<N-1;i++)for(int j=i+1;j<N;j++)if(score[i].sum<score[j].sum){temp=score[i];score[i]=score[j];score[j]=temp;}for(i=0;i<N;i++)score[i].mingci=i+1;}void display(struct stu_score score[]){ cout<<"全班的信息如下："<<endl;for(int i=0;i<N;i++)cout<<score[i].num<<" "<<score[i].sum<<""<<score[i].mingci<<endl;}（3）运行结果2.利用上一题的结构类型，创建包含10个结点的无序链表。
编写5个函数分别实现下述功能：（1）显示链表；（2）添加结点；（3）删除结点；（4）计算每位学生的总分；（5）按英语成绩从大到小排序。
（1）思路分析：声明链表；调用函数display显示链表；调用函数add添加结点；调用函数delet删除结点；调用函数px实现按英语成绩从大到小排序；计算每位学生的总分在主函数内完成（2）源代码：#include<iostream.h>#include<stdio.h>#define N 2struct stu_info{int no;char name[6];char sex[2];int age;char classes[4];float physics;float math;float english;float sum;struct stu_info *next;};void display(struct stu_info *head){struct stu_info *p;p=head;while(p!='\0'){cout<<p->no<<" "<<p->name<<" "<<p->sex<<" "<<p->age<<" "<<p->classes<<endl;cout<<p->math<<" "<<p->english<<" "<<p->physics<<endl;p=p->next;}}void add(struct stu_info *head,struct stu_info *pNode){struct stu_info *p;p=head;while(p->next!=NULL)p=p->next;p->next=pNode;}void delet(struct stu_info stu[],struct stu_info *head){struct stu_info *p, *q;int a;cout<<"输入a="<<endl;cin>>a;if(head == NULL){cout<<"空链表";return;}p = head;while((p!=NULL)&&(p->math!=a)){q = p;p = p->next; // 把指针p往后移动一个结点}if((p != NULL) && (p->math==a)){if(p==head)head=p->next; // 删除的是首结点elseq->next=p->next; // 删除的是中间结点}}void px(struct stu_info stu[]){struct stu_info temp;for(int i=0;i<N-1;i++)for(int j=i+1;j<N;j++)if(stu[i].sum<stu[j].sum){temp=stu[i];stu[i]=stu[j];stu[j]=temp;}}void main(){struct stu_info stu[N];struct stu_info *head;struct stu_info *pNode,Node;pNode=&Node;cout<<"输入编号"<<endl;cin>>Node.no;cout<<"输入姓名"<<endl;gets();cout<<"输入性别"<<endl;gets(Node.sex);cout<<"输入班级"<<endl;gets(Node.classes);cout<<"输入年龄"<<endl;cin>>Node.age;cout<<"输入数学成绩"<<endl;cin>>Node.math;cout<<"输入英语成绩"<<endl;cin>>Node.english;cout<<"输入物理成绩"<<endl;cin>>Node.physics;Node.next=NULL;head=&stu[0];for (int i=0;i<N;i++){cout<<"输入第"<<i+1<<"个学生的学号"<<endl;cin>>stu[i].no;cout<<"输入第"<<i+1<<"个学生的姓名"<<endl;gets(stu[i].name);cout<<"输入第"<<i+1<<"个学生的班级"<<endl;gets(stu[i].classes);cout<<"输入第"<<i+1<<"个学生的性别"<<endl;gets(stu[i].sex);cout<<"输入第"<<i+1<<"个学生的年龄"<<endl;cin>>stu[i].age;cout<<"输入第"<<i+1<<"个学生的数学成绩"<<endl;cin>>stu[i].math;cout<<"输入第"<<i+1<<"个学生的英语成绩"<<endl;cin>>stu[i].english;cout<<"输入第"<<i+1<<"个学生的物理成绩"<<endl;cin>>stu[i].physics;if(i<N-1) stu[i].next=&stu[i+1];else stu[i].next=NULL;}display(head);add(head,pNode);display(head);delet(stu,head);display(head);for (int j=0;j<N;j++){stu[j].sum=stu[j].english+stu[j].math+stu[j].physics;cout<<stu[j].sum<<endl;}px(stu);}（3）运行结果：错误分析：链表的基本功能函数未完全掌握，运用起来不熟练。