数据结构实验报告答案

很多人对于写报告感到头疼，不了解报告的内容与格式，该怎么写出格式正确、内容合理的报告呢？今天小编给大家找来了《数据结构实验报告答案》，供需要的小伙伴们查阅，希望能够帮助到大家。

第一篇：数据结构实验报告答案

数据结构实验报告

南京信息工程大学实验(实习)报告

实验(实习)名称数据结构实验(实习)日期 2011-11-2得分指导教师周素萍

系公共管理系专业信息管理与信息系统年级10级班次1姓名常玲学号2010230700

3实验一顺序表的基本操作及C语言实现

【实验目的】

1、顺序表的基本操作及 C 语言实现

【实验要求】

1、用 C 语言建立自己的线性表结构的程序库，实现顺序表的基本操作。

2、对线性表表示的集合，集合数据由用户从键盘输入(数据类型为整型)，建立相应的顺序表，且使得数据按从小到大的顺序存放，将两个集合的并的结果存储在一个新的线性表集合中，并输出。

【实验内容】

1、 根据教材定义的顺序表机构，用 C 语言实现顺序表结构的创建、插入、删除、

查找等操作;

2、 利用上述顺序表操作实现如下程序：建立两个顺序表表示的集合(集合中无重

复的元素)，并求这样的两个集合的并。

【实验结果】

[实验数据、结果、遇到的问题及解决]

一. Status InsertOrderList(SqList &va,ElemType x)

{

}

二. Status DeleteK(SqList &a,int i,int k)

{

1 //在非递减的顺序表va中插入元素x并使其仍成为顺序表的算法 int i; if(va.length==va.listsize)return(OVERFLOW); for(i=va.length;i>0,x

}

//注意i的编号从0开始 int j; if(i<0||i>a.length-1||k<0||k>a.length-i) return INFEASIBLE; for(j=0;j<=k;j++)a.elem[j+i]=a.elem[j+i+k]; a.length=a.length-k; return OK;

三.// 将合并逆置后的结果放在C表中，并删除B表

Status ListMergeOppose_L(LinkList &A,LinkList &B,LinkList &C)

{

LinkList pa,pb,qa,qb; pa=A; pb=B; qa=pa; qb=pb; // 保存pa的前驱指针 // 保存pb的前驱指针 pa=pa->next; pb=pb->next; A->next=NULL; C=A; while(pa&&pb){} while(pa){} qa=pa; pa=pa->next; qa->next=A->next; A->next=qa; if(pa->datadata){} else{} qb=pb; pb=pb->next; qb->next=A->next; //将当前最小结点插入A表表头 A->next=qb; qa=pa; pa=pa->next; qa->next=A->next; //将当前最小结点插入A表表头 A->next=qa;

}

} pb=B; free(pb); return OK; qb=pb; pb=pb->next; qb->next=A->next; A->next=qb;

顺序表就是把线性表的元素存储在数组中，元素之间的关系直接通过相邻元素的位置来表达。

优点：简单，数据元素的提取速度快;

缺点：(1)静态存储，无法预知问题规模的大小，可能空间不足，或浪费存储空间;(2)插入元素和删除元素时间复杂度高——O(n)

求两个集合的并集

该算法是求两个集合s1和s2的并集，并将结果存入s引用参数所表示的集合中带回。 首先把s1集合复制到s中，然后把s2中的每个元素依次插入到集合s中，当然重复的元素不应该被插入，最后在s中就得到了s1和s2的并集，也就是在s所对应的实际参数集合中得到并集。

第二篇：数据结构实验报告

一. 题目要求

1)编程实现二叉排序树，包括生成、插入，删除; 2)对二叉排序树进行先根、中根、和后根非递归遍历;

3)每次对树的修改操作和遍历操作的显示结果都需要在屏幕上用树的形状表示出来。 4)分别用二叉排序树和数组去存储一个班(50人以上)的成员信息(至少包括学号、姓名、成绩3项),对比查找效率，并说明在什么情况下二叉排序树效率高,为什么? 二. 解决方案

