Topological Graph Sorting

Question

I am trying to implement a topological graph sort, and my program is compiling however I am not getting a populated vector. I have tried running a debugger to track where my variables are going and I am not too sure why. Currently, I have made a graph data structure, which contains a vector of vertices. This gets generated during when I generate a new graph (std:: vector vertices;)

My graph is structure like such:

lass Graph {
    struct Edge{
        int dest = -1;
        Edge* next = nullptr;
        Edge(int dest, Edge* next) : dest(dest), next(next){};
        ~Edge() {delete next;}
    };

    struct vertex{
        int id =0;
        int degree = 0;
        int colour = 0;

        vertex* next  = nullptr;
        vertex* previous = nullptr;

    };

    Edge** edges = nullptr;
    std:: vector<vertex> vertices;
    std:: vector<vertex*> ordering;

All of which get set during the graph generation.

I would really appreciate any help with this sorting.

void Graph::myOwnOrderingHelper(int v, bool *visited, std::stack<vector<vertex*>> &Stack) {

    vector<vertex*> hope;

    visited[v] = true;

    for (int i = 0; i < vertices[v].degree; i++) {
        int neighbour = vertices[v].id;

        if (!visited[neighbour]){
            myOwnOrderingHelper(i, visited, Stack);
            cout << vertices[v].next->id;
            hope.push_back(vertices[v].next);
        }
    }

    Stack.push(hope);
}

void Graph::myOwnOrdering() {
    std:: stack<vector<vertex*>> Stack;
    bool* visited = new bool[size];

    for(int i  = 0; i < size; i++){
        visited[i] = false;
    }

    for (int i = 0; i < size; i++){
        if (visited[i] == false){
            myOwnOrderingHelper(i, visited, Stack);
        }
    }

    while (Stack.empty() == false){
        std::vector<vertex*> temp = Stack.top();

        for(int i = 0; i < temp.size(); i++){
            cout << temp[i]->degree << endl;
            ordering.push_back(temp[i]);
        }

        Stack.pop();
    }

}

Answer 1

Look at this code:

for (int i = 0; i < vertices[v].degree; i++) {
    int neighbour = vertices[v].id;

    if (!visited[neighbour]){

Every time through this for loop the value of neighbour will always be the same.

Whatever your for loop is intended to accomplish ( your code is undocumented so it is not easy to guess ) it will in fact always do exactly the same over and over again.

Answer 2

There's needless complexity here, which is obscuring the algorithm. Consider this graph representation:

#include <algorithm>
#include <iostream>
#include <set>
#include <vector>

class Graph {
public:
  struct Vertex {
    std::vector<int> children;
  };

  // Add a vertex and return its index.
  int add_vertex() {
    int ix = vertices.size();
    vertices.push_back(Vertex());
    return ix;
  }

  // Add an edge from vertex a to b, both given by their indices.
  void add_edge(int a, int b) {
    vertices[a].children.push_back(b);
  }

  // Return a vector of vertex indices in topo order.
  std::vector<int> topo_sort() {
    std::set<int> visited;
    std::vector<int> result;

    // (1) The fun happens here. Return the reverse of a dfs post order visit.

    return result;
  }

private:
  std::vector<Vertex> vertices;

  // Recursive helper.
  void topo_sort(int i, std::set<int>& visited, std::vector<int>& result) {
    // (2) And yet more fun here.
  }
};

int main() {
  Graph g;
  int v0 = g.add_vertex();
  int v1 = g.add_vertex();
  int v2 = g.add_vertex();
  int v3 = g.add_vertex();
  int v4 = g.add_vertex();
  g.add_edge(v0, v1);
  g.add_edge(v0, v2);
  g.add_edge(v0, v4);
  g.add_edge(v1, v4);
  g.add_edge(v2, v4);

  std::vector<int> sorted = g.topo_sort();
  for (int i: sorted) std::cout << i << ' ';
  std::cout << std::endl;
  return 0;
}

With this it's possible to implement topo sort by adding 6 lines.

Hint: When you get unexpected behavior in a small program where you have control of the input data, adding trace prints cerr << ... is often less trouble than setting up a debugger, especially when you're new to programming.

Edit

Since the original code ought to be working by now, the six lines:

At (1),

    for (int i = 0; i < vertices.size(); ++i) topo_sort(i, visited, result);
    std::reverse(result.begin(), result.end());

At (2), it's

   if (visited.count(i)) return;
   visited.insert(i);
   for (int j: vertices[i].children) topo_sort(j, visited, result);
   result.push_back(i);