数据结构课程实验->迷宫->分别用链栈，链队，顺序栈，顺序队实现。

最新推荐文章于 2021-09-22 11:45:06 发布
最新推荐文章于 2021-09-22 11:45:06 发布
阅读量815 收藏 9
点赞数 4
分类专栏： 课程设计 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wyh1618/article/details/83547074
版权

迷宫
    实现老鼠走迷宫程序。
    功能要求：①输出每一步尝试的状态，直到走完迷宫或无法走通②在迷宫有解的前提下，输出从起点到终点的最短通路。
    设计要求：迷宫至少10×10；起点和终点可自定义，也可固定；迷宫可随机生成，也可固定，可以无解；两个功能可用不同算法和程序实现；输出可以是图形界面，也可以是文本界面（如下例）。
# # # # # # # # # #
# 0 # # 0 0 0 # # #
# 0 0 0 0 # 0 0 0 #
# 0 0 # # # # # 0 #
# # #    #      # 0 #
# # #      #  0 0 0 #
# # #     #   0 # # #
# # # # # # 0 # # #
# # # # # # 0 0 0 #
# # # # # # # # # #

 

//欢迎大佬批评。。。

//哪里不懂的评论。。。

 

顺序栈

#include<iostream>
#include<malloc.h>
#define maxsize 100
using namespace std;
#define M 8
#define N 8
int mg[M+2][N+2]=
{
    {1,1,1,1,1,1,1,1,1,1},
    {1,0,0,0,0,0,1,1,0,1},
    {1,0,1,1,0,0,1,1,0,1},
    {1,0,1,1,0,1,1,1,0,1},
    {1,0,1,1,0,1,0,1,1,1},
    {1,1,0,1,0,1,0,0,1,1},
    {1,0,1,1,0,1,1,1,0,1},
    {1,0,0,1,0,1,1,1,1,1},
    {1,1,0,0,0,0,0,0,0,1},
    {1,1,1,1,1,1,1,1,1,1}
};
typedef struct
{
   int i;
   int j;
   int di;
}box;
typedef struct
{
    box date[maxsize];
    int top;
}sqstack;
void initstack(sqstack *&s)
{
    s=(sqstack *)malloc(sizeof(sqstack));
    s->top=-1;
}
void destorystack(sqstack *&s)
{
    free(s);
}
bool stackempty(sqstack *s)
{
    return s->top==-1;
}
bool push(sqstack *&s,box &e)
{
    if(s->top==maxsize-1)
        return false;
    s->top++;
    s->date[s->top]=e;
    return true;
}
bool pop(sqstack *&s,box &e)
{
    if(s->top==-1)
        return false;
    e=s->date[s->top];
    s->top--;
    return true;
}
bool gettop(sqstack *&s,box &e)
{
    if(s->top==-1)
        return false;
    e=s->date[s->top];
    return true;
}
bool mgpath(int xi,int yi,int xe,int ye)
{
    box path[maxsize],e;
    int i,j,di,il,jl,k;
    bool find;
    sqstack *s;
    initstack(s);
    e.i=xi;
    e.j=yi;
    e.di=-1;
    push(s,e);
    mg[xi][yi]=-1;
    while(!stackempty(s))
    {
        gettop(s,e);
        i=e.i;
        j=e.j;
        di=e.di;
        if(xe==i&&ye==j)
        {
            cout<<"\t迷宫路径如下:"<<endl;
            cout<<"\t";
            k=0;
            while(!stackempty(s))
            {
                pop(s,e);
                path[k++]=e;
            }
            while(k>=1)
            {
                k--;
                cout<<"("<<path[k].i<<','<<path[k].j<<") ";
            }
            cout<<endl;
            destorystack(s);
            return true;
        }
        find=false;
        while(di<4&&!find)
        {
            di++;
            switch(di)
            {
                case 0:il=i-1;jl=j;break;
                case 1:il=i;jl=j+1;break;
                case 2:il=i+1;jl=j;break;
                case 3:il=i;jl=j-1;break;
            }
            if(mg[il][jl]==0)
                find=true;
        }
        if(find)
        {
            s->date[s->top].di=di;
            e.i=il;
            e.j=jl;
            e.di=-1;
            push(s,e);
            mg[il][jl]=-1;
        }
        else
        {
            pop(s,e);
            mg[e.i][e.j]=0;
        }
    }
    destorystack(s);
    return false;
}
int main()
{
    if(!mgpath(1,1,M,N))
        cout<<"改迷宫没有解"<<endl;
    return 0;
}

