用C语言随机生成一个迷宫

#include<stdio.h>
#include <stdlib.h>
#include <time.h>

//定义迷宫大小
#define ROW 10
#define COL 10

//定义节点状态
#define WALL 0
#define PATH 1

//初始化迷宫
int maze[ROW][COL] = { {0} };

//生成迷宫
int createMaze(int row, int col)
{
    //设置起点和终点
    maze[0][0] = PATH;
    maze[row - 1][col - 1] = PATH;

    //设置当前位置和方向
    int x = 0, y = 0, dir = 0;

    //定义四个方向上的偏移量
    int dx[4] = { 0, 1, 0, -1 };
    int dy[4] = { -1, 0, 1, 0 };

    //随机生成路径
    while (1)
    {
        //寻找当前节点的邻居节点
        int neighbor[4] = { 0 };
        int count = 0;
        int i;
        for (i = 0; i < 4; i++)
        {
            int nx = x + dx[i];
            int ny = y + dy[i];
            if (nx >= 0 && nx < row && ny >= 0 && ny < col && maze[nx][ny] == WALL)
            {
                neighbor[count++] = i;
            }
        }
        //如果当前节点没有可访问的邻居节点，则回溯
        if (count == 0)
        {
            int flag = 0;
            for (i = 0; i < 4; i++)
            {
                int nx = x + dx[i];
                int ny = y + dy[i];
                if (nx >= 0 && nx < row && ny >= 0 && ny < col && maze[nx][ny] == PATH)
                {
                    neighbor[count++] = i;
                    flag = 1;
                }
            }
            if (flag == 0) break;
        }

        //随机选择一个邻居节点
        int index = neighbor[rand() % count];
        x += dx[index];
        y += dy[index];
        maze[x][y] = PATH;
    }
    return 0;
}

//打印迷宫
int printMaze(int row, int col)
{
    int i, j;
    for (i = 0; i < row; i++)
    {
        for (j = 0; j < col; j++)
        {
            if (maze[i][j] == WALL)
                printf("■");
            if (maze[i][j] == PATH)
                printf("  ");
        }
        printf("\n");
    }
    return 0;
}
int main()
{
    srand(time(NULL)); //初始化随机数生成器
    createMaze(ROW, COL);
    printMaze(ROW, COL);
    return 0;
}

运行后只出现黑窗，无内容

引用chatgpt部分指引作答：
运行结果：

我注意到在生成迷宫的代码中，当回溯到起点时，程序会陷入无限循环。这是因为在回溯时，没有将当前节点标记为已访问。为了解决这个问题，你可以在回溯时将当前节点标记为已访问（即将maze[x][y]的值设为PATH），以避免重复回溯到同一个节点。下面是修改后的代码：

#include<stdio.h>
#include <stdlib.h>
#include <time.h>

//定义迷宫大小
#define ROW 10
#define COL 10

//定义节点状态
#define WALL 0
#define PATH 1
#define VISITED 2

//初始化迷宫
int maze[ROW][COL] = { {0} };

//生成迷宫
int createMaze(int row, int col)
{
    //设置起点和终点
    maze[0][0] = PATH;
    maze[row - 1][col - 1] = PATH;

    //设置当前位置和方向
    int x = 0, y = 0, dir = 0;

    //定义四个方向上的偏移量
    int dx[4] = { 0, 1, 0, -1 };
    int dy[4] = { -1, 0, 1, 0 };

    //随机生成路径
    while (1)
    {
        //将当前节点标记为已访问
        maze[x][y] = VISITED;

        //寻找当前节点的邻居节点
        int neighbor[4] = { 0 };
        int count = 0;
        int i;
        for (i = 0; i < 4; i++)
        {
            int nx = x + dx[i];
            int ny = y + dy[i];
            if (nx >= 0 && nx < row && ny >= 0 && ny < col && maze[nx][ny] == WALL)
            {
                neighbor[count++] = i;
            }
        }
        //如果当前节点没有可访问的邻居节点，则回溯
        if (count == 0)
        {
            int flag = 0;
            for (i = 0; i < 4; i++)
            {
                int nx = x + dx[i];
                int ny = y + dy[i];
                if (nx >= 0 && nx < row && ny >= 0 && ny < col && maze[nx][ny] == PATH)
                {
                    neighbor[count++] = i;
                    flag = 1;
                }
            }
            if (flag == 0) break;
        }

        //随机选择一个邻居节点
        int index = neighbor[rand() % count];
        x += dx[index];
        y += dy[index];
        maze[x][y] = PATH;
    }
    return 0;
}

