数据结构实验报告-答案
国家开放大学《数据结构》课程实验报告(实验2——线性表)参考答案
{
output(p);
p=p->next;
}
printf("\n");
}
//输出最高分及最低分评委信息，删除最高分及最低分结点并计算参赛者的最后平均分
void calc(NODE *head)
{
NODE *q,*p,*pmin,*pmax;
float sum=0; //总分
导
教
师
评
语
指导教师 日期
printf("\n");
//在链表中删除最高分和最低分结点
for(q=head,p=head->next;p!=NULL;q=p,p=p->next)
{
if(p==pmin) { q->next=p->next; p=q; } //删除最低分结点
if(p==pmax) { q->next=p->next; p=q; } //删除最高分结点
p=p->next;
}
//输出最高分及最低分评委信息
printf("给出最高分的评委姓名：%6s年龄：%d评分：%6.2f\n",pmax->,pmax->data.age,pmax->data.score);
printf("给出最低分的评委姓名：%6s年龄：%d评分：%6.2f\n",pmin->,pmin->data.age,pmin->data.score);
float ave=0; //平均分
//查找最高分和最低分并计算总分
p=head->next;
pmin=pmax=p;
数据结构实验报告-答案.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心得体会：本次实验使我们对链表的实质了解更加明确了，对链表的一些基本操作也更加熟练了。
国家开放大学《数据结构》课程实验报告(实验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)出栈/入队的元素依次为:");
数据结构实验题参考答案
【实验题】1．狐狸逮兔子围绕着山顶有10个圆形排列的洞，狐狸要吃兔子，兔子说：“可以，但必须找到我，我就藏身于这十个洞中，你先到１号洞找，第二次隔１个洞（即3号洞）找，第三次隔２个洞（即6号洞）找，以后如此类推，次数不限。
”但狐狸从早到晚进进出出了1000次，仍没有找到兔子。
问兔子究竟藏在哪个洞里？（提示：这实际上是一个反复查找线性表的过程。
）【数据描述】定义一个顺序表，用具有10个元素顺序表来表示这10个洞。
每个元素分别表示围着山顶的一个洞，下标为洞的编号。
#define LIST_INIT_SIZE 10 //线性表存储空间的初始分配量typedef struct {ElemType *elem; //存储空间基址int length; //当前长度int listsize; //当前分配的存储容量（以sizeof(ElemType)为单位）}SqList;【算法描述】status InitList_Sq(SqList &L) {//构造一个线性表LL.elem=(ElemType )malloc(LIST_INIT_SIZE*sizeof(ElemType));If(!L.elem) return OVERFLOW; //存储分配失败L.length=0; //空表长度为0L.listsize=LIST_INIT_SIZE; //初始存储容量return OK;} //InitList_Sqstatus Rabbit(SqList &L){ //构造狐狸逮兔子函数int current=0; //定义一个当前洞口号的记数器，初始位置为第一个洞口for(i=0;i<LIST_INIT_SIZE;i++)L.elem[i]=1; //给每个洞作标记为1，表示狐狸未进之洞L.elem[LIST_INIT_SIZE-1]=L.elem[0]=0;//首先进入第一个洞，标记进过的洞为0。
数据结构实验报告
A
B
C D
E F
G
主程序模块
结点单元模块构建先序二叉树模块
二叉树遍历模块
main
CreatBTree Preorder Inorder Postorde
程序的功能设计、数据结构设计及整体结构
设计合理； 程序运行情况良好， 算法说明清 晰，理论分析与计算正确，实验数据无误 熟练使用开辟工具， 能够迅速准确的进行调
试、纠错和运行
良好的编程风格(缩进，注释，变量名、函
数名见名知意等，程序运行界面友好)
提交的电子文档及打印文档的书写、存放符
合规范化要求
能简明扼要地阐述设计的主要内容， 能准确
流利地回答各种问题
端正的学习态度及认真刻苦程度等
30
20
10
10
20
10。
《数据结构》实验1实验报告
南京工程学院实验报告<班级>_<学号>_<实验X>.RAR文件形式交付指导老师。
一、实验目的1.熟悉上机环境，进一步掌握语言的结构特点。
2.掌握线性表的顺序存储结构的定义及实现。
3.掌握线性表的链式存储结构——单链表的定义及实现。
4.掌握线性表在顺序存储结构即顺序表中的各种基本操作。
5.掌握线性表在链式存储结构——单链表中的各种基本操作。
二、实验内容1.顺序线性表的建立、插入及删除。
2.链式线性表的建立、插入及删除。
三、实验步骤1.建立含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度。
2.利用前面的实验先建立一个顺序表L={21，23，14，5，56，17，31}，然后在第i个位置插入元素68。
3.建立一个带头结点的单链表，结点的值域为整型数据。
要求将用户输入的数据按尾插入法来建立相应单链表。
四、程序主要语句及作用程序1的主要代码(附简要注释)public struct sequenlist{public const int MAXSIZE=1024; /*最大值为1024*/public elemtype[] vec;public int len; /* 顺序表的长度 */public sequenlist( int n){vec=new elemtype[MAXSIZE ];len = n;}};class Program{static void Main(string[] args){sequenlist list1 = new sequenlist(5);for (int i = 0; i < 5; i++){list1.vec[i] = i;}for (int i = 0; i < 5; i++){Console.Write("{0}---", list1.vec[i]) ;}Console.WriteLine("\n");Console.WriteLine("表长：{0}\n",list1.len );Console.ReadKey();}}程序2的主要代码(附简要注释)public void insertlist(int i, int x){if (len >= MAXSIZE)throw new Exception("上溢"); /*长度大于最大值则抛出异常*/if (i < 1 || i > len + 1)throw new Exception("位置");/插入位置小于1或大于len+1则抛出插入位置错误的异常for (int j = len; j >= i; j--)vec[j] = vec[j - 1]; //注意第j个元素存在数组下标为j-1处vec[i - 1] = x;len++;}};class Program{static void Main(string[] args){sequenlist list2 = new sequenlist(7);list2.vec[0] = 21;list2.vec[1] = 23;list2.vec[2] = 14;list2.vec[3] = 5;list2.vec[4] = 56;list2.vec[5] = 17;list2.vec[6] = 31;Console.Write("请输入第i个位置插入元素：");int loc =Convert.ToInt32( Console.ReadLine());Console.Write("请输入第{0}个位置插入的元素：", loc);int ele = Convert.ToInt32(Console.ReadLine());Console.WriteLine("插入前的线性表：");for (int i = 0; i < list2.len ; i++){Console.Write("{0}---", list2.vec[i]);}Console.WriteLine("\n");list2.insertlist(loc, ele);Console.WriteLine("插入后的线性表：");for (int i = 0; i < list2.len ; i++){Console.Write("{0}---", list2.vec[i]);}Console.WriteLine("\n");Console.ReadKey();}}程序3的主要代码(附简要注释)class Node{private int num;public int Num{set { num = value; }/输入值get { return num; }/获得值}private Node next;public Node Next{set { next = value; }get { return next; }}}class Pp{static void Main(string[] args){Node head;Node tempNode, tempNode1;int i;head = new Node();Console.WriteLine("输入六项数据：\n");Console.Write("输入第1项数据:");head.Num = Convert.ToInt32(Console.ReadLine());head.Next = null;tempNode = head;for (i = 1; i < 6; i++){tempNode1 = new Node();Console.Write("输入第{0}项数据:",i+1);tempNode1.Num = Convert.ToInt32(Console.ReadLine());/插入项转换为整形数值 tempNode1.Next = null;tempNode.Next = tempNode1;tempNode = tempNode.Next;}Console.WriteLine("线性表:");tempNode = head;for (i = 0; i < 6; i++){Console.Write("{0}", tempNode.Num);if (i < 5){Console.Write("--");}tempNode = tempNode.Next;}Console.ReadKey();}}五、程序运行结果截图程序1程序2程序3六、收获，体会及问题(写得越详细、越个性化、越真实越好，否则我不知道你做这个实验的心路历程，也就无法充分地判断你是否是独立完成的这个实验、你是否在做这个实验时进行了认真仔细地思考、通过这个实验你是否在实践能力上得到了提高)这次试验刚开始做时完全不知道从哪下手，才刚上了几节课，对于线性表、链式表都不是理解的很透彻，不知道用哪个软件编写程序。
(完整版)数据结构实验答案及解析
《数据结构》实验指导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
数据结构实验答案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返回其值。
数据结构实验报告10图的操作答案
for(i=0;i<G->n;i++){//建立顶点表
while((G->adjlist[i].vertex=getchar())=='\n');//读入顶点信息
G->adjlist[i].firstedge=NULL;//边表置为空表
}
for(k=0;k<G->e;k++){//建立边表
VertexType vertex;//顶点域
EdgeNode *firstedge;//边表头指针
}VertexNode;
typedef VertexNode AdjList[MaxVertexNum];
//AdjList是邻接表类型
typedef struct {
AdjList adjlist;//邻接表
实 验 报 告
院（系）:信息科学与技术学院课程名称:数据结构日期:
班级
学号
实验室
专业
姓名
计算机号
实验名称
图的存储与基本操作
成绩评定
所用软件
V C或TC
教师签名
实
验
目
的
（1）掌握图的存储结构；
（2）实现图的邻接矩阵存储。
（3）掌握图的遍历方法。
实
验
准
备
1、复习书上有关内容。
2、阅读实验内容1。
3、编出实验内容2.3的源程序。
}
}
//打印邻接表:
void PrintALGraph(ALGraph *G)
{
int i;
EdgeNode *p;
for(i=0;i<G->n;i++)
数据结构实验报告答案1
(此文档为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以内的整数（如果做得更好可以输入学校的名称，运动项目的名称）输出形式：有中文提示，各学校分数为整形界面要求：有合理的提示，每个功能可以设立菜单，根据提示，可以完成相关的功能要求。
太原理工数据结构实验答案
实验一线性表一．目的与要求本次实习的主要目的是为了使学生熟练掌握线性表的基本操作在顺序存储结构和链式存储结构上的实现，提高分析和解决问题的能力。
要求仔细阅读并理解下列例题，上机通过，并观察其结果，然后独立完成后面的实习题。
二．例题问题描述:用链表形式存储一个字符串，插入、删除某个字符，最后按正序、逆序两种方式输出字符串。
输入:初始字符串，插入位置，插入字符，删除字符。
输出:已建立链表（字符串），插入字符后链表，删除字符后链表，逆转后链表。
存储结构:采用链式存储结构算法的基本思想:建立链表当读入字符不是结束符时，给结点分配存储空间，写数据域，将新结点插到表尾；插入字符：根据读入的字符在链表中找插入位置，将新结点插入到该位置之前；删除字符：根据读入的删除字符在链表中找到被删结点后，将其从链表中删除；链表逆转：从链表的第一个结点开始对所有结点处理，将每个结点的前驱变为它的后继；打印链表：从链表的第一个结点开始，依次打印各[运行情况]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.1 理解数据结构的基本概念和操作1.2 学会使用数据结构解决实际问题1.3 掌握常用数据结构的实现和应用2. 实验环境2.1 操作系统：Windows 102.2 编程语言：C++2.3 开发工具：Visual Studio3. 实验内容3.1 实验一：线性表的实现和应用3.1.1 设计并实现线性表的基本操作函数3.1.2 实现线性表的插入、删除、查找等功能 3.1.3 实现线性表的排序算法3.1.4 应用线性表解决实际问题3.2 实验二：栈和队列的实现和应用3.2.1 设计并实现栈的基本操作函数3.2.2 设计并实现队列的基本操作函数3.2.3 实现栈和队列的应用场景3.2.4 比较栈和队列的优缺点3.3 实验三：树的实现和应用3.3.1 设计并实现二叉树的基本操作函数3.3.2 实现二叉树的创建、遍历和查找等功能3.3.3 实现树的遍历算法（前序、中序、后序遍历）3.3.4 应用树解决实际问题4. 数据结构实验结果4.1 实验一的结果4.1.1 线性表的基本操作函数实现情况4.1.2 线性表的插入、删除、查找功能测试结果4.1.3 线性表的排序算法测试结果4.1.4 线性表解决实际问题的应用效果4.2 实验二的结果4.2.1 栈的基本操作函数实现情况4.2.2 队列的基本操作函数实现情况4.2.3 栈和队列的应用场景测试结果4.2.4 栈和队列优缺点的比较结果4.3 实验三的结果4.3.1 二叉树的基本操作函数实现情况4.3.2 二叉树的创建、遍历和查找功能测试结果 4.3.3 树的遍历算法测试结果4.3.4 树解决实际问题的应用效果5. 实验分析与总结5.1 实验问题与解决方案5.2 实验结果分析5.3 实验总结与心得体会6. 附件附件一：实验源代码附件二：实验数据7. 法律名词及注释7.1 版权：著作权法规定的对原创作品享有的权利7.2 专利：国家授予的在一定时间内对新型发明享有独占权利的证书7.3 商标：作为标识企业商品和服务来源的标志的名称、符号、图案等7.4 许可协议：指允许他人在一定条件下使用自己的知识产权的协议。
数据结构实验报告-线性表
1 线性表1. 实验题目与环境1.1实验题目及要求（1）顺序表的操作利用顺序存储方式实现下列功能：根据键盘输入数据建立一个线性表，并输出该线性表；对该线性表进行数据的插入、删除、查找操作，并在插入和删除数据后，再输出线性表。
（2）单链表的操作利用链式存储方式实现下列功能：根据键盘输入数据建立一个线性表，并输出该线性表；对该线性表进行数据的插入、删除、查找操作，并在插入和删除数据后，再输出线性表。
（3）线性表的应用约瑟夫环问题。
有n个人围坐一圈，现从某个人开始报数，数到M的人出列，接着从出列的下一个人开始重新报数，数到M的人又出列，如此下去，直到所有人都出列为止。
要求依次输出出列人的编码。
2.问题分析（1）顺序表的操作利用一位数组来描述顺序表，即将所有元素一词储存在数组的连续单元中，要在表头或中间插入一个新元素时，需要将其后的所有元素都向后移动一个位置来为新元素腾出空间。
同理，删除开头或中间的元素时，则将其后的所有元素向前移动一个位置以填补空位。
查找元素时，则需要利用循环语句，一一判断直到找出所要查找的元素（或元素的位置），输出相关内容即可（2）单链表的操作利用若干个结点建立一个链表，每个节点有两个域，即存放元素的数据域和存放指向下一个结点的指针域。
设定一个头指针。
在带头结点的单链表中的第i个元素之前插入一新元素，需要计数找到第i-1个结点并由一指针p指向它，再造一个由一指针s指向的结点，数据为x，并使x的指针域指向第i个结点，最后修改第i-1个结点的指针域，指向x结点。
删除第i个元素时，需要计数寻找到第i个结点，并使指针p指向其前驱结点，然后删除第i个结点并释放被删除结点的空间。
查找第i个元素，需从第一个结点开始计数找到第i个结点，然后输出该结点的数据元素。
（3）线性表的应用程序运行之后，首先要求用户指定初始报数的上限值，可以n<=30,此题中循环链表可不设头结点，而且必须注意空表和"非空表"的界限。
国家开放大学《数据结构》课程实验报告(实验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));
数据结构实验报告(2015级)及答案
《数据结构》实验报告专业__信息管理学院______ 年级__2015级___________ 学号___ _______ 学生姓名___ _ _______ 指导老师____________华中师范大学信息管理系编I 实验要求1．每次实验中有若干习题，每个学生至少应该完成其中的两道习题。
2．上机之前应作好充分的准备工作，预先编好程序，经过人工检查无误后，才能上机，以提高上机效率。
3．独立上机输入和调试自己所编的程序，切忌抄袭、拷贝他人程序。
4．上机结束后，应整理出实验报告。
书写实验报告时，重点放在调试过程和小节部分，总结出本次实验中的得与失，以达到巩固课堂学习、提高动手能力的目的。
II 实验内容实验一线性表【实验目的】1．熟悉VC环境，学习如何使用C语言实现线性表的两种存储结构。
2．通过编程、上机调试，进一步理解线性表的基本概念,熟练运用C语言实现线性表基本操作。
3．熟练掌握线性表的综合应用问题。
【实验内容】1．一个线性表有n个元素（n<MAXSIZE, MAXSIZE指线性表的最大长度），且递增有。
现有一元素x要插入到线性表的适当位置上，并保持线性表原有的顺序不变。
设计程序实现。
要求：采用顺序存储表示实现；采用链式存储表示方法实现；比较两种方法的优劣。
2. 从单链表中删除指定的元素x，若x在单链表中不存在，给出提示信息。
要求：①指定的值x由键盘输入；②程序能处理空链表的情况。
3．设有头结点的单链表，编程对表中的任意值只保留一个结点，删除其余值相同的结点。
要求：①该算法用函数（非主函数）实现；②在主函数中调用创建链表的函数创建一个单链表，并调用该函数，验证算法的正确性。
LinkedList Exchange（LinkedList HEAD，p）∥HEAD是单链表头结点的指针，p是链表中的一个结点。
本算法将p所指结点与其后继结点交换。
{q=head->next；∥q是工作指针，指向链表中当前待处理结点。
九江学院 数据结构 实验报告 完整答案
《数据结构》实验报告班级学号：姓名：《数据结构》实验报告学院：信息科学与技术学院专业：学期：班级：学号：姓名：易网返利网——淘宝购物返现逐新时尚-品牌服装-提供：目录实验1 函数、指针、结构体复习 (1)1.1 实验目的 (1)1.2 实验准备 (1)1.3 实验任务 (1)实验2 线性表 (4)2.1 实验目的 (4)2.2 实验准备 (4)2.3 实验任务 (4)实验3 栈和队列 (19)3.1 实验目的 (19)3.2 实验准备 (19)3.3 实验任务 (19)实验4 线性表的综合应用 (27)4.1 实验目的 (27)4.2 实验准备 (27)4.3 实验任务 (27)实验5 树和二叉树 (32)5.1 实验目的 (32)5.2 实验准备 (32)5.3 实验任务 (32)实验6 图 (42)6.1 实验目的 (42)6.2 实验准备 (42)6.3 实验任务 (42)实验7 查找 (46)7.1 实验目的 (46)7.2 实验准备 (46)7.3 实验任务 (46)实验8 排序 (55)8.1 实验目的 (55)8.2 实验准备 (55)8.3 实验任务 (55)实验9 综合实验 (58)9.1 实验目的 (60)9.2 实验预习 (60)9.3 实验任务 (60)实验1 函数、指针、结构体复习院（系）：信息科学与技术学院课程名称：数据结构教师签名：1.1 实验目的1．掌握C语言的语法并由算法形成相应的程序。
2．熟练掌握C语言函数调用的相关知识点。
3．熟练掌握C语言的指针和结构体相关知识点。
4．理解数据结构的基本概念。
1.2 实验准备1．复习C语言的函数调用、指针、结构体的相关知识点。
2．算法的概念和算法分析等知识。
3．C语言程序设计有关函数及数组等的知识及编程环境的使用方法。
4．复习课堂讲解的理论内容。
1.3 实验任务1．在提示/**********blank**********/下面填写合适的内容完成程序设计。
《数据结构》实验报告二及其答案
《数据结构》实验报告二学校：班级：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();}实验二答案：//程序目的建立二叉树，同时对他进行先序排列。
国家开放大学《数据结构》课程实验报告(实验4——二叉树)参考答案
（实验4二叉树）
学生姓名
学 号
班 级
指导老师
实验名称
实验成绩
实验报告
实ቤተ መጻሕፍቲ ባይዱ
验
概
述
实验目的：
（1）根据数组tree，建立与该二叉树对应的链式存储结构。
（2）对该二叉树采用中序遍历法显示遍历结果。
实验要求：
（1）在主函数中，通过键盘输入建立设定的完全二叉树的顺序存储结构。
（2）设计子函数，其功能为将顺序结构的二叉树转化为链式结构。
（2）中序遍历采用递归算法，即中序遍历左子树、访问根结点、中序遍历右子树。
实
验
内
容
程序代码：
/*实验3.1二叉树的顺序存储结构和链式存储结构*/
#include <stdio.h>
#include <stdlib.h>
#define MaxSize 20
/*二叉树链式存储结构结点定义*/
typedef struct BTreeNode
指
导
教
师
评
语
指导教师 日期
（3）设计子函数，其功能为对给定二叉树进行中序遍历，显示遍历结果。
（4）通过实例判断算法和相应程序的正确性。
实验基本原理：
（1）顺序存储的二叉树转化为链式存储结构，采用递归算法，递归函数的形式为Creab(tree,n,i,b)，其中形参：tree为顺序存储二叉树的数组，n为二叉树的结点数，i是二叉树某结点在数组tree中的下标（初始值为1），b为要建立的链式存储二叉树结点指针。转化时，首先建立*b结点，将tree[i]的值赋给*b的数据域，再调用递归函数分别构造左子树和右子树。
数据结构实验报告答案
《数据结构与算法分析》课程设计内容体系主要内容《数据结构课程设计》课程，可使学生深化理解书本知识，致力于用学过的理论知识和上机取得的实践经验，解决具体、复杂的实际问题，培养软件工作者所需的动手能力、独立解决问题的能力。
该课程设计侧重软件设计的综合训练，包括问题分析、总体结构设计、用户界面设计、程序设计基本技能和技巧、多人合作，以至一整套软件工作规范的训练和科学作风的培养。
一、课程设计要求学生必须仔细阅读《数据结构与算法分析》课程设计方案，认真主动完成课程设计的要求。
有问题及时主动通过各种方式与教师联系沟通。
学生要发挥自主学习的能力，充分利用时间，安排好课程设计的时间计划，并在课程设计过程中不断检测自己的计划完成情况，及时的向教师汇报。
课程设计按照教学要求需要两周时间完成，两周中每天（按每周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以内的整数（如果做得更好可以输入学校的名称，运动项目的名称）输出形式：有中文提示，各学校分数为整形界面要求：有合理的提示，每个功能可以设立菜单，根据提示，可以完成相关的功能要求。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据结构(C语言版) 实验报告专业班级学号姓名实验1实验题目：单链表的插入和删除实验目的：了解和掌握线性表的逻辑结构和链式存储结构，掌握单链表的基本算法及相关的时间性能分析。
实验要求：建立一个数据域定义为字符串的单链表，在链表中不允许有重复的字符串；根据输入的字符串，先找到相应的结点，后删除之。
实验主要步骤：1、分析、理解给出的示例程序。
2、调试程序，并设计输入数据（如：bat，cat，eat，fat，hat，jat，lat，mat，#），测试程序的如下功能：不允许重复字符串的插入；根据输入的字符串，找到相应的结点并删除。
3、修改程序：（1）增加插入结点的功能。
（2）将建立链表的方法改为头插入法。
程序代码:#include""#include""#include""#include""typedef struct node . .示意图：headheadhead心得体会：本次实验使我们对链表的实质了解更加明确了，对链表的一些基本操作也更加熟练了。
另外实验指导书上给出的代码是有一些问题的，这使我们认识到实验过程中不能想当然的直接编译执行，应当在阅读并完全理解代码的基础上再执行，这才是实验的意义所在。
实验2实验题目：二叉树操作设计和实现实验目的：掌握二叉树的定义、性质及存储方式，各种遍历算法。
实验要求：采用二叉树链表作为存储结构，完成二叉树的建立，先序、中序和后序以及按层次遍历的操作，求所有叶子及结点总数的操作。
实验主要步骤：1、分析、理解程序。
2、调试程序，设计一棵二叉树，输入完全二叉树的先序序列，用#代表虚结点（空指针），如ABD###CE##F##，建立二叉树，求出先序、中序和后序以及按层次遍历序列，求所有叶子及结点总数。
实验代码#include""#include""#include""#define Max 20ertex=a; irstedge=NULL; irstedge;G->adjlist[i].firstedge=s; irstedge;R[i]留在原位j--;}while(R[0].key<R[j].key); ey≥R[j].key 是终止R[j+1]=R[0]; ey<R[j].key){ =======一次划分函数===== int Partition(SeqList R,int i,int j){ ey>= ey < ，则R[i++]=R[j]; ey<= ey > ，则R[j--]=R[i]; ====快速排序===========void QuickSort(SeqList R,int low,int high){ high]快速排序int pivotpos; high]做一次划分，得到基准记录的位置QuickSort(R,low,pivotpos-1); ey<R[k].key)k=j; high]调整为大根堆，除R[low]外，其余结点均满足堆性质int large; ey<R[large+1].key)large++; ey) n]构造为堆int i;for(i=n/2;i>0;i--)Heapify(R,i,n); n]调整为大根堆}n]进行堆排序，不妨用R[0]做暂存单元int i;BuildHeap(R); n]构造为初始大根堆for(i=n;i>1;i--){ i]进行堆排序，共做n-1趟。
R[0]=R[1]; R[1]=R[i];R[i]=R[0]; i-1]重新调整为堆，仅有R[1]可能违反堆性质。
}}m]和R[m+1..high]归并成有序的序列R[low..high]==void Merge(SeqList R,int low,int m,int high){int i=low,j=m+1,p=0; ey<=R[j].key)? R[i++]:R[j++];while(i<=m) high]}n]做一趟归并排序========void MergePass(SeqList R,int length){int i;for(i=1;i+2*length-1<=n;i=i+2*length)Merge(R,i,i+length-1,i+2*length-1); n]做二路归并排序=============== void MergeSort(SeqList R){int length;for(length=1;length<n;length*=2) ey);}ey);}//==========主函数======void main(){int i;SeqList R;input_int(R);printf("\t******** Select **********\n");printf("\t1: Insert Sort\n");printf("\t2: Bubble Sort\n");printf("\t3: Quick Sort\n");printf("\t4: Straight Selection Sort\n");printf("\t5: Heap Sort\n");printf("\t6: Merge Sort\n");printf("\t7: Exit\n");printf("\t***************************\n");scanf("%d",&i); //输入整数1-7，选择排序方式switch (i){case 1: InsertSort(R); break; //值为1，直接插入排序case 2: BubbleSort(R); break; //值为2，冒泡法排序case 3: QuickSort(R,1,n); break; //值为3，快速排序case 4: SelectSort(R); break; //值为4，直接选择排序case 5: HeapSort(R); break; //值为5，堆排序case 6: MergeSort(R); break; //值为6，归并排序case 7: exit(0); //值为7，结束程序}printf("Sort reult:");output_int(R);}实验结果：Please input num(int):10Plase input 10 integer:26530175112993786374269476438******** Select **********1: Insert Sort2: Bubble Sort3: Quick Sort4: Straight Selection Sort5: Heap Sort6: Merge Sort7: Exit***************************1129, 265, 301, 751, 937, 863, 742, 694, 76, 438,129, 265, 301, 751, 863, 937, 742, 694, 76, 438,129, 265, 301, 742, 751, 863, 937, 694, 76, 438,129, 265, 301, 694, 742, 751, 863, 937, 76, 438,76, 129, 265, 301, 694, 742, 751, 863, 937, 438,76, 129, 265, 301, 438, 694, 742, 751, 863, 937,Sort reult: 76, 129, 265, 301, 438, 694, 742, 751, 863, 937,276,265,301,751,129,937,863,742,694,438,76,129,265,301,751,438,937,863,742,694,76,129,265,301,438,751,694,937,863,742,76,129,265,301,438,694,751,742,937,863,76,129,265,301,438,694,742,751,863,937,Sort reult: 76, 129, 265, 301, 438, 694, 742, 751, 863, 937,376,129,265,751,937,863,742,694,301,438,76,129,265,751,937,863,742,694,301,438,76,129,265,438,301,694,742,751,863,937,76,129,265,301,438,694,742,751,863,937,76,129,265,301,438,694,742,751,863,937,76,129,265,301,438,694,742,751,863,937,Sort reult: 76, 129, 265, 301, 438, 694, 742, 751, 863, 937, 476,301,751,129,937,863,742,694,265,438,76,129,751,301,937,863,742,694,265,438,76,129,265,301,937,863,742,694,751,438,76,129,265,301,438,863,742,694,751,937,76,129,265,301,438,694,742,863,751,937,76,129,265,301,438,694,742,751,863,937,Sort reult: 76, 129, 265, 301, 438, 694, 742, 751, 863, 937, 5863,694,751,265,438,301,742,129, 76,937,751,694,742,265,438,301, 76,129,863,937,742,694,301,265,438,129, 76,751,863,937,694,438,301,265, 76,129,742,751,863,937,438,265,301,129, 76,694,742,751,863,937,301,265, 76,129,438,694,742,751,863,937,265,129, 76,301,438,694,742,751,863,937,129, 76,265,301,438,694,742,751,863,937,76,129,265,301,438,694,742,751,863,937,Sort reult: 76, 129, 265, 301, 438, 694, 742, 751, 863, 937,6265,301,129,751,863,937,694,742, 76,438,129,265,301,751,694,742,863,937, 76,438,129,265,301,694,742,751,863,937, 76,438,76,129,265,301,438,694,742,751,863,937,Sort reult: 76, 129, 265, 301, 438, 694, 742, 751, 863, 937,7Press any key to continue运行速度比较：直接排序冒泡排序直接插入冒泡排序快速排序时间复杂度 O(n2)，其中快速排序效率较高其它的效率差不多堆排序归并排序时间复杂度 (nlogn) ,平均效率都很高心得体会：此次试验了解了各种排序的基本思想，在分析各种排序的程序代码，对程序进行调试执行等等过程中，锻炼了自己分析数据结构的能力。