dfs 非递归java_如何将回溯法DFS改写为非递归的？

enum EnumNodeColor

{

EnumNodeColor_white,

EnumNodeColor_gray,

EnumNodeColor_black,

};

struct Edge;

struct Vertex

{

std::list m_edges;

};

struct Edge

{

int m_start;

int m_end;

int m_weight;

Edge(int start = -1, int end = -1, int weight = INT_MAX)

: m_start(start), m_end(end), m_weight(weight){}

};

class AdjacencylistGraph

{

private:

bool m_directed;

std::vector m_vertexes;

public:

AdjacencylistGraph();

void StackDFS(std::vector &parent, std::vector &d, std::vector &f);

};

void AdjacencylistGraph::StackDFS(std::vector &parent, std::vector &d, std::vector &f)

{

parent = vector(m_vertexes.size(), -1);

d = vector(m_vertexes.size(), INT_MAX);

f = vector(m_vertexes.size(), INT_MAX);

int time = 0;

vector colors(m_vertexes.size(), EnumNodeColor_white);

stack< pair< int, list::iterator > > nodes_iters;

for (int i = 0; i < m_vertexes.size(); )

{

if (colors[i] == EnumNodeColor_white)

{

d[i] = ++time;

colors[i] = EnumNodeColor_gray;

nodes_iters.push(pair< int, list::iterator >(i, m_vertexes[i].m_edges.begin()));

while (!nodes_iters.empty())

{

int u = nodes_iters.top().first;

list::iterator edgebegin = nodes_iters.top().second;

bool finished = true;

for (auto itr = edgebegin; itr != m_vertexes[u].m_edges.end(); ++itr)

{

if (colors[itr->m_end] == EnumNodeColor_white)

{

int v = itr->m_end;

parent[v] = u;

d[v] = ++time;

colors[v] = EnumNodeColor_gray;

nodes_iters.top().second = ++itr;

nodes_iters.push(pair< int, list::iterator >(v, m_vertexes[v].m_edges.begin()));

finished = false;

break;

}

}

if (finished)

{

f[u] = ++time;

colors[u] = EnumNodeColor_black;

nodes_iters.pop();

}

}

}

else

++i;

}

}