对于前三个题目要求，我们用一个程序实现代码如下 #include #include #include #include "Stack.h"//栈的头文件，没有用上

typedefintElemType;

//数据类型 typedefint Status;

//返回值类型 //定义二叉树结构 typedefstructBiTNode{ ElemType

data;

structBiTNode *lChild, *rChild;//左右子树域 }BiTNode, *BiTree; intInsertBST(BiTree&T,int key){//插入二叉树函数

if(T==NULL) {

T = (BiTree)malloc(sizeof(BiTNode));

T->data=key;

T->lChild=T->rChild=NULL;

return 1; } else if(keydata){ InsertBST(T->lChild,key); } else if(key>T->data){

InsertBST(T->rChild,key); } else

return 0; } BiTreeCreateBST(int a[],int n){//创建二叉树函数 BiTreebst=NULL; inti=0; while(i

//数据域

InsertBST(bst,a[i]);

i++; } returnbst; } int Delete(BiTree&T)

{

BiTreeq,s;

} if(!(T)->rChild){ //右子树为空重接它的左子树

q=T; T=(T)->lChild; free(q); }else{

if(!(T)->lChild){ //若左子树空则重新接它的右子树

q=T; T=(T)->rChild; }else{ q=T; s=(T)->lChild; while(s->rChild){

q=s; s=s->rChild; }

(T)->data=s->data; //s指向被删除结点的前驱

if(q!=T)

q->rChild=s->lChild;

else

q->lChild=s->lChild;

free(s); } } return 1;

//删除函数，在T中删除key元素 intDeleteBST(BiTree&T,int key){ if(!T) return 0; else{

if(key==(T)->data) return Delete(T);

else{

if(key<(T)->data)

returnDeleteBST(T->lChild,key);

else

returnDeleteBST(T->rChild,key);

} } } intPosttreeDepth(BiTree T){//求深度

inthr,hl,max; if(!T==NULL){ hl=PosttreeDepth(T->lChild); hr=PosttreeDepth(T->rChild); max=hl>hr?hl:hr; return max+1; } else

return 0;

} void printtree(BiTreeT,intnlayer){//打印二叉树 if(T==NULL) return ; printtree(T->rChild,nlayer+1); for(inti=0;i

"); } printf("%d ",T->data); printtree(T->lChild,nlayer+1); } void PreOrderNoRec(BiTree root)//先序非递归遍历 { BiTree p=root; BiTreestack[50]; intnum=0; while(NULL!=p||num>0) {

while(NULL!=p)

{

printf("%d ",p->data);

stack[num++]=p;

p=p->lChild;

}

num--;

p=stack[num];

p=p->rChild; } printf(" "); } void InOrderNoRec(BiTree root)//中序非递归遍历 { BiTree p=root;

} intnum=0; BiTreestack[50]; while(NULL!=p||num>0) { while(NULL!=p) {

stack[num++]=p;

p=p->lChild; } num--; p=stack[num]; printf("%d ",p->data); p=p->rChild; } printf(" "); void PostOrderNoRec(BiTree root)//后序非递归遍历 { BiTree p=root; BiTreestack[50]; intnum=0; BiTreehave_visited=NULL;

while(NULL!=p||num>0) {

while(NULL!=p)

{

stack[num++]=p;

p=p->lChild;

}

p=stack[num-1];

if(NULL==p->rChild||have_visited==p->rChild)

{

printf("%d ",p->data);

num--;

have_visited=p;

p=NULL;

}

else

{

p=p->rChild;

} } printf(" "); }

