数据结构：递归实现简单迷宫

先标记进来的点2，入栈，递归形成子问题——如何走剩下的迷宫？

从入口点向四周试探，如果任意一个方向走成功了，就return 1，

也就是整个迷宫就有解了，如果这个方向走失败了，说明这个方向以后不论怎么走都失败，

要出栈这个结点。当四个方向全失败了，出栈入口点，并返回0.

栈结构实现：简单迷宫出口判断 - CSDN博客点击打开链接

数据结构：静态栈与动态栈的实现 - CSDN博客点击打开链接

Stack.h

#include <stdlib.h>
#include <string.h>

typedef struct Position DataType;

typedef struct Stack
{
    DataType *arr;//指向动态空间的指针
    int capacity;//空间总容量
    int size;//有效元素个数
}Stack,* PStack;

// 栈的初始化 
void StackInit(Stack *S, int capacity);

// 入栈 
void StackPush(Stack *S, DataType data);

// 出栈 
void StackPop(Stack *S);

// 获取栈顶元素 
DataType StackTop(Stack *S);

// 获取栈中元素个数 
void StackSize(Stack *S);

// 检测栈是否为空 
int StackEmpty(Stack *S);

Maze.h

#pragma once
#define MAX_ROW 6
#define MAX_COL 6

typedef struct Position
{
    int _x;
    int _y;
}Position;

typedef struct Maze
{
    int _map[MAX_ROW][MAX_COL];

}Maze, *PMaze;

// 栈的初始化 
void InitMaze(Maze *m, int map[][MAX_COL]);

// 检测入口是否为有效入口 
int IsValidEntry(Maze *m, Position entry);

// 检测cur位置是否是通路 
int IsPass(Maze *m, Position cur);

// 检测Cur是否在出口 
int IsExit(Maze *m, Position cur, Position entry);

// 走迷宫 
int PassMaze(Maze *m,Position entry ,Stack *s);
int _passMaze(Maze *m,Position cur,Position entry,Stack *s);

// 打印迷宫 
void PrintMaze(Maze *m);

Stack.c

#include "stack.h"
#include "Maze.h"

void StackInit(Stack *S,int capacity)//栈初始化
{
	S->arr = (DataType*)malloc(capacity*sizeof(DataType));
	if(NULL == S->arr)
	{
	   printf("申请空间失败！\n");
	   return;
	}
	S->capacity = capacity;
	S->size = 0;
}


void AddCapacity(Stack *S)//扩容
{
   if(NULL == S->arr)
	{
	   printf("扩容失败\n");
	   return;
	}

   S->arr = (DataType*)realloc(S->arr,sizeof(DataType)*(S->capacity)*2);//扩容为原来的二倍
   
   if (NULL == S->arr)
    {
        printf("空间扩增失败!!!\n");
        return;
    }
   S->capacity =2 * (S->capacity);
}

void PrintfStack(Stack *S)//打印栈
{
   int i = 0;
   if(NULL == S->arr)
	{
	   printf("打印失败\n");
	   return;
	}
   for(;i<S->size;i++)
   {
	   printf("[%d %d]->",S->arr[i]);
   }
   printf("\n");
}

void StackPush(Stack *S,DataType data)//入栈
{
	if(NULL == S->arr)
	{
	   printf("入栈失败\n");
	   return;
	}
	if(S->capacity == S->size)//空间已满
	{
	   AddCapacity(S);
	}
	S->arr[S->size] = data;
	S->size++;
}

void StackPop(Stack *S)//出栈
{
   if(NULL == S->arr)
	{
	   printf("出栈失败\n");
	   return;
	}
   S->size--;
}

DataType StackTop(PStack P)//获取栈顶元素
{
	return P->arr[P->size - 1];
  /* int ret = 0;
   if(NULL == S->arr)
	{
	   printf("获取栈失败\n");
	   return;
	}
   if(0 == S->size)
   {
   printf("栈为空！\n");
   return;
   }
  
   printf("栈顶元素为：%d \n", S->arr[S->size - 1]);*/
}

void StackSize(Stack *S)//获取元素个数
{
   if(NULL == S->arr)
	{
	   printf("获取栈失败\n");
	   return;
	}
   printf("元素个数为：%d\n",S->size);
}

int StackEmpty(Stack *S)//检测栈是否为空
{
    if(NULL == S->arr)
	{
	   printf("获取栈失败\n");
	   return 0;
	}
	if(S->size == 0)
	{
	printf("栈为空\n");
	return 0;
	}
	return 1;
}