//打印迷宫
int printMaze(int row, int col)
{
    int i, j;
    for (i = 0; i < row; i++)
    {
        for (j = 0; j < col; j++)
        {
            if (maze[i][j] == WALL)
                printf("■");
            if (maze[i][j] == PATH)
                printf("  ");
        }
        printf("\n");
    }
    return 0;
}

int main()
{
    srand(time(NULL)); //初始化随机数生成器
    createMaze(ROW, COL);
    printMaze(ROW, COL);
    return 0;
}

现在，代码应该可以成功生成并打印迷宫了。

测试看看

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

//定义迷宫大小
#define ROW 10
#define COL 10

//定义节点状态
#define WALL 0
#define PATH 1

//初始化迷宫
int maze[ROW][COL] = { {0} };

//生成迷宫
int createMaze(int row, int col)
{
    //设置起点和终点
    maze[0][0] = PATH;
    maze[row - 1][col - 1] = PATH;

    //设置当前位置和方向
    int x = 0, y = 0;

    //定义四个方向上的偏移量
    int dx[4] = { 0, 1, 0, -1 };
    int dy[4] = { -1, 0, 1, 0 };

    //记录已访问的节点
    int visited[row][col];
    memset(visited, 0, sizeof(visited));

    //随机生成路径
    while (1)
    {
        //寻找当前节点的邻居节点
        int neighbor[4] = { 0 };
        int count = 0;
        int i;
        for (i = 0; i < 4; i++)
        {
            int nx = x + dx[i];
            int ny = y + dy[i];
            if (nx >= 0 && nx < row && ny >= 0 && ny < col && maze[nx][ny] == WALL && !visited[nx][ny])
            {
                neighbor[count++] = i;
            }
        }

        //如果当前节点没有可访问的未访问邻居节点，则回溯
        if (count == 0)
        {
            int flag = 0;
            for (i = 0; i < 4; i++)
            {
                int nx = x + dx[i];
                int ny = y + dy[i];
                if (nx >= 0 && nx < row && ny >= 0 && ny < col && maze[nx][ny] == PATH && !visited[nx][ny])
                {
                    neighbor[count++] = i;
                    flag = 1;
                }
            }
            if (flag == 0) break;
        }

        //随机选择一个邻居节点
        int index = neighbor[rand() % count];
        int nx = x + dx[index];
        int ny = y + dy[index];
        visited[nx][ny] = 1;
        x = nx;
        y = ny;
        maze[x][y] = PATH;
    }
    return 0;
}

//打印迷宫
int printMaze(int row, int col)
{
    int i, j;
    for (i = 0; i < row; i++)
    {
        for (j = 0; j < col; j++)
        {
            if (maze[i][j] == WALL)
                printf("■");
            if (maze[i][j] == PATH)
                printf("  ");
        }
        printf("\n");
    }
    return 0;
}

int main()
{
    srand((unsigned int)time(NULL)); //初始化随机数生成器
    createMaze(ROW, COL);
    printMaze(ROW, COL);
    return 0;
}

主要是没有正确回溯

//生成迷宫
int createMaze(int row, int col)
{
    //设置起点和终点
    maze[0][0] = PATH;
    maze[row - 1][col - 1] = PATH;

    //设置当前位置和方向
    int x = 0, y = 0;

    //定义四个方向上的偏移量
    int dx[4] = { 0, 1, 0, -1 };
    int dy[4] = { -1, 0, 1, 0 };

    //记录已访问的节点
    int visited[row][col];
    memset(visited, 0, sizeof(visited));

    //随机生成路径
    while (1)
    {
        //寻找当前节点的邻居节点
        int neighbor[4] = { 0 };
        int count = 0;
        int i;
        for (i = 0; i < 4; i++)
        {
            int nx = x + dx[i];
            int ny = y + dy[i];
            if (nx >= 0 && nx < row && ny >= 0 && ny < col && maze[nx][ny] == WALL && !visited[nx][ny])
            {
                neighbor[count++] = i;
            }
        }

        //如果当前节点没有可访问的未访问邻居节点，则回溯
        if (count == 0)
        {
            int flag = 0;
            for (i = 0; i < 4; i++)
            {
                int nx = x + dx[i];
                int ny = y + dy[i];
                if (nx >= 0 && nx < row && ny >= 0 && ny < col && maze[nx][ny] == PATH && !visited[nx][ny])
                {
                    neighbor[count++] = i;
                    flag = 1;
                }
            }
            if (flag == 0) break;
        }

        //随机选择一个邻居节点
        int index = neighbor[rand() % count];
        int nx = x + dx[index];
        int ny = y + dy[index];
        visited[nx][ny] = 1;
        x = nx;
        y = ny;
        maze[x][y] = PATH;
    }
    return 0;
}

