八数码问题C代码.docx

八数码问题C代码.docx

《八数码问题C代码.docx》由会员分享，可在线阅读，更多相关《八数码问题C代码.docx（14页珍藏版）》请在冰豆网上搜索。

八数码问题C代码

********************************************************************

 *本函数是用A*算法来实现八数码的问题

 *

 *

 *算法的步骤如下：

 *1、初始化两个链表open和closed，将初始状态放入open表中

 *2、重复下列过程，直至找到目标结点为止，如果open表为空，那

 *  么查找失败；

 *3、从open表中拿出具有最小f值的结点（将这一结点称为BESTNODE），

 *  并放入closed表中；

 *4、如果BESTNODE为目标结点，成功求得解,退出循环；

 *5、如果BESTNODE不是目标结点，那么产生它的后继结点（此后继结

 *  点与其祖先的状态不同），后继结点组成一个链表；

 *6、对每个后继结点进行以下过程：

 *7、建立它到BESTNODE的parent指针；

 *8、如果此结点在open表中，首先将open表中的结点添加进BESTNODE

 *  的后继结点链中，然后计算两个结点的g值，如果此结点的g值小

 *  于open表中的结点时，open表中的结点改变parent指针，同时将

 *  此结点删除；

 *9、如果此结点在closed表中，首先将closed表中的结点添加进BESTNODE

 *  的后继结点中，然后计算两个结点的g值，如果此结点的g值小于

 *  closed表中的结点时，closed表中的结点改变parent指针；将

 *  closed表中的结点重新放入open表中，同时将此结点删除；

 *10、如果此结点既不在open表中也不再closed表中，那么添加此结点至

 *  BESTNODE的后继结点链中。

 *

 *

 *Author:

转载作者不详。

 *

 *2011.5.16

 *

 *

 ********************************************************************/

#include"stdafx.h"

#include

#include

#include

#definesize3

usingnamespacestd;

//定义二维数组来存储数据表示某一个特定状态

typedefintstatus[size][size];

structSpringLink;

//定义状态图中的结点数据结构

typedefstructNode

{

 statusdata;//结点所存储的状态

   Node*parent;//指向结点的父亲结点

 SpringLink*child;//指向结点的后继结点

 intfvalue;//结点的总的路径

 intgvalue;//结点的实际路径

 inthvalue;//结点的到达目标的苦难程度

   Node*next;//指向open或者closed表中的后一个结点

}NNode,*PNode;

//定义存储指向结点后继结点的指针的地址

typedefstructSpringLink

{

 Node*pointData;//指向结点的指针

 SpringLink*next;//指向兄第结点

}SPLink,*PSPLink;

//定义open表和close表

PNodeopen;

PNodeclosed;

//开始状态与目标状态

statusstartt={2,8,3,1,6,4,7,0,5};

statustarget={1,2,3,8,0,4,7,6,5};

//初始化一个空链表

voidinitLink（PNode&Head）

{

 Head=（PNode）malloc（sizeof（NNode））;

 Head->next=NULL;

}

//判断链表是否为空

boolisEmpty（PNodeHead）

{

 if（Head->next==NULL）

  returntrue;

 else

  returnfalse;

}

//从链表中拿出一个数据，通过FNode返回

voidpopNode（PNode&Head,PNode&FNode）

{

 if（isEmpty（Head））

 {

  FNode=NULL;

  return;

 }

 FNode=Head->next;

 Head->next=Head->next->next;

 FNode->next=NULL;

}

//向结点的（最终）后继结点链表中添加新的子结点

voidaddSpringNode（PNode&Head,PNodenewData）

{

 PSPLinknewNode=（PSPLink）malloc（sizeof（SPLink））;

 newNode->pointData=newData;

 newNode->next=Head->child;

 Head->child=newNode;

}

//释放状态图中存放结点后继结点地址的空间

//注意传入参数PSPLink引用类型

voidfreeSpringLink（PSPLink&Head）

{

 PSPLinktmm;

 while（Head!

=NULL）

 {

  tmm=Head;

  Head=Head->next;

  free（tmm）;

 }

}

//释放open表与closed表中的资源

voidfreeLink（PNode&Head）

{

 PNodetmn;

 tmn=Head;

 Head=Head->next;

 free（tmn）;

 while（Head!

=NULL）

 {

  //首先释放存放结点后继结点地址的空间

  freeSpringLink（Head->child）;

  tmn=Head;

  Head=Head->next;

  free（tmn）;

 }

}

//向普通链表中添加一个结点

voidaddNode（PNode&Head,PNode&newNode）

{

 newNode->next=Head->next;

 Head->next=newNode;

}

//向非递减排列的链表中添加一个结点

voidaddAscNode（PNode&Head,PNode&newNode）

{

 PNodeP;

 PNodeQ;

 P=Head->next;

 Q=Head;

 while（P!

=NULL&&P->fvaluefvalue）

 {

  Q=P;

  P=P->next;

 }

 //上面判断好位置之后，下面就是简单的插入了

 newNode->next=Q->next;

 Q->next=newNode;

}

