迷宫问题求解(C++非递归程序)

           　　　　　　　 　迷宫问题求解(C++非递归程序) 

              
一、【实验内容】
【问题描述】
      以一个m*n的长方阵表示迷宫，0，1分别表示迷宫中的通路和障碍。设计一个程序，对任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论，

【基本要求】：首先实现一个以链表作存储结构的栈类型，然后编写一个求解迷宫的非递归的程序，求得的通路以三元组（I,j,d）的形式输出，其中（i，j）指示迷宫中的一个坐标，d表示做到下一个坐标的方向。如：对于下列数据的迷宫，输出的一条通路为：（1，1，1），（1，2，2），（2，2，2），
（3，2，3），（3，1，2），……。
   迷宫数据从文件中读取出来。
　　　　　　
【测试数据】：
迷宫的测试数据如下：左上角（1，1）为入口，右下角（8，9）为出口
  1       2       3       4       5       6       7       8

进0 0 0 1 0 0 1 0
    0 0 1 0 0 0 1 0
    0 0 0 0 1 1 0 1
    0 1 1 1 0 0 1 0
    0 0 0 1 0 0 0 0
    0 1 0 0 0 1 0 1
    0 1 1 1 1 0 0 1
    1 1 0 0 0 1 0 1
    1 1 0 0 0 0 0 0 出
                                         

二、实验目的
1、加深对栈特性理解，以便在解决实际问题中灵活运用它们
2、加深对栈操作实际算法的理解
3、进一步熟悉掌握链表的操作；
4、掌握指针的应用
5、更进一步掌握有关类的操作

 

 

 

三、实验文档：
                  迷宫求解问题
一、 需求分析
1、本程序实现迷宫的探索过程. 以用户和计算机对话的方式，即在计算机终端上显示“提示信息”之后，由用户在键盘上输入演示程序中规定的运算命令，然后程序就探索路径并输出路径。
2、本演示程序中，输入形式以“回车符”为结束标志，且允许出现重复字符。
3、利用二维指针实现迷宫位置的存储，并用栈存贮探索路径，每个结点含三个整形变量。输入的形式以回车结束。
4、本程序中，用户可以读去文件里的迷宫，也可自己重新输入迷宫，而且用户可以输入任意大小的迷宫，然后程序自动探索路径，并输出迷宫的路径
5、测试数据
00100010
00100010
00001101
01110010
00010000
01000101
01111001
11000101
11000000
二、概要设计
为实现上述程序功 能，应以栈存储结点。为此，需要定义一个抽象数据类型。
1. 抽象数据类型定义为：
ADT stack{
数据对象：D={ai|ai∈LinkList, i=1,2,...n, n≥0}
数据关系：R1={|ai-1,ai∈D|=2,……n }，即当前结点与下一个结点的关系
基本操作：
stack();            
构造函数，建立一个空栈；
操作结果：通过字符串a构造两个位数不限的长整数。
void Push(DataType data);
初始条件：已存在栈
操作结果：把元素data压入栈顶
DataType Pop();
初始条件：已存在栈，且非空
操作结果： 栈顶元素出栈，且删除栈顶元素
DataType GetPop();   
初始条件：已存在栈，且非空
操作结果：获取栈顶元素
void Clear();  
初始条件：已存在栈
操作结果：把当前的栈清空
bool IsEmpty();
初始条件：已存在栈
操作结果：如果栈为空，则结果为“真”，否则为“假”          
}ADT OrderedList

 

2.本程序包含三个模块：
1)主程序模块：
void main(){
    初始化；
do{
   接受命令；
   处理命令；
}while(“命令”=”退出”)
}
2)、栈模块——实现定义的抽象数据类型
3)、路径探索模块——实现探索迷宫路径
                    
路径探索模块
三、详细设计