来自GPT的回答：

这个问题可能是由于迷宫的尺寸太小而导致的。在你的代码中，迷宫的尺寸被定义为10x10（ROW=10，COL=10），而每个迷宫单元格的宽度为2个字符（一个空格表示路径，一个字符表示墙壁）。

如果你的命令提示符窗口尺寸太小，无法容纳10x10的迷宫，你可能无法看到迷宫的完整输出。你可以尝试增大命令提示符窗口的尺寸，或者缩小迷宫的尺寸。

另外，你可以尝试在每行打印迷宫后，使用fflush(stdout)来刷新输出缓冲区，以确保迷宫立即显示在命令提示符窗口中。修改后的代码如下所示：

c
Copy code
//打印迷宫
int printMaze(int row, int col)
{
    int i, j;
    for (i = 0; i < row; i++)
    {
        for (j = 0; j < col; j++)
        {
            if (maze[i][j] == WALL)
                printf("■");
            if (maze[i][j] == PATH)
                printf("  ");
        }
        printf("\n");
        fflush(stdout); // 刷新输出缓冲区
    }
    return 0;
}
这样，每打印一行迷宫后，就会立即将其显示在命令提示符窗口中。

如果你还是无法看到完整的迷宫，请尝试调整窗口的尺寸或缩小迷宫的尺寸（例如，将迷宫的尺寸改为5x5），以便适应命令提示符窗口的大小。

因为现在一直处于 代码31行的这个while循环中

这段代码在生成迷宫时存在一个错误。在回溯时，当当前节点没有可访问的邻居节点时，代码会尝试在已经是路径的节点中选择一个邻居节点，这是不正确的。

在回溯时，应该回溯到上一个未访问的节点，而不是已经是路径的节点。修改代码中的回溯部分如下：

//如果当前节点没有可访问的邻居节点，则回溯
if (count == 0)
{
    int flag = 0;
    for (i = 0; i < 4; i++)
    {
        int nx = x + dx[i];
        int ny = y + dy[i];
        if (nx >= 0 && nx < row && ny >= 0 && ny < col && maze[nx][ny] == WALL)
        {
            neighbor[count++] = i;
            flag = 1;
        }
    }
    if (flag == 0) {
        // 回溯到上一个未访问的节点
        maze[x][y] = WALL;
        x -= dx[dir];
        y -= dy[dir];
        continue;
    }
}

通过这样的修改，回溯时将正确地回到上一个未访问的节点，并且生成的迷宫将是正确的。

你需要的10*10迷宫，可以用一组10个10维的向量来做，向量内容为0或1随机数即可

参考gpt：
这段代码实现了一个简单的随机生成迷宫并打印出来的功能。根据你的描述，代码运行后只出现一个黑窗口而没有任何内容显示。

这个问题可能是因为代码中的迷宫打印部分存在一些问题。你可以尝试修改printMaze函数来解决这个问题。在代码中，墙用"■"字符表示，路径用两个空格表示。

请将以下代码替换掉原来的printMaze函数部分：

//打印迷宫
int printMaze(int row, int col)
{
    int i, j;
    for (i = 0; i < row; i++)
    {
        for (j = 0; j < col; j++)
        {
            if (maze[i][j] == WALL)
                printf("■");
            if (maze[i][j] == PATH)
                printf("  ");
        }
        printf("\n");
    }
    return 0;
}

如果问题仍然存在，请确保你的编译器和环境设置正确，并且能够正确地运行C语言程序。如果你使用的是IDE，可以尝试在IDE的设置中查找是否有相关的配置选项，例如确保输出窗口能够正确显示程序的输出。

另外，请确保你已经正确包含了所需的头文件（例如stdio.h、stdlib.h和time.h），并且编译器能够找到这些头文件。如果有其他的编译器警告或错误信息，请检查并修复这些问题。

希望这些信息对你有所帮助，如果还有其他问题，请随时提问。

试试这个

#include<stdio.h> 
#include<stdlib.h>
#include<time.h>
#include<conio.h>
 
struct Node
{
    int data;
    int flag;
};
 
struct Path
{
    int xpath;
    int ypath;
    int pox;    //在队列中的下标 
};
 
