数据结构设计——用栈实现迷宫问题的求解

本篇文章中所有数据结构都是后期整理的，如有问题欢迎指正，转载请注明出处http://www.cnblogs.com/a1982467767/p/8889583.html

求解迷宫问题

 

1，问题描述 

 以一个m*n的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。迷宫问题要求求出从入口（1，1）到出口（m,n）的一条通路，或得出没有通路的结论。 基本要求： 首先实现一个以链表作存储结构的栈类型，然后编写一个求迷宫问题的非递归程序，求得的通路，其中：（i，j）指示迷宫中的一个坐标， d表示走到下一坐标的方向。 左上角（1，1）为入口，右下角（m,n）为出口。 

2.设计思路： 

　　用栈实现迷宫问题的求解； 

3．实验代码： 

栈实现迷宫求解问题： 

************************************************************************************************************

//maze_stack.cpp
#include<stdio.h>
#include<stdlib.h>
#include<windows.h>
#include"seqstack.h"

#define MAX_ROW  12
#define MAX_COL  14

int maze[12][14] = {
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1,
    1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1,
    1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1,
    1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1,
    1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1,
    1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1,
    1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1,
    1, 0, 0, 0, 0, 1 ,0 ,0, 0 ,0 ,1 ,0 ,1 ,1,
    1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1,
    1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
};

void print_line()
{
    system("cls");
    printf("迷宫如下‘■’代表墙,数字 或者‘☆’表示路径
");
    int i, j;
    for (i = 0; i < MAX_ROW; i++){
        for (j = 0; j < MAX_COL; j++)
            if (maze[i][j] == 1)       printf("■");
            else if (maze[i][j] >= 3){
                printf("%2d", maze[i][j] - 2);
                /*if (i == MAX_ROW-2 && j == MAX_COL-2)  printf("★");
                else                   printf("☆");*/        
            }    
            else  printf("  ");
            printf("
");
        }
    printf("已到达出口...
");
    printf("可见使用栈求出的路径并非最优路径，根据我依次探索的方向不同，结果也将不同
");
}

void visit(mark p,int sign, PSeqStack S)
{
    Push_SeqStack(S,p);
    switch (sign)
    {
    case 1: p.col++; Push_SeqStack(S, p); maze[p.row][p.col] = 2; break;//向右
    case 2: p.row++; Push_SeqStack(S, p); maze[p.row][p.col] = 2; break;//向下
    case 3: p.col--; Push_SeqStack(S, p); maze[p.row][p.col] = 2; break;//向左
    case 4: p.row--; Push_SeqStack(S, p); maze[p.row][p.col] = 2; break;//向上
    }
}

int main()
{
    struct point p = { 1, 1 };
    maze[p.row][p.col] = 2;//遍历过的点设置为2
    PSeqStack S = Init_SeqStack();
    Push_SeqStack(S,p);
    while (!Empty_SeqStack(S))
    {
        Pop_SeqStack(S, &p);
        if (p.row == MAX_ROW - 2 && p.col == MAX_COL - 2)
            break;
        if (p.col + 1 < MAX_COL - 1 && maze[p.row][p.col + 1] == 0)//向右
        {    
            visit(p, 1, S);
            continue;
        }
        if (p.row + 1 < MAX_ROW - 1 && maze[p.row + 1][p.col] == 0)//向下
        {
            visit(p, 2, S);
            continue;
        }
        if (p.col - 1 >= 1 && maze[p.row][p.col - 1] == 0)//向左
        {
            visit(p, 3, S);
            continue;
        }
        if (p.row - 1 >= 1 && maze[p.row - 1][p.col] == 0)//向上
        {
            visit(p, 4, S);
            continue;
        }//以上是对迷宫的四个方向进行操作
    }
    if (p.row == MAX_ROW - 2 && p.col == MAX_COL - 2)//是否为出口
    {
        int count = GetLength_SeqStack(S)+3;//为了与迷宫0,1,2的区别所以基数要以3开始
        printf("成功找到出口，路径倒序输出：
");
        printf("(%d,%d)
", p.row, p.col);
        maze[p.row][p.col] = count;
        while (!Empty_SeqStack(S))//按照前驱进行查找
        {
            count--;
            Pop_SeqStack(S, &p);
            maze[p.row][p.col] = count;
            printf("(%d,%d)
", p.row, p.col);            
        }
        printf("3秒后打印路径......");
        Sleep(3000);
        print_line();
    }
    else {
        printf("没有出路
");
    }
    system("pause");
    return 0;
}
//end maze_stack.cpp

*************************************************************************************************************

//seqstack.h
#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 100

typedef struct point{
    int  row, col;
}mark;

typedef mark DataType;

typedef struct {
    DataType data[MAXSIZE];
    int top;
}SeqStack, * PSeqStack;

PSeqStack Init_SeqStack (void)
{
    PSeqStack S;
    S = (PSeqStack)malloc(sizeof(SeqStack));
    if (S)
        S->top = -1;
    else
        exit(-1);
    return S;
}

int Empty_SeqStack(PSeqStack S)
{
    //return (S->top==-1);
    if (S->top == -1)
        return 1;
    else
        return 0;
}

int Push_SeqStack(PSeqStack S,DataType x)
{
    if (S->top == MAXSIZE - 1)
    {
        printf("栈满不能入栈
");
        return 0;
    }
    else 
    {
        S->top++;
        S->data[S->top] = x;
        return 1;
    }
}

int Pop_SeqStack(PSeqStack S,DataType *x)
{
    if(Empty_SeqStack(S))
        return 0;
    else
    {
        *x = S->data[S->top];
        S->top--;
        return 1;
    }
}

int GetTop_SeqStack(PSeqStack S ,DataType *x)
{
    if(Empty_SeqStack(S))
        return 0;
    else
    {
        *x = S->data[S->top];
        return 1;
    }
}
int GetLength_SeqStack(PSeqStack S)
{
    return S->top + 1;
}

void Distory_SeqStack(PSeqStack *S)
{
    if(*S)
        free(*S);
    *S = NULL;
}//end seqstack.h

4.运行结果：

栈求解迷宫：