迷宫（数据结构栈课设-可运行）

数据机构迷宫源码：用栈来完成一个迷宫。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<windows.h>
#include<time.h>
#include<vector>
#define MAXSIZE 100
#define X 9
#define Y 9
typedef struct {
	int state;		//0是墙 1是未走过的路 2走过的路 3分岔路 4是返回的路
	int x;
	int y;
}SElemType;

typedef struct StackNode {
	SElemType data;
	struct StackNode* next;
}StackNode, * LinkStack;

void InitStack(LinkStack& S);//初始化栈
int StackEmpty(LinkStack S); //判栈空
int PushStack(LinkStack& S, SElemType e);//压栈
int PopStack(LinkStack& S, SElemType& e);//出栈
int Read(LinkStack& S, SElemType e);  //读取栈顶

void Printf_Map(int Map[][Y]);  //画迷宫

int RandMap(int* b_x, int* b_y, int* o_x, int* o_y);//读取迷宫

int Map[X][Y]; //地图二维数组

int main() {
	LinkStack S;
	SElemType e;
	int num = 0;
	int d, u, l, r;
	int x, y;
	int b_x, b_y, o_x, o_y;
	int return_Read = 1;
	InitStack(S);//初始化栈
	d = u = l = r = 0;//初始化四个方向
	Map[X][Y] = { 0 };//初始化地图

	RandMap(&b_x, &b_y, &o_x, &o_y);//随机产生地图后返回初始地址和终点地址
	e.x = b_x;
	e.y = b_y;   //给起始结点赋值
	x = o_x;     
	y = o_y;
	printf("起点%d %d 终点%d %d\n", b_x, b_y, o_x, o_y);


	e.state = 2;
	PushStack(S, e);   //起始结点入栈

	//将起点和终点打印在地图上
	Map[e.x][e.y] = 2;
	Map[o_x][o_y] = 1;
	Printf_Map(Map);
	system("pause");
	system("cls");




	while (1)
	{
		//向下走
		if (Map[e.x + 1][e.y] == 1)
		{
			d = 1;
			num++;
		}
		//向上走
		if (Map[e.x - 1][e.y] == 1)
		{
			u = 1;
			num++;
		}
		//向左走
		if (Map[e.x][e.y - 1] == 1)
		{
			l = 1;
			num++;
		}
		//向右走
		if (Map[e.x][e.y + 1] == 1)
		{
			r = 1;
			num++;
		}
		if (num == 0)
		{
			e.state = 2;//标记为走过的路
			//退回到分叉路口
			while (e.state != 3)
			{
				PopStack(S, e);
				return_Read = Read(S, e);
				Map[e.x][e.y] = 4;//把返回的路标记为4
			}
			PopStack(S, e);
			Read(S, e);
			Map[e.x][e.y] = 4;
			e.state = 3;
		}
		else if (num == 1)
		{
			e.state = 2;
		}
		else if (num > 1)
		{
			e.state = 3;
		}

		num = 0;
		if (r == 1)
		{
			e.y = e.y + 1;
		}
		else if (d == 1)
		{
			e.x = e.x + 1;
		}
		else if (l == 1)
		{
			e.y = e.y - 1;
		}
		else if (u == 1)
		{
			e.x = e.x - 1;
		}


		d = u = l = r = 0;
		PushStack(S, e);

		//退出条件 走到终点时
		if (e.x == o_x && e.y == o_y)
		{
			Map[e.x][e.y] = 2;
			Sleep(1000);
			system("cls");
			Printf_Map(Map);
			printf("\n成功走出\n");
			system("pause");
			printf("走出的倒序路径为");
			while (S != NULL)
			{
				printf("%d %d", S->data.x, S->data.y);
				printf("\n");
				S = S->next;
			}
			break;
		}

		Map[e.x][e.y] = 2;
		Printf_Map(Map);
		Sleep(1000);
		system("cls");//迷宫每走一步就清屏达到动态移动效果
		///
		if (return_Read == 0)
		{
			//退出条件 本来就没有终点
			Map[e.x][e.y] = 2;
			Sleep(1000);
			system("cls");
			Printf_Map(Map);
			printf("\n该迷宫没有通路\n");
			system("pause");

			break;
		}
	}
	
	
	return 0;
}


//S为栈顶指针

void InitStack(LinkStack& S) {	//构造一个空栈，栈顶指针为空
	S = NULL;
}