链栈

#include<iostream>
#include<malloc.h>
#define maxsize 100
using namespace std;
#define M 8
#define N 8
int mg[M+2][N+2]=
{
    {1,1,1,1,1,1,1,1,1,1},
    {1,0,0,0,0,0,1,1,0,1},
    {1,0,1,1,0,0,1,1,0,1},
    {1,0,1,1,0,1,1,1,0,1},
    {1,0,1,1,0,1,0,1,1,1},
    {1,1,0,1,0,1,0,0,1,1},
    {1,0,1,1,0,1,1,1,0,1},
    {1,0,0,1,0,1,1,1,1,1},
    {1,1,0,0,0,0,0,0,0,1},
    {1,1,1,1,1,1,1,1,1,1}
};
typedef struct
{
   int i;
   int j;
   int di;
}box;
typedef struct a
{
    box date;
    struct a *next;
}sqstack;
void initstack(sqstack *&s)
{
    s=(sqstack *)malloc(sizeof(sqstack));
    s->next=NULL;
}
void destorystack(sqstack *&s)
{
    sqstack *pre=s,*p=s->next;
    while(p!=NULL)
    {

        free(pre);
        pre=p;
        p=pre->next;
    }
    free(pre);
}
bool stackempty(sqstack *s)
{
    return (s->next==NULL);
}
bool push(sqstack *&s,box &e)
{
    sqstack *p;
    p=(sqstack *)malloc(sizeof(sqstack));
    p->date=e;
    p->next=s->next;
    s->next=p;
}
bool pop(sqstack *&s,box &e)
{
    sqstack *p;
    if(s->next==NULL)
        return false;
    p=s->next;
    e=p->date;
    s->next=p->next;
    free(p);
    return true;
}
bool gettop(sqstack *&s,box &e)
{
    e=s->next->date;
    return true;
}
bool mgpath(int xi,int yi,int xe,int ye)
{
    box path[maxsize],e;
    int i,j,di,il,jl,k;
    bool find;
    sqstack *s;
    initstack(s);
    e.i=xi;
    e.j=yi;
    e.di=-1;
    push(s,e);
    mg[xi][yi]=-1;
    while(!stackempty(s))
    {
        gettop(s,e);
        i=e.i;
        j=e.j;
        di=e.di;
        if(xe==i&&ye==j)
        {
            cout<<"\t迷宫路径如下:"<<endl;
            cout<<"\t";
            k=0;
            while(!stackempty(s))
            {
                pop(s,e);
                path[k++]=e;
            }
            while(k>=1)
            {
                k--;
                cout<<"("<<path[k].i<<','<<path[k].j<<") ";
            }
            cout<<endl;
            destorystack(s);
            return true;
        }
        find=false;
        while(di<4&&!find)
        {
            di++;
            switch(di)
            {
                case 0:il=i-1;jl=j;break;
                case 1:il=i;jl=j+1;break;
                case 2:il=i+1;jl=j;break;
                case 3:il=i;jl=j-1;break;
            }
            if(mg[il][jl]==0)
                find=true;
        }
        if(find)
        {
            s->date.di=di;
            e.i=il;
            e.j=jl;
            e.di=-1;
            push(s,e);
            mg[il][jl]=-1;
        }
        else
        {
            pop(s,e);
            mg[e.i][e.j]=0;
        }
    }
    destorystack(s);
    return false;
}
int main()
{
    if(!mgpath(1,1,M,N))
        cout<<"改迷宫没有解"<<endl;
    return 0;
}

顺序队

