迷宫问题算法//链栈实现

//迷宫问题

/*用链栈实现的，第一行和第一列我设为墙，出发点是(1,1)，迷宫用二维数组随机生成，先向右走，每走一步，就把这个点放入栈中，并判断这个点在栈中有没有出现过(不走回头路)和前方是不是墙，遇到墙的话，它会会判断其他方向，如果其他三方都是墙，它会把这个点从栈中释放，退回先前的一个点，直到找到非墙口，并继续循环判断，如果有通路的话但找的不是最短的路径。*/

 

//算法
#include <iostream>
#include <stdlib.h>
#include <time.h>
using namespace std;
const int MaxSize = 100;
struct Maze
{
    int maze_x;
    int maze_y;
    int direction;
    Maze *last;
};
int find_Maze(int x, int y, Maze *head)
{
    Maze *p = head;
    while (p != NULL)
    {
        if (p->maze_x == x && p->maze_y == y){
            return 1;
        }
        p = p->last;
    }
    return 0;
}
Maze *walk_Maze(int data[100][100], int m, int n)
{
    Maze *top, *p;
    top = p = new Maze;
    int j = 1, found;
    p->maze_x = 1; p->maze_y = 1; p->last = NULL;
    do{
        while (j <= 4)
        {
            found = 0;
            switch (j)
            {
            case 1:                                           // 往右走
                if (p->maze_y + 1 < m && data[p->maze_x][p->maze_y + 1] == 0 && !find_Maze(p->maze_x, p->maze_y + 1, top)){
                    p = new Maze;
                    p->maze_x = top->maze_x;
                    p->maze_y = top->maze_y + 1;
                    p->last = top;
                    top->direction = j;
                    top = p;
                    found = 1;
                }
                break;
            case 2:                                         // 往左走
                if (p->maze_y - 1 >= 0 && data[p->maze_x][p->maze_y - 1] == 0 && !find_Maze(p->maze_x, p->maze_y - 1, top)){
                    p = new Maze;
                    p->maze_x = top->maze_x;
                    p->maze_y = top->maze_y - 1;
                    p->last = top;
                    top->direction = j;
                    top = p;
                    found = 1;
                }
                break;
            case 3:                                        // 往下走
                if (p->maze_x + 1 < n && data[p->maze_x + 1][p->maze_y] == 0 && !find_Maze(p->maze_x + 1, p->maze_y, top)) {
                    p = new Maze;
                    p->maze_x = top->maze_x + 1;
                    p->maze_y = top->maze_y;
                    p->last = top;
                    top->direction = j;
                    top = p;
                    found = 1;
                }
                break;
            case 4:                                     //往上走
                if (p->maze_x - 1 >= 0 && data[p->maze_x - 1][p->maze_y] == 0 && !find_Maze(p->maze_x - 1, p->maze_y, top)){
                    p = new Maze;
                    p->maze_x = top->maze_x - 1;
                    p->maze_y = top->maze_y;
                    p->last = top;
                    top->direction = j;
                    top = p;
                    found = 1;
                }
                break;
            }
            if (found == 1){
                j = 1;
                break;
            }
            else
                j++;
        }
        if (j > 4){
            if (top->last != NULL){
                p = p->last;
                top = p;
                j = top->direction + 1;
            }
            else
                return NULL;
        }
    } while (top->maze_x != n - 1 || top->maze_y != m - 1);
    top->direction = j;
    return top;
}
void display(Maze *Q, int data[100][100], int n, int m)
{
    int i, j, top = 0;
    Maze *A[MaxSize];
    if (Q == NULL){
        cout << endl << "迷宫没有通路!" << endl;
    }
    else{
        while (Q != NULL){
            A[top++] = Q;
            Q = Q->last;
        }
        cout << endl << "迷宫通路:" << endl;
        while (top > 0){
            top--;
            data[A[top]->maze_x][A[top]->maze_y] = A[top]->direction + 1;
        }
        for (i = 0; i < n; i++){
            for (j = 0; j < m; j++){
                if (data[i][j] <= 1)
                    cout << data[i][j] << ' ';
                else{
                    switch (data[i][j])
                    {
                    case 2:cout << "→"; break;
                    case 3:cout << "←"; break;
                    case 4:cout << "↓"; break;
                    case 5:cout << "↑"; break;
                    }
                }
            }
            cout << endl;
        }
        cout << endl;
    }
}

int main()                          //n行m列迷宫,0为可行，1为障碍
{
    Maze *Q;
    int i, j, n, m, data[100][100];
    cin >> n >> m;
    //创建地图
    srand(NULL);
    for (i = 0; i < n; i++)
    for (j = 0; j < m; j++){
        data[i][j] = rand() % 2;
    }
    data[1][1] = 0;    //入口置0
    data[n - 1][m - 1] = 0;    //出口置0
    //打印
    for (i = 0; i < n; i++) {
        for (j = 0; j < m; j++){
            if (i == 0 || j == 0)
                data[i][j] = 1;
            cout << data[i][j] << ' ';
        }
        cout << endl;
    }
    Q = walk_Maze(data, m, n);
    display(Q, data, n, m);

    return 0;
}

转载于:https://my.oschina.net/foreverwiner/blog/759718