深度优先搜索：格式化输出？

Question

If I have the following graph:

  Marisa  Mariah
       \  / 
Mary---Maria---Marian---Maryanne
         |
Marley--Marla

How should be Depth First Search function be implemented such that I get the output if "Mary" is my start point ?

Mary
   Maria
       Marisa
       Mariah
       Marian
            Maryanne
       Marla
            Merley

I do realize that the number of spaces equal to depth of the vertex( name ) but I don't how to code that. Following is my function:

void DFS(Graph g, Vertex origin)
{
    stack<Vertex> vertexStack;
    vertexStack.push(origin);
    Vertex currentVertex;
    int currentDepth = 0;

    while( ! vertexStack.empty() )
    {
        currentVertex = vertexStack.top();
        vertexStack.pop();

        if(currentVertex.visited == false)
        {
            cout << currentVertex.name << endl;

            currentVertex.visited = true;
            for(int i = 0; i < currentVertex.adjacencyList.size(); i++)
                vertexStack.push(currentVertex.adjacencyList[i]);
        }

    }
}

Thanks for any help !

Answer 1

Just store the node and its depth your stack:

std::stack<std::pair<Vertex, int>> vertexStack;
vertexStack.push(std::make_pair(origin, 0));
// ...
std::pair<Vertex, int> current = vertexStack.top();
Vertex currentVertex = current.first;
int     depth        = current.second;

If you want to get fancy, you can extra the two values using std::tie() :

Vertex currentVertex;
int    depth;
std::tie(currentVertex, depth) = vertexStack.top();

With knowing the depth you'd just indent the output appropriately.

The current size of your stack is, BTW, unnecessarily deep! I think for a complete graph it may contain O(N * N) elements (more precisely, (N-1) * (N-2)). The problem is that you push many nodes which may get visited.

Assuming using an implicit stack (ie, recursion) is out of question (it won't work for large graphs as you may get a stack overflow), the proper way to implement a depth first search would be:

1. push the current node and edge on the stack
2. mark the top node visited and print it, using the stack depth as indentation
3. if there is no node
4. if the top nodes contains an unvisited node (increment the edge iterator until such a node is found) go to 1.
5. otherwise (the edge iterator reached the end) remove the top node and go to 3.

In code this would look something like this:

std::stack<std::pair<Node, int> > stack;

stack.push(std::make_pair(origin, 0));
while (!stack.empty()) {
    std::pair<Node, int>& top = stack.top();
    for (; top.second < top.first.adjacencyList.size(); ++top.second) {
         Node& adjacent = top.first.adjacencyList[top.second];
         if (!adjacent.visited) {
              adjacent.visted = true;
              stack.push(std::make_pair(adjacent, 0));
              print(adjacent, stack.size());
              break;
         }
     }
     if (stack.top().first.adjacencyList.size() == stack.top().second) {
          stack.pop();
     }
 }

Answer 2

Let Rep(Tree) be the representation of the tree Tree . Then, Rep(Tree) looks like this:

Root
  <Rep(Subtree rooted at node 1)>
  <Rep(Subtree rooted at node 2)>
               .
               .
               .

So, have your dfs function simply return the representation of the subtree rooted at that node and modify this value accordingly. Alternately, just tell every dfs call to print the representation of the tree rooted at that node but pass it the current depth. Here's an example implementation of the latter approach.

void PrintRep(const Graph& g, Vertex current, int depth)
{
   cout << std::string(' ', 2*depth) << current.name << endl;
   current.visited = true;
   for(int i = 0; i < current.adjacencyList.size(); i++)
      if(current.adjacencyList[i].visited == false)
         PrintRep(g, current.adjacencyList[i], depth+1);           
}

You would call this function with with your origin and depth 0 like this:

PrintRep(g, origin, 0);