C 语言实现迷宫 DFS算法

最新推荐文章于 2023-06-08 18:00:00 发布
最新推荐文章于 2023-06-08 18:00:00 发布
阅读量1.3k 收藏 2
点赞数 2
文章标签： c/c++ c# 数据结构与算法
原文链接：https://my.oschina.net/hutao1/blog/179930
版权

为什么80%的码农都做不了架构师？>>>   hot3.png

    上周学校布置的数据结构教学作业是生成一个迷宫，并且判断是否有通路，于是我索性做了一个迷宫游戏，第一次写这样长的代码，没有组织好，可能在可读性上不是很好，另外应该可以改进很多地方，比如说goto语句的替换，实现DFS时比较早，用了较多的goto，后来就限制使用了，总之这个程序里还是学到了很多，有可以改进的地方，欢迎大家留言批评指正。

先上一个图

后面俩行提示是对齐的，这个截图是较早时搞的，代码里改过了，就是俩个空格的问题，起点是雌性图标，终点是雄性图表。

再看另外一个风格：

这些都是在搜狗输入法特殊符号里找的，试用过很多的符号，最好保留了这俩个。

在开始界面：

 

 

 

在运行过程中如果 F1 ，则输出路线：

 

当然，也可以ESC退出。

下面上代码吧：（之前写的原版本，就不改了，VS2013平台）

先是头文件：headfile.h

/*2013年11月中下旬完成该代码设计，其中可能有一些多余的代码，本来打算用那些知识点来实现，后来没有用到，不过保留着的，也有些事注释掉的
如果写上会增加其他功能，或许在其他程序中会用到，留在备参考
本程序实现的功能：
1：浏览深度优先算法生成的迷宫，得到走迷宫的路线；
2：游戏模式，一个小人走迷宫，寻找另外一个小人，可以中途ESC键退出或F1键寻求帮助*/

#define ERROR 0
#define OVERFLOW 0
#define UNDERFLOW 0
#define OK 1
#define MAX_ARRAY_DIM 3
#define STACKINCREMENT 10
#define STACK_INIT_SIZE 50

typedef int SElemType;
typedef int ElemType;
typedef   struct
{
 SElemType *base;
 SElemType *top;
 int stackSize;
}sqStack;
typedef struct      //坐标，走迷宫时用
{
 int x;
 int y;
}*Pos;
typedef struct Node //存储路线坐标
{
 Pos data;
 Node *next;
}Node, *LinkType;
typedef struct      //存储路线
{
 LinkType top;
 LinkType base;
 int size;
}*Stack;

int visit(int, int);
void make_maze(int**, int);
void Initarray(int **e, int n);
int InitStack(sqStack *s);  //初始化栈，分配50个容量的栈
int Deep_F_S(int **arra_y);
void Push(sqStack *s, ElemType e);
int Pop(sqStack *s);
int text(int **maze, int n);
void print_maze(int **p, int n);
void print_li(int **maze, int n);
void print_num(int**maze, int n);
void print_zf(int **maze, int n);
int road(int **maze, int n);//检测是否有路
int Maze_Path(int **maze, int n, Pos start, Pos end);
int control(char ch);
int Game(int**maze, int n);
void gotoxy(int x, int y);
int Get_n(int **p);

