数据结构实验源代码Word格式文档下载.docx
《数据结构实验源代码Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《数据结构实验源代码Word格式文档下载.docx（75页珍藏版）》请在冰豆网上搜索。
data.val=b;
//输入密码
data.num=j;
//输入序号
next=head->
}
//将尾结点的next域指向第一个结点，构成循环链表
请输入一个数m：
m）;
if（m<
=0）printf（"
输入错误"
do{
i=1;
while（i!
=m）{//将q指针指向所要输出的结点的前一结点
i++;
p=q->
//p指向输出结点
next=p->
//将输出结点的前结点的next域指向输出结点的后结点
num:
%d\tval:
%d\n"
p->
data.num,p->
data.val）;
//输出
m=p->
data.val;
//取得输出结点的密码
free（p）;
}while（q->
next!
=q）;
//只剩最后一个结点时结束
q->
data.num,q->
//输出最后一个结点
free（q）;
//释放最后一个结点
free（head）;
//释放头结点
system（"
pause"
}
第3章
（1）
iostream>
conio.h>
#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},
};
struct
inti,j,di;
Stack[MaxSize],Path[MaxSize];
inttop=-1;
intcount=1;
intminlen=MaxSize;
voidPrint（）
for（inti=0;
i<
M+2;
i++）
for（intj=0;
j<
N+2;
j++）
if（mg[i][j]）cout<
<
1"
;
elsecout<
0"
cout<
endl;
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<
count++<
for（k=0;
k<
=top;
k++）
（"
Stack[k].i<
"
Stack[k].j<
）"
"
if（（k+1）%5==0）cout<
if（top+1<
minlen）
Path[k]=Stack[k];
minlen=top+1;
mg[Stack[top].i][Stack[top].j]=0;
top--;
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;
if（mg[i][j]==0）find=1;
if（find==1）
Stack[top].di=di;
Stack[top].i=i;
Stack[top].j=j;
mg[i][j]=-1;
else
最短路径如下：
长度:
minlen<
路径:
minlen;
Path[k].i<
Path[k].j<
if（（k+1）%5==0）cout<
intmain（）
迷宫地图如下\n"
Print（）;
迷宫所有路径如下：
mgpath（）;
getch（）;
（2）
malloc.h>
#include<
assert.h>
time.h>
#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;
p->
data=A;
link=top[m];
top[m]=p;
return1;
intpop（STLinktop[],intm）/*出栈*/
intA;
p=top[m];
A=p->
data;
top[m]=top[m]->
link;
returnA;
inttrainpush（intM,intA[],STLinktop[]）
intm,k=0,l;
top[k]=NULL;
/*初始化第一个堆栈*/
push（top,A[0],0）;
/*把第一节车厢压入缓冲铁轨*/
缓冲铁轨:
1栈顶值:
top[0]->
data）;
for（m=1;
m<
M;
m++）/*把车厢都压入缓冲铁轨*/
if（A[m]>
top[k]->
data）/*前面所有栈顶值最大值一定为最后一个栈的栈顶值，如果此次需
进栈的车厢号比前面所有栈顶值都大重新建立一个新的栈并把车厢号压入新的栈的栈底*/
init（top,++k）;
push（top,A[m],k）;
printf（"
缓冲铁轨：
%d栈顶值：
k+1,top[k]->
else
/*将此次需进栈的车厢号与所有栈顶值比较，插入到第一次遇到的栈顶值比将要入栈的车厢号要大的栈中，比如
要插入10号车厢，缓冲铁轨的栈顶值排列如下：
2、11、5、12，13，将10插在11所在的栈的栈顶*/
{l=0;
while（l<
=k）
top[l]->
data）
l++;
push（top,A[m],l）;
%d栈顶值:
l+1,top[l]->
l=k+1;
returnk+1;
voidtrainpop（intM,intA[],STLinktop[],intN）
intm,n=0,min,l=0,amin=0,bmin=0;
/*把所有车厢都压出缓冲铁轨*/
min=top[n]->
for（m=0;
m++）
for（l=n+1;
l<
N;
l++）
if（（top[l]!
=NULL）&
（top[l]->
data<
min））/*取缓冲铁轨中栈顶元素最小的*/
min=top[l]->
amin=l;
/*将栈顶值最小的栈的栈号保存起来*/
A[m]=pop（top,amin）;
/*把最小的栈顶元素压出栈并赋值给A*/
A[%d]=%d\n"
m,A[m]）;
if（top[amin]==NULL）
min=top[amin+1]->
n=amin+1;
min=top[amin]->
n=amin;
intmain（void）
inti,M,A[100],N=0;
请输入火车车厢总长：
M）;
请输入未转轨前车厢的排列顺序，不能输入重复相同数据且不可遗漏车厢号\n"
for（i=0;
i<
scanf（"
A[i]）;
for（i=0;
i,A[i]）;
N=trainpush（M,A,top）;
所使用的缓冲铁轨数为:
N）;
火车转轨后，出轨顺序如下，请核对是否是所需顺序:
trainpop（M,A,top,N）;
第5章
inti,j,n,a[16][16];
/*全局定义方阵行、列、阶数以及最大方阵容量*/
voidcreat（）/*建立魔方阵*/
intk;
j=n/2+1;
a[1][j]=1;
for（k=2;
=n*n;
i=i-1;
j=j+1;
if（（i<
1）&
（j>
n））
i=i+2;
j=j-1;
if（i<
1）i=n;
if（j>
n）j=1;
if（a[i][j]==0）
a[i][j]=k;
voidprint（）/*输出魔方阵*/
for（i=1;
%5d"
a[i][j]）;
voidmain（）
intk,p,m;
while
（1）
p=1;
while（p==1）
请输入n（n<
=15,n是奇数）\n"
if（（n!
=0）&
（n<
=15）&
（n%2!
=0））
矩阵阶数是:
n）;
p=0;
else{
输入错误请重新输入\n"
a[i][j]=0;
creat（）;
print（）;
第6章
#defineVERBOSE
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];
~哈夫曼编码~"
*1.压缩文件*2.解压文件*3.退出"
***请选择要执行的操作***:
cin>
>
ch;
while（ch）
switch（ch）
{
case'
1'
:
printf（"
\nHUFF1:
HuffmanCodeCompressionProgram."
\n14-Aug-90BillDemas.Version1.0\n\n"
printf（"
压缩文件名:
scanf（"
%s"
file[0]）;
生成文件名:
file[1]）;
compress（file[0],file[1]）;
ch='
0'
break;
2'
\nDHUFF:
HuffmanCodeDecompressionProgram."
解压文件名:
decompress（file[0],file[1]）;
3'
exit（0）;
default:
cout<
cin>
}
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（）;
（2）BuildingInitialHeap.\n"
build_initial_heap（）;
（3）BuildingtheCodeTree.\n"
build_code_tree（）;
（4）GeneratingtheCodeTable.\n"
if（!
generate_code_table（））
ERROR!
CodeValueOutofRange.CannotCompress.\n"
else
（5）Compressing&
CreatingtheOutputFile.\n"
if（（ofile=fopen（f2,"
wb"
{
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"
compression_report（）;
fclose（ifile）;
--Filenotfound!
voiddecompress（char*f1,char*f2）//解压
fread（&
file_size,sizeof（file_size）,1,ifile）;
fread（code,2,256,ifile）;
fread（code_length,1,256,ifile）;
（1）Buildingthetree.\n"
build_decomp_tree（）;
（2）Decompressing&
if（（ofile=fopen（f2,"
decompress_image（）;
fclose（ofile）;
printf（"
fclose（ifile）;
}//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
升级会员 