数据结构学习记录-迷宫设计(最短路径)

原创 2012年03月24日 22:37:05

本程序主要是采用队列的思想,将4个方向的通路入队,然后依次先去,直到入口结束!!~~~~~~~~~~~~~~

 

定义头文件t11.h

 

#include"stdio.h"
#include"string.h"
#include"ctype.h"
#include"malloc.h"
#include"stdlib.h"  //atoi(),exit();
#include"io.h"      //eof()
#include"math.h"


#define  TRUE  1
#define  FALSE  0
#define  OK   1
#define  ERROR 0

typedef int Status;
typedef int Boolean;

 

定义队列的数据结构包含在m1.h头文件里

 

#define INIT_STACK_SIZE 40
#define STACK_ADD 10
#define INIT_QUEUE 100
#define INIT_ADD 40
typedef struct
{
 int road;
 int foot;
 int direct;
}migong,*mi;

typedef struct
{
 mi elem;      //  定义能够接受迷宫结构体指针的变量
 int size;     //  记录迷宫初始化大小
}ji,*hui;

typedef struct
{
 int i;           // 行
 int j;           // 列
}cun;

typedef struct     //  把位子放入栈中 线性表操作
{
 cun *top;
 cun *bottom;
 int stacksize;
} Sqstack;

typedef struct sq
{
 int i,j;               //存放前面的下标位置
 int i1,j1;           //  存放当前位置  
}sq;


typedef struct
{
 sq*front;
 sq*rear;
 int size;
}dui;

 

定义的实现函数代码(一些实现函数)定义在文件migong.cpp里

 

void initdui(dui &L)                   //  初始化队列   
{
    L.front=(sq*)malloc(INIT_QUEUE*sizeof(sq));
 L.rear=L.front;
 if(!L.front)
 {
  printf("内存分配失败!!");
  exit(1);
 }
 L.size=INIT_QUEUE;
 printf("初始化成功!! \n");
}

void enqueue(dui &L,int i,int j,int i1,int j1)            //   此队列针对迷宫先全部进完后再出,而设的顺序队列
{
 if(L.rear-L.front>L.size)  // 队列已满,追加空间
    {
  L.front=(sq*)realloc(L.front,(L.size+INIT_ADD)*sizeof(sq));
 if(!L.front)
 {
  printf("追加空间失败!!");
  exit(1);
 }
 }
 L.rear->i=i;
 L.rear->j=j;
 L.rear->i1=i1;
 (L.rear++)->j1=j1;


}


void initstack(Sqstack &L)            //  初始化栈操作
{
 L.bottom=(cun*)malloc(INIT_STACK_SIZE*sizeof(cun));
 if(!L.bottom)
 {
  printf("内存分配失败!!");
  exit(-1);
 }
 L.top=L.bottom;
    L.stacksize=INIT_STACK_SIZE;
}

Status push(Sqstack &L,int q,int p)          // 压入位置 q表示行,p表示列
{
 if(L.top-L.bottom >= L.stacksize)
 { L.bottom=(cun*)realloc(L.bottom,(L.stacksize+STACK_ADD)*sizeof(cun));
 if(!L.bottom)
 {
  printf("内存分配失败!!");
  exit(-1);
 }
 L.top=L.bottom+L.stacksize;
 L.stacksize+=STACK_ADD;
 }
   L.top->i=q;
 (L.top++)->j=p;

 return OK;
}

Status pop(Sqstack &L,int &k,int &l)    //   弹出 将栈顶的元素带回
{
 if(L.top == L.bottom)
   return ERROR;  
   k=(--L.top)->i;            //  这点自己犯的问题  不能--L.top->i  这样就表示值减1  没意义,出错
   l=L.top->j;
   return OK;
}

 Status emptystack(Sqstack L)         //  判断栈为空
{
 if(L.top == L.bottom)
  return OK;
 else
  return ERROR;
}

void init(ji &L)                               //   初始化数据
{
 printf("输入迷宫的大小:");
 scanf("%d",&L.size);
 L.size+=2;
 L.elem=(mi)malloc(L.size*L.size*sizeof(migong));
 if(!L.elem)
 {
  printf("分配内存失败!!");
  exit(1);
 }
 printf("初始化成功!\n");
}

void print(ji L)
{
  int m;
     printf("打印输出!!\n\n");
     m=L.size*L.size;
 for(int i=0;i<m;i++)
 {
        if((i+1)%L.size != 1 && (i+1)%L.size != 0 && i>L.size-1 && i<m-L.size+1)
   printf("%-4d",(L.elem+i)->road);
  
  if((i+1)%L.size == 0 && i>L.size && i<m-L.size-1)

  
   printf("\n\n");
  
  
 
 }
 printf("\n");
}

void shuru(ji &L)
{
 int m=L.size*L.size;
 for(int i=0;i<m;i++)
 {
  (L.elem+i)->direct=1;
        (L.elem+i)->foot=0;
  if((i+1)%L.size == 1 || (i+1)%L.size == 0 || i<=L.size-1 || i>=m-L.size+1)
   (L.elem+i)->road=0;
        else
   (L.elem+i)->road=1;    //  表示通路,初始化全部为
 }
    print(L);
    printf("设置墙:\n");
 printf("输入迷宫的行和列:");
 int k,j;
 char ch='y';
 while('y' == ch || 'Y' == ch)
 {
         scanf("%d%d",&k,&j);
   (L.elem+k*L.size+j)->road=0;
   printf("是否继续(Y/y):");
   getchar();
   ch=getchar();
 }
 print(L);
}


