A星算法求解8数码问题实验Word下载.docx
《A星算法求解8数码问题实验Word下载.docx》由会员分享，可在线阅读，更多相关《A星算法求解8数码问题实验Word下载.docx（18页珍藏版）》请在冰豆网上搜索。
4、Ａ＊算法总结
4、１,把起始状态添加到开启列表。
4、2,重复如下工作:
a） 寻找开启列表中f值最低的节点,我们称它为BESＴNOE
b）把它切换到关闭列表中。
ｃ） 对相邻的4个节点中的每一个
*假如它不在开启列表,也不在关闭列表,把它添加到开启列表中。
把ＢＥＳTNODＥ作为这一节点的父节点。
记录这一节点的f与g值
*假如它已在开启或关闭列表中,用g值为参考检查新的路径是否更好。
更低的ｇ值意味着更好的路径、假如如此,就把这一节点的父节点改为BＥSＴＮODE,同时重新计算这一节点的f与g值,假如保持开启列表的f值排序,改变之后需要重新对开启列表排序。
ｄ）停止
把目标节点添加到关闭列表,这时候路径被找到,或者没有找到路径,开启列表差不多空了,这时候路径不存在、
４、３,保存路径、从目标节点开始,沿着每一节点的父节点移动直到回到起始节点、这就是求得的路径。
5、数据结构
采纳结构体来保存八数码的状态、f与g的值以及该节点的父节点;
stｒuctNｏde｛
ｉnt s［３][３];
／/保存八数码状态,０代表空格
intf,g;
//启发函数中的ｆ与ｇ值
stｒuｃtNｏde＊ nｅxｔ;
stｒucｔNodｅ＊ｐreｖious;
//保存其父节点
};
６、实验结果,如图３所示
图3 A*算法求解八数码问题实验结果
7、源代码
//——－-——-—-——-—－-—---－－———－－-———-—－－—--—－————－—－-－—－———－——－-－--—-—-——－——-－-———-
／／代码:
利用A＊算法求解八数码问题、
／/八数码问题的启发函数设计为:
f（n）=d（ｎ）+ｐ（n）,其中A＊算法中的g（n）依照具体情况设计为ｄ（n）,意为n节点的深度,而ｈ（n）设计为p（ｎ）,意为放错的数码与正确的位置距离之与、
//后继结点的获取:
数码的移动等效为空格的移动。
首先判断空格上下左右的可移动性,其次移动空格获取后继结点。
/／--－————————－-—-——－--————－———－--——--—-—－—-—－-—-—-－——-－－—---－——－－—－----———－--——
＃ｉnｃludｅ〈ｓｔｄiｏ、h>
#ｉnｃlｕde〈stdliｂ、h〉
#ｉｎcluｄｅ〈math、h>
/／八数码状态对应的节点结构体
struｃｔ Noｄe{
ｉnts［３］［3］;
//保存八数码状态,０代表空格
inｔｆ,g;
/／启发函数中的f与ｇ值
strｕctNoｄe* neｘt;
sｔructNodｅ＊pｒeviｏｕs;
iｎt ｏpｅｎ＿N＝0;
//记录Open列表中节点数目
／／八数码初始状态
intinｉｔal＿s［３］［3］={
２,8,3,
１,６,4,
7,０,５
};
//八数码目标状态
inｔ finａｌ_ｓ［3］[３]=｛
1,2,3,
８,0,4,
７,6,5
｝;
//-———-－--—-－—————-——————————－————－——－————－—－———－－---—－—－－-—————－－-———-——-
//添加节点函数入口,方法:
通过插入排序向指定表添加
／／—－——-－—-－—－-————－—－－－——-——---—---－—-—---—--－—－—－——-————--——-—-—－--————-－
ｖｏｉｄ Add＿Node（ｓｔrｕcｔ Nｏｄe＊heａd,sｔruｃt Node*p）
{
ｓｔruct Node*ｑ;
if（head—〉neｘｔ）/／考虑链表为空
｛ ｑ＝ hｅad-〉neｘt;
ﻩif（p-〉f <
heａd—＞nexｔ－＞f）｛／/考虑插入的节点值比链表的第一个节点值小
ﻩﻩﻩp—＞next=ｈead—〉ｎeｘt;
ﻩﻩhead－＞neｘt= p;
ﻩ}
ｅlｓe{
ﻩ whｉlｅ（q-〉nexｔ）//考虑插入节点x,形如ａ<
=ｘ<
=ｂ
ﻩ {
ﻩｉf（（q-〉ｆ <
p—〉f｜|q—〉f==p-〉ｆ）＆&
（ｑ－>
ｎext—>
ｆ >
ｐ->
ｆ｜｜q—〉ｎext-〉ｆ==p—>
ｆ））{
ﻩﻩﻩ p-〉nｅxt=ｑ—>
ｎｅxt;
ﻩﻩﻩ q-〉ｎｅxt=p;
ﻩ break;
ﻩﻩﻩ}
ﻩ q＝q－〉nexｔ;
｝
ﻩif（ｑ-〉nｅxｔ=＝ＮＵLL）／/考虑插入的节点值比链表最后一个元素的值更大
ﻩﻩｑ—＞ｎext ＝ ｐ;
ﻩ ｝
｝
else head－＞next=p;
｝
//——--—－-—-—————-—-———--—－-——-——--—－--—－——-－－—－—－—-－—－—---－-——--－-－——－－—-—
／/删除节点函数入口
//——--—————-－———————--—---—-－————-－-—--——－－——--—-—－-——-－-－——－－——-——－--－——-
voiｄ del_Ｎodｅ（sｔｒｕctNode＊ｈｅad,sｔrｕctNodｅ ＊p ）
ｓtrucｔNodｅ＊q;
q=ｈeａd;
ｗhile（q-＞ｎeｘt）
｛
ﻩif（q—〉neｘt==p）{
ﻩ q－〉next＝ ｐ－＞next;
ﻩp-〉nｅｘｔ＝NＵLL;
ﻩ if（q－>
neｘt ==NULL）ｒeｔurn;
／/freｅ（ｐ）;
｝
q=q—〉ｎext;
｝
}
//--—－—-－——－—－-———-－--－-————-—－——－—－—-——－－—————－——--—－-——－－—－—-—--———-—-—－
／/判断两个数组是否相等函数入口
/／－——-——————---———-———-——-—－－—－—--———-——-—－———－—--—－——-——－—－—－——-－—－－-－—-—
ｉntequａl（ｉntｓ1［3］[3］,inｔs2［３][3］）
ｉｎti,j,flａg=0;
for（ｉ=0;
i<
3;
i+＋）
ﻩfor（ｊ＝0;
j〈３ ;
ｊ+＋）
ﻩﻩif（s1［ｉ］[j］!
＝s２[i］[ｊ］）｛ｆlａg=1;
break;
ｉf（！
flaｇ）
ﻩrｅｔurn 1;
eｌse retuｒn0;
//——－—-—-－----———--——----－———－———---———--—--－—--－-－——-—-——－－——-—-—－－-－——－—
//判断后继节点是否存在于Ｏpen或Closｅd表中函数入口
／／－－－—-—-—－--—－—－——-—－———-———————-—－———－-—－—-－--－—－—-——-—-—－——-————-－-—-－—
inteｘiｔ_Nｏdｅ（ｓｔｒuct Nodｅ＊head,intｓ[3][３],ｓtｒuｃｔＮodｅ＊Old_Nｏde）
sｔrucｔNode＊q=hｅａｄ-〉nｅxｔ;
iｎｔｆｌag ＝０;
ｗhile（q）
ﻩ if（equａl（q—>
s,s））｛
ﻩﻩｆlag=１;
ﻩﻩOld_Nｏde—＞ｎexｔ＝ｑ;
ﻩ retuｒn 1;
ﻩ else ｑ＝ q—＞nｅxt;
iｆ（!
flag）reｔｕrn0;
//——－－－----——－－－－—-—--———---－—－－—－——----－—－－-－--－————－－－—-——－————-－-－－-—－－
//计算ｐ（n）的函数入口
/／其中p（n）为放错位的数码与其正确的位置之间距离之与
/／具体方法:
放错位的数码与其正确的位置对应下标差的绝对值之与
／／--———-－－——－——－—————－－——－－—－-－－-——-－——-－-———－——－——-—－—————-———-——-－—---－—
intwronｇ＿ｓuｍ（inｔｓ[３］[3］）
｛
inti,j,fi,ｆｊ,sum＝0;
ｆoｒ（i=0 ;
i＜3;
i++）
ﻩfor（ｊ=０;
j〈3;
ｊ++）
ﻩfoｒ（ｆi=0;
fi<
３;
fi+＋）
ﻩ for（ｆｊ＝0;
fj〈3;
ｆj++）
ﻩﻩif（（ｆｉnaｌ_s[fｉ］［ｆｊ］== ｓ［ｉ］［ｊ］））{
ｓum＋=fａbs（i—ｆi）+fabs（j—fj）;
ﻩ ｂrｅak;
ﻩ }
ﻩ
ﻩ｝
retｕrnsum;
//-—－—-———-－----－————－—---—－—--－—-－—-－—-－————-—-－—－--－-－—-—-－---———-—－—-－—
//获取后继结点函数入口
//检查空格每种移动的合法性,假如合法则移动空格得到后继结点
／/———-—-—--—－——－－-—－—-—－—－———-———--－———－—-—－——－－———－－-—－——-—－－—————-－-－－－—
ｉｎｔｇeｔ_ｓucｃeｓsoｒ（sｔrｕｃt Node＊ＢＥSTＮODＥ,intｄｉrectiｏｎ, stｒｕｃtＮode*Sｕcｃesｓor）／/扩展BESTNＯDＥ,产生其后继结点ＳＵCCESＳOR
inｔ i,j,ｉ_0,j_０,ｔeｍp;
ｆor（i＝０;
ｉ〈３;
i++）
ｆoｒ（ｊ＝0;
j〈３;
j+＋）
ﻩＳucｃessor－>
s[i］［ｊ]= ＢＥＳTＮODＥ—〉s［i]［j];
//获取空格所在位置
fｏr（ｉ=0;
ｉ<
3;
ｆor（j=０;
j<
ｊ＋+）
ﻩﻩif（ＢＥＳTＮOＤＥ－>
s[ｉ][j］== 0）｛ｉ_０＝i;
j＿0=j;
ｂreaｋ;
swiｔch（dirｅctｉｏn）
｛
ﻩｃaｓe ０:
ｉf（（i_0－1）＞—1）{
ﻩtemｐ =Suｃcｅｓsｏr－〉s［i_0］［ｊ＿０］;
ﻩﻩﻩ Successor—〉ｓ［ｉ＿０]［ｊ_0］= Ｓuｃcessor-＞s[i_０-１][j_0];
ﻩﻩＳuｃｃeｓｓor－>
ｓ［i_０—1］［j_０］＝tｅmｐ;
ﻩﻩreturn 1;
ﻩﻩ｝
ﻩ elseｒeｔurｎ ０;
ﻩﻩﻩﻩ
ﻩcase 1:
if（（j_0－1）〉—１）｛
ﻩﻩ teｍp =Suｃceｓsｏr->
ｓ[i＿0］［j_0］;
ﻩﻩ Successｏr-＞s［i_0][j_0］=Suｃｃessｏr—>
s[ｉ_０］[ｊ_0－1］;
ﻩSuｃcesｓor—〉ｓ［ｉ_0］［j＿０—1]=temp;
ﻩﻩﻩ retｕrn1;
ﻩ｝
ﻩ eｌｓe reｔurｎ0;
ﻩｃａse2:
if（（j_0+1）＜３）{
ﻩﻩ tｅmp=Sucｃｅsｓｏｒ—＞s[i_０］[j_0];
ﻩﻩＳuccｅsｓｏｒ-〉s[i_0］[j_0]=Suｃcesｓor-〉ｓ[i_0][ｊ_0+1］;
ﻩﻩ Successor—〉ｓ［i_0］［j＿0＋1］= ｔemp;
ﻩﻩﻩreturｎ１;
ﻩﻩ}
elsｅreturn0;
ﻩﻩﻩ
ﻩ caｓｅ3:
if（（i_0＋1）〈3）{
ﻩﻩ temp ＝Successｏr—>
s［ｉ＿０]［j_０］;
ﻩﻩＳｕｃｃｅsｓor-＞ｓ［i_０][ｊ＿０］ =Ｓｕccｅssor->
s［i_0+１］［j_0］;
ﻩﻩﻩSuccessｏｒ-〉s[i_0+1］[j_0］= tｅｍｐ;
ﻩﻩ ｒeturn1;
ﻩﻩ ｝
ﻩﻩ eｌse ｒｅtｕrn ０;
ﻩﻩ
}
//----—－----—---—－-－—-——-－—-－－-——－--—-—－—--——－—-－－——-－—-———－－-－－—－－——-—--—
//从OPen表获取最佳节点函数入口
//—---—－－-—-———--－－——－—————-—-——-－———－——-——－————-－-———-——-－-———-—－—－——-—-－
struｃt Ｎodｅ*geｔ_BＥSTNODE（struｃt Ｎｏｄe＊Ｏｐeｎ）
returｎ Oｐeｎ—>
nｅxｔ;
／／-——-—--—-—－-－--—-－——-—-－--—-－-——————－－——－－—－--—-———----－-———－－———--—－－——
／/输出最佳路径函数入口
//－—－—－－—--——－—－--－——-———-－———--－---－--———－—-－—————－－-——－—－-——－—－—————-－-－
vｏidpｒｉnt_Patｈ（ｓｔruct Nodｅ＊ｈead）
stｒuｃtＮｏde＊ｑ,*q1,＊p;
iｎt i,j,cｏunt=１;
ｐ=（strucｔNoｄe＊）ｍaｌｌoｃ（sizeof（strｕｃtNoｄｅ））;
／／通过头插法变更节点输出次序
p—〉ｐrｅviｏus＝NUＬL;
q＝head;
ｗhiｌe（q）
q1=q—>
preｖiouｓ;
ｑ—〉pｒevioｕs= p－〉pｒｅvｉous;
ｐ-〉preｖｉous ＝ q;
ｑ =ｑ1;
q=p-〉prｅvious;
ｗhｉle（q）
if（q＝=ｐ－>
pｒevｉouｓ）priｎtf（”八数码的初始状态:
\ｎ”）;
elｓｅif（ｑ—〉ｐrｅvious==NＵＬＬ）prｉnｔf（”八数码的目标状态:
\n”）;
elsｅprｉntf（＂八数码的中间态%ｄ\n”,cｏunt++）;
for（i＝０;
for（j=0;
ﻩ{
ﻩpｒintf（”%４ｄ＂,q－>
s[i］［j]）;
ﻩﻩｉf（ｊ== 2）printｆ（”\n”）;
ﻩ ｝
ｐｒintｆ（"
f=%d, g＝％d\n\n”,q-〉f,ｑ->
ｇ）;
q= ｑ－＞prｅｖiouｓ;
}
/／————-－—--－——-—-—-—--———--－-———---－－-———－—-－———-—-－-－————--—--—-————-—--—
/／A＊子算法入口:
处理后继结点
/／-—－—----－－－——-－---—--－—--—-—————————-—－---—-－-——－——－--—－－-—---———－——————
voｉdsub＿A＿algｏｒｉthm（ｓtrｕctNode ＊Opｅn, sｔruｃｔNoｄe*BESTNOＤE,ｓtｒuｃｔNｏｄｅ* Closed,sｔruct Node *Ｓｕccｅsｓoｒ）
sｔrｕｃtNｏde* Ｏｌｄ_Ｎoｄｅ= （structNode＊）ｍalloc（sｉzeof（strｕｃｔNｏｄe））;
Succeｓsor－>
ｐｒｅｖioｕs＝ BＥSＴNOＤE;
／/建立从succｅssor返回BESＴNＯDE的指针
Ｓuccｅssor—＞ｇ =BESTNOＤE-＞g+ 1;
／/计算后继结点的ｇ值
//检查后继结点是否已存在于Open与Closed表中,假如存在:
该节点记为ｏld＿Nｏdｅ,比较后继结点的ｇ值与表中oｌd＿Nｏde节点
/／g值,前者小代表新的路径比老路径更好,将Ｏld_Noｄe的父节点改为BＥＳTNＯＤE,并修改其ｆ,g值,后者小则什么也不做。
//即不存在Ｏpen也不存在Ｃlｏｓed表则将其加入ＯPen表,并计算其f值
ｉｆ（eｘit_Node（Opｅｎ, Sｕcｃｅsｓor-〉ｓ, Ｏｌｄ_Nodｅ） ）{
ﻩ if（Suｃcesｓｏr－〉g 〈Old_Node-〉ｇ）｛
Ｏｌｄ_Nｏde-〉ｎｅxｔ－〉previoｕs =ＢＥＳＴNODE;
/／将Ｏld_Nｏdｅ的父节点改为BＥＳTNＯDE
ﻩ Oｌd＿Nｏｄｅ－>
ｎeｘｔ-＞ｇ=Ｓucｃesｓｏｒ-〉g;
／/修改ｇ值
ﻩ Old＿Nodｅ—>
next－〉f=Ｏld_Ｎodｅ—〉g + wｒong_sｕm（Ｏld_Nｏdｅ->
ｓ）;
/／修改ｆ值
ﻩﻩ/／排序~~～~~～～～～~～～~～~~～～
ﻩﻩｄel_Ｎodｅ（Ｏpeｎ,Oｌd_Nｏdｅ）;
ﻩﻩ Add_Nodｅ（Open,Olｄ_Nｏde）;
ﻩ｝
ﻩ
｝
ﻩelse if（ ｅxit_Ｎoｄｅ（Ｃlosｅd,Sｕｃcｅｓsoｒ—>
ｓ, Oｌｄ_Noｄｅ））｛
if（Ｓuccessoｒ－〉ｇ＜Old＿Nodｅ—〉g）｛
ﻩ Oｌd_Node—＞ｎｅxt->
pｒｅviｏus=ＢEＳTＮODＥ;
ﻩﻩＯld_Node-〉next-〉g= Succｅssor—〉g;
ﻩ Old_Ｎodｅ—>
ｆ =Ｏld＿Node-＞g +wrong_suｍ（Olｄ_Noｄe-〉s）;
ﻩﻩ//排序～~～～～～～～～~～~~～～～～～
ﻩﻩ ｄel_Nｏｄe（Closeｄ,Ｏlｄ_Noｄｅ）;
Add_Node（Cｌｏsed,Oｌｄ_Ｎoｄe）;
ﻩ｝
ﻩ }
ﻩﻩ eｌｓe｛
ﻩﻩＳuccessor—〉f=Succesｓｏｒ－>
g +ｗｒｏｎg_sum（Sｕｃcessoｒ—〉s）;
ﻩﻩﻩ Add_Ｎode（Oｐen, Sｕccesｓor）;
ﻩﻩ ｏpen＿N+＋;
ﻩﻩ｝
//-——--———－—－－-—－—-—---———－-—－—-———－—－-————－—－－－－—－－———-—－-－－--——－-－—-————
／／A*算法入口
／／八数码问题的启发函数为:
f（n）=ｄ（n）+p（n）
／/其中Ａ*算法中的g（n）依照具体情况设计为ｄ（n）,意为n节点的深度,而ｈ（n）设计为p（n）,
//意为放错的数码与正确的位置距离之与
//－——－—－-－——-—-—－--—-——-—--———-－—－—－—-－－——－-——-———---—--—--－—－-——－-——－－—－—
vｏｉd Ａ_algorithm（stｒｕｃtＮode *Ｏpeｎ, structNode*Ｃlｏｓed）//A*算法
ｉｎtｉ,j;
strｕct Nｏｄe*ＢESTＮOＤＥ, *initａｌ,*Sucｃｅｓsor;
ｉnｉtal = （sｔｒｕｃtＮodｅ＊）malloc（sｉzeｏｆ（strｕｃｔ Noｄｅ））;
／／初始化起始节点
ｆoｒ（ｉ=0;
ｉ＜３;
ﻩ fｏｒ（j=0;
j<
j＋＋）
ﻩinital—〉s［i］［j] = inital_s［i］［ｊ］;
initaｌ－＞f ＝wroｎｇ_sum（initaｌ_ｓ）;
ｉnitａｌ-〉ｇ=０;
ｉnitａl—〉ｐrｅｖiｏｕs= NULL;
ｉnitａl—〉ｎext =NULL;
Adｄ_Noｄe（Open,inｉｔａl）;
／/把初始节点放入OPEN表
ｏpen＿N++;
wｈiｌe（１）
｛
ﻩｉf（open_N ==０）{ｐrinｔf（"
fａilure!
”）;
rｅｔｕrn;
else {
ﻩﻩ BEＳTNＯDE＝get_ＢＥSTNODＥ（Oｐｅn）;
//从OＰEＮ表获取ｆ值最小的BＥＳTNＯDE,将其从OＰEN表删除并加入ＣＬOＳＥD表中
ﻩﻩdeｌ_Nｏde（Open, BESTNODE）;
ﻩﻩｏpeｎ_N—－;
ﻩ ﻩ Adｄ_Nｏde（Cｌｏsed,ＢEＳTＮOＤE）;
ﻩﻩ iｆ（eｑuaｌ（ＢＥSTNＯDE-〉ｓ,fｉｎａl＿s））｛//判断BESＴNODＥ是否为目标节点
ﻩﻩﻩprintf（"
sｕccess！
\n＂）;
ﻩﻩﻩ priｎt_Ｐａth（BＥSTNOＤE）;
ﻩﻩﻩ reｔurn;
ﻩ/／针对八数码问题,后继结点Ｓｕccesｓor
升级会员 