(下面程序中也可以把搜索路径作为一个类。。。。)
程序代码如下
/////////////////////////////////////////////////////
/////////////LinkList.h文件//////////////////////////
#include
#include
using namespace std;
struct DataType       //定义描述迷宫中当前位置的结构类型
{
 int x;          //x代表当前位置的行坐标
 int y;          //y代表当前位置的列坐标
 int pre;        //pre表示移动到下一步的方向
};
struct Move         //定义下一个位置的方向
{
 int x;
 int y;
};
struct LinkNode      //链表结点
{
 DataType data;
 LinkNode *next;
};
//下面定义栈
class stack
{
private:
 LinkNode *top;           //指向第一个结点的栈顶指针
public:
 stack();              //构造函数，置空栈
 ~stack();             //析构函数
 void Push(DataType data);           //把元素data压入栈中
 DataType Pop();                  //使栈顶元素出栈
 DataType GetPop();               //取出栈顶元素
 void Clear();                   //把栈清空
 bool IsEmpty();        //判断栈是否为空，如果为空则返回1，否则返回0
};

/////////////////////////////////////
/////////LinkList.cpp文件////////////
#include"LinkList.h"
stack::stack()          //构造函数，置空栈
{
 top=NULL;
}
stack::~stack()         //析构函数
{
/* LinkNode *p=top;
 while(top!=NULL)
 {
  p=top;
  top=top->next;
 // delete p;
 }*/
 
}
void stack::Push(DataType x)          //把元素data压入栈中
{
 LinkNode *TempNode;
 TempNode=new LinkNode;
 TempNode->data=x;
 TempNode->next=top;
 top=TempNode;
}
DataType stack::Pop()                 //使栈顶元素出栈
{
 DataType Temp;
 LinkNode *TempNode;
 //if(top==NULL) return NULL;
// else
// {
  TempNode=top;
  top=top->next;
  Temp=TempNode->data;
  delete TempNode;
  return Temp;
// }
}
DataType stack::GetPop()               //取出栈顶元素
{
 return top->data;
}
void stack::Clear()                    //把栈清空
{
 top=NULL;
}
bool stack::IsEmpty()        //判断栈是否为空，如果为空则返回1，否则返回0
{
 if(top==NULL) return true;
 else return false;
}
////////////////////////////////////////////////////////
////////////////main.cpp文件////////////////////////////

#include"LinkList.h"
Move move[4]={{0,1},{1,0},{0,-1},{-1,0}};   //定义当前位置移动的4个方向
bool Mazepath(int **maze,int m,int n);     
     //寻找迷宫maze中从（0，0）到（m,n）的路径
     //到则返回true,否则返回false
void PrintPath(stack p);        //输出迷宫的路径
void Restore(int **maze,int m,int n);        //恢复迷宫
int** GetMaze(int &m,int &n);       //获取迷宫（可从文件中读取，也可输入）
                                 //返回存取迷宫的二维指针

int main()
{
 int m=0,n=0;       //定义迷宫的长和宽
 int **maze;        //定义二维指针存取迷宫
 maze=GetMaze(m,n);  //调用GetMaze(int &m,int &n)函数，得到迷宫
 if(Mazepath(maze,m,n)) //调用Mazepath(int **maze,int m,int n)函数获取路径
  cout<<"迷宫路径探索成功!/n";
 else cout<<"路径不存在!/n";
 return 0;
}