int main(){//主函数

printf("

---------------------二叉排序树的实现-------------------"); printf(" "); int layer; inti; intnum; printf("输入节点个数:"); scanf("%d",&num); printf("依次输入这些整数(要不相等)"); int *arr=(int*)malloc(num*sizeof(int)); for(i=0;i

scanf("%d",arr+i); } BiTreebst=CreateBST(arr,num); printf(" "); printf("二叉树创建成功!"); printf(" "); layer=PosttreeDepth(bst); printf("树状图为: "); printtree(bst,layer); int j; int T; int K; for(;;){ loop: printf(" "); printf("

***********************按提示输入操作符************************:"); printf(" "); printf("

1:插入节点

2:删除节点

3:打印二叉树

4:非递归遍历二叉树

5:退出"); scanf("%d",&j);

switch(j){

case 1:

printf("输入要插入的节点:");

scanf("%d",&T);

InsertBST(bst,T);

printf("插入成功!"); printf("树状图为: ");

printtree(bst,layer);

break;

case 2:

}

printf("输入要删除的节点"); scanf("%d",&K); DeleteBST(bst,K); printf("删除成功!"); printf("树状图为: "); printtree(bst,layer); break; case 3: layer=PosttreeDepth(bst); printtree(bst,layer); break; case 4:

printf("非递归遍历二叉树"); printf("先序遍历: "); PreOrderNoRec(bst); printf("中序遍历: "); InOrderNoRec(bst);

printf("后序遍历: ");

PostOrderNoRec(bst);

printf("树状图为: ");

printtree(bst,layer);

break; case 5:

printf("程序执行完毕!");

return 0; } goto loop; } return 0; 对于第四小问，要储存学生的三个信息，需要把上面程序修改一下，二叉树结构变为 typedefintElemType;

//数据类型 typedefstring SlemType;

typedefint Status;

//返回值类型 //定义二叉树结构 typedefstructBiTNode{ SlemType name; ElemType score; ElemType no;

//数据域 structBiTNode *lChild, *rChild;//左右子树域 }BiTNode, *BiTree; 参数不是key,而是另外三个

intInsertBST(BiTree&T,intno,intscore,string name){//插入二叉树函数

if(T==NULL) {

T = (BiTree)malloc(sizeof(BiTNode));

T->no=no;T->name=name;T->score=score;

T->lChild=T->rChild=NULL;

return 1; } else if(nono){ InsertBST(T->lChild,no,score,name); } else if(key>T->data){

InsertBST(T->rChild,no,score,name); } else

return 0; } 其他含参函数也类似 即可完成50个信息存储

用数组存储50个信息，查看以往代码

#include #include using namespace std; class student{ private: intnum; string name; int ob1; int ob2; intara; public: void set(inta,stringb,intc,int d); void show(); int average(); }; void student ::set(inta,stringb,intc,int d){ num=a; name=b; ob1=c; ob2=d; ara=(c+d)/2; } void student::show(){ cout<<"学号："numlock; switch(numlock){ case 0: cout<<"输入想查询的学号"<>i; if(i==j){ cout<<"该学号信息已被删除"<>j; delete[j]ptr; cout<<"删除成功"<>k; if(k!=j){

cout<<"该学号信息已经存在，添加失败"<

break; } cout<<"重新输入添加的学号"<>q; cout<<"输入姓名"<>w; cout<<"输入科目一的成绩"<>e; cout<<"输入科目二的成绩"<>r; ptr[k].set(q,w,e,r); break; case 3: for( m=1;m<20;m++){

for(int n=m+1;n<20;n++){

if(ptr[m].average()

student a;

a=ptr[m];

ptr[m]=ptr[n];

ptr[n]=a;

}}

ptr[m].show(); } break; case 4: cout<<"谢谢使用"<

二叉排序树储存数据界面(储存学生信息略)

创建二叉树：

插入节点：

删除节点：

非递归遍历：

退出：

数组储存学生信息界面

分析查找效率：