//全局变量
int n, m;     //迷宫的行和列 
Node* maze;   //迷宫存放 
Path* que;
int top = -1;
int front = -1;
int rear = -1;
 
void create()
{
    int i, j;
    printf("输入迷宫(随机生成)的行和列：");
    scanf("%d%d", &n, &m);
    maze = new Node[n * m];
    srand(time(NULL));
    for (i = 0; i < n; i++)
    {
        for (j = 0; j < m; j++)
        {
            int temp = rand() % 4;
            if (temp != 1) maze[i * m + j].data = 1;
            else maze[i * m + j].data = 0;
            maze[i * m + j].flag = 0;
        }
    }
    maze[0].data = 8;  //设置起点 
    maze[n * m - 1].data = 1;
    printf("生成迷宫：\n");
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            printf("%d", maze[i * m + j].data);
        }
        printf("\n");
    }
}
int judge_head()
{
    int k = 1;
    if (que[front].xpath == n - 1 && que[front].ypath == m - 1)
    {
        printf("找到迷宫的通路！\n");
        int x = que[front].xpath;
        int y = que[front].ypath;
        int t = que[front].pox;    //前一个坐标在队列的下标 
        while (x != 0 || y != 0)
        {
            maze[x * m + y].data = 8;
            x = que[t].xpath;
            y = que[t].ypath;
            t = que[t].pox;
            k++;
        }
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < m; j++)
            {
                printf("%d", maze[i * m + j].data);
            }
            printf("\n");
        }
        printf("路径长度为：%d\n", k);
        return 1;
    }
    return 0;
}
void push_road(int x, int y)
{
    if (maze[x * m + y].data == 1 && maze[x * m + y].flag == 0)
    {
        que[(++rear) % (n * m)].xpath = x;
        que[rear % (n * m)].ypath = y;
        que[rear % (n * m)].pox = front;   //设置上一个坐标在队列中的位置 
        maze[x * m + y].flag = 1;
    }
}
/*搜索路径*/
void seek_road()   /*先实现一个路径先*/
{
    //path = new Path[n*m];
    int x1, y1;
    que = new Path[n * m];                  //利用广度优先实现最短路径
    que[0].xpath = 0;
    que[0].ypath = 0;
    que[0].pox = 0;
    maze[0].flag = 1;
    rear++;
    while (front != rear)
    {
        int x = que[(++front) % (n * m)].xpath;  //获取队头的坐标，然后将其四周的通路进队,知道操作完队尾元素 
        int y = que[front % (n * m)].ypath;
        //    path[++top] = que[front];
        if (judge_head()) return;
        if (y + 1 < m)
            push_road(x, y + 1);
        if (x + 1 < n)
            push_road(x + 1, y);
        if (y - 1 >= 0)
            push_road(x, y - 1);
        if (x - 1 >= 0)
            push_road(x - 1, y);
    }
    printf("没有通路！\n");
}
int main()
{
    create();
    seek_road();
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define ROWS 10
#define COLS 20

int maze[ROWS][COLS];

void init_maze() {
    int i, j;
    for (i = 0; i < ROWS; i++) {
        for (j = 0; j < COLS; j++) {
            maze[i][j] = 1;
        }
    }
}

void print_maze() {
    int i, j;
    for (i = 0; i < ROWS; i++) {
        for (j = 0; j < COLS; j++) {
            if (maze[i][j] == 0) {
                printf(" ");
            } else {
                printf("#");
            }
        }
        printf("\n");
    }
}

void generate_maze(int row, int col) {
    maze[row][col] = 0;
    int direction[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
    int rand_dir[4];
    int i, temp;
    for (i = 0; i < 4; i++) {
        rand_dir[i] = i;
    }
    for (i = 0; i < 4; i++) {
        int r = rand() % 4;
        temp = rand_dir[i];
        rand_dir[i] = rand_dir[r];
        rand_dir[r] = temp;
    }
    for (i = 0; i < 4; i++) {
        int next_row = row + direction[rand_dir[i]][0] * 2;
        int next_col = col + direction[rand_dir[i]][1] * 2;
        if (next_row >= 0 && next_row < ROWS && next_col >= 0 && next_col < COLS) {
            if (maze[next_row][next_col] == 1) {
                maze[row + direction[rand_dir[i]][0]][col + direction[rand_dir[i]][1]] = 0;
                generate_maze(next_row, next_col);
            }
        }
    }
}

int main() {
    srand(time(NULL));
    init_maze();
    generate_maze(1, 1);
    print_maze();
    return 0;
}