int StackEmpty(LinkStack S) {    //判断栈空
	if (S == NULL)
		return 1;
	else
		return 0;
} 

int PushStack(LinkStack& S, SElemType e) {
	LinkStack p;
	p = new StackNode;	//生成新的节点P
	p->data = e;	    //将数据的新节点赋值成e
	p->next = S;		//将新节点插入栈顶
	S = p;				//将S向上移动成为新的栈顶指针
	return 0;
}
int PopStack(LinkStack& S, SElemType& e) {
	LinkStack p;
	if (S == NULL)	    //空栈
		return 0;
	e = S->data;	    //将栈顶节点数据的数据赋值到e里面
	p = S;				//栈顶增加一个p指针
	S = S->next;		//指针S向下移动
	delete p;			//释放栈顶空间
	return 1;
}

int Read(LinkStack& S, SElemType e)
{
	if (S == NULL)
	{
		return 0;
	}
	e = S->data;
	return 1;
}

void Printf_Map(int Map[][Y])  //打印地图
{
	int i, j;
	for (i = 0; i < X; i++)
	{
		for (j = 0; j < Y; j++)
		{
			printf("%d ", Map[i][j]);
		}
		printf("\n");
	}
}

int RandMap(int* b_x, int* b_y, int* o_x, int* o_y)
{
	//int Map[X][Y] = { 0 };
	int i, j, k;
	int x, y;
	int location; 
	int temp;
	int begin_x, begin_y;
	int out_x, out_y;
	//初始化地图
	for (i = 1; i <= X - 1; i = i + 2)
	{
		for (j = 1; j <= Y - 1; j = j + 2)
		{
			Map[i][j] = 1;//找到迷宫的九宫格中心
		}
	}


	/*
		666
	*/

	//Printf_Map(Map);

	//生成随机地图
	srand((int)time(NULL));
	for (i = 1; i <= X - 1; i = i + 2)
	{
		for (j = 1; j <= Y - 1; j = j + 2)
		{
			temp = rand() % 2 + 1; //随机生成1~2
			for (k = 0; k < temp; k++)
			{
				while (1)
				{
					x = i;
					y = j;
					location = rand() % 4;
					if (x == 1 && location == 0)
					{
						continue;
					}
					else if (x == X - 2 && location == 1)
					{
						continue;
					}
					else if (y == 1 && location == 2)
					{
						continue;
					}
					else if (y == Y - 2 && location == 3)
					{
						continue;
					}
					else
						break;
				}
				switch (location)
				{
				case 0: x = x - 1; break;
				case 1: x = x + 1; break;
				case 2: y = y - 1; break;
				case 3: y = y + 1; break;
				}
				Map[x][y] = 1;
			}
		}
	}
	//随机产生一个起点
	srand((int)time(NULL));
	while (1)
	{
		begin_x = rand() % (X);
		begin_y = rand() % (Y);
		if (begin_x == 0 && begin_y == 0)
		{
			continue;
		}
		else if (begin_x == 0 && begin_y == Y - 1)
		{
			continue;
		}
		else if (begin_x == X - 1 && begin_y == 0)
		{
			continue;
		}
		else if (begin_x == X - 1 && begin_y == Y - 1)
		{
			continue;
		}
		if (begin_x == 0 || begin_x == X || begin_y == 0 || begin_y == Y)
		{
			break;
		}
	}
	Map[begin_x][begin_y] = 1;

	//随机产生一个终点
	srand((int)time(NULL));
	while (1)
	{
		out_x = rand() % (X);
		out_y = rand() % (Y);
		if (out_x == 0 && out_y == 0)
		{
			continue;
		}
		else if (out_x == 0 && out_y == Y - 1)
		{
			continue;
		}
		else if (out_x == X - 1 && out_y == 0)
		{
			continue;
		}
		else if (out_x == X - 1 && out_y == Y - 1)
		{
			continue;
		}
		if (out_x == begin_x || out_y == begin_y)
		{
			continue;
		}
		if (out_x == 0 || out_x == X || out_y == 0 || out_y == Y)
		{
			break;
		}
	}
	//Map[out_x][out_y] = 1;
	//Printf_Map(Map);

	//指针传参
	*b_x = begin_x;
	*b_y = begin_y;
	*o_x = out_x;
	*o_y = out_y;
	return 0;
}