太原理工大学数据结构试验Word文档格式.docx
《太原理工大学数据结构试验Word文档格式.docx》由会员分享，可在线阅读，更多相关《太原理工大学数据结构试验Word文档格式.docx（18页珍藏版）》请在冰豆网上搜索。
#include"
stdio.h"
malloc.h"
conio.h"
typedefstructnode{
chara;
structnode*link;
}node,*nodelink;
voidreadlink（nodelinkhead）{
nodelinkp,q;
charc;
p=head;
printf（"
请输入顺序表中的递增有序元素:
"
）;
scanf_s（"
%c"
&
c）;
if（c=='
\n'
）printf（"
顺序表为空\n\n"
while（c!
='
）{
q=（nodelink）malloc（sizeof（node））;
q->
a=c;
p->
link=q;
p=q;
scanf_s（"
}
p->
link=0;
}//构造顺序表
intadd（nodelinkhead）{
nodelinkp;
if（p->
link==0）return0;
while（p->
link!
=0）{
if（p->
a>
link->
a）{
printf（"
输入有误请重新输入\n\n"
return0;
}
p=p->
link;
return1;
}//判断输入元素是否递增
voidinsert（nodelinkhead,charx）{
nodelinkp,q,m;
inti=0;
q=（nodelink）malloc（sizeof（node））;
q->
a=x;
m=p;
=x）{
q->
link=m->
m->
i=1;
break;
m=p;
if（i==0）{
}//插入元素
voidmain（）{
nodelinkhead;
charx,z;
head=（nodelink）malloc（sizeof（node））;
head->
readlink（head）;
while（add（head）==0）
readlink（head）;
您输入的顺序表为:
for（p=head->
p!
=0;
p=p->
link）
printf（"
p->
a）;
\n请输入您要插入的字符:
x=getchar（）;
insert（head,x）;
插入%c后的顺序表为:
x）;
\n\n"
z）;
\n\n\n"
main（）;
}
五、实验结果与分析
[实习题运行结果截图]
6、讨论、心得
顺序存储结构是在内存中开辟一个连续的空间用来存储数据,因此对于内存的需求和苛刻,必须是连续的空间.在数据查找（特别是不按照规律排列的数据）,时间复杂度教少.效率高.
链式存储结构是采取连表指针来指示数据的存储位置,这就可以是在内存中随意的存储,没有必须连续储存空间的要求,对于内存的要求相对教容易.但是要是是从小到大顺序排列的数据,链式存储结构的时间复杂度教小,效率高.但是要是不规则排布的数据一般时间复杂度较高,效率更低
实验二：
树形结构
熟悉树的各种表示方法和各种遍历方式，掌握有关算法的实现，了解树在计算机科学及其它工程技术中的应用
编写递归算法，计算二叉树中叶子结点的数目。
采用二叉链表存储。
采用递归方法建立和遍历二叉树。
首先建立二叉树的根结点，然后建立其左右子树，直到空子树为止。
后序遍历二叉树时，先遍历左子树，后遍历右子树，最后访问根结点。
[实习题源代码]
#include<
stdio.h>
malloc.h>
structBiTree{
chardata;
structBiTree*lchild;
structBiTree*rchild;
};
structBiTree*CreatBiTree（）{
charx;
structBiTree*p;
scanf（"
x）;
if（x!
.'
p=（structBiTree*）malloc（sizeof（structBiTree））;
data=x;
lchild=CreatBiTree（）;
rchild=CreatBiTree（）;
else
p=NULL;
returnp;
intLeafNum（structBiTree*T）{
if（!
T）
return0;
else
T->
lchild&
&
!
rchild）
returnLeafNum（T->
lchild）+LeafNum（T->
rchild）;
intmain（）{
intnum;
structBiTree*T;
请按先序序列输入二叉树\n"
T=CreatBiTree（）;
while（T==NULL）{
empoty,again:
\n"
num=LeafNum（T）;
\n二叉树叶子结点为:
%d\n"
num）;
\n\n\n\n"
树型结构是一类最重要的非线性，可以体现分支结构和层次结构
实验三：
图的应用
熟悉图的存储结构，掌握有关算法的实现，了解图在计算机科学及其他工程技术中的应用。
采用邻接表存储结构，编写一个求无向图的连通分量个数的算法。
图采用邻接矩阵的方式存储。
采用广度优先搜索的方法，从顶点A开始，依次访问与A邻接的顶点VA1,VA2,...,VAK,访问遍之后,若没有访问B，则继续访问与VA1邻接的顶点VA11,VA12,...,VA1M，再访问与VA2邻接顶点...，如此下去，直至找到B，最先到达B点的路径，一定是边数最少的路径。
实现时采用队列记录被访问过的顶点。
每次访问与队头顶点相邻接的顶点，然后将队头顶点从队列中删去。
若队空，则说明到不存在通路。
在访问顶点过程中，每次把当前顶点的序号作为与其邻接的未访问的顶点的前驱顶点记录下来，以便输出时回溯。
stdlib.h>
intn;
structVNode{
intposition;
structVNode*next;
structArcNode{
intmark;
structVNode*first;
voidDFS（structArcNode*v,structArcNode*w）{
structVNode*L;
w->
mark=1;
L=w->
first;
while（L!
=NULL）{
if（（v+（L->
position））->
mark==0）{
DFS（v,（v+L->
position））;
L=L->
next;
inti,j,k;
intnum=0;
structArcNode*p;
structVNode*temp;
structVNode*flag;
该无向图有多少个顶点：
%d"
n）;
while（n<
1）{
你输入的值不合理，请重新输入：
p=（structArcNode*）malloc（n*sizeof（structArcNode））;
for（i=0;
i<
n;
i++）{
请输入以V%d为弧尾的所有弧，并以-1结束输入\n"
i+1）;
k）;
if（k==-1）{
p[i].mark=0;
p[i].first=NULL;
else{
temp=（structVNode*）malloc（sizeof（structVNode））;
temp->
position=k;
next=NULL;
p[i].first=temp;
flag=temp;
while（k!
=-1）{
flag->
next=temp;
}
i=0;
while（p[i].mark==0）{
DFS（p,（p+i））;
num++;
while（p[i].mark!
=0&
n）{
i++;
此图的连通分量个数为：
system（"
pause"
对图结构和矩阵之间的概念和关系还不是很了解，在写程序是出现了很多错误，我自己对输出图结构这方面还不是很了解，通过慢慢摸索，写出了程序，有很大的成就感。
实验四：
查找
通过本次实验，掌握查找表上的有关查找方法，并分析时间复杂度。
2、存储结构和算法思想
存储结构]
有序表采用顺序方式存储。
首先用待查找记录与查找区间中间位置记录比较，若相等则查找成功，返回该记录在表中的位置数，若小于中间位置记录，则修改区间上界为中间位置减1，若大于中间位置记录，则修改区间下界为中间位置加1，在新的区间内继续查找。
当查找区间下界大于上界，则该记录不存在。
intdata;
structBiTree*lchild;
structBiTree*rchild;
structBiTree*CreatBiTree（）{
intx;
p=（structBiTree*）malloc
（sizeof（structBiTree））;
voidSearchBST（structBiTree*T,intk）{
T）{
你查找的数据不存在！
elseif（T->
data==k）{
你查找的数据存在！
elseif（k<
data）{
SearchBST（T->
lchild,k）;
rchild,k）;
intkey;
chartemp;
请按先序序列输入排序二叉树\n"
你输入的对叉树为空，请重新输入：
temp=getchar（）;
请输入你要查找的数据：
key）;
SearchBST（T,key）;
7、讨论、心得
通过这次实验，我对查找方法有了更多的熟悉，对问题有了更深刻的认识。
实验五：
排序
通过本次实验，掌握线性表的排序方法，并分析时间复杂度。
待排序记录顺序存储。
快速排序算法每次任取一个记录的关键字为标准，将其余记录分为两组，将所有关键字小于或等于标准的记录都放在它的位置之前，将所有关键字大于标准的记录都放在它的位置之后。
对这两组再进行快速排序，直到完全有序。
每递归1次，递归深度加1。
#defineNULL0
#include<
conio.h>
structnode*next;
}NODE;
voidread（NODE*head,intn）{
NODE*p;
if（n==0）
return0;
p=（NODE*）malloc（sizeof（NODE））;
next=p;
x=x;
read（p,n-1）;
voidwrite（NODE*head,intn）{
return;
p=head->
%d"
write（p,n-1）;
voidpx（NODE*head,intn）{
intmin;
inti,s=0;
NODE*r;
NODE*t;
r=head->
t=head;
min=p->
x;
if（min>
p->
x）{
min=p->
r=p;
s=i;
s;
i++）
t=t->
t->
next=r->
r->
next=head->
next=r;
px（head->
next,n-1）;
intn;
NODE*head;
head=（NODE*）malloc（sizeof（NODE））;
输入个数n:
输入%d个数据:
n）;
read（head,n）;
您输入的数据为:
write（head,n）;
\n排序后的数据为:
px（head,n）;
getchar（）;
时间复杂度
比较：
排序方法
最好情况
最坏情况
平均情况
稳定性
冒泡排序
O（n）
O（n2）
稳定
快速排序
O（nlogn）
不稳定
简单选择排序
堆排序
直接插入排序
希尔排序
O（n1.3）
归并排序
基数排序
O（d（r+n））
升级会员 