//计算结点额h值，当前节点与目标节点数码错位个数

intcomputeHValue（PNodetheNode）

{

 intnum=0;

 for（inti=0;i<3;i++）

 {

  for（intj=0;j<3;j++）

  {

   if（theNode->data[i][j]!

=target[i][j]）

    num++;

  }

 }

 returnnum;

}

//计算结点的f，g，h值

voidcomputeAllValue（PNode&theNode,PNodeparentNode）

{

 if（parentNode==NULL）

  theNode->gvalue=0;

 else

  theNode->gvalue=parentNode->gvalue+1;

 theNode->hvalue=computeHValue（theNode）;

 theNode->fvalue=theNode->gvalue+theNode->hvalue;

}

//初始化函数，进行算法初始条件的设置

voidinitial（）

{

 //初始化open以及closed表

 initLink（open）;

 initLink（closed）;

 //初始化起始结点，令初始结点的父节点为空结点

 PNodeNULLNode=NULL;

 PNodeStart=（PNode）malloc（sizeof（NNode））;

 for（inti=0;i<3;i++）

 {

  for（intj=0;j<3;j++）

  {

   Start->data[i][j]=startt[i][j];

  }

 }

 Start->parent=NULL;

 Start->child=NULL;

 Start->next=NULL;

 computeAllValue（Start,NULLNode）;

 //起始结点进入open表

 addAscNode（open,Start）;

}

//将B节点的状态赋值给A结点

voidstatusAEB（PNode&ANode,PNodeBNode）

{

 for（inti=0;i<3;i++）

 {

  for（intj=0;j<3;j++）

  {

   ANode->data[i][j]=BNode->data[i][j];

  }

 }

}

//两个结点是否有相同的状态

boolhasSameStatus（PNodeANode,PNodeBNode）

{

 for（inti=0;i<3;i++）

 {

  for（intj=0;j<3;j++）

  {

   if（ANode->data[i][j]!

=BNode->data[i][j]）

    returnfalse;

  }

 }

 returntrue;

}

//结点与其祖先结点是否有相同的状态

boolhasAnceSameStatus（PNodeOrigiNode,PNodeAnceNode）

{

 while（AnceNode!

=NULL）

 {

  if（hasSameStatus（OrigiNode,AnceNode））

   returntrue;

  AnceNode=AnceNode->parent;

 }

 returnfalse;

}

//取得方格中空的格子的位置，通过row,col返回。

voidgetPosition（PNodetheNode,int&row,int&col）

{

 for（inti=0;i<3;i++）

 {

  for（intj=0;j<3;j++）

  {

   if（theNode->data[i][j]==0）

   {

    row=i;

    col=j;

    return;

   }

  }

 }

}

//交换两个数字的值

voidchangeAB（int&A,int&B）

{

 intC;

 C=B;

 B=A;

 A=C;

}

//检查相应的状态是否在某一个链表中，判断spciNode所指的节点是否在theLink所指的链表中。

//theNodeLink返回在链表中与spciNode状态相同的节点指针，preNode指向相同节点前驱。

boolinLink（PNodespciNode,PNodetheLink,PNode&theNodeLink,PNode&preNode）

{

 preNode=theLink;

 theLink=theLink->next;

 while（theLink!

=NULL）

 {

  if（hasSameStatus（spciNode,theLink））

  {

   theNodeLink=theLink;

   returntrue;

  }

  preNode=theLink;

  theLink=theLink->next;

 }

 returnfalse;

}

//产生结点的后继结点（与祖先状态不同）链表

//通过spring参数返回节点的后继节点链表

voidGenerateSpringLink（PNodetheNode,PNode&spring）

