精华内容
下载资源
问答
  • 数据结构迷宫求解

    2014-12-02 21:44:57
    数据结构 迷宫求解问题 数据结构课程设计源代码 txt格式
  • 迷宫求解的源码 以一个 m*n 的长方阵表示迷宫,0 和 1 分别表示迷宫中的通路和障碍。设计一个程序,对任意设 定的迷宫,求出一条从入口到出口的通路,或得出没有通路的结论。
  • C语言数据结构迷宫求解 最近在学数据结构,然后在迷宫求解问题上,在网上搜索到的代码写的不够详细,所以打算写一下详细一点的代码,尽量包含一些完整的注释,帮助大家理解。下面贴出代码 这份代码使用的是回溯法来...

    C语言数据结构迷宫求解

    最近在学数据结构,然后在迷宫求解问题上,在网上搜索到的代码写的不够详细,所以打算写一下详细一点的代码,尽量包含一些完整的注释,帮助大家理解。下面贴出代码

    这份代码使用的是回溯法来求解,回溯法就是沿这一个方向进行探索,如果失败,则原路返回,如果可以走通,则继续往下走。

    #include <stdio.h>
    #include <stdlib.h>
    #include<malloc.h>
    typedef struct Data {
    	int x;
    	int y;
    	int k;							//这是下一步走的方向(与主函数里的move[][0]对应,move二维数组里的x位)
    
    } data;							//数据结构体,记录迷宫走的坐标
    
    typedef struct StackTop {
    	data* d;
    	int top;				//栈顶
    	int size;			//栈的大小
    
    }Stack;					//栈的结构体
    
    
    void CreateStacks(Stack **p)					//创建栈
    {
    	Stack *top = NULL;
    	top = (Stack*)malloc(sizeof(struct StackTop));
    	if (top == NULL)
    	{
    		printf("Create failed\n");
    		exit(0);
    	}
    	else
    	{
    		top->d = (data*)malloc(100 * sizeof(data));			//这个100是为了创建较大一点的线性表
    		top->top = -1;					//在寻找路径时会先进行入栈,所以初始化为-1
    		top->size = 100;				//往大的方面写,以免不够用
    	}
    	*p = top;
    
    }
    
    int IsEmpty(Stack *p)			//判断栈是否为空
    {
    	if (p->top == -1)
    	{
    		printf("NULL\n");
    		return 1;
    	}
    	else {
    		return 0;
    	}
    
    }
    
    
    void Push(Stack **p, data x)					//入栈
    {
    	data s;
    	Stack* top;
    	top = *p;
    	if (top->top == top->size - 1)				//因为top是记录数组下标的,所以是从0开始记录,而size从1开始记录
    	{
    		printf("FULL\n");
    		exit(0);
    	}
    	else
    	{
    		top->top++;							//栈顶加一
    		top->d[top->top] = x;					//入栈
    	}
    
    }
    
    void Pop(Stack **p)
    {
    	Stack* top;
    	top = *p;
    	if (IsEmpty(top))
    	{
    		exit(0);
    	}
    	else
    	{
    		top->top--;
    
    	}
    
    }
    
    data getStackTop(Stack *top)					//取栈顶首元素
    {
    	if (top->top == -1)
    	{
    		printf("NULL\n");
    
    	}
    	else
    	{
    		return top->d[top->top];
    	}
    
    }
    
    void Path(int maze[][12], int mark[][12], int x1, int y1, int x2, int y2, Stack **p, int diretction[8][2])
    {
    	Stack* top;
    	top = *p;
    	int dir;								//下一步要走的方向
    	int dir1, dir2, dir3, dir4;				//dir3与dir4为dir1,dir2两个当前坐标加上diretction数组的移动坐标得到的移动后的坐标
    	int flag = 0;
    	data s;
    	data s1;
    	s.x = x1;
    	s.y = y1;
    	s.k = -1;
    
    	mark[x1][y1] = 1;
    	Push(&top, s);
    
    	while (!IsEmpty(top))
    	{
    		s1 = getStackTop(top);
    		Pop(&top);
    		dir1 = s1.x;               //dir1为移动前坐标
    		dir2 = s1.y;				//dir2为移动前坐标
    		dir = s1.k + 1;				//拿到diretction二维数组的前一个下标,等价于方向,因为diretction只需要第一个下标变化
    		while (dir <= 7)
    		{
    
    			dir3 = dir1 + diretction[dir][0];     //dir3与dir4为dir1,dir2两个当前坐标加上diretction数组的移动坐标得到的移动后的坐标
    			dir4 = dir2 + diretction[dir][1];
    			if (maze[dir3][dir4] == 0 && mark[dir3][dir4] == 0)                  //迷宫路径为0,且当前位置没走过
    			
    			{
    				mark[dir3][dir4] = 1;								//记录走过路径
    				s1.x = dir1;										//覆盖位置
    				s1.y = dir2;
    				s1.k = dir;
    				Push(&top, s1);									//入栈
    				dir1 = dir3;									//当前位置更替为之前移动的位置
    				dir2 = dir4;
    				dir = -1;
    			}
    			if (dir3 == x2 && dir4 == y2)			//如果抵达终点,进行出栈,将路径打印出来
    			{
    				printf("The revers path is:\n");
    				while (!IsEmpty(top))
    				{
    					s = getStackTop(top);
    
    					printf("the node is :%d  %d\n", s.x, s.y);
    					Pop(&top);
    
    				}
    				flag = 1;							//标志符,将外面的循环结束
    				break;
    
    			}
    
    			dir++;
    		}
    		if (flag == 1)    //将外面的循环结束
    		{
    			break;
    		}
    	}
    }
    
    
    int main()
    {
    	Stack *p = NULL;
    	int maze[12][12] = {
    	{1,1,1,1,1,1,1,1,1,1,1,1},
    	{1,0,1,1,1,0,0,0,0,0,0,1},
    	{1,0,0,0,1,0,0,0,1,0,0,1},
    	{1,0,1,0,1,1,0,0,1,0,0,1},
    	{1,0,1,0,0,1,0,1,1,0,0,1},
    	{1,0,1,0,0,1,0,1,1,0,0,1},
    	{1,1,1,1,0,1,0,1,0,0,0,1},
    	{1,0,0,1,0,0,0,1,0,1,1,1},
    	{1,0,0,1,0,0,0,1,0,1,1,1},
    	{1,0,1,1,0,1,0,1,0,0,0,1},
    	{1,0,0,0,0,1,0,1,1,1,0,1},
    	{1,1,1,1,1,1,1,1,1,1,1,1} };	//迷宫是10*10,但是为了方便,不让节点走出迷宫范围外,选择12*12,在迷宫周围布上一层“围墙“(0是路径,1是墙)
    	int x = 1, y = 1;     //迷宫起点
    	int mark[12][12];		//这是记录路径的表,记录走过的路径
    	for (int i = 0; i < 12; i++)
    	{
    		for (int j = 0; j < 12; j++)				//因为懒得一个个输入0了,所以直接初始化了。
    		{
    			mark[i][j] = 0;
    		}
    	}
    	int move[8][2] = { {0,1} ,{1,0},{-1,0} ,{0,-1},{1,1},{1,-1},{-1,1},{-1,-1} };			//行走的方向
    	int x1 = 10, y1 = 10;				//终点
    	CreateStacks(&p);					//创建栈
    	Path(maze, mark, x, y, x1, y1, &p, move);		//寻找路径
    	return 0;
    }
    
    
    展开全文
  • 数据结构实验报告 迷宫求解问题实验 上机环境 DevC++ 二程序设计相关信息 1实验题目迷宫求解问题 问题描述 实验题3.5 改进3.1.4节中的求解迷宫问题程序要求输出如图3.14所示的迷宫的所有路径并求最短路径长度及最短...
  • 数据结构迷宫求解问题论文, 用战来实现迷宫的求解问题
  • C语言 栈 数据结构 迷宫求解(附完整代码)

    万次阅读 多人点赞 2018-11-15 20:20:49
    要求:以书中3.2.4节迷宫求解为基础实现迷宫游戏,游戏运行时显示一个迷宫地图(迷宫内容结构可以参照书中图片,也可以自己编写),玩家从地图左上角的入口处进入迷宫,从右下角出口离开迷宫。玩家不能穿墙而过。本...

    一、程序设计思路

    1、题目:应用栈实现迷宫游戏

    要求:以书中3.2.4节迷宫求解为基础实现迷宫游戏,游戏运行时显示一个迷宫地图(迷宫内容结构可以参照书中图片,也可以自己编写),玩家从地图左上角的入口处进入迷宫,从右下角出口离开迷宫。玩家不能穿墙而过。

    2、解决思路

    采用“穷举求解”方法,需要用到栈,从入口开始,往四个方向走,依次将走过的坐标点–入栈;如果走到“死路”,就出栈;一一循环;最后栈中保存的就是出迷宫的路线。

    3、算法描述

    求迷宫中一条从入口到出口的路径的算法可简单描述如下:

    设当前位置的初值为入口位置;

    do{
    若当前位置可通,
    则{
    将当前位置压至栈顶; //纳入路径
    如果当前位置是出口位置,则结束;
    否则切换当前位置的东邻方块为新的当前位置;
    }
    否则,
    若栈不为空且栈顶位置尚有其他方向未经探索,
    则设定新的当前位置为沿顺时针方向旋转找到的栈顶位置的下一相邻方块;
    若栈不为空且栈顶位置的四周均不可通,
    则{
    删去栈顶位置;
    若栈不为空,则重新测试新的栈顶位置,
    直至找到一个可通的相邻块或者出栈至栈空;
    }
    }while(栈不为空);

    二、程序源代码
    栈部分

    
    
    
    #include "stdafx.h"                //包含标准C的头文件,stdio.h,string.h等
    
    #include <malloc.h>               //动态储存分配函数头文件,用于栈的储存空间分配
    
    #include <stdlib.h>               //standard library标准库头文件
    
    typedef int DirectiveType;        //下一个通道方向  
    
    #define RANGE 100                 //迷宫大小  
    
    #define STACK_INIT_SIZE 100       //定义栈的初始大小
    
    #define STACKINCREMENT    10      //定义栈的储存增量,在栈长度越界时
    
    typedef int DirectiveType;        //下一个通道方向  
    
    #define RANGE 100                 //迷宫大小  
    
    #define ROW 10                    //迷宫的行数
    
    #define COL 10                    //迷宫的列数    
    
     
    
    typedef struct        
    
    {
    
        int m, n;
    
        int arr[RANGE][RANGE];       //迷宫数组
    
    }MazeType;                       //迷宫的类型
    
     
    
    typedef struct
    
    {
    
        int row;                     //迷宫中的行
    
        int col;                     //迷宫中的列
    
    }PosType;                        //坐标(row,col)
    
     
    
    typedef struct
    
    {
    
        int step;                    //当前位置在路径上的"序号"
    
        PosType seat;                //当前的坐标位置
    
        DirectiveType di;            //往下一个坐标位置的方向
    
    }SElemType;                      //栈的元素类型
    
     
    
    typedef struct
    
    {
    
        SElemType *base;             //栈底
    
        SElemType *top;              //栈顶
    
        int stacksize;               //栈的大小
    
    }SqStack;                        //定义栈
    
     
    
    bool InitStack(SqStack &s)
    
    {                                //栈的初始化
    
        s.base = (SElemType
    *)malloc(STACK_INIT_SIZE * sizeof(SElemType));
    
        if (!s.base)
    
        {
    
           exit(-2);
    
        }
    
        s.top = s.base;
    
        s.stacksize = STACK_INIT_SIZE;
    
        return true;
    
    }
    
     
    
    bool GetTop(SqStack s, SElemType &e)  
    //当栈s不为空时,返回栈顶e
    
    {
    
        if (s.top == s.base)
    
           return false;
    
        e = *(s.top - 1);
    
        return true;
    
    }
    
     
    
    bool Push(SqStack &s, SElemType e)    
    //在栈s中插入元素e,入栈
    
    {
    
        if (s.top - s.base >=
    s.stacksize)
    
        {                                 //若栈满,追加存储空间
    
           s.base = (SElemType
    *)realloc(s.base, (s.stacksize + STACKINCREMENT) * sizeof(SElemType));
    
           if (!s.base)
    
               exit(-2);  
    
           s.top = s.base + s.stacksize;
    
           s.stacksize += STACKINCREMENT;
    
        }
    
        *s.top++ = e;
    
        return true;
    
    }
    
     
    
    bool Pop(SqStack &s, SElemType &e)     //在栈s中删除栈顶,出栈
    
    {
    
        if (s.top == s.base)               //当栈空时
    
           return false;                  //返回错误
    
        e = *--s.top;                      //e指向新栈顶
    
        return true;
    
    }
    
     
    
    bool StackEmpty(SqStack s)            
    //栈判空
    
    {
    
        return s.base == s.top;            
    
    }
    
     
    
    bool DestoryStack(SqStack &s)         
    //销毁栈
    
    {
    
        free(&s);                          //释放栈s的储存空间
    
        return true;
    
    }
    
    
    

    迷宫部分

    
    
    bool InitMaze(MazeType &maze, int a[ROW][COL], int row, int col)  //初始化迷宫
    
    {
    
        int i, j;                            //设置迷宫maze的初值,包括加上边缘一圈的值
    
        for (i = 1; i<row - 1;
    i++)         
    
        {
    
           for (j = 1; j<col - 1; j++)
    
           {
    
               maze.arr[i][j] = a[i][j];
    
           }
    
        }                                          
    
        for (j = 0; j<row; j++)                     //加上围墙
    
           maze.arr[0][j] = maze.arr[row
    - 1][j] = 1;
    
        for (i = 0; i<col; i++)
    
           maze.arr[i][0] =
    maze.arr[i][col - 1] = 1;
    
        return true;
    
    }
    
     
    
    bool Pass(MazeType maze, PosType curpos)
    
    {                                                 
    //判断当前节点是否通过
    
        if (maze.arr[curpos.row][curpos.col]
    == 0)     //当节点为0时返回真
    
           return true;
    
        else
    
           return false;
    
    }
    
     
    
    bool FootPrint(MazeType &maze, PosType curpos)
    
    {                                                  
    //留下足迹
    
        maze.arr[curpos.row][curpos.col]
    = 2;           //走过且走得通
    
        return true;
    
    }
    
     
    
    bool MarkPrint(MazeType &maze, PosType curpos)
    
    {                                                  
    //留下不能通过的标记
    
        maze.arr[curpos.row][curpos.col]
    = 3;           //走过但走不通
    
        return true;
    
    }
    
     
    
    SElemType CreateSElem(int step, PosType pos, int di)
    
    {                                                   
    //创建元素e
    
        SElemType e;
    
        e.step = step;
    
        e.seat = pos;
    
        e.di = di;
    
        return e;
    
    }
    
     
    
    PosType NextPos(PosType curpos, DirectiveType di)   //curpos当前位置
    
    {                                                  
    //返回当前节点的下一节点
    
        PosType pos = curpos;
    
        switch (di)
    
        {
    
        case 1:        //右
    
           pos.col++;
    
           break;
    
        case 2:        //下
    
           pos.row++;
    
           break;
    
        case 3:        //左
    
           pos.col--;
    
           break;
    
        case 4:        //上
    
           pos.row--;
    
           break;
    
        }
    
        return pos;
    
    }
    
     
    
    bool PosEqual(PosType pos1, PosType pos2)
    
    {                                               
    //判断是不是出口
    
        if (pos1.row == pos2.row
    && pos1.col == pos2.col)    
    
           return true;                            
    
        else
    
           return false;
    
    }
    
     
    
    void PrintMaze(MazeType maze, int row, int col)
    
    {                                               
    //打印路径
    
        int i, j;
    
        printf(" ");
    
        for (i = 0; i<col; i++)                    //打印列数名
    
           printf("%d ", i);
    
        printf("\n");
    
        for (i = 0; i<row; i++)
    
        {
    
           printf("%d",
    i);                      //打印行数名
    
           for (j = 0; j<col; j++)
    
           {
    
               switch (maze.arr[i][j])
    
               {
    
               case 0:
    
                  printf("  ");                 //没走过,但是通路
    
                  break;
    
               case 1:
    
                  printf("■");                  //墙,障碍物
    
                  break;
    
               case 2:
    
                  printf("*
    ");                 //走过且走得通
    
                  break;
    
               case 3:
    
                  printf("@
    ");                 //走过但走不通,死胡同
    
                  break;
    
               default:
    
                  break;
    
               }
    
           }
    
           printf("\n");
    
        }
    
    }
    
     
    
    bool MazePath(MazeType &maze, PosType start, PosType end)
    
    {                               //求解迷宫maze中,从入口start到出口end的一条路径
    
        SqStack s;                  //定义栈
    
        SElemType e;            
    
        InitStack(s);               //初始化栈
    
        PosType curpos = start;             
    
        int curstep = 1;                                //探索第一步
    
        do {
    
           if (Pass(maze, curpos))
    
           {    //如果当前位置可以通过,即是未曾走到的通道块
    
               FootPrint(maze,
    curpos);                //留下足迹
    
               e = CreateSElem(curstep,
    curpos, 1);    //创建元素
    
               Push(s, e);                             //加入路径
    
               if (PosEqual(curpos,
    end))              //到达终点(出口)
    
                  return true;                        
    
               curpos = NextPos(curpos,
    1);            //获得下一节点
    
               curstep++;                              //探索下一步
    
           }
    
           else 
    
           {                                           //当前位置不能通过
    
               if (!StackEmpty(s))
    
               {
    
                  Pop(s, e);
    
                  while (e.di == 4
    && !StackEmpty(s)) //找寻了四个方向
    
                  {
    
                      MarkPrint(maze,
    e.seat);
    
                      Pop(s, e);                      //留下不能通过的标记,并退回一步
    
                  }
    
                  if (e.di<4)
    
                  {
    
                      e.di++;                         //换一个方向探索
    
                      Push(s, e);
    
                      curpos =
    NextPos(e.seat, e.di); //设定当前位置是该方向上的相邻块
    
                  }
    
               }
    
           }
    
        } while (!StackEmpty(s));
    
        return false;
    
    }
    
     
    
    
    

    主函数部分

    
    
    int main()                   //迷宫求解主函数
    
    {
    
        int i, j;                
    
        PosType start, end;      //开始,终点坐标
    
        MazeType maze;           
    
        int a[ROW][COL] = {                 //原始迷宫,其中'1'表示墙,'0'表示通道
    
           { 1,1,1,1,1,1,1,1,1,1 },
    
           { 1,0,0,1,0,0,0,1,0,1 },
    
           { 1,0,0,1,0,0,0,1,0,1 },
    
           { 1,0,0,0,0,1,1,0,0,1 },
    
           { 1,0,1,1,1,0,0,0,0,1 },
    
           { 1,0,0,0,1,0,0,0,0,1 },
    
           { 1,0,1,0,0,0,1,0,0,1 },
    
           { 1,0,1,1,1,0,1,1,0,1 },
    
           { 1,1,0,0,0,0,0,0,0,1 },
    
           { 1,1,1,1,1,1,1,1,1,1 }
    
        };
    
        printf("\n-------------------------------------------------\n");
    
        printf("\n原始迷宫如下:\n");
    
        printf("(其中'1'表示墙,'0'表示通道)\n");
    
        for (i = 0; i<10; i++)           //双重循环输出原始迷宫
    
        {
    
           for (j = 0; j<10; j++)
    
           {
    
               printf("%d ",
    a[i][j]);
    
           }
    
           printf("\n");
    
        }
    
        InitMaze(maze, a, ROW, COL);                 //初始化迷宫
    
        start.row = 1;                               //给定迷宫起点坐标
    
        start.col = 1;                               //(1,1)
    
        end.row = 8;                                 //给定迷宫终点坐标   
    
        end.col = 8;                                 //(8,8)
    
        if (MazePath(maze, start,
    end))              //如果找到一条路径
    
        {
    
           printf("\n-------------------------------------------------\n");
    
           printf("\n穷举法求解迷宫路径如下:\n");
    
           printf("(其中'*'表示求解路径,'@'表示死胡同)\n");
    
           PrintMaze(maze, ROW,
    COL);               //输出迷宫路径
    
        }
    
        else                                         //否则,没有通路
    
           printf("\n---------从入口到出口没有通路!-----\n");
    
    }
    
    
    

    三、运行结果
    迷宫求解

    附:源代码链接迷宫求解源代码

    展开全文
  • 数据结构 课程设计 迷宫求解代码。使用C/C++编写。
  • c语言数据结构迷宫求解 严蔚敏版 使用栈和结构体
  • 初学数据结构和C语言,尝试实现了迷宫求解问题。代码组织比较差,改进的地方也有很多,博君一乐而已。希望能够帮助到别人
  • 数据结构 迷宫求解 C++ 数据结构 迷宫求解 C++ 数据结构 迷宫求解 C++
  • 自己做的,感觉还可以,数据结构迷宫求解,主要用了C++来编程。
  • 数据结构 迷宫求解

    2011-12-21 23:56:04
    代码的注释几乎每行都有 很容易看懂程序 代码质量很高
  • 数据结构 - 迷宫求解

    2021-03-07 23:41:25
    迷宫求解 #include <stdio.h> #include<stdlib.h> int mg[10][10]= {{1,1,1,1,1,1,1,1,1,1}, {1,0,0,1,0,0,0,1,0,1}, {1,0,0,1,0,0,0,1,0,1}, {1,0,0,0,0,1,1,0,0,1}, {1,0,1,1,1,0,0,0,0,1}, {1,0...

    迷宫求解

    #include <stdio.h>
    #include<stdlib.h>
    int mg[10][10]= {{1,1,1,1,1,1,1,1,1,1},
        {1,0,0,1,0,0,0,1,0,1},
        {1,0,0,1,0,0,0,1,0,1},
        {1,0,0,0,0,1,1,0,0,1},
        {1,0,1,1,1,0,0,0,0,1},
        {1,0,0,0,1,0,0,0,0,1},
        {1,0,1,0,0,0,1,0,0,1},
        {1,0,1,1,1,0,1,1,0,1},
        {1,1,0,0,0,0,0,0,0,1},
        {1,1,1,1,1,1,1,1,1,1}
    };//地图
    int M=8;//行数
    int N=8;//列数
    typedef struct
    {
        int i;//当前方块行号
        int j;//当前方块列号
        int di;//下一个可走的相邻方块的方位号
    } Box; //定义方块类型
    typedef struct
    {
        Box data[100];
        int top;//栈顶指针
    } StType; //定义顺序栈类型
    bool mgpath(int xi,int yi,int xe,int ye)//求解路径为:(xi,yi)->(xe,ye)
    {
        int i,j,k,di,find;
        StType st;//定义栈st
        st.top=-1;//初始化栈顶指针
        st.top++;//初始方块进栈
        st.data[st.top].i=xi;
        st.data[st.top].j=yi;
        st.data[st.top].di=-1;
        mg[xi][yi]=-1;
        while(st.top>-1)//栈不为空时循环
        {
            i=st.data[st.top].i;
            j=st.data[st.top].j;
            di=st.data[st.top].di;//取栈顶方块
            if(i==xe&&j==ye)//找到出口,输出路径
            {
                printf("迷宫路径如下:\n");
                for(k=0; k<=st.top; k++)
                {
                    printf("(%d,%d)\t",st.data[k].i,st.data[k].j);
                    if((k+1)%5==0)
                        printf("\n");
                }
                printf("\n");
                return true;
            }
            find=0;
            while(di<4&&find==0)//站下一个可走方块
            {
                di++;
                switch(di)
                {
                case 0:
                    i=st.data[st.top].i-1;
                    j=st.data[st.top].j;
                    break;
                case 1:
                    i=st.data[st.top].i;
                    j=st.data[st.top].j+1;
                    break;
                case 2:
                    i=st.data[st.top].i+1;
                    j=st.data[st.top].j;
                    break;
                case 3:
                    i=st.data[st.top].i;
                    j=st.data[st.top].j-1;
                    break;
                }
                if(mg[i][j]==0)
                    find=1;//找下一个可走相邻方块
            }
            if(find==1)//找到了下一个可走方块
            {
                st.data[st.top].di=di;//修改原栈顶元素的di值
                st.top++;//下一个可走方块进栈
                st.data[st.top].i=i;
                st.data[st.top].j=j;
                st.data[st.top].di=-1;
                mg[i][j]=-1;//避免重复走到该方块
            }
            else//没有路径可走则退栈
            {
                mg[st.data[st.top].i][st.data[st.top].j]=0;//让该位置变为其他路径可走方块
                st.top--;//将该方块退栈
            }
        }
        return false;
    }
    int main()
    {
        if(!mgpath(1,1,M,N))
            printf("无解");
        return 0;
    }
    
    
    展开全文
  • 数据结构迷宫代码

    2017-12-07 20:45:01
    首先实现一个以链表作存储结构的栈类型,然后编写一个求解迷宫的非递归程序。求得的通路以 三元组(i,j,d)的形式输出,其中(i,j)指示迷宫中的一个位置(行号和列号),d 表示走到下一 位置的方向(对于迷宫中...
  • 数据结构课程设计】迷宫求解(含源代码)VC6.0 C/C++ 可运行
  • 数据结构迷宫求解问题,清华大学严蔚的教材的迷宫问题求解代码。
  • 数据结构里的迷宫求解。严蔚敏书里的迷宫求解,是用C语言写的,简单易懂。迷宫随机生成。
  • 数据结构 C语言 迷宫问题求解 栈 针对严蔚敏 吴伟民编著的数据结构(C语言版)中讲到栈的时候,会有一个迷宫求解的实验题,我写了一下,然后希望对别人有帮助……运行环境visual studio 2012
  • 根据书中的伪代码实现的迷宫求解,但是并不是最优解,适合刚开始学栈的同学参考 #include #include #include #include #define TURE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASINLE -1 #...
  • 迷宫求解代码 #include<stdio.h> #include<windows.h> //迷宫坐标位置类型 #define MAXSIZE 12 //迷宫的行数和列数最多为10 struct Location{ //坐标 int x; int y; }; struct Location begin; //...

    迷宫求解代码

    #include<stdio.h>
    #include<windows.h> //迷宫坐标位置类型
    #define MAXSIZE 12  //迷宫的行数和列数最多为10 
    struct Location{    //坐标  
        int x;
        int y;
    }; 
    
    struct Location begin; //起点
    struct Location end;   //终点 
    struct Location next; //下一个位置
    struct Location dom[4]={{0,1},{1,0},{0,-1},{-1,0}}; //移动方向,依次为东南西北
    
    typedef int Maze[MAXSIZE][MAXSIZE];
    Maze m;
    
    int row,col;//行和列数 
    
    
    void Print(int row,int col)//定义墙元素值为0,可通过路径为-1,通过路径为足迹
    {
        int i,j;
        for(i=0;i<=row+1;i++)
    	{
            for(j=0;j<=col+1;j++)
                printf("%3d",m[i][j]);
            printf("\n");
        }
        printf("\n"); 
    }
    
    
    void Seek(struct Location now,int nowstep)//递归找下一点 
    {
        int i;
        for(i=0;i<=3;i++) { //依次试探东南西北四个方向
            next.x=now.x+dom[i].x;
            next.y=now.y+dom[i].y; 
            if(m[next.x][next.y] == -1){
                m[next.x][next.y]=++nowstep;
                if(next.x != end.x || next.y != end.y)
                    Seek(next,nowstep); // 试探下一点(递归调用)
                else
                    Print(row,col);
                m[next.x][next.y]=-1; //恢复为通路,试探下一条路
                nowstep--;
            }
        }
    }
    
    
    int main()
    { 
        int i,j,num,x1,y1;
        printf("注:行数和列数不包含外墙\n "); 
        printf("请输入迷宫的行数和列数(不超过10): \n"); //外围墙不计入,自动生成 
        scanf("%d %d" ,&row,&col);
        for(i=0;i<=col+1;i++)
    	{ 
            m[0][i]=0;  //上边墙
            m[row+1][i]=0;//下边墙
        }
        for(j=1;j<=row;j++)
    	{
            m[j][0]=0;  //左边墙
            m[j][col+1]=0;//右边墙
       }
        for(i=1;i<=row;i++) //最初迷宫内没有墙 
    	{
            for(j=1;j<=col;j++)
                m[i][j]=-1; //定义通道初值为-1
        } 
        printf("请输入迷宫内墙的个数: \n");
        scanf("%d", &num);
        if(num)
            printf("请输入迷宫内每个墙所在的位置(行和列): \n");
        for(i=1;i<=num;i++)
    	{
            scanf("%d %d" ,&x1,&y1);
            m[x1][y1]=0;
        }
        printf("生成迷宫:\n");
        Print(row,col);
        printf("请输入起点的位置(行和列):\n ");
        scanf("%d%d",&begin.x,&begin.y); 
        printf("请输入终点的位置(行和列): \n");
        scanf("%d%d",&end.x,&end.y);
        m[begin.x][begin.y]=1; 
        Seek(begin,1); //由第一步起点试探起
        system("pause"); 
        return 0;
    } 
    
    
    展开全文
  • 首先,先标明对于迷宫求解这个项目,首先我提出自己的思路,利用“穷举求解”的方法(严蔚敏老师数据结构一书中提到,一开始不知方法其名。)其实简单来说就是一条路一条路去试,当然不能随便试,我的方法是按照从...
  • 数据结构(C语言版)的迷宫求解完整代码,用C++编写的,希望对各位有用
  • 数据结构迷宫求解

    千次阅读 2018-09-24 21:51:37
    迷宫:根据迷宫中通路的数量和路的特点,可将迷宫分为三类 简单迷宫 多通路迷宫(通路间不带环) ...找迷宫通路需要使用回溯法,找迷宫通路是对回溯法的一个很好的应用,实现回溯的过程用到了数据结构—栈  ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,679
精华内容 1,871
关键字:

数据结构迷宫求解

数据结构 订阅