Maze.c

#include "stack.h"  
#include "Maze.h"  
  
//1. 用栈对简单迷宫进行求解，迷宫只有一个出口  
//采用循环方式实现  
  
void PrintMaze(Maze *m)//打印迷宫  
{  
    int i = 0;  
    assert(m);  
  
    for (; i < MAX_ROW; ++i)  
    {  
        int j = 0;  
        for (; j < MAX_COL; ++j)  
        {  
            printf("%d ", m->_map[i][j]);  
        }  
        printf("\n");  
    }  
  
}  
  
void InitMaze(Maze *m, int map[][MAX_COL])//迷宫初始化,就是将地图中的值赋给迷宫  
{  
    int i = 0;  
    assert(m);  
  
    for (; i < MAX_ROW; ++i)  
    {  
        int j = 0;  
        for (; j < MAX_COL; ++j)  
        {  
            m->_map[i][j] = map[i][j];  
        }  
    }  
}  
  
int IsValidEntry(Maze *m, Position entry)//检测迷宫入口是否合法  
{  
    assert(m);  
  
    //必须位于迷宫边界且值为1  
    if ((entry._x == 0 || entry._y == 0 || entry._x == MAX_ROW - 1  
        || entry._y == MAX_COL - 1) && (m->_map[entry._x][entry._y] == 1))  
        return 1;  
    return 0;  
}  
  
int IsPass(Maze *m, Position cur)// 检测cur位置是否是通路   
{  
    assert(m);  
  
    //值为1且不能越界  
    if ((cur._x >= 0 && cur._x <= MAX_ROW-1) &&   
        (cur._y >= 0 && cur._y <= MAX_COL-1) &&  
         m->_map[cur._x][cur._y] == 1)  
	{
		return 1;  
	}
    return 0;  
  
}  
  
int IsExit(Maze *m, Position cur, Position entry)// 检测Cur是否在出口   
{  
    assert(m);  
  
    //出口位置就是处于边界值为1且不能是入口  
    if ((cur._x == 0 || cur._y == 0 || cur._x == MAX_ROW - 1  
        || cur._y == MAX_COL - 1) && (m->_map[cur._x][cur._y] == 2)  
        && ((cur._x != entry._x) || (cur._y != entry._y)))  
	{
		return 1;  
	}  
    return 0;  
}  
int PassMaze(Maze *m, Position entry,Stack *s)
{
   if(!IsValidEntry(m,entry))
   {
	   printf("入口有误");
	   return 0;
   }

   _passMaze(m,entry,entry,s);//两个entry意义不同，第一个作为起始点，第二个作为入口点用来判断出口
   return 0;
}

int _passMaze(Maze *m,Position cur,Position entry,Stack *s)
{
	Position next;
	if(IsPass(m,cur))//判断cur能否走通
	{
		m->_map[cur._x][cur._y] = 2;//走过的赋2，入栈
		StackPush(s,cur);

	       if(IsExit(m, cur, entry))//判断是否为出口
			return 1;

		   next = cur;//按照上左右下寻找通路，next的值会改变，每次判断都要重新赋值
	       next._x -= 1;
	       if(_passMaze(m, next, entry,s))
		       return 1;

		   next = cur;
	       next._y -= 1;
	       if(_passMaze(m, next, entry,s))
		       return 1;

	       next = cur;
	       next._y += 1;
	       if(_passMaze(m, next, entry,s))
		       return 1;

	   		   next = cur;
	       next._x += 1;
	       if(_passMaze(m, next, entry,s))
		       return 1;

	   m->_map[cur._x][cur._y] = 3;
	   StackPop(s);   
  }

   return 0;
}

test()

void TestMaze()
{
    Position entry;
    Maze m;
	Stack s;
    int map[6][6] = { 
	{ 0, 0, 0, 0, 0, 0 },
    { 0, 0, 1, 0, 0, 0 },
    { 0, 0, 1, 0, 0, 0 },
    { 0, 0, 1, 1, 1, 0 },
    { 0, 0, 1, 0, 1, 1 },
    { 0, 0, 1, 0, 0, 0 } };
	StackInit(&s, 10);
    InitMaze(&m, map);
    PrintMaze(&m);
	
    entry._x = 5;
    entry._y = 2;

    PassMaze(&m,entry,&s);

    printf("\n");
    PrintMaze(&m);
	PrintfStack(&s);

}
int main()
{
    TestMaze();//测试迷宫
    system("pause");
    return 0;
}

数据结构：递归实现简单迷宫

猜你喜欢