迷宫

//迷宫

#include <stdio.h>

 #include <malloc.h>
 //记录通道块在迷宫矩阵当中的横、纵坐标
struct Position {
        int x;
         int y;
    
};
//放入栈当中的通道块元素
 struct SElement {
        int ord;    //记录此通道块在整个通道当中的次序
        Position p; //记录此通道块在矩阵当中的位置
         int di;    //记录下一次测试这一路径的临近路径的位置
    
};
 //创建栈数据结构
 #define STACK_INIT_SIZE 100
 #define STACKINCREMENT 10

 struct MyStack {
         SElement* base;
        SElement* top;
         int stacksize;
    
};
//创建一个栈如果创建成功则返回1，否则就返回0
 int InitStack(MyStack* s)
 {
        s->base = (SElement*)malloc(STACK_INIT_SIZE * sizeof(SElement));//为栈分配初始空间
         if (!s->base) return 0;
        s->top = s->base;//设定为空栈
         s->stacksize = STACK_INIT_SIZE;
         return 1;
     }
 //判断栈是否为空，如果是空的就返回0，否则就返回1
 int IsStackEmpty(MyStack* s)
 {
         if (s->top == s->base) return true;
         return false;
     }
//获取栈顶元素,如果栈为空就返回0 否则就返回1
 int GetTop(MyStack* s, SElement* e)
 {
         if (IsStackEmpty(s)) return 0;
         e = s->top - 1;
         return 1;
     }
 //获取栈的长度，并且通过程序返回
 int StackLength(MyStack* s)
 {
        return s->top - s->base;
     }
//插入元素e为新的栈顶元素，插入成功则返回1，否则返回0
int  Push(MyStack* s, SElement e)
{
        if (s->top - s->base >= STACK_INIT_SIZE)
             {
                 s->base = (SElement*)realloc(s->base, (s->stacksize + STACKINCREMENT) * sizeof(SElement));
                if (!s->base) return 0;
             s->top = s->base + s->stacksize;
                s->stacksize += STACKINCREMENT;
        }
 * (s->top) = e;
         s->top++;
         return 1;
     }
 //弹出栈顶元素赋值给e弹出成功返回1，弹出失败返回0
 int Pop(MyStack* s, SElement* e)
{
         if (IsStackEmpty(s)) return 0;
     * e = *(s->top - 1);
         s->top--;
     return 1;
     }
 //定义墙元素为2 可走路径为0 已知路径为curStep 不能够通过的路径为-1
#define MazeScale 10
 int Maze[MazeScale][MazeScale] = { { 2,2,2,2,2,2,2,2,2,2 },{ 2,0,0,2,0,0,0,2,0,2 },{ 2,0,0,2,0,0,0,2,0,2 },{ 2,0,0,0,0,2,2,0,0,2 },
 {2,0,2,2,2,0,0,0,0,2},{ 2,0,0,0,2,0,0,0,0,2 },{ 2,0,2,0,0,0,2,0,0,2 },{ 2,0,2,2,2,0,2,2,0,2 },{ 2,2,0,0,0,0,0,0,0,2 },{ 2,2,2,2,2,2,2,2,2,2 } };
//辅助函数考察当前路径能否通过
bool Pass(Position posi)
{
        //只有路径所在位置的数字为0的是可以走的
             if (Maze[posi.x][posi.y] == 0)
             {
             return true;
            }
         return false;
     }
 //按顺时针方向从东开始寻找矩阵当中某一个位置的临近位置
 Position NextPosition(Position now, int direction)
 {
     Position next;
         int x = now.x;
        int y = now.y;
        switch (direction)
            {
                 //东
                     case 1: {
                        next.x = x;
                        next.y = y + 1;
                        break;
                    }
                //南
                    case 2: {
                         next.x = x + 1;
                       next.y = y;
                     break;
                    }
                //西
                    case 3: {
                        next.x = x;
                         next.y = y - 1;
                        break;
                    }
                 //北
                    case 4:
                        {
                                 next.x = x - 1;
                                 next.y = y;
                            break;
                             }
                        default:break;
                    }
    return next;
     }
 //留下足迹
 void FootPrint(Position p, int step)
 {
         Maze[p.x][p.y] = step;
     }
 //路径不可走的话就留下-1的标记
void MarkPrint(Position p)
 {
         Maze[p.x][p.y] = -1;
 }
 int main()
 {
         //打印出迷宫矩阵
            for (int i = 0; i<MazeScale; i++)
        {
                for (int j = 0; j<MazeScale; j++)
                {
                     printf("%d ", Maze[i][j]);
                   }
                 printf("\n");
             }
         //迷宫程序主体
             MyStack  path;//记录路径的栈
        InitStack(&path);//初始化路径数组
        Position curp;//当前被试位置
   //初始化当前位置为矩阵入口
        curp.x = 1;
         curp.y = 1;
         int curStep = 1;//被探索的步数
         do
           {
                 if (Pass(curp))
                     {
                         FootPrint(curp, curStep);//可走就在迷宫里面留下足迹
                         //创建一个栈元素，存储可行路径的相关值，将这个元素存储到栈当中
                          SElement e;
                        e.di = 1;//意味着下一个被试路块为这一个路块的正上方的路块
                        e.ord = curStep;
                        e.p.x = curp.x;
                         e.p.y = curp.y;
                        Push(&path, e);//将路径块入栈
                        if (curp.x == MazeScale - 2 && curp.y == MazeScale - 2) break; //如果被压入的路径块到了迷宫的终点就退出循环
                         //找到下一个被试块
                         curp = NextPosition(curp, 1);//找到前一个被试块东面的路径块作为被试块
                        curStep++;//被探索的步数加一
                    }
        else//如果当前被试路径不能够通过的话
                     {
                        if (!IsStackEmpty(&path))
                            {
                                SElement e;
                                Pop(&path, &e);
                                curStep--;
                               //将这一段所有的周围路径都已经被测试过的路径从栈中清除
                                     while (e.di == 4 && !IsStackEmpty(&path)) {
                                         MarkPrint(e.p);
                                         Pop(&path, &e);
                                        curStep--;
                    
                }
                                 //如果当前栈顶还有未被测试的路径就测试剩余的周围路径
                                     if (e.di<4)
                                   {
                                        curp = NextPosition(e.p, e.di + 1);
                                    e.di++;
                                         curStep++;
                                      Push(&path, e);
                                     }
                            }
                    }
            }while (!IsStackEmpty(&path));
             printf("\n");
             //打印出结果迷宫矩阵
                for (int i = 0; i<MazeScale; i++)
                {
                    for (int j = 0; j<MazeScale; j++)
                         {
                             printf("%d   ", Maze[i][j]);
                         }
                     printf("\n");
                 }
            return 0;
         }