{

 introw;

 intcol;

 getPosition（theNode,row,col）;

 //空的格子右边的格子向左移动

 if（col!

=2）

 {

  PNoderlNewNode=（PNode）malloc（sizeof（NNode））;

  statusAEB（rlNewNode,theNode）;

  changeAB（rlNewNode->data[row][col],rlNewNode->data[row][col+1]）;

  if（hasAnceSameStatus（rlNewNode,theNode->parent））

  {

   free（rlNewNode）;//与父辈相同，丢弃本结点

  }

  else

  {

   rlNewNode->parent=theNode;

   rlNewNode->child=NULL;

   rlNewNode->next=NULL;

   computeAllValue（rlNewNode,theNode）;

   //将本结点加入后继结点链表

   addNode（spring,rlNewNode）;

  }

 }

 //空的格子左边的格子向右移动

 if（col!

=0）

 {

  PNodelrNewNode=（PNode）malloc（sizeof（NNode））;

  statusAEB（lrNewNode,theNode）;

  changeAB（lrNewNode->data[row][col],lrNewNode->data[row][col-1]）;

  if（hasAnceSameStatus（lrNewNode,theNode->parent））

  {

   free（lrNewNode）;//与父辈相同，丢弃本结点

  }

  else

  {

   lrNewNode->parent=theNode;

   lrNewNode->child=NULL;

   lrNewNode->next=NULL;

   computeAllValue（lrNewNode,theNode）;

   //将本结点加入后继结点链表

   addNode（spring,lrNewNode）;

  }

 }

 //空的格子上边的格子向下移动

 if（row!

=0）

 {

  PNodeudNewNode=（PNode）malloc（sizeof（NNode））;

  statusAEB（udNewNode,theNode）;

  changeAB（udNewNode->data[row][col],udNewNode->data[row-1][col]）;

  if（hasAnceSameStatus（udNewNode,theNode->parent））

  {

   free（udNewNode）;//与父辈相同，丢弃本结点

  }

  else

  {

   udNewNode->parent=theNode;

   udNewNode->child=NULL;

   udNewNode->next=NULL;

   computeAllValue（udNewNode,theNode）;

   //将本结点加入后继结点链表

   addNode（spring,udNewNode）;

  }

 }

 //空的格子下边的格子向上移动

 if（row!

=2）

 {

  PNodeduNewNode=（PNode）malloc（sizeof（NNode））;

  statusAEB（duNewNode,theNode）;

  changeAB（duNewNode->data[row][col],duNewNode->data[row+1][col]）;

  if（hasAnceSameStatus（duNewNode,theNode->parent））

  {

   free（duNewNode）;//与父辈相同，丢弃本结点

  }

  else

  {

   duNewNode->parent=theNode;

   duNewNode->child=NULL;

   duNewNode->next=NULL;

   computeAllValue（duNewNode,theNode）;

   //将本结点加入后继结点链表

   addNode（spring,duNewNode）;

  }

 }

}

//输出给定结点的状态

voidoutputStatus（PNodestat）

{

 for（inti=0;i<3;i++）

 {

  for（intj=0;j<3;j++）

  {

   cout<data[i][j]<<"";

  }

  cout<

 }

}

//输出最佳的路径

voidoutputBestRoad（PNodegoal）

{

 intdeepnum=goal->gvalue;

 if（goal->parent!

=NULL）

 {

  outputBestRoad（goal->parent）;

 }

 cout<<"第"<

"<

 outputStatus（goal）;

}

voidAStar（）

{

 PNodetmpNode;//指向从open表中拿出并放到closed表中的结点的指针

 PNodespring;//tmpNode的后继结点链

 PNodetmpLNode;//tmpNode的某一个后继结点

 PNodetmpChartNode;

 PNodethePreNode;//指向将要从closed表中移到open表中的结点的前一个结点的指针

 boolgetGoal=false;//标识是否达到目标状态

 longnumcount=1;//记录从open表中拿出结点的序号

 initial（）;//对函数进行初始化

 initLink（spring）;//对后继链表的初始化

 tmpChartNode=NULL;

 cout<<"从open表中拿出的结点的状态及相应的值"<

 while（!

isEmpty（open））

 {

  //从open表中拿出f值最小的元素,并将拿出的元素放入closed表中

  popNode（open,tmpNode）;

  addNode（closed,tmpNode）;

  cout<<"第"<

"<

  outputStatus（tmpNode）;

  cout<<"其f值为：

"<fvalue<

  cout<<"其g值为：

"<gvalue<

  cout<<"其h值为：

"<hvalue<

  //如果拿出的元素是目标状态则跳出循环

  if（computeHValue（tmpNode）==0）

  {

   getGoal=true;

   break;

  }

  //产生当前检测结点的后继（与祖先不同）结点列表，产生的后继结点的parent属性指向当前检测的结点

  GenerateSpringLink（tmpNode,spring）;

  //遍历检测结点的后继结点链表

  while（!

isEmpty（spring））

  {

   popNode（spring,tmpLNode）;

   //状态在open表中已经存在，thePreNode参数在这里并不起作用

   if（inLink（tmpLNode,open,tmpChartNode,thePreNode））

   { //此时他们hvalue值一样

    addSpringNode（tmpNode,tmpChartNode）;

    if（tmpLNode->gvaluegvalue） //等价于if（tmpLNode->fvaluefvalue） 

    {

     tmpChartNode->parent=tmpLNode->parent;

     tmpChartNode->gvalue=tmpLNode->gvalue;

     tmpChartNode->fvalue=tmpLNode->fvalue;

    }

    free（tmpLNode）;

   }

   //状态在closed表中已经存在

   elseif（inLink（tmpLNode,closed,tmpChartNode,thePreNode））  

   { //此时他们hvalue值一样

    addSpringNode（tmpNode,tmpChartNode）;

    if（tmpLNode->gvaluegvalue）

    {

     PNodecommu;

     tmpChartNode->parent=tmpLNode->parent;

     tmpChartNode->gvalue=tmpLNode->gvalue;

     tmpChartNode->fvalue=tmpLNode->fvalue;

     freeSpringL