main.cpp

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include<windows.h>
#include "headfile.h"
int n = 0;
static int i = 0, j = 0;
int main()
{
 printf("design by hutao!\n2013\\11\\24\n");
 system("pause");
 system("cls");

 HANDLE color;
 color = GetStdHandle(STD_OUTPUT_HANDLE);
 SetConsoleTextAttribute(color, FOREGROUND_GREEN);
 //SetConsoleTextAttribute(color, BACKGROUND_RED | BACKGROUND_INTENSITY);

 Pos start, end;
 start = (Pos)malloc(sizeof(Pos));
 end = (Pos)malloc(sizeof(Pos));

 static int **p;

 printf("1:game\t2:visit\n");
 int c = 0;
 scanf_s("%d", &c);

PRI:
 printf("plsese input the size of this maze you want:\t");
 scanf_s("%d", &n);                        //how many lines of this maze

 if (n < 5)
 {
  system("cls");
  printf("It's too small!\n");
  goto PRI;
 }
 else if (n % 2 == 0)
 {
  system("cls");
  printf("please input odd!\n");
  goto PRI;
 }
 else if (n > 35)
 {
  printf("It's too hard! are you sure? 1:yes 2:no\t");
  int a = 0;
  scanf_s("%d", &a);
  while (a != 1)
   goto PRI;
 }
 else if (n < 15)
 {
  printf("It's too easy! are you sure? 1:yes 2:no\t");
  int a = 0;
  scanf_s("%d", &a);
  while (a != 1)
   goto PRI;
 }

 p = (int **)malloc(sizeof(int *)* n);
 for (i = 0; i < n; i++)
  p[i] = (int *)malloc(sizeof(int)* n); //get the momery of the array

 make_maze(p, n);                            //make this erray

 end->x = end->y = n - 2; //设置入口和出口
 start->y = start->x = 1;

 switch (c) //选择功能，是走迷宫游戏还是看迷宫生成
 {
 case 1: Game(p, n);
  if (GetAsyncKeyState(VK_F1))
  {
   Maze_Path(p, n, start, end);
   print_maze(p, n);
   system("pause"); return OK;
  }
  else
   system("pause"); return OK;
 case 2:print_maze(p, n); break;                           //output the maze you make
 default: printf("don't do this!\n");
 } 
 if (Maze_Path(p, n, start, end) == ERROR)
  printf("\nThis maze haven't path!\n");
 else
 {
  printf("\nThe maze has the path to end!\nDo you want to get the path?\n1: yes 2: no\t");
  int a;
  scanf_s("%d", &a);
  switch (a)
  {
  case 1: system("cls"); print_maze(p, n); break;
  case 2: break;
  }
 }

 system("pause");
 return 0;
}

fun.cpp

 

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <stdarg.h>
#include<windows.h>
#include "headfile.h"

extern int n;
int x = 1;
static int i = 0, j = 0;
sqStack  *visited_x = (sqStack*)malloc(sizeof(sqStack));
sqStack  *visited_y = (sqStack*)malloc(sizeof(sqStack));

