纯c，回溯法，使用链栈求解迷宫问题

这是主函数：

#include "link_stack.h"
#define m 6
#define n 8
void find(int maze[m + 2][n + 2], int start_x, int start_y, int end_x, int end_y, int direction[4][2]);
int main()
{

	int maze[m + 2][n + 2] = {
   {1,1,1,1,1,1,1,1,1,1},
   {1,0,0,1,1,0,1,1,1,1},
   {1,0,0,1,0,1,1,1,1,1},
   {1,0,0,0,0,0,0,0,1,1},
   {1,0,1,1,1,0,0,1,1,1},
   {1,1,0,0,1,1,0,0,0,1},
   {1,0,1,1,0,0,1,1,0,1},
   {1,1,1,1,1,1,1,1,1,1}, };
	int direction[4][2] = {
		{0,1},
		{1,0},
		{0,-1},
		{-1,0},
	};
	int start_x = 1;
	int start_y = 1;
	int end_x = 6;
	int end_y = 8;
	find(maze, start_x, start_y, end_x, end_y, direction);
	return 0;
}
void find(int maze[m + 2][n + 2], int start_x, int start_y, int end_x, int end_y, int direction[4][2])
{
	int x, y, d;
	int next_x, next_y;
	int flag = 0;
	PLinkStack stack = createNullStack_link();
	Mazedirect element;
	element.x = start_x;//将起点位置入栈
	element.y = start_y;
	element.d = -1;
	push_link(stack, element);
	maze[start_x][start_y] = 2;//将起点位置设置为2，表示已走过
	while (!isNullStack_link(stack))//当栈为空的时候，代表所有的路都走不了，直接退出，
	{
		if (flag == 1)   //这里的flag是为了防止初始位置出栈
		{
			pop_link(stack);
		}
		if (flag == 0)
		{
			flag = 1;
		}
		if (!isNullStack_link(stack))//如果栈不为空，取栈顶元素，也就是取之前未尝试的位置，开始尝试
		{
			element = top_link(stack);
		}
		x = element.x; //确定下一次要尝试的位置
		y = element.y;
		d = element.d + 1;
		while (d<=3)//开始向其他方向尝试
		{
			next_x = x + direction[d][0]; //按照右，下，左，上的方式尝试
			next_y = y + direction[d][1];
			if (maze[next_x][next_y] == 0) //如果该点未走过
			{
				element.x = next_x; //将该点入栈
				element.y = next_y;
				element.d = d;
				push_link(stack, element);
				maze[next_x][next_y] = 2;//该点已走过，标记该点
				x = next_x;//移动到下一个位置
				y = next_y;
				if (x == end_x && y == end_y)//如果下一个位置就是终点
				{
					while (!isNullStack_link(stack))//打印路径
					{
						element = top_link(stack);
						pop_link(stack);
						printf("%d %d\n", element.x, element.y);
					}
					return;
				}
				else d = 0; //如果下一个位置还不是终点，那么这时候，就要重新开始按照右，下，左，上的方式尝试，所以置为0
			}
			else d++; //如果某一个方向走不了，那么就换一个方向，所以需要给d加1；
		}
	}
	printf("wrong");
	return;
}

这是link_stack.h函数

#include <stdio.h>
#include <stdlib.h>
typedef struct maze_direct
{
    int x;
    int y;
    int d;
}Mazedirect;
typedef Mazedirect DataType;
struct node
{
    DataType  info;
    struct node* link;
};

typedef struct node* PNode;

struct LinkStack {
    PNode  top;
};
typedef struct LinkStack* PLinkStack;



PLinkStack createNullStack_link()
{

    PLinkStack link = (PLinkStack)malloc(sizeof(struct LinkStack));
    if (link != NULL)
    {
        link->top = NULL;
    }
    else printf("wrong");
    return link;

}

int isNullStack_link(PLinkStack L)
{
    if (L == NULL)
    {
        return -1;
    }
    if (L->top == NULL)
    {
        return 1;
    }
    else return 0;
}




int push_link(PLinkStack L, DataType x)
{

    if (L == NULL)
    {
        return 0;
    }
    PNode p = (PNode)malloc(sizeof(struct node));
    if (p != NULL)
    {
        p->info = x;
        p->link = L->top;
        L->top = p;
        return 1;
    }
    return 0;

}




DataType pop_link(PLinkStack L)
{
    if (isNullStack_link(L))
    {
        return;
    }
    DataType result = L->top->info;
    PNode p = L->top;
    L->top = L->top->link;
    free(p);
    return result;
}

DataType top_link(PLinkStack L)
{
    if (isNullStack_link(L))
    {
        return;
    }
    return L->top->info;
}



void destroystack_link(PLinkStack L)
{
    if (L == NULL) return 0;
    if (L->top == NULL)
    {
        return 0;
    }
    struct node* p = L->top, * q;
    free(L);
    while (p != NULL)
    {
        q = p->link;
        free(p);
        p = q;
    }
}

若有错误请各位直接指出