八数码问题文档格式.docx
《八数码问题文档格式.docx》由会员分享，可在线阅读，更多相关《八数码问题文档格式.docx（14页珍藏版）》请在冰豆网上搜索。
voidInit_List（PList）;
//初始化链表
intIsEmpty_List（PList）;
//判断链表是否为空
voidAdd_List（PList,ElemType*）;
//向链表中插入一个元素
voidRemove_List（PList,ElemType*,int）;
//从链表中取出一个元素
intHasElem（PList,ElemType*）;
//判断链表中是否有某个元素
voidSort_List（PList）;
//根据h对链表进行排序
voidDestroy_List（PList）;
//删除链表
voidInit_Stack（PStack）;
//初始化栈
intIsEmpty_Stack（PStack）;
//判断栈是否为空
voidPush（PStack,ElemType*）;
//压栈
voidPop（PStack,ElemType*）;
//出栈
voidDestroy_Stack（PStack）;
//删除栈
intGeth（int[][BOUND]）;
//根据状态计算h
intExpand（PList,PList,ElemType*）;
//根据一个节点进行扩展
voidShow_Node（Node*）;
//显示节点信息
voidAssign_Node（Node*,Node*）;
//节点复制
intEqual_Node（Node*,Node*）;
//判断两个节点的状态是否相等
ElemType*last;
intmain（）
Listopen,close;
Stackstack;
ElemType*N=NULL;
intflag=0;
Init_List（&
open）;
close）;
Init（N,&
while
（1）
{
if（IsEmpty_List（&
open））
{
printf（"
搜索失败!
\n"
）;
break;
}
N=（ElemType*）malloc（sizeof（ElemType））;
Remove_List（&
open,N,1）;
Add_List（&
close,N）;
if（Equal_Node（last,N））
搜索成功!
flag=1;
else
if（Expand（&
open,&
close,N）==0）
continue;
Sort_List（&
}
Sleep（2000）;
system（"
cls"
if（1==flag）
Init_Stack（&
stack）;
while
（1）
Push（&
stack,N）;
if（N->
parent==NULL）
{
break;
}
N=N->
parent;
while（!
IsEmpty_Stack（&
stack））
system（"
路径显示:
Pop（&
Show_Node（N）;
Sleep（1000）;
Destroy_Stack（&
Destroy_List（&
return0;
}
voidInit（ElemType*N,List*open）
inti,j;
printf（"
输入初始状态:
N=（ElemType*）malloc（sizeof（ElemType））;
for（i=0;
i<
BOUND;
i++）
for（j=0;
j<
j++）
scanf（"
%d"
&
N->
num[i][j]）;
输入最终状态:
last=（ElemType*）malloc（sizeof（ElemType））;
last->
N->
h=Geth（N->
num）;
parent=NULL;
Add_List（open,N）;
voidInit_List（PListplist）
plist->
elem=（ElemType*）malloc（INIT_LIST_SIZE*sizeof（ElemType））;
listsize=INIT_LIST_SIZE;
length=0;
intIsEmpty_List（PListplist）
if（plist->
length==0）
return1;
voidAdd_List（PListplist,ElemType*e）
length>
=plist->
listsize）
plist->
elem=（ElemType*）realloc（plist->
elem,（plist->
listsize+INCREMENT_LIST_SIZE）*sizeof（ElemType））;
listsize+=INCREMENT_LIST_SIZE;
Assign_Node（&
plist->
elem[plist->
length],e）;
length++;
voidRemove_List（PListplist,ElemType*N,intindex）
intk;
N=NULL;
else
Assign_Node（N,&
elem[index-1]）;
for（k=index;
k<
length;
k++）
Assign_Node（&
elem[k-1],&
elem[k]）;
length--;
voidSort_List（PListplist）
inti,j,flag;
ElemTypetemp;
for（i=plist->
length-1;
i>
0;
i--）
flag=0;
i;
if（plist->
elem[j].h>
elem[j+1].h）
Assign_Node（&
temp,&
elem[j]）;
elem[j],&
elem[j+1]）;
elem[j+1],&
temp）;
flag=1;
if（!
flag）
intHasElem（PListplist,ElemType*e）
inti,j,k,t;
for（k=0;
t=0;
for（i=0;
for（j=0;
if（plist->
elem[k].num[i][j]==e->
num[i][j]）
{
t++;
}
if（t==BOUND*BOUND）
return1;
voidDestroy_List（PListplist）
free（plist->
elem）;
length=plist->
listsize=0;
voidInit_Stack（PStackpstack）
pstack->
base=（ElemType*）malloc（INIT_STACK_SIZE*sizeof（ElemType））;
top=pstack->
base;
stacksize=INIT_STACK_SIZE;
intIsEmpty_Stack（PStackpstack）
if（pstack->
top==pstack->
base）
voidPush（PStackpstack,ElemType*pelem）
top-pstack->
base>
=pstack->
stacksize）
pstack->
base=（ElemType*）realloc（pstack->
base,（pstack->
stacksize+INCREMENT_STACK_SIZE）*sizeof（ElemType））;
base+pstack->
stacksize;
stacksize+=INCREMENT_STACK_SIZE;
Assign_Node（pstack->
top,pelem）;
（pstack->
top）++;
voidPop（PStackpstack,ElemType*pelem）
if（IsEmpty_Stack（pstack））
exit（0）;
Assign_Node（pelem,（pstack->
top-1））;
top）--;
voidDestroy_Stack（PStackpstack）
free（pstack->
base）;
top=NULL;
stacksize=0;
intGeth（intnum[][BOUND]）
inti,j,h=BOUND*BOUND;
if（num[i][j]==last->
h--;
returnh;
intExpand（PListpopen,PListpclose,ElemType*e）
intdir,i,j,m,n,a,b,state,t;
ElemType*temp;
t=0;
for（dir=0;
dir<
4;
dir++）
temp=（ElemType*）malloc（sizeof（ElemType））;
if（e->
num[i][j]==0）
n=i;
m=j;
temp->
num[i][j]=e->
num[i][j];
a=n+move[dir][0];
b=m+move[dir][1];
if（a<
0||a>
BOUND-1||b<
0||b>
BOUND-1）
continue;
state=temp->
num[n][m];
temp->
num[n][m]=temp->
num[a][b];
num[a][b]=state;
HasElem（popen,temp）&
&
!
HasElem（pclose,temp））
temp->
parent=e;
h=Geth（temp->
Add_List（popen,temp）;
t++;
returnt;
voidShow_Node（Node*N）
num[i][j]!
=0）
printf（"
%3d"
N->
else
%3c"
'
'
printf（"
voidAssign_Node（Node*N1,Node*N2）
N1->
num[i][j]=N2->
N1->
h=N2->
h;
parent=N2->
intEqual_Node（Node*N1,Node*N2）
if（N1->
=N2->
return0;
return1;
升级会员 