void make_maze(int **maze, int n)
{
 int i = 0, j = 0;
 int a = 0;
 for (i = 0; i < n; i++)
 {
  for (j = 0; j < n; j++)
  {

   if (i % 2 == 1 && j % 2 == 1)
    maze[i][j] = 0;
   else
    maze[i][j] = 1;
  }
 }
 InitStack(visited_x);
 InitStack(visited_y);

 time_t t;
 srand((unsigned)time(&t));
 a += (int)(rand());//随机生成起点
 switch (a)
 {
 case 0:i = (n - 1) / 2; j = (n - 1) / 2; break;
 case 1:i = (n - 1) / 2 - 2; j = (n - 1) / 2; break;
 case 2:i = (n - 1) / 2 + 2; j = (n - 1) / 2; break;
 case 3:i = (n - 1) / 2; j = (n - 1) / 2 - 2; break;
 case 4:i = (n - 1) / 2; j = (n - 1) / 2 + 2; break;
 }
 Push(visited_x, i);
 Push(visited_y, j); //生成起点入栈 
 Deep_F_S(maze);
}
void print_maze(int**maze, int n)
{
 //输出迷宫
 int a = 3;
 for (i = 0; i < n; i++)
 {
  for (j = 0; j < n; j++)
  {
   if (maze[i][j] == 4)
    maze[i][j] = 0;
  }
 }
PR:
 printf("please choose the style you want:\n1 ：¤\n2 ：╔\n3 : 0、1、2\n");
 scanf_s("%d", &a);
 switch (a)
 {
 case 1: system("cls"); print_zf(maze, n); break;
 case 2: system("cls"); print_li(maze, n); break;
 case 3: system("cls"); print_num(maze, n); break;
 default:system("cls"); printf("please input correct choise!\n"); goto PR;
 }

 gotoxy(4, 2);
 printf("◎");
 gotoxy(2 * n - 2, n - 1);
 printf("♂");
 printf("\n\n");
}
void print_zf(int **maze, int n)
{
 int m, o;
 printf("\n");
 for (m = 0; m < n; m++)
 {
  printf("  ");
  for (o = 0; o < n; o++)
  {
   switch (maze[m][o])
   {
   case 1: printf("¤"); break;
   case 0:printf("  "); break;
   case 2:printf("+ "); break;
   }
  }
  printf("\n");
 }
 printf("\n");
}
void print_num(int**maze, int n)
{
 int m, o;
 printf("\n");
 for (m = 0; m < n; m++)
 {
  printf("  ");
  for (o = 0; o < n; o++)
  {
   printf("%d ", maze[m][o]);
  }
  printf("\n");
 }
 printf("\n");
}
void print_li(int **maze, int n)
{
 int m = 0, o = 0;
 printf("\n");
 for (m = 0; m < n; m++)
 {
  printf("  ");
  for (o = 0; o < n; o++)
  {
   if (m == 0 && o == 0)
    printf("╔");
   else if (m == n - 1 && o == n - 1)
    printf("╝");
   else if (m == 0 && o == n - 1)
    printf("╗");
   else if (m == n - 1 && o == 0)
    printf("╚");
   else if (o == 0 && m>0 && m < n - 1)
   {
    if (maze[m][o + 1] != 1)
     printf("║");
    else
     printf("╠");
   }
   else if (o == n - 1 && m>0 && m < n - 1)
   {
    if (maze[m][o - 1] != 1)
     printf("║");
    else
     printf("╣");
   }
   else if (m == 0 && o>0 && o < n - 1)
   {
    if (maze[m + 1][o] != 1)
     printf("═");
    else
     printf("╦");
   }
   else if (m == n - 1 && o>0 && o < n - 1)
   {
    if (maze[m - 1][o] != 1)
     printf("═");
    else
     printf("╩");
   }
   else if (m>0 && o > 0 && m < n - 1 && o < n - 1)//除了四周
   {
    if (maze[m][o] == 1)
    {
     if (maze[m - 1][o] == 1 && maze[m][o - 1] == 1 && maze[m + 1][o] != 1 && maze[m][o + 1] != 1)//上左下右
      printf("╝");
     if (maze[m - 1][o] == 1 && maze[m][o - 1] != 1 && maze[m + 1][o] != 1 && maze[m][o + 1] == 1)
      printf("╚");
     if (maze[m - 1][o] != 1 && maze[m][o - 1] != 1 && maze[m + 1][o] == 1 && maze[m][o + 1] == 1)
      printf("╔");
     if (maze[m - 1][o] != 1 && maze[m][o - 1] == 1 && maze[m + 1][o] == 1 && maze[m][o + 1] != 1)
      printf("╗");
     if (maze[m - 1][o] != 1 && maze[m][o - 1] != 1 && maze[m + 1][o] != 1 && maze[m][o + 1] == 1)
      printf("═");
     if (maze[m - 1][o] != 1 && maze[m][o - 1] == 1 && maze[m + 1][o] != 1 && maze[m][o + 1] != 1)
      printf("═");
     if (maze[m - 1][o] == 1 && maze[m][o - 1] != 1 && maze[m + 1][o] != 1 && maze[m][o + 1] != 1)
      printf("║");
     if (maze[m - 1][o] != 1 && maze[m][o - 1] != 1 && maze[m + 1][o] == 1 && maze[m][o + 1] != 1)
      printf("║");
     if (maze[m - 1][o] == 1 && maze[m][o - 1] == 1 && maze[m + 1][o] == 1 && maze[m][o + 1] == 1)
      printf("╬");
     if (maze[m - 1][o] == 1 && maze[m + 1][o] == 1)//上下是墙
     {
      if (maze[m][o - 1] == 1 && maze[m][o + 1] != 1)
       printf("╣");
      else if (maze[m][o + 1] == 1 && maze[m][o - 1] != 1)
       printf("╠");
      else if (maze[m][o + 1] != 1 && maze[m][o - 1] != 1)
       printf("║");
     }
     if (maze[m][o - 1] == 1 && maze[m][o + 1] == 1)//左右是墙
     {
      if (maze[m - 1][o] == 1 && maze[m + 1][o] != 1)
       printf("╩");
      else if (maze[m + 1][o] == 1 && maze[m - 1][o] != 1)
       printf("╦");
      else if (maze[m + 1][o] != 1 && maze[m - 1][o] != 1)
       printf("═");
     }
    }


   }
   if (maze[m][o] == 0)
    printf("  ");
   else if (maze[m][o] == 2)
    printf("* ");
  }
  printf("\n");
 }
 printf("\n");
}
int Deep_F_S(int **maze)
{
S:while (x == 0)
{
   goto X;
}
  int i = 1;
  int j = 1;
X: x = 0;
  int a = 0; //在随机数时用作存储容器
IF:
  if (i == 1 && j == 1 && (maze[i + 2][j] == 0 || maze[i][j + 2] == 0))
  { //左上
   if (maze[i][j + 2] == 0)
   {
    maze[i][j] = 2;
    maze[i][j + 1] = 0;
    Push(visited_x, i);
    Push(visited_y, j);
    j += 2;
   }
   else
   {
    maze[i][j] = 2;
    maze[i + 1][j] = 0;
    Push(visited_x, i);
    Push(visited_y, j);
    i += 2;
   }
   goto IF;
  }
  else if (i == 1 && j == 1)  //上一条语句执行失败才会执行这条语句
  {
   goto AA;
  }
  if (i == n - 2 && j == n - 2 && (maze[n - 4][n - 2] == 0 || maze[n - 2][n - 4] == 0))
  {//右下
   if (maze[n - 2][n - 4] == 0)
   {
    maze[i][j] = 2;
    maze[i][j - 1] = 0;
    Push(visited_x, i);
    Push(visited_y, j);
    j -= 2;
   }
   else
   {
    maze[i][j] = 2;
    maze[i - 1][j] = 0;
    Push(visited_x, i);
    Push(visited_y, j);
    i -= 2;
   }
   goto IF;
  }
  else if (i == n - 2 && j == n - 2)
  {
   goto AA;
  }
  if (i == 1 && j == n - 2 && (maze[i + 2][j] == 0 || maze[i][j - 2] == 0))
  {//右上
   if (maze[i + 2][j] == 0)
   {
    maze[i][j] = 2;
    maze[i + 1][j] = 0;
    Push(visited_x, i);
    Push(visited_y, j);
    i += 2;
   }
   else
   {
    maze[i][j] = 2;
    maze[i][j - 1] = 0;
    Push(visited_x, i);
    Push(visited_y, j);
    j -= 2;
   }
   goto IF;
  }
  else if (i == 1 && j == n - 2)
  {
   goto AA;
  }
  if (i == n - 2 && j == 1 && (maze[i - 2][j] == 0 || maze[i][j + 2] == 0))
  {//左下
   if (maze[i - 2][j] == 0)
   {
    maze[i][j] = 2;
    maze[i - 1][j] = 0;
    Push(visited_x, i);
    Push(visited_y, j);
    i -= 2;
   }
   else
   {
    maze[i][j] = 2;
    maze[i][j + 1] = 0;
    Push(visited_x, i);
    Push(visited_y, j);
    j += 2;
   }
   goto IF;
  }
  else if (i == n - 2 && j == 1)
  {
   goto AA;
  }
  if (i == 1 && (maze[i + 2][j] == 0 || maze[i][j - 2] == 0 || maze[i][j + 2] == 0))
  {//上
   if (maze[i + 2][j] == 0)
   {
    maze[i][j] = 2;
    maze[i + 1][j] = 0;
    Push(visited_x, i);
    Push(visited_y, j);
    i += 2;
    goto IF;
   }
   else if (maze[i][j + 2] == 0)
   {
    maze[i][j] = 2;
    maze[i][j + 1] = 0;
    Push(visited_x, i);
    Push(visited_y, j);
    j += 2;
    goto IF;
   }
   else if (maze[i][j - 2] == 0)
   {
    maze[i][j] = 2;
    maze[i][j - 1] = 0;
    Push(visited_x, i);
    Push(visited_y, j);
    j -= 2;
    goto IF;
   }
   else
    printf("ERROR");
  }
  else if (i == 1)
  {
   goto AA;
  }
  if (i == n - 2 && (maze[i - 2][j] == 0 || maze[i][j - 2] == 0 || maze[i][j + 2] == 0))
  {//下 
   if (maze[i - 2][j] == 0)
   {
    maze[i][j] = 2;
    maze[i - 1][j] = 0;
    Push(visited_x, i);
    Push(visited_y, j);
    i -= 2;
    goto IF;
   }
   else if (maze[i][j - 2] == 0)
   {
    maze[i][j] = 2;
    maze[i][j - 1] = 0;
    Push(visited_x, i);
    Push(visited_y, j);
    j -= 2;
    goto IF;
   }
   else if (maze[i][j + 2] == 0)
   {
    maze[i][j] = 2;
    maze[i][j + 1] = 0;
    Push(visited_x, i);
    Push(visited_y, j);
    j += 2;
    goto IF;
   }
   else
    printf("ERROR");
  }
  else if (i == n - 2)
  {
   goto AA;
  }
  if (j == 1 && (maze[i][j + 2] == 0 || maze[i - 2][j] == 0 || maze[i + 2][j] == 0))
  {//左
   if (maze[i][j + 2] == 0)
   {
    maze[i][j] = 2;
    maze[i][j + 1] = 0;
    Push(visited_x, i);
    Push(visited_y, j);
    j += 2;
    goto IF;
   }
   else if (maze[i - 2][j] == 0)
   {
    maze[i][j] = 2;
    maze[i - 1][j] = 0;
    Push(visited_x, i);
    Push(visited_y, j);
    i -= 2;
    goto IF;
   }
   else if (maze[i + 2][j] == 0)
   {
    maze[i][j] = 2;
    maze[i + 1][j] = 0;
    Push(visited_x, i);
    Push(visited_y, j);
    i += 2;
    goto IF;
   }
   else
    printf("ERROR");
  }
  else if (j == 1)
  {
   goto AA;
  }
  if (j == n - 2 && (maze[i][j - 2] == 0 || maze[i - 2][j] == 0 || maze[i + 2][j] == 0))
  {//右
   if (maze[i][j - 2] == 0)
   {
    maze[i][j] = 2;
    maze[i][j - 1] = 0;
    Push(visited_x, i);
    Push(visited_y, j);
    j -= 2;
    goto IF;
   }
   else if (maze[i + 2][j] == 0)
   {
    maze[i][j] = 2;
    maze[i + 1][j] = 0;
    Push(visited_x, i);
    Push(visited_y, j);
    i += 2;
    goto IF;
   }
   else if (maze[i - 2][j] == 0)
   {
    maze[i][j] = 2;
    maze[i - 1][j] = 0;
    Push(visited_x, i);
    Push(visited_y, j);
    i -= 2;
    goto IF;
   }
   else
    printf("ERROR");
  }
  else if (j == n - 2)
  {
   goto AA;
  }
  if (maze[i + 2][j] == 0 || maze[i - 2][j] == 0 || maze[i][j - 2] == 0 || maze[i][j + 2] == 0)
  {
  SW:
   a = (int)rand() % 4; // 生成随机数

   switch (a)
   {
   case 0:
   {
    if (maze[i - 2][j] == 0) //up
    {
     maze[i][j] = 2;
     maze[i - 1][j] = 0;
     Push(visited_x, i);
     Push(visited_y, j);
     i -= 2;
     goto IF;
    }
    else
     goto SW;  //随机种子

   }     break;
   case 1:
   {
    if (maze[i][j - 2] == 0)//left
    {
     maze[i][j] = 2;
     maze[i][j - 1] = 0;
     Push(visited_x, i);
     Push(visited_y, j);
     j -= 2;
     goto IF;
    }
    else
     goto SW;  //随机种子
   }   break;
   case 2:
   {
    if (maze[i + 2][j] == 0)//down
    {
     maze[i][j] = 2;
     maze[i + 1][j] = 0;
     Push(visited_x, i);
     Push(visited_y, j);
     i += 2;
     goto IF;
    }
    else
     goto SW;  //随机种子
   }   break;
   case 3:
   {
    if (maze[i][j + 2] == 0)
    {
     maze[i][j] = 2;
     maze[i][j + 1] = 0;
     Push(visited_x, i);
     Push(visited_y, j);
     j += 2;
     goto IF;
    }
    else
     goto SW;  //随机种子
   } break;
   default: printf("ERROR");
   }

  }
AA:while (text(maze, n) == 0)
{
    maze[i][j] = 2;
    i = Pop(visited_x);
    j = Pop(visited_y);
    goto S;
}
   for (i = 0; i < n; i++)
   {
    for (j = 0; j < n; j++)
    {
     if (maze[i][j] == 2)
      maze[i][j] = 0;
    }
   }

   return OK;
}
int InitStack(sqStack *s)  //初始化栈，分配50个容量的栈
{

 s->base = (ElemType*)malloc(STACK_INIT_SIZE*sizeof(ElemType));
 if (!(s->base))
  exit(0);   // 表示正常退出
 s->top = s->base;
 s->stackSize = STACK_INIT_SIZE;
 return OK;
}
void Push(sqStack *s, ElemType e)
{
 // 如果栈满，追加空间
 if ((s->top - s->base) >= (s->stackSize))
 {
  s->base = (ElemType *)realloc(s->base, (s->stackSize + STACKINCREMENT) * sizeof(ElemType));
  if (!s->base)
   exit(0);

  s->top = s->base + s->stackSize;              // 设置栈顶
  s->stackSize = s->stackSize + STACKINCREMENT; // 设置栈的最大容量
 }

 *((*s).top) = e;
 s->top++;
}
int Pop(sqStack *s)
{
 ElemType *e;
 e = (ElemType*)malloc(sizeof(ElemType));
 if (s->top == s->base)
  return 0;
 *e = *--(s->top);   // 将栈顶元素弹出并修改栈顶指针
 return *e;
}
int text(int **maze, int n)
{
 int i = 0, j = 0, a = 0;
 for (i = 0; i < n; i++)
 {
  for (j = 0; j < n; j++)
  {
   if (i % 2 == 1 && j % 2 == 1 && maze[i][j] == 0)
    return 0;
  }
 }
 return OK;
}
int Maze_Path(int **maze, int n, Pos start, Pos end)//如果是向左走了一步，那就一定会退回来，这个要控制刚过来的地方不能回去；
{
 visited_x->top = visited_x->base;
 visited_y->top = visited_y->base;
 Pos now;
 now = (Pos)malloc(sizeof(Pos));
 now->x = start->x;
 now->y = start->y;
 do
 {
  while (maze[now->x + 1][now->y] == 0 || maze[now->x][now->y + 1] == 0 ||
   maze[now->x - 1][now->y] == 0 || maze[now->x][now->y - 1] == 0)//如果有一个方向可通
  {
   if (maze[now->x + 1][now->y] == 0) //如果下边可通
   {
    maze[now->x][now->y] = 2; //留下足迹
    Push(visited_x, now->x);
    Push(visited_y, now->y);
    now->x++;
    if (now->x == end->x && now->y == end->y)
    {
     maze[now->x][now->y] = 2; //留下足迹
     return OK;
    }
    else
     continue;
   }
   if (maze[now->x][now->y + 1] == 0) //如果右边可通
   {
    maze[now->x][now->y] = 2; //留下足迹
    Push(visited_x, now->x);
    Push(visited_y, now->y);
    now->y++;
    if (now->x == end->x && now->y == end->y)
    {
     maze[now->x][now->y] = 2; //留下足迹
     return OK;
    }
    else
     continue;
   }
   if (maze[now->x][now->y - 1] == 0) //如果左边可通
   {
    maze[now->x][now->y] = 2; //留下足迹
    Push(visited_x, now->x);
    Push(visited_y, now->y);
    now->y--;
    if (now->x == end->x && now->y == end->y)
    {
     maze[now->x][now->y] = 2; //留下足迹
     return OK;
    }
    else
     continue;
   }
   if (maze[now->x - 1][now->y] == 0) //如果上边可通
   {
    maze[now->x][now->y] = 2; //留下足迹
    Push(visited_x, now->x);
    Push(visited_y, now->y);
    now->x--;
    if (now->x == end->x && now->y == end->y)
    {
     maze[now->x][now->y] = 2; //留下足迹
     return OK;
    }
    else
     continue;
   }
  }
  maze[now->x][now->y] = 4; //进了死胡同，则……
  now->x = Pop(visited_x);
  now->y = Pop(visited_y);
 } while (now->x != start->x&&now->y != start->y);
 return ERROR;
}
int Game(int**maze, int n)
{
 int a = 0;
 system("cls");
 printf("direction：↑\t↓\t←\t→\nhelp: F1\nquit: ESC\n"); 
 system("pause"); 
 system("cls");
 print_maze(maze, n);

 char ch = '0';
 Pos now;
 Pos start;
 Pos end;
 now = (Pos)malloc(sizeof(Pos));
 now->x = 1;
 now->y = 1;//起点位置
 start = (Pos)malloc(sizeof(Pos));
 start->x = 1;
 start->y = n - 2;
 end = (Pos)malloc(sizeof(Pos));
 end->x = n - 2;
 end->y = n - 2;

 gotoxy((now->x + 1) * 2, now->y + 1);
 printf("♀");  //输出起点；

 gotoxy(1, end->x + 3);
 printf("direction：↑\t↓\t←\t→\n help: F1\n quit: ESC\n");
 gotoxy(1, end->x + 6); //隐藏光标

 while (now->x != n - 2 || now->y != n - 2)//当没有到达终点时
 {
  if (GetAsyncKeyState(VK_UP))//四个if判断是否有方向键输入
  {
   if (maze[now->x - 1][now->y] == 0)
   {
    gotoxy((now->y + 1) * 2, now->x + 1 - 1);
    printf("♀");
    gotoxy((now->y + 1) * 2, now->x + 1);
    printf("  ");
    now->x--;
    gotoxy(0, end->x + 6);
    Sleep(100);
   }
  }
  else if (GetAsyncKeyState(VK_DOWN))
  {
   if (maze[now->x + 1][now->y] == 0)//下边可以走，则相应位置输出小人，现在位置输出空格
   {
    gotoxy((now->y + 1) * 2, now->x + 1 + 1); //上边的x加一是变化行所以这里对应的列加以一；单加一只是不变，再加一才是加一
    printf("♀");
    gotoxy((now->y + 1) * 2, now->x + 1);   //横坐标的变化要俩倍是因为涉及非英文字符的输出迷宫
    printf("  ");
    now->x++;
    gotoxy(0, end->x + 6);
    Sleep(100);
   }
  }
  else if (GetAsyncKeyState(VK_LEFT))
  {
   if (maze[now->x][now->y - 1] == 0)
   {
    gotoxy((now->y + 1) * 2 - 2, now->x + 1);
    printf("♀");
    gotoxy((now->y + 1) * 2, now->x + 1);
    printf("  ");
    now->y--;
    gotoxy(0 , end->x + 6);
    Sleep(100);
   }
  }
  else if (GetAsyncKeyState(VK_RIGHT))
  {
   if (maze[now->x][now->y + 1] == 0)
   {
    gotoxy((now->y + 1) * 2 + 2, now->x + 1);
    printf("♀");
    gotoxy((now->y + 1) * 2, now->x + 1);
    printf("  ");
    now->y++;
    gotoxy(0, end->x + 6);
    Sleep(100);
   }
  }
  
  else if (GetAsyncKeyState(VK_F1))
  {
   system("cls");
   return OK;
  }
  else if (GetAsyncKeyState(VK_ESCAPE))
  {
   system("cls");
   printf("COME　ON!\n");
   return OK;
  }
  
 }
 printf("\n\n\n\t\t\tYou are win!\n\t\t\t");

 return OK;

}
void gotoxy(int x, int y)
{
 COORD pos = { x, y };
 HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
 SetConsoleCursorPosition(hOut, pos);
}

 以上就是完整的代码了，也可以直接到我的网盘里下载整个工程，如果是vs2013或12平台应该可以直接用