void shituan(ji &L,int z,int x,int &m,int &n)   //  判断方向
{  

 switch((L.elem+L.size*z+x)->direct)     //  线性表中位置的转换
 {
 case 1:m=z,n=x+1;break;
 case 2:m=z+1,n=x;break;
 case 3:m=z,n=x-1;break;
 case 4:m=z-1,n=x;break;
 }
}

void chuli(ji &L,dui &T)
{
 int m=1,n=1,i=1,j=1;
 int q=0,p,t;
 sq*w=T.front-1,*r;
 printf("开始执行!!");
 enqueue(T,1,1,1,1);
 (L.elem+L.size+1)->foot=1;
   t=1;

 while(m != L.size-2 || n != L.size-2)   //   循环条件是不是最后一个位置
 {
    //  printf("进入循环!!");
       //  getchar();
    r=w;
   q=0; 
  for(p=1;p<=t;p++)
  {
  
   w++;         //  查询入队元素的位置,不停的更新
   i=w->i;      //  取得已经入队元素的当前位置坐标
   j=w->j;
          while((L.elem+L.size*i+j)->direct <= 4)      //  寻找4个方位 满足条件的位置
    {
                 // printf("进入内部循环!!");
                    shituan(L,i,j,m,n);
                           if((L.elem+L.size*m+n)->road != 0 && (L.elem+L.size*m+n)->foot != 1)   // 该位置不是墙也不是已经走过的路径
         {
                       enqueue(T,m,n,i,j);                  //  压入位置
                       q++;                         //  入队元素个数记录
                       (L.elem+L.size*m+n)->foot=1; 

[数据结构]求解迷宫最短路径问题

一、问题概述        之前,我们了解了如何实现迷宫问题(对于迷宫只有一个出口可以通的情况),事实上我们的迷宫有多个出口,对于每条路径来说,有长有短,所以在这里,我们讨论一下迷宫的最短路径,...
  • xxpresent
  • xxpresent
  • 2016年12月08日 16:23
  • 1532

迷宫最短路径问题解析

有一个二维数组,0表示路,-1表示墙,求其中任意两点的最短路径。 我们先看,怎么求一条路径:求两点路径是一个数据结构上的典型的迷宫问题,很多数据结构的书上都有介绍,解决办法如下: 从一点开...
  • a1259109679
  • a1259109679
  • 2015年08月29日 09:47
  • 7106

用栈解决迷宫问题(输出所有路径和最短路径)

#include #define M 8 //行数 #define N 8 //列数 #define MaxSize 100 //栈最多元素个数 int mg[M+2][N+...
  • qq_34216631
  • qq_34216631
  • 2016年10月20日 20:56
  • 2737

迷宫问题 与 最短路径 怎样记录路径的总结(dijikstra,bfs,floyd,优先队列)

这次集训做了几个关于记录路径的问题,大体基于迪杰斯特拉(dijikstra)和弗洛伊德(floyd)算法还有BFS广搜。 记录前驱要比记录后驱更保险,因为从终点往起点追溯很容易,而从起点往后追溯有很多...
  • winter2121
  • winter2121
  • 2017年03月15日 20:28
  • 682

迷宫最短路径长度bfs

#include #include using namespace std; struct note { int x;//横坐标 int y;//纵坐标 int f;//父亲在队列中的编号,用于...
  • acm_JL
  • acm_JL
  • 2016年03月11日 10:53
  • 1770

POJ 3984 迷宫问题(BFS:迷宫最短路径且输出路径)

POJ 3984 迷宫问题(BFS:迷宫最短路径且输出路径) http://poj.org/problem?id=3984 分析: 典型的BFS应用,要你求从左上角到右下角的最短路径,且保证有唯一解,...
  • u013480600
  • u013480600
  • 2014年05月10日 15:51
  • 3140

广度优先搜索迷宫的最短路径走法!

引用自我的上一篇博客:用DFS实现的走迷宫,这里用BFS再走一遍! 感觉最近快迷失在迷宫里面了!可怕。。。 不说了上代码,有问题希望大神们指出来!虚心接受! import java.ut...
  • Divide_
  • Divide_
  • 2016年04月25日 23:23
  • 1422

迷宫的最短路径(按c++的python改写)

下面是代码,结果有点问题,明天再改改 # -*- coding: utf-8 -*- """ Created on Mon Aug 28 22:12:01 2017 @author: Ad...
  • wuzhouqingcy
  • wuzhouqingcy
  • 2017年08月28日 22:24
  • 480

数据结构学习记录-迷宫设计

迷宫程序设计是第三个实验,思想是不停的试探,然后标记判断出路的过程 一般自己习惯把头文件全部放在一个文件里名为t11.h   #include"stdio.h" #include"string...
  • wu10045125
  • wu10045125
  • 2012年03月24日 22:34
  • 575

迷宫的最短路径之BFS算法

给定一个大小为N*M的迷宫,由通道('.')和墙壁('#')组成,其中通道S表示起点,通道G表示终点,每一步移动可以达到上下左右中不是墙壁的位置。试求出起点到终点的最小步数。(本题假定迷宫是有解的)(...
  • lrgdongnan
  • lrgdongnan
  • 2016年06月28日 10:19
  • 9563
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:数据结构学习记录-迷宫设计(最短路径)
举报原因:
原因补充:

(最多只允许输入30个字)