因为二叉树查找要创建二叉树，而数组查找只创建一个数组，二叉树的创建时间比较长，所以对于数据量较少的情况下数组的查找效率比较高。但当数据量增加时，二叉树的查找优势就显现出来。所以数据量越大的时候，二叉树的查找效率越高。

四. 总结与改进

这个实验工作量还是很大的，做了很久。树状图形输出还是不美观，还需要改进。

一开始打算用栈实现非递归，但是根据书里面的伪代码发现部分是在C++编译器里运行不了的(即使补充了头文件和数据的定义)，所以之后参考了网上的数组非递归，发现其功能和栈相似。

递归遍历的实现比非递归的遍历真的简单很多。

开始时只看到前三问，所以没有写到储存学生数据的代码，里面还可以用clock()函数加一个计算查找所要数据时间的代码，让二叉树查找与数组查找到效率比较更加直观。

第三篇：数据结构实验报告

课程 数据结构 _ 院 系

专业班级 实验地点

姓 名 学 号

实验时间 指导老师

数据结构上机实验报告1

一﹑实验名称：

实验一——链表

二﹑实验目的：

1. 了解线性表的逻辑结构特性;

2. 熟悉链表的基本运算在顺序存储结构上的实现，熟练掌握链式存储结构的描述方法;

3. 掌握链表的基本操作(建表、插入、删除等) 4. 掌握循环链表的概念，加深对链表的本质的理解。 5. 掌握运用上机调试链表的基本方法

三﹑实验内容：

(1) (2) (3) (4) 创建一个链表 在链表中插入元素 在链表中删除一个元素 销毁链表 四﹑实验步骤与程序

#include #include typedef struct LNode {int data; struct LNode *next; }Lnode, *LinkList; //假设下面的链表均为带头结点。 void CreatLinkList(LinkList &L,int j) {//建立一个链表L,数据为整数，数据由键盘随机输入。

LinkList p,q; L=(LinkList )malloc(sizeof(Lnode)); L->next=NULL; q=L;

cout<<"请输入一个链表："<

for(int i=0;i

{

p=(LinkList)malloc(sizeof(Lnode));

cin>>p->data;

p->next=q->next;

q->next=p;

q=p;

} } int PrintLinkList(LinkList &L) {//输出链表L的数据元素

LinkList p;

} void LinkListLengh(LinkList &L) {//计算链表L的数据元素个数。 int i=0; p=L->next; if(L->next==NULL) {

} cout<<"链表的数据元素为:"; while(p)

{

cout

p=p->next; } cout<<"链表没有元素!"<

} LinkList p; p=L->next; while(p) {

i++;

p=p->next;

} cout<<"链表的数据元素个数为:"<

LinkList p,s; int j=0; p=L;

while(p&&j

} if(!p||j>i-1) { p=p->next; ++j;

}

} cout<<"插入元素的位置不合理!"; return 0; s=(LinkList)malloc(sizeof(LNode)); s->data=x; s->next=p->next; p->next=s; return 1; int DeleteLinkList(LinkList &L,int i) {//删除链表L的第I个数据元素。

LinkList p,q; int j=0; p=L; while(p->next&&j

} if(!(p->next)||j>i-1) { p=p->next; ++j;

}

} cout<<"删除元素的位置不合理!"; return 0; q=p->next; p->next=q->next; i=q->data; free(q); return 1; void DestroyLinkList(LinkList &L) {//销毁链表L。

LinkList p,q; p=L->next; while(L->next!=NULL) { q=p->next; L->next=q;

free(p); } p=q;

free(L);

cout<<"链表已经被销毁!"<

LinkList L;

int i,j,x; cout<<"第一次数据结构上机实验—链表"<>j;

CreatLinkList(L,j);

LinkListLengh(L);

PrintLinkList(L);

cout<<"在第几个元素前插入:"; cin>>i; cout<<"输入插入的元素:"; cin>>x;

InsertLinkList(L,i,x);

LinkListLengh(L);

PrintLinkList(L);

cout<<"输入删除元素的位置:"; cin>>i;

DeleteLinkList(L,i);

LinkListLengh(L);

PrintLinkList(L);

cout<<"销毁程序后为:"<

DestroyLinkList(L); } 五﹑实验结果

