C语言栈求解迷宫

采用穷举，地图用二维数组表示，0为可通，1为不可通，位置用int型表示，例如：a[2][3] 的位置为12，a[9][9]的位置为88；输出结果为位置路径，代码如下：

#include <stdio.h>
#include<malloc.h>

typedef int SElemType;

#define Maxsize 30
typedef struct {
	SElemType* base;
	SElemType* top;
	int size;
}SqStack, * ListStack;

void StackInit(ListStack& S) {     //初始化
	S = (ListStack)malloc(sizeof(SqStack));
	S->base = (SElemType*)malloc(Maxsize * sizeof(SElemType));
	S->top = S->base;
	S->size = Maxsize;
}

void StackPush(ListStack S, SElemType e) {//入栈
	if (S->base == S->top - S->size)
	{
		return;
	}
	*S->top++ = e;
}

SElemType StackPop(ListStack S) {//出栈
	if (S->base == S->top) return 0;
	SElemType e;
	e = *S->top--;
	return e;
}

void StackDisplay(ListStack S) {//输出栈
	for (SElemType* i = S->base; i < S->top; i++)
	{
		printf("%d ", *i);             //字符修改
	}
}

SElemType StackGet(ListStack S) {//取栈的顶部
	if (S->base == S->top) { return 0; }
	else { return *(S->top - 1); }
}

int IfContinue(int *map,int culumn,int position) { //判断迷宫的方向
	 int cow_run = position / culumn;
	 int culumn_run = position % culumn;
	 if (*(map + (cow_run - 1) * culumn + culumn_run) == 0) {
		 return 1;//向上走
	 }
	 else if (*(map + cow_run * culumn + culumn_run+1) == 0)
	 {
		 return 2;//向右走
	 }
	 else if(*(map + (cow_run+1) * culumn + culumn_run) == 0)
	 {
		 return 3;//向下走
	 }
	 else if(*(map + cow_run * culumn + culumn_run-1) == 0)
	 {
		 return 4;//向左走
	 }
	 else
	 {
		 return 0;//无路可走
	 }

}
void find(int* map, int cow, int culumn,int start,int end) {//cow是总行数，culumn为总列数，start为初始化位置，end为终点位置
	ListStack S;StackInit(S);
	StackPush(S,start);//起始位置入栈
	int cow_run, culumn_run;//目前位置的行，列
	cow_run = start / culumn;culumn_run = start % culumn;
	while (cow_run!=(end/culumn) || culumn_run!=(end%culumn))
	{
		if (cow_run != StackGet(S) / culumn || culumn_run != StackGet(S) % culumn){//判断是否刚退栈
		 	StackPush(S, cow_run * culumn + culumn_run); //新元素入栈
		 	}
		*(map + cow_run * culumn + culumn_run) = 1;//将走过的点的值置为1
		switch (IfContinue(map,culumn,cow_run*culumn+culumn_run))
		{
		case 1:cow_run -= 1;break;//向上
		case 2:	culumn_run += 1;break;//向右
		case 3:	cow_run += 1;break;//向下
		case 4:	culumn_run -= 1;break;//向左
		case 0:StackPop(S); cow_run = StackGet(S) / culumn;
			culumn_run = StackGet(S) % culumn;break;//死路，退栈，返回上一节点
		}
		StackDisplay(S);//将栈打印出来，便于看清
		printf("\n");
		for (int i = 0; i < culumn; i++)
		{
			for (int j = 0; j < culumn; j++)
			{
				printf("%d ", *(map + i * culumn + j));//打印目前迷宫
			}
			printf("\n");
		}
	    printf("\n");
	}
}

int main(){
	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} };

	 find(map[0], 10, 10,11,88);
	//printf("%d", IfContinue(map[0], 10,11));
	return 0;
}