http://pan.baidu.com/share/link?shareid=56644180&uk=657817718&third=15

 

转载于:https://my.oschina.net/hutao1/blog/179930

weixin_33795093
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C/C++ DFS算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-22 7272
DFS（深度优先搜索）是一种基于栈实现的图搜索算法，用于检索和遍历图或树的所有节点。它从一个起始点开始，沿着一个路径尽可能地深入图中的节点，直到无法继续，然后回溯到前一个节点，继续探索其他路径，直到遍历完所有节点。
c语言随机迷宫自动寻路,【C / EasyX】随机迷宫生成和路径搜索(DFS)
weixin_29557763的博客
05-18 1054
#include #include #include #include //////////////////////////////以下是 宏定义参数 //////////////////////////////#define WIN_WIDTH 1200 // 窗体宽度#define WIN_HEIGHT 680 ...
P1605 迷宫( C语言版 DFS+回溯 )
xiaobo_Clanguage的博客
03-10 726
题目背景 迷宫 【问题描述】 给定一个N*M方格的迷宫，迷宫里有T处障碍，障碍处不可通过。给定起点坐标和 终点坐标，问: 每个方格最多经过1次，有多少种从起点坐标到终点坐标的方案。在迷宫 中移动有上下左右四种方式，每次只能移动一个方格。数据保证起点上没有障碍。 输入样例 输出样例 【数据规模】 1≤N,M≤5 题目描述 输入输出格式 输入格式： 【输入】 第一行N、M...
dfs走迷宫
weixin_45751835的博客
05-19 408
给一张个迷宫，问能否从起点走到终点，只能往上下左右走，不能斜着走 Input 多组测试数据，每组第一行两个正整数，分别为n和m 表示n这个迷宫有n行m列(0<n,m<10) 接着是n行m列， '#'表示路 ‘’表示墙 ‘S’表示起点 ‘T’表示终点 Output 每组测试数据输出一个结果，如果能从S走到T，输出“YES”,否则输出“NO” Sample Input 2 2 S #T 3 3 S*# #T Sample Output YES NO #include <stdio.h>
c语言生成迷宫算法,[原创]递归随机迷宫生成算法详解
weixin_29216353的博客
05-25 168
该楼层疑似违规已被系统折叠隐藏此楼查看此楼#include#include#includecharcw[][4]={"　...
入门解决迷宫问题和算法DFS（递归+回溯）（C语言）
weixin_53360917的博客
11-27 573
代码中用for语句代用了下面的4个if语句： #include<stdio.h> int n , m , q , p , min=9999999 , startx , starty , a[100][100] , v[100][100]; int dx[4]={0,0,1,-1},dy[4]={1,-1,0,0}; void dfs(int x,int y,int step) { if(x==q&&y==p) { if(step<min) min=...
基于QT实现dfs寻论算法的迷宫可视化
03-06
通过以上步骤，我们便能在Qt环境下实现DFS算法的迷宫可视化。这种实现方式不仅能够帮助开发者更好地理解DFS算法，也使得非专业人员能够直观地观察算法的运行过程，提升学习效果。在实际项目中，类似的可视化技术还...
C语言迷宫求解算法设计
最新发布
07-07
本主题将深入探讨如何使用C语言实现迷宫求解算法。C语言以其高效和灵活性，成为实现这类算法的理想选择。我们将关注两种常见的算法：深度优先搜索（DFS）和广度优先搜索（BFS）。 1. 深度优先搜索（DFS） DFS是一种...
C++小游戏 完整迷宫（DFS生成）
10-28
标题 "C++小游戏 完整迷宫（DFS生成）" 提到的是一个使用C++编程语言开发的小游戏，其中包含了迷宫的生成算法，特别是采用了深度优先搜索（DFS）策略来创建迷宫。DFS是一种图遍历算法，常用于解决各种路径寻找问题，...
基于C语言实现的迷宫游戏代码
09-04
【基于C语言实现的迷宫游戏代码】是一个教学示例，旨在帮助学习游戏开发的人理解如何使用C语言来创建简单的迷宫游戏。这个游戏的核心部分涉及到了C语言的基础知识，包括递归算法、流程控制和基本的图形绘制。下面将...
C++实现迷宫算法实例解析
09-04
C++ 实现迷宫算法是一个典型的路径搜索问题，通常采用深度优先搜索（DFS）或广度优先搜索（BFS）策略。在这个实例中，作者使用了深度优先搜索方法来寻找迷宫的出口。以下是关于这个实例的详细解释： 首先，迷宫被...
自动生成的迷宫（c语言）
10-25
用c语言实现的可自动生成地图的迷宫，含源码（vc++6.0欲调试需安装ege图形库），exe文件可运行。无闪烁，高速，asdw控制方向，可调大小。致谢原始文件。
c语言随机生成迷宫和走迷宫图形版（含VC6源代码）
05-31
走迷宫的游戏。包括迷宫的随机创建和控制移动等。含VC6源代码，并且代码里面的注释很详细（编译前请自己安装EasyX库）
G - 迷宫问题
qq_45229862的博客
11-24 1296
G - 迷宫问题 定义一个二维数组： int maze[5][5] = { 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, }; 它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。 Input 一个5 × 5的二维数组，表...
C 语言 DFS 迷宫
SmileCloud201
11-21 1652
/*dfs(深度优先算法)算法 走迷宫*/ *int maze[5][5] = {0, 1, 0, 0, 0,                    0, 1, 0, 1, 0,                    0, 0, 0, 0, 0,                   0, 1, 1, 1, 0,                   0, 0, 0, 1, 0}; 它表示
C语言实现迷宫随机生成（广度优先搜索算法）
走向CTO的路上...
06-08 864
其中，0表示可以通过的通路，1表示障碍物。输出的最后一行给出了起点到终点的最短路径长度。首先，它生成一个随机的迷宫，然后使用广度优先搜索算法找到从起点到终点的最短路径。由于代码中使用了随机数生成的迷宫，每次运行的结果可能不同。请注意，这里的迷宫只包含两种类型的格子：0 表示空格，1 表示障碍物。这是一个简单的迷宫生成和求解程序。最后，它输出迷宫和最短路径的长度。
基于深度优先的随机迷宫生成算法（C语言版）
qq_58811011的博客
06-15 3688
基于深度优先的随机迷宫生成算法（C语言版）
蓝桥杯2017 迷宫 C语言dfs
myl2019的博客
03-23 975
X星球的一处迷宫游乐场建在某个小山坡上。 它是由10x10相互连通的小房间组成的。 房间的地板上写着一个很大的字母。 我们假设玩家是面朝上坡的方向站立，则： L表示走到左边的房间， R表示走到右边的房间， U表示走到上坡方向的房间， D表示走到下坡方向的房间。 X星球的居民有点懒，不愿意费力思考。 他们更喜欢玩运气类的游戏。这个游戏也是如此！ 开始的时候，直升机把100名玩家放入一个个小...
C 语言 随机prim算法 生成迷宫
奇点.的博客
12-14 4565
C 语言 随机prim算法 生成迷宫。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值