六﹑实验心得体会：

链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。它可以根据需要开辟内存单元。链表中每一个元素称为“结点”，每个结点都应包括两个部分：一为用户需要用的实际数据，二为下一个结点的地址。

实验的程序设计规划(实现的功能、分几个模块、子函数) (1) 编写链表创建子函数void CreatLinkList(L,j) (2) 编写链表插入子函数 int InsertLinkList(LinkList &L, int i, int x) (3)链表的打印int PrintLinkList(LinkList &L) (4)编写链表删除子函数 int DeleteLinkList(LinkList &L,int i) (5)编写链表销毁子函数void DestroyLinkList(LinkList &L) (6)编写主函数Main()，通过功能菜单调用子函数 (7)编译调试程序

经过多次的调试，修改，实验结果终于正确了，在这个过程中，经历了不知道怎么进行声明区的编写如包含文件，宏定义，函数声明，全局变量声明，结构体等的定义等的结合，到学会了使用先把程序主要规划为四个部分来写就简单多了，第一，定义;第二，写所要调用的子函数;第三，写主函数，调用子函数;第四就是程序的编译与调试，修改。数据结构实验需要我们对每个程序的算法有深刻的理解，才能应用到实际中去，因此我们需要在做实验之前要熟悉实验的内容，且先把所要实验的程序写出来，在实验中就可以查找错误并加以改正，这是一个成长的过程。

数据结构上机实验报告

2 一﹑实验名称：

实验二—队列

二﹑实验目的： 1. 掌握队列这种抽象数据类型的特点, 掌握栈与队列在实际问题中的应用和基本编程技巧,并能在相应的问题中选用它; 2. 熟练掌握循环队列和链队列的基本操作实现算法，特别是队满和队空的描述方法;

3.掌握栈与队列的数据类型描述及特点;

4.掌握栈的顺序和链式存储存表示与基本算法的实现; 5.掌握队列的链式存储表示与基本操作算法实现; 6.按照实验题目要求，独立完成实际程序的编写编写、调试和运行，并通过用例数据的运行过程抓获相关屏面验证程序设计的正确性; 7.认真书写实验报告，并按时提交。

三﹑实验内容：

对顺序循环队列，常规的设计方法是使用対尾指针和对头指针，对尾指针用于指示当前的対尾位置下标，对头指针用于指示当前的対头位置下标。现要求：

(1)掌握栈和队列的特点，即后进先出和先进先出的原则。 (2)设计一个使用对头指针和计数器的顺序循环队列抽象数据类型，其中操作包括：初始化，入队列，出队列，取对头元素和判断队列是否为空;

(3)编写主函数进行测试。

四﹑实验步骤与程序

#include #include #include #define OK 1 #define ERROR 0 #define OVERFLOW 0 typedef struct QNode { int data; struct QNode *next; }QNode,*QueuePtr; typedef struct { QueuePtr front; QueuePtr rear; }LinkQueue; int InitQueue(LinkQueue &Q) {

} Q.rear=Q.front=(QueuePtr)malloc(sizeof(QNode)); if(!Q.rear) exit(OVERFLOW); Q.front->next=NULL; return OK; void QueueEmpty(LinkQueue Q) {

} void EnQueue(LinkQueue &Q,int e) {

} int EnnQueue(LinkQueue &Q,int e) { QueuePtr p; p=(QueuePtr)malloc(sizeof(QNode)); QueuePtr p; p=(QueuePtr)malloc(sizeof(QNode)); if(!p) printf("error"); if(Q.front==Q.rear) printf("该链队为空:"); else printf("该链队不为空:"); p->data=e; Q.rear->next=p; Q.rear=p; printf("元素%d入队成功",e);

} if(!p) return ERROR; p->data=e; Q.rear->next=p; Q.rear=p;