#include<iostream>
#include<malloc.h>
#define maxsize 100
using namespace std;
int mg[10][10]=
{
    {1,1,1,1,1,1,1,1,1,1},
    {1,0,0,1,0,0,0,1,0,1},
    {1,0,0,1,0,0,0,1,0,1},
    {1,0,0,0,0,1,1,0,0,1},
    {1,0,1,1,1,0,0,0,0,1},
    {1,0,0,0,1,0,0,0,0,1},
    {1,0,1,0,0,0,1,0,0,1},
    {1,0,1,1,1,0,1,1,0,1},
    {1,1,0,0,0,0,0,0,0,1},
    {1,1,1,1,1,1,1,1,1,1}
};
typedef struct
{
    int i,j;
    int pre;
}box;
typedef struct
{
    box date[maxsize];
    int front,rear;
}qutype;
void initqueue(qutype *&q)
{
    q=(qutype *)malloc(sizeof(qutype));
    q->front=q->rear=-1;
}
bool enqueue(qutype *&q,box &e)
{
    if(q->rear==maxsize-1)
        return false;
    q->rear++;
    q->date[q->rear]=e;
    return true;
}
bool dequeue(qutype *&q,box &e)
{
    if(q->rear==q->front)
        return false;
    q->front++;
    e=q->date[q->front];
    return true;
}
bool destoryqueue(qutype *&q)
{
    free(q);
}
bool emptyqueue(qutype *&q)
{
    return (q->rear==q->front);
}
void print(qutype *&q,int front)
{
    int k=front,j,ans=0;
    cout<<endl;
    do
    {
        j=k;
        k=q->date[k].pre;
        q->date[j].pre=-1;
    }while(k!=0);
    cout<<"\t迷宫路径如下："<<endl;
    cout<<"\t";
    k=0;
    while(k<maxsize)
    {
        if(q->date[k].pre==-1)
        {
            cout<<"("<<q->date[k].i<<','<<q->date[k].j<<") ";
        }
        k++;
    }
    cout<<endl;
}
bool mgpath1(int xi,int yi,int xe,int ye)
{
    box e;
    int i,j,di,il,jl;
    qutype *q;
    initqueue(q);
    e.i=xi;
    e.j=yi;
    e.pre=-1;
    enqueue(q,e);
    mg[xi][yi]=-1;
    while(!emptyqueue(q))
    {
        dequeue(q,e);
        i=e.i;
        j=e.j;
        if(xe==i&&ye==j)
        {
            print(q,q->front);
            destoryqueue(q);
            return true;
        }
        for(di=0;di<4;di++)
        {
            switch(di)
            {
                case 0:il=i-1;jl=j;break;
                case 1:il=i;jl=j+1;break;
                case 2:il=i+1;jl=j;break;
                case 3:il=i;jl=j-1;break;
            }
            if(mg[il][jl]==0)
            {
                e.i=il;
                e.j=jl;
                e.pre=q->front;
                enqueue(q,e);
                mg[il][jl]=-1;
            }
        }
    }
    destoryqueue(q);
    return false;
}
int main()
{
    if(!mgpath1(1,1,8,8))
        cout<<"该迷宫无解"<<endl;
    return 0;
}

 

链队

#include<iostream>
#include<cstring>
#include<cstring>
#include<malloc.h>
using namespace std;
int map[10][10]={
    {1,1,1,1,1,1,1,1,1,1},
    {1,0,0,1,0,0,0,1,0,1},
    {1,0,0,1,0,0,0,1,0,1},
    {1,0,0,0,0,1,1,0,0,1},
    {1,0,1,1,1,0,0,0,0,1},
    {1,0,0,0,1,0,0,0,0,1},
    {1,0,1,0,0,0,1,0,0,1},
    {1,0,1,1,1,0,1,1,0,1},
    {1,1,0,0,0,0,0,0,0,1},
    {1,1,1,1,1,1,1,1,1,1}
};
int m,n;
int point[4][2]={1,0,0,1,-1,0,0,-1};
int startx,starty,endx,endy;
int e1,e2;
int ans=1;
bool flag=false;
bool vis[1000][10000];
typedef struct linknode
{
    int xx,yy;
    int data;
    struct linknode *pre;
    struct linknode *next;
}qutype;

