数据结构实训doc.docx
《数据结构实训doc.docx》由会员分享，可在线阅读，更多相关《数据结构实训doc.docx（28页珍藏版）》请在冰豆网上搜索。
数据结构实训doc
数据结构实训报告
班级：
099班
姓名：
学号：
指导老师：
实训时间：
2010.6.26
目录
实验一：
线性表3
（一）实验目的3
（二）实验内容3
（三）实验算法思想3
（四）实验代码4
（五）实验结果8
实验二：
堆栈8
（一）实验目的8
（二）实验内容8
（三）实验算法思想8
（四）实验代码8
（五）实验结果13
实验三：
排序13
（一）实验目的13
（二）实验内容13
（三）实验算法思想13
（四）实验代码14
（五）实验结果17
实验二：
查找17
（一）实验目的17
（二）实验内容18
（三）实验算法思想18
（四）实验代码19
（五）实验结果20
实验一线性表的插入和删除算法的实现
一：
实验目的
掌握用VC上机调试线性表的基本方法；掌握线性表的基本操作，以线性表示，链式表示两种存储方式实现线性表的建立，插入，删除等算法；了解线性表的查找，合并算法的实现。
二：
实验内容
熟悉在vc环境下的编程和调试程序的方法，在线性表或链式表中选择一种实现线性表的创建，插入，删除操作，并用主函数检测各个函数的可行性；
三：
实验算法思想：
如果是线性存储，首先找到要增加数据的前一个位子，从数组尾部后退一个位子直到插入的位子，再将数据赋值给这个数组。
如果是删除数据，首先是找到这个数组的下标，将这个数据赋值给一个输入输出变量，把删除位子后的位子向前移动一个位子。
如果是链式存储，则首先要找到前一个链表再用一个指针指向下一个链表，即要删除或增加的数据。
四：
实验代码：
#include
#include
typedefintDataType;
#defineMaxsize100
typedefstructnode
{DataTypedata;
structnode*next;
}SeqList;
typedefstruct
{
DataTypelist[Maxsize];
intsize;
}Seqlist;
voidInitiate（Seqlist*L）
{
L->size=0;
}
intLength（SeqlistL）
{
return（L.size）;
}
intInsert1（Seqlist*L,inti,DataTypex）
{intj;
if（L->size>Maxsize）
{printf（"wrong!
\n"）;
return0;
}
elseif（i<0||i>L->size）
{printf（"wrong!
\n"）;
return0;
}
for（j=L->size;j>i;j--）
L->list[j]=L->list[j-1];
L->list[i]=x;
L->size++;
return1;
}
intDelete1（Seqlist*L,inti,DataType*x）
{intj;
if（i<0||i>L->size）
{printf（"wrong!
\n"）;
return0;
}
*x=L->list[i];
for（j=i;jsize;j++）
L->list[j]=L->list[j+1];
L->size--;
return1;
}
SeqList*creat（void）//创建函数
{intn,m,i=0;
SeqList*head,*p,*r;
p=（SeqList*）malloc（sizeof（SeqList））;
head=p;
p->next=NULL;
r=p;//r为尾指针
printf（"输入你想创建的数据个数\n"）;
scanf（"%d",&n）;
while（i{
printf（"请输入数据!
\n"）;
scanf（"%d",&m）;
p=（SeqList*）malloc（（sizeof（SeqList））*n）;
p->data=m;
p->next=NULL;
r->next=p;
r=r->next;
i++;
}
r->next=NULL;
return（head）;
}
SeqList*Insert（SeqList*head,inti,DataTypex）//插入函数从位置i插入元素x
{SeqList*p,*q;
intj;
p=head;
j=-1;
while（p->next!
=NULL&&j{p=p->next;
j++;
}
if（j!
=i-1）
{printf（"插入位置错误!
\n"）;
gotoend;
}
if（（q=（SeqList*）malloc（sizeof（SeqList）））==NULL）
exit
（1）;
q->data=x;
q->next=p->next;
p->next=q;
end:
return（head）;
}
SeqList*Delete（SeqList*head,inti）//删除函数删除位置i的元素
{SeqList*p,*s;
intj;
p=head;
j=-1;
while（p->next!
=NULL&&p->next->next!
=NULL&&j{p=p->next;
j++;
}
if（j!
=i-1）
{printf（"删除位置错误!
\n"）;
gotoend;
}
s=p->next;
p->next=p->next->next;
free（s）;
end:
returnhead;
}
voidprint（SeqList*head）//输出函数
{SeqList*p;
p=head->next;
if（head!
=NULL）
do
{printf（"%d",p->data）;
p=p->next;
}while（p!
=NULL）;
}
voidmain1（）
{
SeqList*head;
inti;
DataTypex,c;
system（"color4A"）;//调用系统颜色
head=creat（）;
system（"cls"）;//清屏
print（head）;
printf（"\n"）;
printf（"请输入要插入的数据!
\n"）;
scanf（"%d",&x）;
printf（"请输入数据要插入的位置!
\n"）;
scanf（"%d",&i）;
head=Insert（head,i,x）;
print（head）;
printf（"\n"）;
printf（"请输入要删除数据的位置!
\n"）;
scanf（"%d",&c）;
head=Delete（head,c）;
print（head）;
printf（"\n"）;
printf（"经处理后的最终数据如下:
\n"）;
print（head）;
printf（"\n"）;
}
voidmain2（）
{
Seqlistmylist;
inti,x,k;
Initiate（&mylist）;
printf（"请输入个的数据\n"）;
for（i=0;i<5;i++）
scanf（"%d",&mylist.list[i]）;
mylist.size=5;
system（"color4A"）;//调用系统颜色
printf（"请输入要插入的数据\n"）;
scanf（"%d",&x）;
printf（"请输入要插入数据的位子\n"）;
scanf（"%d",&i）;
Insert1（&mylist,i,x）;
system（"cls"）;//清屏
for（i=0;iprintf（"%d",mylist.list[i]）;
printf（"请输入要删除数据的位置!
\n"）;
scanf（"%d",&i）;
Delete1（&mylist,i,&k）;
for（i=0;iprintf（"%d",mylist.list[i]）;
printf（"经处理后的最终数据如下:
\n"）;
for（i=0;iprintf（"%d",mylist.list[i]）;
printf（"\n"）;
}
voidmain（）
{ints;
do
{system（"color4A"）;
printf（"\t\t\t|--------------------------|\n"）;
printf（"\t\t\t|1:
链式表|\n"）;
printf（"\t\t\t|2：
顺序表|\n"）;
printf（"\t\t\t|3:
退出|\n"）;
printf（"\t\t\t|--------------------------|\n"）;
printf（"请输入要选择的功能:
\n"）;
scanf（"%d",&s）;
switch（s）
{case1:
main1（）;break;
case2:
main2（）;break;
}
}while（s!
=3）;
}
五：
运行结果：
实验二：
堆栈
实验目的：
掌握vc上机调试堆栈和队列的基本方法，掌握堆栈和队列的基本操作，循环表示算法程序实现
实验内容：
堆栈和队列操作的基本实现，上级调试本次内容。
实验算法：
在堆栈顶部插入和删除元素，插入一个元素，再top+1;使堆栈指针top+1；
在队列队首删除元素，队尾增加一个元素。
实验代码：
#include
#include
typedefintDataType;
typedefstructnode
{
DataTypedata;
structnode*next;
}SeqStack;
typedefstruct
{
DataTypestack[100];
inttop1;
}Seqstack;
voidchushi（Seqstack*L）
{L->top1=0;
}
intstackempty（SeqstackL）
{
if（L.top1<=0）
return0;
else
return1;
}
intPush1（Seqstack*L,DataTypex）
{if（L->top1>100）
{printf（"堆栈已满无法再插入!
\n"）;
return0;
}
else
{L->stack[L->top1]=x;
L->top1++;
return1;
}
}
intpop1（Seqstack*L,DataType*d）
{if（L->top1<=0）
{printf（"堆栈已空无法再删除!
\n"）;
return0;
}
else
{L->top1--;
*d=L->stack[L->top1];
return1;
}
}
SeqStack*top,*p;
intn;
voidprint（）//输出堆栈函数
{
if（top==NULL）
{printf（"堆栈为空!
\n"）;
return;
}
p=top;
do
{
printf（"%d",p->data）;
p=p->next;
}while（p!
=NULL）;
printf（"\n"）;
}
voidpush（intx）//进堆栈函数
{p=（SeqStack*）malloc（sizeof（SeqStack））;
p->next=top;
p->data=x;
top=p;
}
intpop（void）//出堆栈函数
{intx;
if（top==NULL）
{printf（"堆栈已空!
\n"）;
return0;
}
p=top;
x=p->data;
top=p->next;
free（p）;
returnx;
}
voidmain3（）
{intx,i;
system（"color4A"）;
printf（"请输入数据的个数:
\n"）;
scanf（"%d",&n）;
for（i=0;i{
printf（"请输入数据:
\n"）;
scanf（"%d",&x）;
push（x）;
}
printf（"出栈的数据元素如下:
\n"）;
print（）;
if（pop（））
{printf（"删除原栈顶后的数据如下:
\n"）;
print（）;
}
}
voidmain4（）
{inti,d,x;
SeqstackL;
chushi（&L）;
system（"color4A"）;
printf（"请输入数据的个数:
\n"）;
scanf（"%d",&n）;
for（i=0;i{
printf（"请输入数据:
\n"）;
scanf（"%d",&x）;
Push1（&L,x）;
}
printf（"出栈元素如下:
\n"）;
while（stackempty（L））
{pop1（&L,&d）;
printf（"%d",d）;
}
printf（"\n"）;
}
voidmain（）
{inth;
do
{system（"color4A"）;
printf（"\t\t\t|-------------------|\n"）;
printf（"\t\t\t|1:
顺序堆栈|\n"）;
printf（"\t\t\t|2：
链式堆栈|\n"）;
printf（"\t\t\t|3：
退出|\n"）;
printf（"\t\t\t|-------------------|\n"）;
printf（"请输入要选择的功能:
\n"）;
scanf（"%d",&h）;
switch（h）
{case1:
main4（）;break;
case2:
main3（）;break;
}
}while（h!
=3）;
}
五：
实验结果：
实验三：
排序
一：
实验目的
掌握常用的排序方法，灵活运用各种排序算法，并掌握各种排序方法的时间复杂度。
二：
实验内容
使用各种排序算法对随机产生的100个数据排序。
三：
算法思想
<一>:
冒泡法基本思想：
设数组a中存放了n个数据元素，循环进行n-1次如下的排序过程：
第一次时，依次比较相邻俩个数据，若为逆序，则交换位子，否则不交换，这样，当比较完n-1次后最大的数据放在最后位子；第二次数据个数减少一个，重复前面的算法，这样第二大的数据就排在倒数第二个位置，依次下去。
最后最小的排在最前面。
<二>:
选择排序思想：
每次从待排序的数据集合中选出最小的或最大的关键字放在最前面或最后面，当数据集合为空时排序结束。
<三>：
快序排序思想：
设数组a中存放了n个数据元素，low为数组的低端下标，high为数组的高端下标。
从数组的中任选一个元素调整数组使其左边的元素小于它，右边的元素大于它。
反复进行类似的递归。
<四>:
实验代码：
#include
#include
#include
#include
#defineN100
voidsort1（inta[],intn）/*用冒泡法从小到大排序*/
{inti,j,flag=1,temp;
for（i=1;i{flag=0;
for（j=0;j{if（a[j]>a[j+1]）
{flag=1;
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}}}
voidsort2（inta[],intn）/*用选择法从小到大排序*/
{inti,j,k,t;
for（i=0;i{k=i;
for（j=i+1;jif（a[j]k=j;
if（k!
=i）
{t=a[i];
a[i]=a[k];
a[k]=t;}}
}
voidInsertSort（int*a,intn）/*用插入排序法从小到大排序*/
{
inti,j,temp;
for（i=1;iif（a[i]{
temp=a[i];
for（j=i-1;temp=0;j--）
a[j+1]=a[j];
a[j+1]=temp;
}}
voidShellSort（inta[],intn,intd[],intnumOfD）/*希尔排序算法*/
{inti,j,k,m,span;
inttemp;
for（m=0;m{span=d[m];
for（k=0;k{for（i=k;i{temp=a[i+span];
j=i;
while（j>-1&&temp<=a[j]）
{a[j+span]=a[j];
j=j-span;
}
a[j+span]=temp;}}}}
voidCreatHeap（inta[],intn,inth）/*创建最大堆*/
{inti,j,flag;
inttemp;
i=h;
j=2*i+1;
temp=a[i];
flag=0;
while（j=1）
{
if（jj++;
if（temp>a[j]）
flag=1;
else
{a[i]=a[j];
i=j;
j=2*i+1;
}
}
a[i]=temp;
}
voidInitCreatHeap（inta[],intn）/*创建最大堆*/
{inti;
for（i=（n-1）/2;i>=0;i--）
CreatHeap（a,n,i）;
}
voidHeapSort（inta[],intn）/*堆排序算法*/
{inti;
inttemp;
InitCreatHeap（a,n）;
for（i=n-1;i>0;i--）
{temp=a[0];
a[0]=a[i];
a[i]=temp;
CreatHeap（a,i,0）;
}}
voidQuickSort（inta[],intlow,inthigh）/*快速排序*/
{inti=low,j=high,temp=a[low];
while（i{while（ij--;
if（i{a[i]=a[j];
i++;
}
while（ii++;
if（i{a[j]=a[i];
j--;}
}
a[i]=temp;
if（lowQuickSort（a,low,i-1）;
if（i}
voidmain（）
{inta[N],i,m,b[]={4,2,1};
srand（time（NULL））;/*调用系统时间来实现自动播种*/
do
{system（"color4A"）;
for（i=0;i{
a[i]=rand（）%1000;
}
printf（"\t\t\t----------------------------\n"）;
printf（"\t\t\t|1:
用冒泡法从小到大排序|\n"）;
printf（"\t\t\t|2:
用选择法从小到大排序|\n"）;
printf（"\t\t\t|3:
用插入排序法从小到大排序|\n"）;
printf（"\t\t\t|4:
用希尔排序法从小到大排序|\n"）;
printf（"\t\t\t|5:
用快速排序法从小到大排序|\n"）;
printf（"\t\t\t|6:
用堆排序法从小到大排序|\n"）;
printf（"\t\t\t|7:
退出排序|\n"）;
printf（"\t\t\t----------------------------\n"）;
printf（"\t\t\t请从上面序号中选择你想使用的排序方法!
\n"）;
scanf（"%d",&m）;
switch（m）
{case1:
sort1（a,N）;break;
case2:
sort2（a,N）;break;
case3:
InsertSort（a,N）;break;
case4:
ShellSort（a,N,b,3）;break;
case5:
QuickSort（a,0,99）;break;
case6:
HeapSort（a,N）;break;
}
if（m!
=7）
{printf（"取得的一百个元素排序如下:
\n"）;
for（i=0;iprintf（"%4d",a[i]）;
if（i%10==0）
printf（"\n"）;
}
else
printf（"欢迎下次再使用本系统^_^!
\n"）;
}while（m!
=7）;
}
<五>运行结果：
实验四：
查找
一：
实验目的
掌握查找的不同方法，并能用高级语言实现查找算法；熟悉二叉树的构造和查找方法
二：
实验内容
设计一个读入一串整数构成二叉排序树的算法。
三：
实验算法思想：
构造二叉树，并在遍历过程中查找数据。
遍历方法类似二分查找。
三：
实验代码：
#include
#include
typedefintDataType;
typedefstructnode
{DataTypedata;
structnode*leftChild;
structnode*rightChild;
}BiTreeNode;
intSearch（BiTreeNode*root,DataTypex）
{BiTreeNode*p;
if（root!
=NULL）
{p=root;
while（p!
=NULL）
{if（p->data==x）
return1;
if（x>p->data）
p=p->rightChild;
else
p=p->leftChild;
}
}
return0;
}
intInsert（BiTreeNode**root,DataTypex）
{BiTreeNode*current,*parent=NULL,*p;
current=*root;
while（current!
=NULL）
{if（current->data==x）
return0;
升级会员 