数据结构—深度优先迷宫（链栈）

#include "stdafx.h"
#include "stdafx.h"
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

//定义结点，栈顶链栈类型

typedef int DataType;
struct Node
{
	DataType data;
	struct Node* next;
};
typedef struct Node *PNode;
typedef struct Node *top;
typedef struct Node *LinkStack;



//创建空栈
LinkStack SetNullStack()
{
	LinkStack top=(LinkStack)malloc(sizeof(struct Node));//申请栈顶空间top指向
	if(top!=NULL)
		top->next =NULL;
	else
		printf("alloc failure");
	return top;//返回栈顶指针
}



//判断栈空

int IsNullStack(LinkStack top)
{
	return(top->next == NULL);
}



//进栈

void Push(LinkStack top,DataType x)//进栈
{
	PNode p=(PNode)malloc(sizeof(struct Node));//结点p2用于存放新进栈数据
	if(p!=NULL)
	{
		p->data =x;
		p->next =top->next ;//使指针域为NULL
		top->next =p;
	}
	else
		printf("alloc failure!\n");
}



//出栈

void Pop(LinkStack top)
{
	PNode p;
	if(IsNullStack(top))
		printf("empty!\n");
	else
	{
		p=top->next ;//孤立然后删除
		top->next =p->next ;
		free(p);
	}
}



//取栈顶元素

int top_seq(LinkStack top)
{
	if(IsNullStack(top))
		printf("empty!\n");
	else
		return top->next ->data ;
}



//打印链栈
void printLinkStack(LinkStack top)
{
	PNode p;
	if (top == NULL)
		printf("\n The Linklist is NULL !\n");
	p = top->next;
	while (p != NULL)
	{
		printf("%d", p->data);
		p = p->next;
	}

	printf("\n");
}

//定义迷宫类型并创建一个迷宫赋初值
struct Maze
{
	int size;//迷宫边长
	int data[9][9];
}maze={9,{{1,1,1,1,1,1,1,1,1},
          {1,0,0,1,1,0,1,1,1},
          {1,1,0,0,0,0,0,0,1},
          {1,0,1,0,0,1,1,1,1},
          {1,0,1,1,1,0,0,1,1},
          {1,1,0,0,1,0,0,0,1},
          {1,0,1,1,0,0,0,1,1},
          {1,1,1,1,1,1,1,0,1},
          {1,1,1,1,1,1,1,1,1}}};


//迷宫深度遍历算法
int mgsdbl(int inX,int inY,int outX,int outY,Maze* maze)//入口坐标，出口坐标，迷宫
{
	int direction[8][2]={{0,1},
	                     {1,1},
	                     {1,0},
	                     {1,-1},
	                     {0,-1},
	                     {-1,-1},
	                     {-1,0},
	                     {-1,1}};
	//入口（0,0）的临近8个位置保存,从入口左边开始顺时针保存
	LinkStack stackX=SetNullStack();//创建存放坐标x的栈
	LinkStack stackY=SetNullStack();//创建存放坐标y的栈
	int posX,posY;//存放当前位置
	int preposX,preposY;//存放上一个位置（用于在出栈前保存位置）
	int i,j;
	int **mark;//标志二维数组，走过的位置设为1
	int mov;//移动方向
	mark=(int**)malloc(sizeof(int*)*maze->size);//给mark分配迷宫maze那么大的空间
	for(i=0;i<maze->size;i++)
		mark[i]=(int*)malloc(sizeof(int)*maze->size);
	for(i=0;i<maze->size;i++)//给mark每个元素赋初值0
		for(j=0;j<maze->size;j++)
			mark[i][j]=0;
	mark[inX][inY]=1;//设置入口标志为1，因为已经走过了
	Push(stackX,inX);//将入口的xy坐标分别入栈
	Push(stackY,inY);
	while(!IsNullStack(stackX))//当栈不为空则说明找到入口即开始下面...
	{
		preposX=top_seq(stackX);//先存放当前位置，然后将当前位置坐标出栈
		preposY=top_seq(stackY);
		Pop(stackX);
		Pop(stackY);
		mov=0;//初始化mov移动0次
		while(mov<8)//小于8则说明周围的位置还没遍历完，可继续遍历
		{
			posX=preposX+direction[mov][0];//从当前位置的左边位置由顺时针方向开始遍历，由posX，Y存放当前所遍历到的位置
			posY=preposY+direction[mov][1];
			if(posX==outX && posY==outY)//如果当前遍历到的位置即为出口则...
			{
				Push(stackX,preposX);//入口点入栈
				Push(stackY,preposY);
				printf("深度搜索迷宫路径如下：\n");
				printf("%d %d\t",outX,outY);//打印出口点
				while(!IsNullStack(stackX))//将路径逆序输出
				{
					posX=top_seq(stackX);
					posY=top_seq(stackY);
					Pop(stackX);
					Pop(stackY);
					printf("%d %d\t",posX,posY);
				}
				return 1;
			}
			if(maze->data[posX][posY]==0 && mark[posX][posY]==0)//若还有路可走（没被标志过）
			{
				mark[posX][posY]=1;//标志这条路走过
				Push(stackX,preposX);
				Push(stackY,preposY);
				preposX=posX;
				preposY=posY;
				mov=0;
			}
			else mov++;
		}
	}
	return 0;
}

int main()
{
	mgsdbl(1,1,6,6,&maze);
	system("pause");
}