如何在C ++中以网格形状制作无向和无权图

Question

I'm trying to implement a for loop to initialize a graph in the shape of a grid, including diagonals. Basically, I have an array that is initialized with values that I want to replicate in the graph. So I have a nested for-loop that has several if statements. The if statements are used to handle the special cases ie element at index 1,1 only has 3 neighbors.

I know my graph function works because if I initialize it by hand, it doesn't seg fault and prints the proper BFS, however my loop seg faults. Please take a look:

Graph Class:

Graph::Graph(int V)
{
    this->V = V;
    adj = new list<int>[V];

}

void Graph::addEdge(int v, int w)
{
    adj[v].push_back(w); // Add w to v’s list.
}

void Graph::BFS(int s, int d)
{
    // Mark all the vertices as not visited
    bool *visited = new bool[V];
    int trail[V];
    for(int i = 0; i < V; i++){
        visited[i] = false;
        trail[i] = -1;

    }
  // Create a queue for BFS
  list<int> queue;

// Mark the current node as visited and enqueue it
visited[s] = true;
queue.push_back(s);

// 'i' will be used to get all adjacent vertices of a vertex
list<int>::iterator i;

while(!queue.empty())
{

    // Dequeue a vertex from queue and print it
    s = queue.front();
    if(s == d){

        break;
    }
    else

    queue.pop_front();

    // Get all adjacent vertices of the dequeued vertex s
    // If a adjacent has not been visited, then mark it visited
    // and enqueue it
    for(i = adj[s].begin(); i != adj[s].end(); ++i)
    {
        if(!visited[*i])
        {
            visited[*i] = true;
            queue.push_back(*i);
            trail[*i] = s;
        }

    }

 }
int x = d;
while(x != -1){

   cout<<x<<endl;
   x = trail[x];


   }  
}

In main program:

int num = 2;

int arr[num+1][num+1];
int x = 1;
for(int i = 1; i<=num; i++){
    for(int j = 1; j<= num; j++){

        arr[i][j] = x;


        cout<<x<<" ";
        x++;

    }
    cout<<endl;

}

int max = 2;
Graph g(max+1);

for(int row = 1; row <= max; row++){

    for(int col = 1; col <= max; col++){

        if(row == 1 && col == 1){

            g.addEdge(arr[row][col],(arr[row][col] +1));
            g.addEdge(arr[row][col],(arr[row][col] +max));
            g.addEdge(arr[row][col],(arr[row][col] + max+1));

        }
        else if(row ==1 && col == max){
            g.addEdge(arr[row][col],(arr[row][col]-1));
            g.addEdge(arr[row][col],(arr[row][col]+max));
            g.addEdge(arr[row][col],(arr[row][col]+max-1));


        }

        else if(row == max && col == max){
            g.addEdge(arr[row][col],(arr[row][col]-1));
            g.addEdge(arr[row][col],(arr[row][col]-max));
            g.addEdge(arr[row][col],(arr[row][col]-max-1));

        }
        else if(row == max && col == 1){
            g.addEdge(arr[row][col],(arr[row][col]-max));
            g.addEdge(arr[row][col],(arr[row][col]-max+1));
            g.addEdge(arr[row][col],(arr[row][col]+1));

        }
        else if(row == max){
            g.addEdge(arr[row][col],(arr[row][col]-1));
            g.addEdge(arr[row][col],(arr[row][col]+1));
            g.addEdge(arr[row][col],(arr[row][col]-max));
            g.addEdge(arr[row][col],(arr[row][col]-max-1));
            g.addEdge(arr[row][col],(arr[row][col]-max+1));

        }
        else if(col == max){

            g.addEdge(arr[row][col],(arr[row][col]-1));
            g.addEdge(arr[row][col],(arr[row][col]-max));
            g.addEdge(arr[row][col],(arr[row][col]+max));
            g.addEdge(arr[row][col],(arr[row][col]-max-1));
            g.addEdge(arr[row][col],(arr[row][col]+max-1));

        }
        else if(col == 1){
           g.addEdge(arr[row][col],(arr[row][col]+1));
           g.addEdge(arr[row][col],(arr[row][col]+max));
           g.addEdge(arr[row][col],(arr[row][col]-max));
           g.addEdge(arr[row][col],(arr[row][col]-max+1));
           g.addEdge(arr[row][col],(arr[row][col]+max+1));

        }
        else if(row == 1){
            g.addEdge(arr[row][col],(arr[row][col]-1));
            g.addEdge(arr[row][col],(arr[row][col]+1));
            g.addEdge(arr[row][col],(arr[row][col]+max));
            g.addEdge(arr[row][col],(arr[row][col]+max-1));
            g.addEdge(arr[row][col],(arr[row][col]+max+1));

        }
        else{

            g.addEdge(arr[row][col],(arr[row][col]+1));
            g.addEdge(arr[row][col],(arr[row][col]-1));
            g.addEdge(arr[row][col],(arr[row][col]+max));
            g.addEdge(arr[row][col],(arr[row][col]-max));
            g.addEdge(arr[row][col],(arr[row][col]-max-1));
            g.addEdge(arr[row][col],(arr[row][col]-max+1));
            g.addEdge(arr[row][col],(arr[row][col]+max-1));
            g.addEdge(arr[row][col],(arr[row][col]+max+1));
        }
    }
}

Note: I wanted my graph vertices to start at 1 but not at 0. This is why my matrix has an extra row and column in it. Also, my graph requires an edge to be added in both directions, so it would be 1--->0 and 0--->1.

Answer 1

It appears that your constructor only allocates N adjacency lists, but you then define N × N nodes. You call addEdge() with each of these nodes as its first argument, which when you get to node N +1, tries to write past the end of adj and causes a buffer overflow.

To catch this kind of bug in the future, you can define adj as a std::vector , which comes with bounds checking. This will do all the work of making it possible to add nodes for you, and also fix the memory leak caused by the absence of a destructor that deletes arr . If for some reason you can't use std::vector or std::array , my advice would be to at least manually bounds-check with a line such as assert(v < V); in Graph::addEdge() .