return OK; void DeQueue(LinkQueue &Q) {

} void GetHead(LinkQueue &Q) { QueuePtr p; QueuePtr p; if(Q.front==Q.rear) printf("该链队为空"); p=Q.front->next; Q.front->next=p->next; if(Q.rear==p) Q.rear=Q.front; free(p); printf("队首元素删除成功");

} if(Q.front==Q.rear) printf("该链队为空"); p=Q.front->next; printf("队首元素为:%d",p->data); void OutQueue(LinkQueue &Q) {

} void LengthQueue(LinkQueue &Q) {

int f=0; QueuePtr p; if(Q.front==Q.rear) QueuePtr p; if(Q.front==Q.rear) printf("该链队为空"); p=Q.front->next; while(p!=Q.rear->next) {

} printf("%d%,",p->data); p=p->next;

} printf("该队列的长度为:%d",f); else {

} p=Q.front->next; while(p!=Q.rear->next) {

} printf("该队列的长度为:%d",f); p=p->next; f++; void main() {

system("cls"); int flag=1,i; LinkQueue Q; InitQueue(Q); printf("************************链队列功能菜单*********************** "); printf("1:初始化链队列,

2:判断链队列是否为空, 3:进入队列,

4:取出队首元素 "); printf("5:输出该队列的所有元素,6:输出该队列的长度,

7:结束程序,

8:清屏 ");

while(flag) {

printf(" 请输入操作符:"); scanf("%d",&i); switch(i) { case 1:

int e,n,k; printf("请输入队列的长度:"); scanf("%d",&n); printf("请输入队列的元素:"); for(e=1;e<=n;e++) {

} printf("初始化链队成功"); break; scanf("%d",&k); EnnQueue(Q,k); case 2: QueueEmpty(Q);

break; case 3:

int j; printf("请输入要进入队列的元素"); scanf("%d",&j); EnQueue(Q,j); break; case 4: GetHead(Q); break; case 5:

printf("该队列的元素为:"); OutQueue(Q); break;

case 6: LengthQueue(Q); break; case 7: flag=0; break; case 8: system("cls"); } break;

} } 五﹑实验结果

六﹑实验心得体会：

程序主要构造了主函数main()和 InitQueue()，QueueEmpty ()EnQueue()，OutQueue()等调用函数，实现了队列的创立，队列是否为空的判断，入队和出队等功能。

通过此次实验，加深了对队列的存储结构的了解，同时也对程序设计能力有了提高，加深了对队列先进先出性质的理解，它允许在表的一端进行插入，在另一端删除元素，这和我们日常生活中的排队是一致的，最早进入队列的元素最早离开。 我们往往写不出程序，这其中的原因我觉得是对程序的结构不是很了解，对实验的内容也不熟练的结果，数据结构给我们许多程序的算法和模型，对我们写程序的思维有很大的锻炼，我们应珍惜每次上机实验的机会去实践课堂上所学的东西并从中发现问题，从而达到提升写程序的能力。

数据结构上机实验报告

3 一﹑实验名称：

实验三—二叉树的遍历

二﹑实验目的：

1、熟悉二叉树的结构特性，了解相应的证明方法;

2、掌握二叉树的生成，掌握二叉树的定义和存储表示，学会建立一棵特定二叉树的方法;

3、理解二叉树的三种遍历方法：先序遍历、中序遍历和后序遍历;

4、 学会编写实现树的各种操作的算法。

二、实验内容：

1、使用类定义实现二叉树，补充完整所缺的函数，并实现创建和遍历二叉树的基本操作;

2、编程实现在二叉链表这种存储方式下，实现二叉的遍历，可采用递归或者非递归实现，遍历算法为在先序、中序和后序遍历算法。

三、实验步骤与程序：

#include #include #include typedef struct BiTNode { char data; struct BiTNode *lchild,*rchild; } BiTNode,*BiTree;//定义结点类型 BiTree CreateBiTree()//创建树 { char p;BiTree T; scanf("%c",&p); if(p==) T=NULL; else { T=(BiTNode *)malloc(sizeof(BiTNode));//为结点开辟空间 T->data=p; T->lchild=CreateBiTree(); T->rchild=CreateBiTree(); } return (T); }

void PreOrder(BiTree T)//先序 { if(T!=NULL) { printf("%c",T->data); PreOrder(T->lchild); PreOrder(T->rchild); } } void InOrder(BiTree T)//中序 { if(T!=NULL) { InOrder(T->lchild); printf("%c",T->data); InOrder(T->rchild); } } void PostOrder(BiTree T)//后序 { if(T!=NULL) { PostOrder(T->lchild); PostOrder(T->rchild); printf("%c",T->data); } } void main()//主函数 {

printf("------------二叉树的遍历------------- "); printf("请输入要遍历的数："); BiTree Ta; Ta=CreateBiTree(); printf("先序遍历:"); printf(" "); PreOrder(Ta); printf(" "); printf("中序遍历:"); printf(" "); InOrder(Ta); printf(" "); printf("后序遍历:"); printf(" "); PostOrder(Ta); } 五﹑实验结果