int** GetMaze(int &m,int &n)
                //获取迷宫（可从文件中读取，也可输入）
    //返回存取迷宫的二维指针
{
 int **maze;              //定义二维指针存取迷宫
 int i=0,j=0;
 char Choose;            //定义一个标志，选择读取文件或直接输入，获取迷宫
 cout<<"请选择从文件中读取文件(1)或重新输入(2):";
 cin>>Choose;           //输入标志
 if(Choose=='1')         //当标志Choose为‘1’时，读取文件
 {
     cout<<"文件里的数字化迷宫如下:/n";
  char ch;             //定义一个字符，读取文件中的内容
  i=0,j=0;
 //首先得到文件中数字字符的数目，并得到迷宫的长和宽
  ifstream fip("test.txt");   
           //定义一个文件对象，并打开文件“test.txt”
  while(fip.get(ch))        //从读取文件中内容（一个个字符）
  {
   if(ch>='0'&&ch<='9')  //获取文件中的数字字符
   {
    j++;               //如果是字符，宽就加1
   }
   if(ch=='/n')       
   {
    i++;           //如果是换行，就行加1
    n=j;          //得到宽，即列数
    j=0;       
   }
  }
  fip.close();    //读取文件结束
  m=i;             //得到长即行数
  maze=new int *[m+2];  //申请长度等于行数加2的二级指针
  for(i= 0;i  {
   maze[i]=new int[n+2];
  }
  i=j=1;
  ifstream fip2("test.txt");//重新读取文件，以得到内容
  while(fip2.get(ch))
  {
   if(ch>='0'&&ch<='9')
   {
    maze[i][j]=ch-'0';      //把数字字符转化为数字，并存到指针里
    cout<    j++;
   }
   if(ch=='/n')         //遇到换行，指针也相应换行
   {
    cout<    i++;
    j=1;
   }
  }
  fip2.close();        //读取结束
 }

 else           //Choose=2  ,输入迷宫
 {
  cout<<"请输入迷宫的长和宽:";
  int a,b;
  cin>>a>>b;             //输入迷宫的长和宽
  cout<<"请输入迷宫内容:/n";
  m=a;
  n=b;          //m,n分别代表迷宫的行数和列数
  maze=new int *[m+2];  //申请长度等于行数加2的二级指针
  for(i= 0;i  {
   maze[i]=new int[n+2];
  }
  for(i=1;i<=m;i++)          //输入迷宫的内容，1代表可通，0代表不通
   for(j=1;j<=n;j++)
    cin>>maze[i][j];
  cout<<"是否保存新迷宫？/n";
  char choose;
  cin>>choose;
  if(choose=='Y'||choose=='y')
  {
   char ch;
   ofstream fop("Newtest.txt");    
   for(i=1;i<=m;i++)
   {
    for(j=1;j<=n;j++)
    {
     ch='0'+maze[i][j];
     fop<    }
    fop<    flush(cout);
   }
   fop.close();
  }
 }
//给迷宫的四周加一堵墙，即把迷宫四周定义为1
 for(i=0;i  maze[i][0]=maze[i][n+1]=1;
 for(i=0;i  maze[0][i]=maze[m+1][i]=1;
 return maze;              //返回存贮迷宫的二维指针maze
}
bool Mazepath(int **maze,int m,int n)
          //寻找迷宫maze中从（0，0）到（m,n）的路径
           //到则返回true,否则返回false
{
 stack q,p;       //定义栈p、q,分别存探索迷宫的过程和存储路径
 DataType Temp1,Temp2;     
 int x,y,loop;
 Temp1.x=1;
 Temp1.y=1;
 q.Push(Temp1);           //将入口位置入栈
 p.Push(Temp1);
 maze[1][1]=-1;          //标志入口位置已到达过
 while(!q.IsEmpty())      //栈q非空，则反复探索
 {
  Temp2=q.GetPop();      //获取栈顶元素
  if(!(p.GetPop().x==q.GetPop().x&&p.GetPop().y==q.GetPop().y))
   p.Push(Temp2);        
     //如果有新位置入栈，则把上一个探索的位置存入栈p
  for(loop=0;loop<4;loop++)   //探索当前位置的4个相邻位置
  {
   x=Temp2.x+move[loop].x;     //计算出新位置x位置值
   y=Temp2.y+move[loop].y;      //计算出新位置y位置值
   if(maze[x][y]==0)         //判断新位置是否可达
   {
    Temp1.x=x;
    Temp1.y=y;
    maze[x][y]=-1;          //标志新位置已到达过
    q.Push(Temp1);         //新位置入栈
   }
   if((x==(m))&&(y==(n)))    //成功到达出口
   {
    Temp1.x=m;
    Temp1.y=n;
    Temp1.pre=0;
    p.Push(Temp1);       //把最后一个位置入栈
    PrintPath(p);        //输出路径
    Restore(maze,m,n);        //恢复路径
    return 1;            //表示成功找到路径
   }
  }
  if(p.GetPop().x==q.GetPop().x&&p.GetPop().y==q.GetPop().y)
        //如果没有新位置入栈，则返回到上一个位置
  {
   p.Pop();
   q.Pop();
  }
 }
 return 0;           //表示查找失败，即迷宫无路经
}
void PrintPath(stack p)        //输出路径
{
 cout<<"迷宫的路径为/n";
 cout<<"括号内的内容分别表示为(行坐标,列坐标,数字化方向,方向)/n";
 stack t;            //定义一个栈，按从入口到出口存取路径
 int a,b;
 DataType data;
 LinkNode *temp;
 temp=new LinkNode;         //申请空间
 temp->data=p.Pop();        //取栈p的顶点元素，即第一个位置
 t.Push(temp->data);  //第一个位置入栈t
 delete temp;         //释放空间
 while(!p.IsEmpty())    //栈p非空，则反复转移
 {
  temp=new LinkNode;
  temp->data=p.Pop();         //获取下一个位置
  //得到行走方向
  a=t.GetPop().x-temp->data.x;   //行坐标方向
  b=t.GetPop().y-temp->data.y;   //列坐标方向
  if(a==1) temp->data.pre=1;     //方向向下，用1表示
  else if(b==1) temp->data.pre=2; //方向向右，用2表示
  else if(a==-1) temp->data.pre=3;  //方向向上，用3表示
  else if(b==-1) temp->data.pre=4;  //方向向左，用4表示
  t.Push(temp->data);            //把新位置入栈
  delete temp;
 }
 //输出路径，包括行坐标，列坐标，下一个位置方向
 while(!t.IsEmpty())         //栈非空，继续输出
 {
  data=t.Pop();
  cout<<'('<  switch(data.pre)   //输出相应的方向
  {
  case 1:cout<<"↓)/n";break;
  case 2:cout<<"→)/n";break;
  case 3:cout<<"↑)/n";break;
  case 4:cout<<"←)/n";break;
  case 0:cout<<")/n";break;
  }
 }
}
void Restore(int **maze,int m,int n)       //恢复迷宫
{
 int i,j;
 for(i=0;i  for(j=0;j  {
   if(maze[i][j]==-1)         //恢复探索过位置，即把-1恢复为0
    maze[i][j]=0;
  }
}
四、调试分析
1、由于对迷宫路径探索的算法和二维指针的推敲不足，使程序调试时费时不少
2、本程序有些代码重复出现，从而减少了空间的利用率和增加了程序代码的杂乱性
3、本程序模块划分比较合理，且利用指针存储迷宫，操作方便。
4、算法的时空分析
    该算法的运行时间和使用系统栈所占有的存储空间与迷宫的大小成正比，在最好情况下的时间和空间复杂度均为O（m+n），在最差情况下均为O（m*n），平均情况在它们之间
5、本实验采用数据抽象的程序设计方法，将程序分为3个模块，使得设计时思路清晰，实现时调试可以顺利完成，各模块具有较好的可重用性，确实得到了一次良好的程序设计训练。
五、用户手册
1、本程序的运行环境为DOS操作系统
2、进入演示程序后即显示文本方式的用户界面
 
 
3、进入界面后，就会提示输入字符串的输入形式，结束符为“回车符”。
六、测试结果
    如上图所示。
七、附录
源程序文件名清单：
LinkList.h                    //元素结点定义单元
LinkList.cpp                  //链表实现单元
Main.cpp                          //主程序

 

四、实验总结（心得体会）
１、进一步熟悉掌握了有关栈的基本操作；
２、对迷宫有了更多的认识
４、更进一步掌握有关类的操作
5、由于对栈的算法推敲不足，使程序调试时费时不少
6、本程序有些代码重复出现，从而减少了空间的利用率和增加了程序代码的杂乱性

 

五、参考文献：
1、《数据结构与算法》    黄定  黄煜廉  刘贤兴  编著 
广东科技出版社  2000年1月第1版
2、《〈数据结构与算法〉学习与实验指导》  黄煜廉 编著   2005. 8
3、《数据结构辅导与提高》   徐孝凯  编著
            清华大学出版社        2003年12月第1版