数据结构作业文档格式.docx
《数据结构作业文档格式.docx》由会员分享，可在线阅读，更多相关《数据结构作业文档格式.docx（30页珍藏版）》请在冰豆网上搜索。
charkey_code[10];
/*哈希表地址*/
structNode*next;
}Node;
typedefstructhashtable/*创建哈希表*/
intkey;
}HashTable[MAX];
typedefstructArcCell//弧信息
intadj;
//权值，顶点距离
}ArcCell;
typedefstructVertexType//顶点类型
intnumber;
char*sight;
//景点名称
char*description;
//景点介绍
}VertexType;
typedefstruct
VertexTypevex[NUM];
//顶点向量
ArcCellarcs[NUM][NUM];
//数组表示，邻接矩阵
intvexnum,arcnum;
//图的当前顶点数和弧数
}MGraph;
typedefstructNode
chardata;
structNode*LChild;
structNode*RChild;
}BiTNode,*BiTree;
typedefstruct
char*ch;
intlen;
}HString;
//@@@-----文本处理器
//------paixu
intshell（structnodea[30],intn）
inti,j,t;
for（t=n/2;
t>
=1;
t=t/2）
for（i=t+1;
i<
=n;
i++）
if（a[i].k<
a[i-t].k）
{
a[0].k=a[i].k;
for（j=i-t;
a[0].k<
a[j].k&
&
j>
0;
j=j-t）
a[j+t].k=a[j].k;
a[j+t].k=a[0].k;
}
return0;
}
//快速排序
intpartition（structnodea[30],ints1,ints2）
{
inti,j;
i=s1;
j=s2;
a[0].k=a[s1].k;
while（i<
j）
while（i<
j&
=a[j].k）
j--;
if（i<
a[i].k=a[j].k;
i++;
a[i].k<
=a[0].k）
i++;
j）
a[j].k=a[i].k;
j--;
a[i].k=a[0].k;
returni;
voidquick（structnodea[30],ints1,ints2）
intm,i,j;
if（s1<
s2）
m=partition（a,s1,s2）;
quick（a,s1,m-1）;
quick（a,m+1,s2）;
//for（i=1;
//堆排序
voidsift（structnodea[30],intp,intm）
inti,j,flag,t;
flag=a[p].k;
i=p;
j=2*i;
t=0;
while（j<
=m&
!
t）
if（j<
m&
a[j].k<
a[j+1].k）j=j+1;
if（flag>
=a[j].k）t=1;
else{
a[i].k=a[j].k;
i=j;
}
a[i].k=flag;
voidheap（structnodea[30],intn）
inti,flag;
for（i=n/2;
i>
--i）
sift（a,i,n）;
for（i=n;
=2;
flag=a[1].k;
a[1].k=a[i].k;
sift（a,1,i-1）;
//菜单
voidMune（）
printf（"
\n"
）;
请输入你的选择!
\n"
1:
希尔排序!
2:
快速排序!
3:
堆排序!
4:
退出?
intHash（intkey）
intmode=key%P;
/*除留余数法得到的余数*/
returnmode;
voidHash_Init（HashTableht）/*哈希表初始化*/
inti;
for（i=0;
i<
MAX;
i++）
ht[i].key=NULLKEY;
ht[i].next=NULL;
intCharToInt（charstr[]）{
returnstr[0]+str[1]+str[2];
intHash_Insert（HashTableht,Node*node）/*为哈希表分配地址*/
intkey=Hash（CharToInt（node->
key_code））;
Node*p;
p=（Node*）malloc（sizeof（Node））;
if（ht[key].key==NULLKEY）
ht[key].key=key;
ht[key].next=node;
k++;
elseif（ht[key].key==key）
p=ht[key].next;
while（p->
next!
=NULL）
p=p->
next;
p->
next=node;
return1;
Node*Hash_Search（HashTableht,intkey）/*查找函数*/
intp0=Hash（key）;
if（ht[p0].key==NULLKEY）
{sum++;
returnNULL;
}
elseif（ht[p0].key==p0）
Node*p=ht[p0].next;
while（p!
=NULL）
if（CharToInt（p->
key_code）==key）
{sum++;
returnp;
sum++;
returnNULL;
intHash_Create（HashTableht）/*哈希表长度*/
Node*node;
Hash_Init（ht）;
printf（"
请输入姓名：
"
/*输入30个姓名*/
for（i=0;
30;
node=（Node*）malloc（sizeof（Node））;
scanf（"
%s"
node->
key_code）;
node->
next=NULL;
Hash_Insert（ht,node）;
\nCreateSuccessfully!
inthash_output（HashTableh）/*哈希表的输出部分*/
Node*a;
inti,j,count2=0;
a=（Node*）malloc（sizeof（Node））;
j=0;
hashlen;
{
printf（"
%4d"
i）;
h[i].key）;
if（h[i].next!
=0）
count2++;
j=1;
a=h[i].next;
while（a）
{
printf（"
->
（*a）.key_code）;
a=（*a）.next;
j++;
count2+=j;
}
returncount2;
voidHash_Link（）/*链表法构造函数*/
HashTableht;
Hash_Create（ht）;
hash_output（ht）;
count=%d\n"
k）;
/*查找总长度*/
ASL=%d/30\n"
/*平均查找长度*/
请输入要查找的数据：
/*输入查找的姓名*/
&
key）;
node=Hash_Search（ht,key）;
查找次数:
%d\n"
sum）;
if（node!
查找成功！
else
查找不成功！
voidhash_create（inth[],intstatus[],intdata）
intaddress;
intdi;
address=data%P;
if（status[address]==0）
h[address]=data;
status[address]=1;
for（di=1;
di<
=hashlen-1;
di++）
address=（（data%P）+di）%hashlen;
if（status[address]==0）
{
h[address]=data;
status[address]=1;
break;
}
return;
inthash_search（inth[],intkey）
{intaddress,di;
address=key%P;
if（h[address]==key）/*哈希表中元素与查找元素是否相等*/
else
for（di=1;
di++）/*哈希表中元素与查找元素不相等，查找下一元素*/
address=（（key%P）+di）%hashlen;
if（h[address]==key）
{
returndi+1;
if（di>
=hashlen）
return0;
charMenu（）
charc;
intflag;
do
flag=1;
system（"
cls"
**************************************************\n"
^^^^^^^1、查询景点路径^^^^^^^^\n"
^^^^^^^2、查询景点信息^^^^^^^^\n"
^^^^^^^3、推荐参观路线^^^^^^^^\n"
^^^^^^^4、退出^^^^^^^^^^^^^^^^\n"
请输入您的选择：
scanf（"
%c"
c）;
if（c=='
1'
||c=='
2'
3'
4'
）
flag=0;
}while（flag）;
returnc;
charSearchMenu（）//查询景点路径
************************************************\n"
^^^^^^^1、按照景点编号查询^^^^^^^\n"
^^^^^^^2、按照景点名称查询^^^^^^^\n"
^^^^^^^3、返回^^^^^^^^^^^^^^^^^^^\n"
intnum;
inti;
charname[20];
c=SearchMenu（）;
switch（c）
case'
:
请输入您要查找的景点编号：
%d"
num）;
for（i=0;
NUM;
if（num==G.vex[i].number）
您要查找景点信息如下:
%-25s\n"
G.vex[i].description）;
按ENTER返回"
getchar（）;
break;
if（i==NUM）
没有找到！
请输入您要查找的景点名称：
name）;
if（!
strcmp（name,G.vex[i].sight））
}while（c!
='
voidCreateUDN（intv,inta）//采用数组表示法，构造无向图G
G.vexnum=v;
//初始化图的顶点数和边数
G.arcnum=a;
G.vexnum;
++i）G.vex[i].number=i;
//初始化每一个顶点的编号
G.vex[0].sight="
大门"
;
G.vex[0].description="
校园出入的正门。
G.vex[1].sight="
图书馆"
G.vex[1].description="
阅览，借阅图书。
G.vex[2].sight="
教学楼"
G.vex[2].description="
学生上课的地方"
G.vex[3].sight="
食堂一"
G.vex[3].description="
吃饭的地方"
G.vex[4].sight="
大学生活动中心"
G.vex[4].description="
日常庆典活动，社团演出"
G.vex[5].sight="
游泳馆"
G.vex[5].description="
游泳"
G.vex[6].sight="
体育场"
G.vex[6].description="
土操场"
G.vex[7].sight="
2宿舍"
G.vex[7].description="
学生日常生活起居地"
G.vex[8].sight="
食堂三"
G.vex[8].description="
民族餐厅"
G.vex[9].sight="
运动场地"
G.vex[9].description="
篮球、排球、足球场地"
++i）
for（j=0;
j<
++j）//初始化邻接矩阵
G.arcs[i][j].adj=Max;
G.arcs[0][1].adj=G.arcs[1][0].adj=20;
G.arcs[1][2].adj=G.arcs[2][1].adj=24;
G.arcs[1][3].adj=G.arcs[3][1].adj=26;
G.arcs[1][4].adj=G.arcs[4][1].adj=16;
G.arcs[1][5].adj=G.arcs[5][1].adj=50;
G.arcs[2][7].adj=G.arcs[7][2].adj=1000;
G.arcs[3][4].adj=G.arcs[4][3].adj=34;
G.arcs[3][6].adj=G.arcs[6][3].adj=10;
G.arcs[4][6].adj=G.arcs[6][4].adj=19;
G.arcs[5][6].adj=G.arcs[6][5].adj=25;
G.arcs[5][7].adj=G.arcs[7][5].adj=500;
G.arcs[7][8].adj=G.arcs[8][7].adj=51;
G.arcs[7][9].adj=G.arcs[9][7].adj=200;
G.arcs[8][9].adj=G.arcs[9][8].adj=100;
voidShortestPath（intnum）//最短路径
intv,w,i,t;
intfinal[NUM];
//辅助数组
intmin;
for（v=0;
v<
v++）
final[v]=0;
D[v]=G.arcs[num][v].adj;
//将num到其余顶点的路径长度初始化为权值
for（w=0;
w<
w++）
P[v][w]=0;
if（D[v]<
20000）
P[v][num]=1;
D[num]=0;
++i）//求v到其余顶点的最短路径
min=Max;
++w）
final[w]）//求下一条最短路径
if（D[w]<
min）
v=w;
min=D[w];
++w）
final[w]&
（（min+G.arcs[v][w].adj）<
D[w]））
D[w]=min+G.arcs[v][w].adj;
for（t=0;
t<
t++）
P[w][t]=P[v][t];
voidoutput（intsight1,intsight2）//输出界面
inta,b,c,d,q=0;
a=sight2;
if（a!
=sight1）
从%s到%s的最短路径是"
G.vex[sight1].sight,G.vex[sight2].sight）;
（最短距离为%dm."
D[a]）;
G.vex[sight1].sight）;
d=sight1;
for（c=0;
c<
++c）
gate:
P[a][sight1]=0;
for（b=0;
b<
b++）
if（G.arcs[d][b].adj<
20000&
P[a][b]）
-->
G.vex[b].sight）;
q=q+1;
P[a][b]=0;
d=b;
if（q%8==0）printf（"
gotogate;
voidHaMiTonian（intm）//用来求推荐路线
if（m>
9）return;
L:
NextValue（m）;
if（x[m]==0）
return;
if（m==7&
G.arcs[0][x[9]-1].adj!
=20000）
升级会员 