栈-求迷宫通路数目和长度

题目：

测试数据：
迷宫起点:(1,1)，终点:(m-1,n-1)
①
迷宫长宽：m=6,n=6
迷宫设置：
（外围一圈的是墙，所以不用自己设置数值，默认都是1，所以6×6迷宫只要输入4×4的数据）
0 0 1 0
0 0 0 1
1 1 0 0
1 1 0 0
正确的路径条数：4（即主函数中b的值应该是4）
我的代码的执行结果：

②
迷宫长宽：m=6,n=6
迷宫设置：（外围一圈的是墙，所以不用自己设置数值，默认都是1，所以6×6迷宫只要输入4×4的数据）
0 1 1 0
0 0 0 1
1 1 0 0
1 1 0 0
正确的路径条数：2（即主函数中b的值应该是2）
我的代码的执行结果：

我的问题：
执行search操作后输出的迷宫和第一次输出的不一样，理应是一样的，都应该是一开始输入数据后初始化的迷宫；
输出的路径经过和成功路径条数都不对；
感觉是search函数错了但是自己找不出问题在哪

我的代码：

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define max 500

struct stacknode
{
    int x,y;
};

typedef struct    //栈定义
{
    struct stacknode *base;
    struct stacknode *top;
    int stacksize;
    int steps;      //实时记录路径的长度
}stack;

struct mgnode       //迷宫每个格子数据域
{
    int data;            //0或1
    int direction[4];    //东南西北四个方向，0-东，1-北，2-西，3-南
};
//
//
//
//
//
//
//初始化迷宫
void initmigong(struct mgnode migong[][50],int m,int n)
{
    system("cls");
    int i=0,j=0;
    //迷宫最外围一周为障碍，值均为1
    for(i=0;i<n;i++)
        migong[0][i].data=1;
    for(i=0;i<n;i++)
        migong[m-1][i].data=1;
    for(i=0;i<m;i++)
        migong[i][0].data=1;
    for(i=0;i<m;i++)
        migong[i][n-1].data=1;
    //设置迷宫内的障碍和通道 
    printf("请设置迷宫：\n");   
    for(i=1;i<m-1;i++)
    {
        for(j=1;j<n-1;j++)
        {
            scanf("%d",&(migong[i][j].data));             //输入的值为0或1
        }
        getchar();
    }
    migong[1][1].data=0,migong[m-2][n-2].data=0;     //迷宫左上角为起点，右下角为重点，值均为0
    int temp[4]={0};
    for(i=0;i<m;i++)
        for(j=0;j<n;j++)
            for(int k=0;k<4;k++)
                migong[i][j].direction[k]=0;     //方向未经过时值为0，经过后值改为1
}

//初始化栈
void initstack(stack *a)
{
    a->base=(struct stacknode*)malloc(sizeof(struct stacknode)*max);
    a->top=a->base;
    a->stacksize=max;
    a->steps=0;
}

//入栈
void push(stack *a,int i,int j)
{
    a->top->x=i;
    a->top->y=j;
    (a->top)++;
}

//出栈
struct stacknode pop(stack* a)
{
    (a->top)--;
    return *(a->top);
}

//判断栈是否为空
bool stackempty(stack *a)
{
    if(a->base==a->top)
        return true;
    return false;
}


//查找成功路径、记录所以成功路径的数目
int search(struct mgnode migong[][50],int m,int n, stack *a, int *record)
{
    int i=1,j=1;
    migong[i][j].data=1;
    int records=0;        //成功路径的数目
    struct stacknode temp;
    while(i<m&&j<n)
    {
        if(i==m-2&&j==n-2)          //到达终点
        {
            printf("抵达终点返回  ");
            record[records++]=a->steps;            //记录一条成功路径的长度
            migong[i][j].data=0;
            if(stackempty(a))  break;       
            temp=pop(a);            //从终点返回上一步，寻找下一条通往终点的通路
            i=temp.x,j=temp.y;
            (a->steps)--;
            continue;
        }
        if(migong[i][j+1].data==0&&migong[i][j].direction[0]==0)       //向东走
        {
            printf("东  ");
            if(migong[i][j].direction[0]==0&&migong[i][j].direction[1]==0&&migong[i][j].direction[2]==0&&migong[i][j].direction[3]==0)
                push(a,i,j);
            migong[i][j].direction[0]=1;
            j++;
            (a->steps)++;
            migong[i][j].data=1;
            continue;
        }
        if(migong[i-1][j].data==0&&migong[i][j].direction[1]==0)       //向北走
        {
            printf("北  ");
            if(migong[i][j].direction[0]==0&&migong[i][j].direction[1]==0&&migong[i][j].direction[2]==0&&migong[i][j].direction[3]==0)
                push(a,i,j);
            migong[i][j].direction[1]=1;
            i--;
            (a->steps)++;
            migong[i][j].data=1;
            continue;
        }
        if(migong[i][j-1].data==0&&migong[i][j].direction[2]==0)       //向西走
        {
            printf("西  ");
            if(migong[i][j].direction[0]==0&&migong[i][j].direction[1]==0&&migong[i][j].direction[2]==0&&migong[i][j].direction[3]==0)
                push(a,i,j);
            migong[i][j].direction[2]=1;
            j--;
            (a->steps)++;
            migong[i][j].data=1;
            continue;
        }
        if(migong[i+1][j].data==0&&migong[i][j].direction[3]==0)       //向南走
        {
            printf("南  ");
            if(migong[i][j].direction[0]==0&&migong[i][j].direction[1]==0&&migong[i][j].direction[2]==0&&migong[i][j].direction[3]==0)
                push(a,i,j);
            migong[i][j].direction[3]=1;
            i++;
            (a->steps)++;
            migong[i][j].data=1;
            continue;
        }
        if(1)                                                      //找不到路了，当前格子清空，退回上一格
        {
            printf("返回  ");
            migong[i][j].data=0;
            for(int k=0;k<4;k++)
                migong[i][j].direction[k]=0;
            if(stackempty(a))  break;
            temp=pop(a);
            i=temp.x,j=temp.y;
            (a->steps)--;
        }
    }
    return records;
}


//打印迷宫
void print(struct mgnode migong[][50],int m,int n)
{
    //system("cls");
    printf("迷宫：\n");
    for(int i=0;i<m;i++)
    {
        for(int j=0;j<n;j++)
        {
            printf("%d ",migong[i][j].data);
        }
        printf("\n");
    }
}



int main()
{
    int m,n;      //m,n>=3
    printf("请输入迷宫的长(m)和宽(n):");
    scanf("%d%d",&m,&n);
    getchar();
    struct mgnode migong[50][50];
    stack a;
    int record[1000]={0};     //记录每条成功路径的长度
    initstack(&a);
    initmigong(migong,m,n);
    print(migong,m,n);
    int b;
    b=search(migong,m,n,&a,record);
    printf("\n");
    print(migong,m,n);
    printf("%d\n",b);
    for(int i=0;i<b;i++)
        printf("%d ",record[i]);
    system("pause");
    return 0;
}

具体代码没仔细看，但迷宫处理时，你应该传入进行各类处理的变量和结构体都应该是实际结构体的一个拷贝
也就是如果你有对保存迷宫基本信息的结构体（例如格子和格子四周的情况）进行编辑时，应该另外设一个中间结构体,类似于
struct p ；
memcpy(&p，&element，sizeof(element));
func(p);
这里要格外注意传参，如果将element的指针或者地址（即*或&操作）传入了函数，那函数将有可能对element的值进行修改