void InitQueue(qutype *&s)
{
    s=(qutype *)malloc(sizeof(qutype));
    s->next=NULL;
}

void DestoryQueue(qutype *&s)
{
    qutype *pre=s,*p=s->next;
    while(p!=NULL)
    {
        free(pre);
        pre=p;
        p=p->next;
    }
    free(pre);
}

bool QueueEmpty(qutype *s)
{
    return s->next==NULL?true:false;
}

void Enqueue(qutype *&s,int e1,int e2)
{
    qutype *p,*t;
    t=s;
    while(t->next!=NULL)
        t=t->next;
    p=(qutype *)malloc(sizeof(qutype));
    p->xx=e1;
    p->yy=e2;
    t->next=p;
    p->next=NULL;
}
void Enqueue1(qutype *&head,int e1,int e2,int x1,int x2)
{
    qutype *p,*t,*r=NULL;
    t=head;
    while(t->next!=NULL)
    {
        if(t->xx==x1&&t->yy==x2)
            r=t;
        t=t->next;
    }
    p=(qutype *)malloc(sizeof(qutype));
    p->xx=e1;
    p->yy=e2;
    t->next=p;
    p->next=NULL;
    p->pre=r;
}
bool Dequeue(qutype *&s)
{
    qutype *p;
    if(s->next==NULL)
        return false;
    p=s->next;
    s->next=p->next;
    free(p);
    return true;
}
qutype GetTop(qutype *s)
{
    linknode xy;
    if(s->next==NULL)
    {
        xy.xx=-1;
        xy.yy=-1;
    }
    else
    {
        xy.xx=s->next->xx;
        xy.yy=s->next->yy;
    }
    return xy;
}

bool check(int x,int y)
{
    if(map[x][y]==0&&vis[x][y]==false)
        return true;
    return false;
}

void display(qutype *&head,int end_x,int end_y)
{
    linknode *p;
    p=head;
    while(p)
    {
        if(p->xx==end_x&&p->yy==end_y)
            break;
        p=p->next;
    }
    while(p->pre!=NULL)
    {
        cout<<"("<<p->xx<<","<<p->yy<<")"<<" ";
        p=p->pre;
    }
    cout<<"("<<startx<<","<<startx<<")"<<endl;
}
void BFS(qutype *&s,qutype *&head,int x,int y)
{
    vis[x][y]=true;
    Enqueue(s,x,y);
    Enqueue1(head,x,y,-1,-1);
    while(!QueueEmpty(s))
    {
        linknode xy;
        xy=GetTop(s);
        if(xy.xx==endx&&xy.yy==endy)
        {
            cout<<endl;
            cout<<"\tDisplay!"<<endl;
            cout<<"\t";
            display(head, endx, endy);
            flag=true;
            break;
        }
        Dequeue(s);
        for(int i=0;i<4;i++)
        {
            int new_x=xy.xx+point[i][0];
            int new_y=xy.yy+point[i][1];
            if(new_x>=0&&new_x<m&&new_y>=0&&new_y<n&&check(new_x, new_y))
            {
                vis[xy.xx+point[i][0]][xy.yy+point[i][1]]=true;
                Enqueue(s, xy.xx+point[i][0], xy.yy+point[i][1]);
                Enqueue1(head,xy.xx+point[i][0],xy.yy+point[i][1],xy.xx,xy.yy);
            }
        }
    }
    DestoryQueue(s);
    if(!flag)
    {
        cout<<"NO_Way"<<endl;
    }
}
int main()
{
    qutype *s;
    qutype *head;
    InitQueue(s);
    InitQueue(head);
    m=10;n=10;
    startx=1;starty=1;
    endx=8;
    endy=8;
    memset(vis ,false,sizeof vis);
    head->xx=startx;
    head->yy=starty;
    head->pre=NULL;
    head->next=NULL;
    BFS(s,head,startx,starty);
    return 0;
}

 

//强行上栈上队列。。。

 

 

 

