数据结构实验源代码.docx
《数据结构实验源代码.docx》由会员分享，可在线阅读，更多相关《数据结构实验源代码.docx（75页珍藏版）》请在冰豆网上搜索。
数据结构实验源代码
第2章
#include
#include
typedefstructdata{//定义一个结构体"data"
intnum;//用于存放人的序号
intval;//用于存放密码
}typedata;
typedefstructnode{//定义一个结构体（结点），其中包含一个数据域和一个指针域
typedatadata;//结构体的嵌套
structnode*next;
}listnode;
typedeflistnode*linklist;
linklisthead;
intmain（void）//进入主函数
{
intn,i,b,m,j;
linklisthead=（listnode*）malloc（sizeof（listnode））;//申请一个空间（头结点head）
listnode*p,*q;//定义两个可以指向结点的指针
printf（"输入总人数：
"）;
scanf（"%d",&n）;
q=head;//用指针q指向头结点
for（j=1;j<=n;j++）//本次循环主要是将每一个人的数据（包括序号、密码）存入循环链表中
{
printf（"请输入第%d号同学的密码:
\n",j）;
scanf（"%d",&b）;
printf（"\n"）;
q->next=（listnode*）malloc（sizeof（listnode））;
//将头结点的next域指向刚生成的一个结点
q=q->next;
q->data.val=b;//输入密码
q->data.num=j;//输入序号
q->next=head->next;}
//将尾结点的next域指向第一个结点，构成循环链表
printf（"请输入一个数m：
"）;
scanf（"%d",&m）;
if（m<=0）printf（"输入错误"）;
do{
i=1;
while（i!
=m）{//将q指针指向所要输出的结点的前一结点
q=q->next;
i++;
}
p=q->next;//p指向输出结点
q->next=p->next;//将输出结点的前结点的next域指向输出结点的后结点
printf（"num:
%d\tval:
%d\n",p->data.num,p->data.val）;//输出
m=p->data.val;//取得输出结点的密码
free（p）;
}while（q->next!
=q）;//只剩最后一个结点时结束
printf（"num:
%d\tval:
%d\n",q->data.num,q->data.val）;//输出最后一个结点
free（q）;//释放最后一个结点
free（head）;//释放头结点
system（"pause"）;
}
第3章
（1）
#include
#include
#include
#defineM4
#defineN6
#defineMaxSize100
usingnamespacestd;
intmg[M+2][N+2]={
{1,1,1,1,1,1,1,1},
{1,0,0,1,0,0,0,1},
{1,1,0,0,0,0,0,1},
{1,0,0,1,0,1,0,1},
{1,0,0,0,0,0,0,1},
{1,1,1,1,1,1,1,1},
};
struct
{
inti,j,di;
}
Stack[MaxSize],Path[MaxSize];
inttop=-1;
intcount=1;
intminlen=MaxSize;
voidPrint（）
{
for（inti=0;i{
for（intj=0;jif（mg[i][j]）cout<<"1";
elsecout<<"0";
cout<}
}
voidmgpath（）
{intcount=1;
inti,j,di,find,k;
top++;
Stack[top].i=1;
Stack[top].j=1;
Stack[top].di=-1;
mg[1][1]=-1;
while（top>-1）
{
i=Stack[top].i;
j=Stack[top].j;
di=Stack[top].di;
if（i==M&&j==N）
{
cout<for（k=0;k<=top;k++）
{
cout<<"（"<if（（k+1）%5==0）cout<<"\n";
}
cout<<"\n";
if（top+1{
for（k=0;k<=top;k++）
Path[k]=Stack[k];
minlen=top+1;
}
mg[Stack[top].i][Stack[top].j]=0;
top--;
i=Stack[top].i;
j=Stack[top].j;
di=Stack[top].di;
}
find=0;
while（di<4&&find==0）
{
di++;
switch（di）
{
case1:
i=Stack[top].i;j=Stack[top].j+1;break;
case2:
i=Stack[top].i+1;j=Stack[top].j;break;
}
if（mg[i][j]==0）find=1;
}
if（find==1）
{
Stack[top].di=di;
top++;
Stack[top].i=i;
Stack[top].j=j;
Stack[top].di=-1;
mg[i][j]=-1;
}
else
{
mg[Stack[top].i][Stack[top].j]=0;
top--;
}
}
cout<<"最短路径如下：
\n";
cout<<"长度:
"<cout<<"路径:
";
for（k=0;k{
cout<<"（"<if（（k+1）%5==0）cout<<"\n";
}
cout<<"\n";
}
intmain（）
{
cout<<"迷宫地图如下\n";
Print（）;
cout<<"迷宫所有路径如下：
\n";
mgpath（）;
getch（）;
}
（2）
#include
#include
#include
#include
#include
#defineLENsizeof（STACK）
typedefstructnode
{
intdata;
structnode*link;
}STACK[50],*STLink;
STLinktop[50];
voidinit（STLinktop[],intm）/*初始化堆栈*/
{
top[m]=NULL;
}
intempty（STLinktop[],intn）/*判断是否为空*/
{
return（top[n]==NULL）;
}
intpush（STLinktop[],intA,intm）/*入栈*/
{
STLinkp;
if（!
（p=（STLink）malloc（LEN）））
return0;
else
{
p->data=A;
p->link=top[m];
top[m]=p;
return1;
}
}
intpop（STLinktop[],intm）/*出栈*/
{
intA;
STLinkp;
p=top[m];
A=p->data;
top[m]=top[m]->link;
free（p）;
returnA;
}
inttrainpush（intM,intA[],STLinktop[]）
{
intm,k=0,l;
top[k]=NULL;/*初始化第一个堆栈*/
push（top,A[0],0）;/*把第一节车厢压入缓冲铁轨*/
printf（"缓冲铁轨:
1栈顶值:
%d\n",top[0]->data）;
for（m=1;m{
if（A[m]>top[k]->data）/*前面所有栈顶值最大值一定为最后一个栈的栈顶值，如果此次需
进栈的车厢号比前面所有栈顶值都大重新建立一个新的栈并把车厢号压入新的栈的栈底*/
{
init（top,++k）;
push（top,A[m],k）;
printf（"缓冲铁轨：
%d栈顶值：
%d\n",k+1,top[k]->data）;
}
else
/*将此次需进栈的车厢号与所有栈顶值比较，插入到第一次遇到的栈顶值比将要入栈的车厢号要大的栈中，比如
要插入10号车厢，缓冲铁轨的栈顶值排列如下：
2、11、5、12，13，将10插在11所在的栈的栈顶*/
{l=0;
while（l<=k）
{
if（A[m]>top[l]->data）
l++;
else
{
push（top,A[m],l）;
printf（"缓冲铁轨:
%d栈顶值:
%d\n",l+1,top[l]->data）;
l=k+1;
}
}
}
}
returnk+1;
}
voidtrainpop（intM,intA[],STLinktop[],intN）
{
intm,n=0,min,l=0,amin=0,bmin=0;/*把所有车厢都压出缓冲铁轨*/
min=top[n]->data;
for（m=0;m{
for（l=n+1;l{
if（（top[l]!
=NULL）&&（top[l]->data{
min=top[l]->data;
amin=l;/*将栈顶值最小的栈的栈号保存起来*/
}
}
A[m]=pop（top,amin）;/*把最小的栈顶元素压出栈并赋值给A*/
printf（"A[%d]=%d\n",m,A[m]）;
if（top[amin]==NULL）
{
min=top[amin+1]->data;
n=amin+1;
}
else
{
min=top[amin]->data;
n=amin;
}
}
}
intmain（void）
{
inti,M,A[100],N=0;
printf（"请输入火车车厢总长：
"）;
scanf（"%d",&M）;
printf（"请输入未转轨前车厢的排列顺序，不能输入重复相同数据且不可遗漏车厢号\n"）;
for（i=0;i{
scanf（"%d",&A[i]）;
}
for（i=0;iprintf（"A[%d]=%d\n",i,A[i]）;
N=trainpush（M,A,top）;
printf（"所使用的缓冲铁轨数为:
"）;
printf（"%d\n",N）;
printf（"火车转轨后，出轨顺序如下，请核对是否是所需顺序:
\n"）;
trainpop（M,A,top,N）;
system（"pause"）;
}
第5章
#include
#include
inti,j,n,a[16][16];/*全局定义方阵行、列、阶数以及最大方阵容量*/
voidcreat（）/*建立魔方阵*/
{
intk;
j=n/2+1;
a[1][j]=1;
for（k=2;k<=n*n;k++）
{
i=i-1;
j=j+1;
if（（i<1）&&（j>n））
{
i=i+2;
j=j-1;
}
else
{
if（i<1）i=n;
if（j>n）j=1;
}
if（a[i][j]==0）
a[i][j]=k;
else
{
i=i+2;
j=j-1;
a[i][j]=k;
}
}
}
voidprint（）/*输出魔方阵*/
{
for（i=1;i<=n;i++）
{
for（j=1;j<=n;j++）
printf（"%5d",a[i][j]）;
printf（"\n"）;
}
}
voidmain（）
{
intk,p,m;
while
（1）
{
p=1;
while（p==1）
{
printf（"请输入n（n<=15,n是奇数）\n"）;
scanf（"%d",&n）;
if（（n!
=0）&&（n<=15）&&（n%2!
=0））
{
printf（"矩阵阶数是:
%d\n",n）;
p=0;
}
else{
printf（"输入错误请重新输入\n"）;
}
for（i=1;i<=n;i++）
for（j=1;j<=n;j++）
a[i][j]=0;
}
creat（）;
print（）;
}
}
第6章
#include
#include
#include
#defineVERBOSE
usingnamespacestd;
shortfather[512];
unsignedshortcode[256],heap_length;
unsignedlongcompress_charcount,file_size,heap[257];
unsignedcharcode_length[256];
longfrequency_count[512];
shortdecomp_tree[512];
FILE*ifile,*ofile;
voidbuild_decomp_tree（）,decompress_image（）;
voiddecompress（charf1[],charf2[]）,compress（charf1[],charf2[]）;
unsignedshortgenerate_code_table（）;
voidbuild_code_tree（）,build_initial_heap（）;
voidcompress_image（）,compression_report（）;
voidget_frequency_count（）;
intmain（）
{
charch,file[2][12];
cout<cout<cout<<"~哈夫曼编码~"<cout<cout<<"*1.压缩文件*2.解压文件*3.退出"<cout<cout<<"***请选择要执行的操作***:
";
cin>>ch;
while（ch）
{
switch（ch）
{
case'1':
printf（"\nHUFF1:
HuffmanCodeCompressionProgram."）;
printf（"\n14-Aug-90BillDemas.Version1.0\n\n"）;
printf（"压缩文件名:
"）;
scanf（"%s",&file[0]）;
printf（"生成文件名:
"）;
scanf（"%s",&file[1]）;
compress（file[0],file[1]）;
ch='0';
break;
case'2':
printf（"\nDHUFF:
HuffmanCodeDecompressionProgram."）;
printf（"\n14-Aug-90BillDemas.Version1.0\n\n"）;
printf（"解压文件名:
"）;
scanf（"%s",&file[0]）;
printf（"生成文件名:
"）;
scanf（"%s",&file[1]）;
decompress（file[0],file[1]）;
ch='0';
break;
case'3':
exit（0）;
break;
default:
cout<<"***请选择要执行的操作***:
";
cin>>ch;
}
}
}
voidcompress（char*f1,char*f2）
{
if（（ifile=fopen（f1,"rb"））!
=NULL）
{
fseek（ifile,0L,2）;
file_size=（unsignedlong）ftell（ifile）;
#ifdefVERBOSE
printf（"
（1）GettingFrequencyCounts.\n"）;
#endif
fseek（ifile,0L,0）;
get_frequency_count（）;
#ifdefVERBOSE
printf（"
（2）BuildingInitialHeap.\n"）;
#endif
build_initial_heap（）;
#ifdefVERBOSE
printf（"（3）BuildingtheCodeTree.\n"）;
#endif
build_code_tree（）;
#ifdefVERBOSE
printf（"（4）GeneratingtheCodeTable.\n"）;
#endif
if（!
generate_code_table（））
printf（"ERROR!
CodeValueOutofRange.CannotCompress.\n"）;
else
{
#ifdefVERBOSE
printf（"（5）Compressing&CreatingtheOutputFile.\n"）;
#endif
if（（ofile=fopen（f2,"wb"））!
=NULL）
{
fwrite（&file_size,sizeof（file_size）,1,ofile）;
fwrite（code,2,256,ofile）;
fwrite（code_length,1,256,ofile）;
fseek（ifile,0L,0）;
compress_image（）;
fclose（ofile）;
}
else
printf（"\nERROR:
Couldn'tcreateoutputfile\n"）;
#ifdefVERBOSE
compression_report（）;
#endif
}
fclose（ifile）;
}
else
printf（"\nERROR:
--Filenotfound!
\n"）;
}
voiddecompress（char*f1,char*f2）//解压
{
if（（ifile=fopen（f1,"rb"））!
=NULL）
{
fread（&file_size,sizeof（file_size）,1,ifile）;
fread（code,2,256,ifile）;
fread（code_length,1,256,ifile）;
#ifdefVERBOSE
printf（"
（1）Buildingthetree.\n"）;
#endif
build_decomp_tree（）;
#ifdefVERBOSE
printf（"
（2）Decompressing&CreatingtheOutputFile.\n"）;
#endif
if（（ofile=fopen（f2,"wb"））!
=NULL）
{
decompress_image（）;
fclose（ofile）;
}
else
printf（"\nERROR:
Couldn'tcreateoutputfile\n"）;
fclose（ifile）;
}
else
printf（"\nERROR:
--Filenotfound!
\n"）;
}//decompress
voidbuild_decomp_tree（）
{
registerunsignedshortloop1;
registerunsignedshortcurrent_index;
unsignedshortloop;
unsignedshortcurrent_node=1;
decomp_tree[1]=1;
for（loop=0;loop<256;loop++）
{
if（code_length[loop]）
{
current_index=1;
for（loop1=code_length[loop]-1;loop1>0;loop1--）
{
current_index=（decomp_tree[current_index]<<1）+
（（code[loop]>>loop1）&1）;
if（!
（decomp_tree[current_index]））
decomp_tree[current_index]=++current_node;
}
decomp_tree[（decomp_tree[current_i
升级会员 