Displaying Depth-First Search Graph Traversal C++ - c++

Question

I am working on traversing a graph which I have set up as a class, using vectors to store the vertices and edges. I am using a Depth-First Search on the graph to show paths as it is traversed, but I would like to somehow get my code to display the vertices in order as it goes through them, in a format sort of like this:
<u, i1, i2, ... v>
Where 'u' and 'v' are BOTH the start vertex (I want it to start and end at the same vertex) and the 'i' values are the vertices that it passes through along the way.
This is the function for DFS that I have so far, I've simplified it so that this can be used as a general reference. Is there anything I can modify here in order to get this to display what I want it to? (It is not currently set up to display anything).
vector<Vertex*> vertices;
vector<Edge*> edges;
class Vertex {
public:
Vertex () {};
Vertex (int id, float safetyIndex, string name)
: id(id), safetyIndex(safetyIndex), name(name), previous(NULL), distFromStart(INT_MAX), color("white")
{
vertices.push_back(this);
}
public:
int id;
float safetyIndex;
string name;
int distFromStart;
Vertex* previous;
string color;
};
class Edge {
public:
Edge () {};
Edge (Vertex* intersection1, Vertex* intersection2, int distance)
: intersection1(intersection1), intersection2(intersection2), distance(distance)
{
edges.push_back(this);
}
bool street_connection(Vertex* intersection1, Vertex* intersection2)
{
return (
(intersection1 == this->intersection1 && intersection2 == this->intersection2) ||
(intersection1 == this->intersection2 && intersection2 == this->intersection1));
}
public:
Vertex* intersection1;
Vertex* intersection2;
int distance;
};
void pathFinder(Vertex* startVertex)
{
DFS_visit(startVertex);
}
void DFS_visit(Vertex* u)
{
u->color = "gray"; // Mark that we have visited intersection 'u'
// Create a vector containing all adjacent vertices to intersection 'u'
vector<Vertex*>* adjVertex = AdjVertices(u);
const int size = adjVertex->size();
for( int i=0; i<size; ++i)
{
Vertex* v = adjVertex->at(i);
if ( v->color == "white" )
{
DFS_visit(v); // recursive function call
}
}
// Once all adjacent vertices have been located, we are done with this node
u->color = "black";
}
vector <Vertex*>* AdjVertices(Vertex* vert)
{
// Creates a vector containing all of the adjacent vertices
// to the intersection in question (vert)
vector<Vertex*>* adjVertex = new vector <Vertex*> ();
const int size = edges.size();
for(int i=0; i<size; ++i)
{
Edge* edge = edges.at(i);
Vertex* adjacent = NULL;
if (edge->intersection1 == vert) // if edge's start vertex is the vertex in question
{
adjacent = edge->intersection2;
}
else if (edge->intersection2 == vert) // if edge's end vertex is the vertex in question
{
adjacent = edge->intersection1;
}
if (adjacent && vertices_check(vertices, adjacent))
{
adjVertex->push_back(adjacent);
}
}
return adjVertex;
}

Answer 1

You could use a Vector (constructed in your other function calling DFS_visit) and pass it on to DFS_visit. In DFS_visit, you add the node at the start and then each time you would return from an investigated child. That should give you a complete path description.
void DFS_visit(Vertex* u, Vector<Vertex*> path )
{
u->color = "gray"; // Mark that we have visited intersection 'u'
path.push_back(u);
// Create a vector containing all adjacent vertices to intersection 'u'
vector<Vertex*>* adjVertex = AdjVertices(u);
const int size = adjVertex->size();
for( int i=0; i<size; ++i)
{
Vertex* v = adjVertex->at(i);
if ( v->color == "white" )
{
DFS_visit(v,path); // recursive function call
path.push_back(u);
}
}
// Once all adjacent vertices have been located, we are done with this node
u->color = "black";
}