Stack Overflow with Pathfinding Algorithm

Question

I have been working on a project that will, in short, generate a 2D matrix of numbers, with "empty" spaces are represented by 0's. Each number is connected by a list of nodes. The nodes contain the number value, the number's X and Y position, and a list of all spaces adjacent to it (its "neighbors"), with the exception of spaces diagonally adjacent to the point, due to the algorithm only allowing movements of up, down, left, and right. The issue that I am having is that, as the title would suggest, I am experiencing some stack overflow issues. I will post my code below, if anyone could help, I would be most appreciative.

CoordList* Puzzle::GeneratePath(CoordList* Path, int GoalX, int GoalY)
{
int CurrX;
int CurrY;

CurrX = Path->NeighborX;
CurrY = Path->NeighborY;

if(CurrX == GoalX && CurrY == GoalY)
{
    return(Path);
}
else
{
    int NewX;
    int NewY;
    double NewDistance;
    int OldX;
    int OldY;
    double OldDistance;
    CoordList* PointNeighbors = NULL;
    CoordList* BestChoice = NULL;

    for(int i = 0; i < NumDirections; i++)
    {
        CoordList* NewNeighbor = new CoordList;
        NewX = CurrX + DirectsX[i];
        NewY = CurrY + DirectsY[i];
        if(IsPossible(NewX, NewY))
        {
            NewNeighbor->NeighborX = NewX;
            NewNeighbor->NeighborY = NewY;

            if(PointNeighbors == NULL)
            {
                NewNeighbor->next = NULL;
                PointNeighbors = NewNeighbor;
            }
            else
            {
                NewNeighbor->next = PointNeighbors;
                PointNeighbors = NewNeighbor;
            }
        }
        //delete NewNeighbor;
    }

    while(PointNeighbors != NULL)
    {
        if(BestChoice == NULL)
        {

            CoordList* AChoice = new CoordList;
            AChoice->next = NULL;
            NewX = PointNeighbors->NeighborX;
            NewY = PointNeighbors->NeighborY;
            AChoice->NeighborX = NewX;
            AChoice->NeighborY = NewY;
            BestChoice = AChoice;
            PointNeighbors = PointNeighbors->next;
            //delete AChoice;
        }
        else
        {
            NewX = PointNeighbors->NeighborX;
            NewY = PointNeighbors->NeighborY;
            NewDistance = DetermineDistance(NewX, NewY, GoalX, GoalY);

            OldX = BestChoice->NeighborX;
            OldY = BestChoice->NeighborY;
            OldDistance = DetermineDistance(OldX, OldY, GoalX, GoalY);

            if(NewDistance < OldDistance)
            {
                BestChoice->NeighborX = NewX;
                BestChoice->NeighborY = NewY;
            }
            PointNeighbors = PointNeighbors->next;
        }
    }
    BestChoice->next = Path;
    Path = BestChoice;
    return(GeneratePath(Path, GoalX, GoalY));
}
}

I was asked to provide my determine distance function. This is just a simple implementation of the traditional Point Distance formula. Provided below.

double Puzzle::DetermineDistance(int OneX, int OneY, int TwoX, int TwoY)
{
int DifX;
int DifY;
double PointSum;

DifX = (TwoX - OneX);
DifY = (TwoY - OneY);
DifX = (DifX * DifX);
DifY = (DifY * DifY);
PointSum = (DifX + DifY);
return (sqrt(PointSum));
}

The following is the IsPossible function, which determines if an X and Y value lies within the possible grid space.

bool Puzzle::IsPossible(int x, int y)
{
if(x + 1 > Size - 1 || x - 1 < 0 
    || y + 1 > Size - 1 || y - 1 < 0)
{
    return false;
}
return true;
}

Answer 1

You might have a infinite recursion loop that causes the stackoverflow, as you make new local variables every recursion, especially with your observered oscillation behaviour. I assume you dont have that problem with small matrices. Its just a shot in the dark :-)

The oscillation problem indicates that you dont check whether you have already been on one place already?

Anyways, maybe you want to reconsider using another pathfinding algorithm. I would suggest a agent based solution. I used to use the following solution to solve a maze of similar structure: I started an agent with a "PositionsList" of spots where it have been, so in the beginning only with the starting point. Then it copied itself to every reachable position not being in his own PositionList, adding the new position to that list and destroying itself then. Repeat that pattern with all new agents until the first agent reaches the goal. That way you are guaranteed to find the optimal path. But it might get pretty memory heavy for big matrices, especially when there are a lot different ways to get to the goal and a lot of possible directions per position! But there are plenty of other very good pathfinding algorithms out there. Maybe one of them suits you well :-)

Good Luck!