六﹑实验心得体会：

实验的程序设计规划(实现的功能、分几个模块、子函数) (1) 先序遍历递归算法函数：void PreOrder(BiTree T) (2) 中序遍历递归算法函数：void InOrder(BiTree T) (3) 后续遍历递归算法函数：void PostOrder(BiTree T) (4) 主函数的实现：void main()

在实验前我认真阅读关于二叉树的实现的内容，为编程实现第一步，本次实验通过按上述的实验步骤一步步实现的，实验过程中出现了一些错误，经过一步步的调试，修改错误，得到了二叉树的遍历用递归运算的方法的程序。通过这个实验，我体会到了理解数据结构的重要性，这有真正理解了定义数据类型的好处，才能用好这样一种数据结构。二叉树的先序，中序与后序的输出都用了递归的算法，而且用起来不是很复杂，这使我更进一步理解了函数递归调用并得到灵活运用;在实现算法上，从算法的效率看，递归方法书写形式较为简洁，更为直观，一般具有较好的空间效率。

总之，不管做什么实验，我们在做实验前都要先预习，对所做的实验有较深的理解，在做实验的时候需要很严谨，仔细的查找错误，从而能在实验中收获知识，提升自己。

数据结构上机实验报告4 一﹑实验名称：

实验四—查找

二﹑实验目的：

1、熟悉掌握顺序表的查找方法;

2、熟练掌握二叉排序树的构造方法和查找算法

3、掌握描述查找过程的判定树的构造方法，以及按照定义计算各种查找方法在等概率情况下查找成功时的平均查找长度;

4、 学会定义线性表的储存类型，实现C++程序的基本结构对线性表的一些基本操作和具体的函数定义;

5、掌握顺序表的基本操作，实现顺序表的查找的等基本运算;

6、掌握对于多函数程序的输入，编辑，调试和运算过程。

二、实验内容：

1、实现顺序表的查找算法

2、 关于衡量查找的主要操作—查找的查找平均效率的平均长度的讨论。

三、实验步骤与程序：

#include #define MAX_SIZE 100 typedef struct{ int key; }element;

element list[MAX_SIZE];

int seqsearch(element list[],int searchnum,int num); int main() {

int i,num,searchnum,k;

printf("---------------数据结构查找实验------------- "); printf("请输入数据元素的个数："); scanf("%d",&num); printf("请输入数据的元素： "); for(i=0;i

printf("请输入要查询的数据元素:"); scanf("%d",&searchnum); k=seqsearch(list,searchnum,num); if(k!=-1) { printf("所查询元素的下标为："); printf("%d ",k); } else printf("查询元素不存在。 "); } return 0; }