C语言 - 【回溯算法】迷宫问题 (顺序栈与链栈)
⚡
11-07 1万+
回溯算法可以看成是栈的一个十分成熟的应用， 本质上秉承着："正确前进错误返回"的原则，通过入栈存储以前经过的所有节点， 当在一个方向上遇到死路，则依次弹栈返回前一个节点，继续按照相同的规律继续下一步的判断+入栈+弹栈操作。 < 本篇文章主要通过顺序栈与链栈(通过链表模拟)的方式实现迷宫问题 > 一：迷宫问题思路分析及实现（顺序栈） 1> 先不谈具体算法，首...
迷宫问题 链队解法
biubiu_buaa的博客
06-19 439
//queue.h #ifndef queue_h #define queue_h #include <stdlib.h> #include <iostream> struct point { public: int index; int x; int y; int pre; }; struct queue { private: struct Node {...
数据结构的顺序栈、链式栈、链队列、循环队列的实现
love_786的博客
07-19 740
如何实现栈和队的操作
数据结构之迷宫求解栈（链式栈）实现，队列（循环队列）实现
qq_43312665的博客
01-01 662
思路： 将迷宫的布局的矩阵（对应位置的值为0：表示通路，1：表示障碍，-1：表示已访问过）作为全局变量，flag作为全局变量，flag=1:邻居中有出口，flag=0：邻居中无出口，然后先把入口Enter的位置入栈，然后把入口在迷宫布局中对应的值改成-1，表示已经访问过，然后进入循环，{栈顶元素出栈，先判断栈顶元素是否是出口的位置，如果是，则退出循环，如果不是则继续，将flag改成0，然后从出栈元...
2021-9-22【数据结构/严蔚敏】【顺序栈&链式栈&迷宫求解&表达式求值】【代码实现算法3.1-3.5】
eternity_memory的博客
09-22 2249
栈的顺序存储结构代码实现 #include<bits/stdc++.h> using namespace std; #define SElemType int #define Status int #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 //-------栈的顺序存储结构----------------- typedef struct{ SElemType *base; //栈底 SElemT
数据结构-栈的应用：顺序栈与链栈的应用
03-22
在这个主题中，我们将专注于栈（Stack）这一特殊的数据结构，及其在实际应用中的两种主要实现方式：顺序栈（Sequential Stack）和链栈（Linked Stack）。栈通常被称为&ldquo;后进先出&rdquo;（LIFO，Last In First Out）的数据...
数据结构实验报告_链栈_迷宫问题波兰表达式_huffman树及其编码_数据结构c++_图操作顺序表查找_
09-29
在这个实验报告中，我们将探讨几个关键的数据结构及其应用，包括链栈、迷宫问题、波兰表达式、哈夫曼树及其编码，以及数据结构在C++中的实现，还有图的操作、顺序表查找等。 首先，链栈是一种基于链表实现的栈数据...
数据结构实验指南：栈与队列算法设计与应用
最新发布
10-14
本文档是一份详细的数据结构实验教学材料，涵盖栈（两种形式分别为顺序栈和链栈）与队列（包括环形队列和链队）的基础操作算法的学习实践，重点在于理解和运用这些基本概念。主要内容围绕着对各种数据结构实现具体的...
C++数据结构实验报告：链栈、迷宫、波兰表达式与Huffman编码
资源摘要信息:&quot;本实验报告详细探讨了数据结构在算法实现中的应用，涵盖了链栈、迷宫问题、波兰表达式、Huffman树及其编码以及顺序表查找等关键知识点。通过对这些内容的学习和实践，我们可以更好地理解和掌握数据...
数据结构之链栈实现
李霁明的博客
06-25 550
文章目录数据结构之链栈实现代码及思想测试截图 数据结构之链栈实现 代码及思想 #include <iostream> #include <cstdio> #include <cstdlib> using namespace std; #define ElemType int #define Status int #define OK 1 #define ERR...
链式队列实现迷宫寻径
网世的博客
11-27 642
测试类 public class TestQueue1 { public static void main(String[] args) { int[][] map={ {1,1,1,1,1,1,1,1,1,1}, {1,0,1,0,1,0,1,1,1,1}, {1,0,0,1,0,1,0,1,1,1}, {1,1,1,1,0,1,0,0,1,
链表，顺序表，链队，链栈，顺序队，顺序栈，二叉树的基本操作函数
wp1027322856的博客
10-24 540
链表的基本操作： #include #include #include typedef struct node{     int data;     struct node *next; }list,*L; L creat(void) {     L l1 = malloc(sizeof(list));     l1->data = -1;     l1->ne
利用栈实现迷宫的求解
weixin_33946605的博客
04-26 165
　　问题描述：这时实验心理学中的一个典型的问题，心理学家吧一只老鼠从一个无顶的大盒子的入口处赶进迷宫。迷宫设置很多隔壁，对前进方向形成了许多障碍，心理学家在迷宫的唯一出口处放置了一块奶酪，吸引老鼠仔迷宫中寻找通路以到达出口。 　　求解思想：回溯法是一种不断试探且及时纠正错误的搜索方法，下面的求解过程采用回溯法。从入口出发，按某一方向向前探索，若能走通（未...
利用栈实现迷宫求解
acwos42408的博客
03-26 290
利用栈实现迷宫求解 前言：众所周知，栈是（First in last out）先进后出的数据结构，利用这个属性可以实现类似与回溯的方式，比如当前数据满足条件，则入栈，否则出栈返回上一级，依次循环。 在本题中，将每个迷宫路径上的点封装成上下左右四个方向数节点，先入栈迷宫入口节点，如果上下左右没被使用，则将其上下左右的点入栈，否则出栈。如果最终达到迷...
迷宫最短路径问题(ShortestPath)的求解——利用链式队列
热门推荐
Catherine的笔记
06-05 1万+
迷宫最短路径问题(ShortestPath)的求解——利用链式队列 注：借助于栈求解迷宫问题时，并不能保证找到一条从迷宫入口到迷宫出口的最短路径。而借助于队列，可以找到从迷宫入口到迷宫出口的最短路径(如果有的话)。在迷宫中寻找最短路径问题在其他领域也存在，例如，在解决电路布线问题时，一种很常用的方法是在布线区域叠上一个网格，该网格把布线区域划分成n*m个方格，就像迷宫一样。从一个方格a的中心点连接到另一个方格b的中
链式栈实现迷宫寻径
网世的博客
11-28 823
测试类 public class maintest { public static void main(String[] args) {//主方法类 int[][] map={ {1,1,1,1,1,1,1,1,1,1}, {1,0,1,0,1,0,1,1,1,1}, {1,0,0,1,0,1,0,1,1,1},
c语言用链表解迷宫,数据结构C语言版的迷宫问题如何解决？
weixin_32139249的博客
05-21 357
满意答案xfvmq38902013.11.17采纳率：51%等级：12已帮助：9028人//迷宫实现 。。。#includeusing namespace std;class Stack{public:void clear();bool push(const int item);bool pop(int & item);bool Top(int & item);bool i...
求解迷宫问题（队列）
Nothing_Wzy的博客
04-16 5930
目录 算法描述 用一个队列q来存储记录走过的坐标 经过多次记录后： 对应的迷宫路径示意图如下： 则读出来的迷宫路径坐标如下： 我们开始敲代码吧： 代码部分 准备工作： 1. 建立迷宫 **//对应的数组下标 0 1 2 3 4 5 6 7 8 9** int a[][10]={ 1,1,1,1,1,1,1,1,1,1, 1,-1,1,0,0,0,1,1,1,1,//起点为-1 ...
Java多线程总结之聊一聊Queue
专注、专心、专业
10-28 2184
上个星期总结了一下synchronized相关的知识，这次将Queue相关的知识总结一下，和朋友们分享。 在Java多线程应用中，队列的使用率很高，多数生产消费模型的首选数据结构就是队列。Java提供的线程安全的Queue可以分为阻塞队列和非阻塞队列，其中阻塞队列的典型例子是BlockingQueue，非阻塞队列的典型例子是ConcurrentLinkedQueue，在实际应用中要根据实际需
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Loganer

感谢

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值