Get the exit of maze using stack in C - c

Question

I have an algorithm that search for a exit of a maze using recursive function , how i pass this to a function without recursive but using stack?What this algorithm do is basically , try to found the exit of a matriz , if the next step is 0 or if has already been covered comeback and try another path, but a i need to change the recursive function to a function using stack instead of recursion how i do that?
void print_maze(char **maze, int width, int height) {
for (int i=0; i<13; i++ ){
for (int j=0; j<10; j++ )
{
printf ("%d", maze[i][j]);
}
printf("\n");
}
}
int maze(int x_current, int y_current,char **mazeHere, int height,int width)
{
if (x_current < 0 || x_current >= width || y_current < 0 || y_current >= height)
return 0;
char here = mazeHere[x_current][y_current];
if (here == 3)
return 1;
if(here == 0 || here == 2)
return 0;
mazeHere[x_current][y_current] = 2;
if(maze(x_current ,y_current-1,mazeHere,height,width))return 1;
if(maze(x_current+1,y_current,mazeHere,height,width))return 1;
if(maze(x_current,y_current+1,mazeHere,height,width))return 1;
if(maze(x_current-1,y_current,mazeHere,height,width))return 1;
else{ mazeHere[x_current][y_current] = 1;
return 0;
}
}
int main(void)
{
char matriz [13][10]={
{0,0,0,0,0,0,0,0,0,0},
{0,0,1,1,1,1,1,0,0,0},
{0,0,1,0,0,0,1,0,0,0},
{0,0,1,0,0,0,1,0,0,0},
{1,1,1,0,1,1,1,1,1,0},
{0,1,0,0,1,0,0,0,0,0},
{0,1,1,0,1,1,1,0,0,0},
{0,0,1,0,1,0,0,0,1,0},
{0,0,1,0,0,0,1,1,1,0},
{0,0,1,1,1,1,1,0,0,0},
{0,0,0,0,0,0,1,0,0,0},
{0,0,0,0,0,0,1,1,1,3},
{0,0,0,0,0,0,0,0,0,0},};
int b= 0;
int height = 10;
int width = 13;
int p = 0;
int o = 0;
char **a = malloc(width * sizeof(char*));
for(int x = 0; x< width; x++){
a[x] = malloc(height * sizeof(char));
}
for (int i=0; i<13; i++ ){
for (int j=0; j<10; j++ )
{
a[i][j]= matriz[i][j];
}
}
int res = maze(4,0,a,height,width);
puts(res ? "success!" : "no luck!");
print_maze(a, width, height);
return 0;
}

Answer 1

I understand it's hard without recursion. By the way, conversion from recursion into using stack is not so hard, if you wrote code of stack data structure and its operation. We are going to pursue the matter on the assume.
Recursive function basically has structure like this:
position *seek(position *now, type arg...){
...
if(condition){
return NULL;
} else {
now->next = seek(arg_next);
}
}
It's OK to understand just with your feeling. What it does here is chaining new result to results until now. In other words, storing results as data structure. Here, data structure changes to stack. Then...:
void seek(stack *stack, type arg...){
...
while(1){
if(condition){
break;
} else {
stack->push(next_result)
}
}
}
It's so easy! All that is left is increasing conditions and considering backtracking. Based on the above, try to rewrite your code!