int seqsearch(element list[],int searchnum,int num) { int j;

list[num].key=searchnum;

for(j=0;list[j].key!=searchnum;j++) ; return j

六﹑实验心得体会：

实验的程序设计规划为先写一个主函数int main() ，再写一个查找的子函数int seqsearch(element list[],int searchnum,int num) ，主函数通过调用子函数的方法实现程序的设计。

所谓“查找”即为在一个众多的数据元素(或记录)的查找表中找出某个“特定的”数据元素(或记录)，通过本次实验，我更进一步的了解数据结构程序实验设计实现算法的基本模型，和算法实现等基本内容，学会了顺序表的查找方法。

数据结构上机实验报告5 一﹑实验名称：

实验五—内部排序

二﹑实验目的：

1、通过实现下述实验内容，学习、实现、对比各种排序算法，掌握各种排序算法的优劣，以及各种算法使用的情况，并加以灵活应用。

2、掌握各种排序时间复杂度的分析方法。

二、实验内容：

1、插入排序：依次将待排序的序列中的每一个记录插入到先前排序好的序列中，直到全部记录排序完毕。

2、快速排序：首先选择一个基准，将记录分割为两部分，左支小于或等于基准，右支则大于基准，然后对两部分重复上述过程，直至整个序列排序完成。

3、讨论各种内部排序方法的基本思路，算法特点，排序过程及它们的时间复杂度的分析。

三、实验步骤与程序：

#include void main() {

} int x; void charu(); void kuaisu(); printf("----------内部排序--------- "); printf("

1、插入排序： "); printf("

2、选择排序： "); printf("请根据序号选择："); scanf("%d",&x); if(x==1) charu(); else kuaisu(); void charu() { int a[7],j,i,m;

printf("插入排序 ");

printf("请输入个您想排序的数据: ");

for(i=0;i<7;i++)scanf("%d",&a[i]);

for(j=1;j<7;j++)

{ m=a[j];

for(i=j-1;i>=0;i--)

{

if(a[i]

break;

else a[i+1]=a[i];

}

a[i+1]=m;

}

printf("排序成功:");

for(i=0;i<7;i++)

printf(" %d",a[i]);

printf(" "); } quick(int first,int end,int L[]) { int left=first,right=end,key;

key=L[first];

while(left

{ while((left=key))

right--;

if(left

L[left++]=L[right];

while((left

left++;

if(left

L[left]=key;

return left;

}

quick_sort(int L[],int first,int end)

{ int split;

if(end>first)

{ split=quick(first,end,L);

quick_sort(L,first,split-1);

quick_sort(L,split+1,end);

}

} void kuaisu() {

int a[7],i;

printf("快速排序 ");

printf("请输入个您想排序的数据: ");

for(i=0;i<7;i++)

scanf("%d",&a[i]);

quick_sort(a,0,9);

printf("排序成功:");

for(i=0;i<7;i++)

printf(" %d",a[i]);

printf(" "); } 五﹑实验结果：

六﹑实验心得体会：

排序的功能是将一个数据元素(或记录)的任意序列，从新排成按关键字有序的序列;直接插入排序的稳定性比快速排序高，且算法较简单。本次实验运用到的是插入排序和快速排序。

第四篇：数据结构实验报告

河南省高等教育自学考试

实 验 报 告 册

计算机及应用专业(本科段)

《数据结构》

姓名周东伟准考证号010512201008所属地市郑州实验地点河南职业技术学院实验日期2014-3-18实验总成绩指导教师签名实验单位(实验室)意见：主考院校审核意见：

河南科技大学自学考试办公室

第五篇：数据结构实验报告

实验名称

数据结构与算法

专业班级

数学与应用数学1201班 学

号

1304120306

姓

名

谢 伟 指导老师

陈 明