在迷宫中寻找路径时进行段错误

Question

I am trying to print out the coordinates of the maze as I am trying to solve using depth first search algorithm, however, it prints out the initial position, but it seg faults. Is there something I am doing wrong??? Here is my code :

#include "mazegen.h"
#include "stack.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#define  BUFFERSIZE 500
#define  FLAG 

void mazeSolution(char maze[100][100], int counter, int counter2)
{
   stack*currentCell;

   int i;
   int j;

   currentCell = create();

  for(i=0; i<counter; i++)
  {
      for(j=0; j<counter2; j++)
      {

          if(maze[i][j] == 'S')
          {
              push(currentCell,i,j);
              currentCell->visited = true;
          }

      }
  }

   printStack(currentCell);

   while(currentCell != NULL)
   { 
      pop(currentCell);

      if(maze[i][j] == 'F')
      {
           break;
      }
      if(i != 0)
      { 
          if(maze[i-1][j] == ' ' && currentCell->visited != true)
          {
              currentCell->visited = true;
              push(currentCell,i-1,j);

          }
      }
      if(maze[i+1][j] == ' ' && currentCell->visited != true)
      {
          currentCell->visited = true;
          push(currentCell,i+1,j);
      }
      if(j != 0)
      {
          if(maze[i][j-1] == ' ' && currentCell->visited != true)
          {
              currentCell->visited = true;
              push(currentCell, i,j-1);
          }
      }
      if(maze[i][j+1] == ' ' && currentCell->visited != true)
      {
           currentCell->visited = true;
            push(currentCell, i, j+1); 
      }

 }

  printf("No solution\n");


  printStack(currentCell);

}

I think it has something to do with my pop function and with the way I have implemented it

void pop (stack*theStack)
{
    node*theHead;

    if(theStack == NULL)
    {
        printf("Empty Stack. Error\n");
         exit(0);
    }

    theHead = removeFromFront(theStack->list);

    theStack->list = theHead;


}
node*removeFromFront(node*theList) 
{
    node*temp;

    temp = theList->next;

    if(temp == NULL)
    {
        printf("pop Error\n");
        return NULL;
    }

    theList = theList->next;

    return theList;
}.       

Answer 1

Look at this portion of your code:

while(currentCell != NULL)
{ 
      pop(currentCell);

      if(maze[i][j] == 'F')
      {
           break;
      }
   ...
}

You are popping a value from the stack - this is ok. But you need to assign the popped value to i and j . In your code, the value of i and j remain unchanged, so you have an infinite while loop. You are continuously pushing values in the stack inside this loop, which ultimately leads to segfault.

Answer 2

Keeping a visited status on the stack is useless - you need to check if the specific position has been visited when you try to access it from some new direction, which may happen if there is a loop in your maze. So the proper place for this attribute is a maze itself, not a stack.

You don't need separate stack and node structures - the stack is actually a list of nodes.

Building a stack is quite easy, but you need to imagine it's structure and behaviour before you start encoding. There are two basic (plain C) solutions: use a pre-allocated array or dynamically linked list. Let's use an array.

A stack's item will be

typedef struct node {
    int i, j;
} Node;

a stack itself:

Node stack[ 10001];

and a number of items currently stacked:

int stkptr = 0;

Now we can test if the stack contains any data:

int StackNonEmpty() { return stkptr; }

push new position onto the stack:

void Push(int i, int j) {
    stack[ stkptr].i = i;
    stack[ stkptr].j = j;
    stkptr ++;
}

read a position from the stack's top (assuming StackNonEmpty() != 0 ):

void Fetch(int *pi, int *pj) {
    *pi = stack[ stkptr - 1].i;
    *pj = stack[ stkptr - 1].j;
}

and remove it from the stack:

void Pop() { stkptr --; }

We also need to define a marker for visited positions:

int VISITED = '.';

or

#define VISITED '.'

and we're ready to write the algorithm:

for(i=0; i<counter; i++)
    for(j=0; j<counter2; j++)
        if(maze[i][j] == 'S')
        {
            Push(i,j);   // set the Start position
            i = counter; // this is to break the outer loop
            break;       // and this breaks the inner loop
        }
while( StackNonEmpty())
{
    Fetch(& i, & j);             // get a current position
    if( maze[i,j] == 'F')              // Finish found?
        break;
    if( maze[i,j] == ' ')              // empty cell?
        maze[i,j] = VISITED;
    // find next possible step
    if( i > 0 && maze[i-1,j] == ' ')   // cell to the left is empty
        Push(i-1,j);                   // step left
    else
    if( j > 0 && maze[i,j-1] == ' ')   // cell above is empty
        Push(i,j-1);                   // step up
    else
    if( i+1 < counter && maze[i+1,j] == ' ')
        Push(i+1,j);                   // step right
    else
    if( j+1 < counter2 && maze[i,j+1] == ' ')
        Push(i,j+1);                   // step down
    else                               // dead end - no way out
        Pop();                         // step back
}
if( StackNonEmpty())      // exited with break, so 'F' found
    PrintStack();
else
    PrintFailureMessage();  // could not reach 'F'

To show the results just print all items of the stack array until the stkptr position:

void PrintStack() {
    for(i = 0; i < stkptr; i ++)
        printf( "%d,%d\n", stack[i].i, stack[i].j);
}

EDIT
'VALID' status assignment corrected (was == instead of =), PrintFailureError replaced with PrintFailureMessage .