void Graph::bfs_worker(int start, void(*process_vertex_early)(int v),
void(*process_vertex_late)(int v), void(*process_edge)(int v, EdgeNode *p))
{
queue<int> q;
int v;
int y;
EdgeNode *p;
q.push(start);
discovered[start] = TRUE;
while(q.empty() == FALSE){
v = q.front();
q.pop();
process_vertex_early(v);
processed[v] = TRUE;
p = this->edges[v];
while(p){
y = p->y;
if(processed[y] == FALSE || this->directed)
process_edge(v,p);
if(discovered[y] == FALSE){
q.push(y);
discovered[y] = TRUE;
parent[y] = v;
}
p = p->next;
}
process_vertex_late(v);
}
}
dfs(graph *g, int v)
{
int i; /* counter */
int y; /* successor vertex */
if (finished) return; /* allow for search termination */
discovered[v] = TRUE;
process_vertex_early(v);
for (i=0; i<g->degree[v]; i++) {
y = g->edges[v][i];
if (valid_edge(g->edges[v][i]) == TRUE) {
if (discovered[y] == FALSE) {
parent[y] = v;
dfs(g,y);
} else
if (processed[y] == FALSE)
process_edge(v,y);
}
if (finished) return;
}
process_vertex_late(v);
processed[v] = TRUE;
}
bfs(graph *g, int start)
{
queue q; /* queue of vertices to visit */
int v; /* current vertex */
int i; /* counter */
init_queue(&q);
enqueue(&q,start);
discovered[start] = TRUE;
while (empty(&q) == FALSE) {
v = dequeue(&q);
process_vertex_early(v);
processed[v] = TRUE;
for (i=0; i<g->degree[v]; i++)
if (valid_edge(g->edges[v][i]) == TRUE) {
if (discovered[g->edges[v][i]] == FALSE) {
enqueue(&q,g->edges[v][i]);
discovered[g->edges[v][i]] = TRUE;
parent[g->edges[v][i]] = v;
}
if (processed[g->edges[v][i]] == FALSE)
process_edge(v,g->edges[v][i]);
}
process_vertex_late(v);
}
}
void dfs(Graph &g, int v)
{
std::vector<EdgeNodePtr> nextEdge(g.vc+1);
std::vector<VStatus> vs(g.vc+1);
std::stack<int> s;
s.push(v);
vs[v] = DIS;
process_vertex_early(v);
nextEdge[v] = g.eNs[v];
while (!s.empty()) {
int x = s.top();
EdgeNodePtr yp = nextEdge[x];
if (yp) {
int y = yp->y;
nextEdge[x] = yp->next;
bool newEdge = false;
if(vs[y] == UND) {
nextEdge[y] = g.eNs[y];
s.push(y);
vs[y] = DIS;
process_vertex_early(y);
}
if (vs[y] != PRO || g.directed) {
process_edge(x, y);
}
} else {
s.pop();
process_vertex_late(x);
vs[x] = PRO;
}
}
}
void bfs(graph *g, int start)
{
queue q;
init_queue(&q);
enqueue(&q, start);
discovered[start] = true;
while (empty_queue(&q) == false)
{
int v = dequeue(&q);
process_vertex_early(v);
processed[v] = true;
edgenode *p = g->edges[v];
while (p != NULL)
{
int y = p->y;
if (valid_edge(p))
{
if ((!processed[y]) || g->directed)
{
process_edge(v, y);
}
if (!discovered[y])
{
enqueue(&q, y);
discovered[y] = true;
parent[y] = v;
}
}
p = p->next;
}
process_vertex_late(v);
}
}
void BreadthFirstSearch::bfs(Graph *g, int start) {
Queue q;
int current_v;
int successor_v;
edgenode *current_edges;
q.enqueue(start);
q.print();
discovered[start] = true;
while(q.queueSize() > 0) {
current_v = q.dequeue();
process_vertex_early(current_v);
processed[current_v] = true;
current_edges = g->edges[current_v];
while(current_edges != nullptr) {
successor_v = current_edges->y;
if((!processed[successor_v])) {
process_edge(current_v, successor_v);
}
if(!discovered[successor_v]) {
q.enqueue(successor_v);
discovered[successor_v] = true;
parent[successor_v] = current_v;
}
current_edges = current_edges->next;
}
process_vertex_late(current_v);
}
}
void Graph::dfs_worker(int v, void(*process_vertex_early)(int v),
void(*process_vertex_late)(int v), void(*process_edge)(int v,EdgeNode *p))
{
EdgeNode *p;
int y;
if(finished) return;
discovered[v] = TRUE;
entry_time[v] = ++time;
process_vertex_early(v);
p = this->edges[v];
while(p){
y = p->y;
if(!discovered[y]){
parent[y] = v;
process_edge(v,p);
dfs_worker(y,process_vertex_early, process_vertex_late, process_edge);
}
else if( (!processed[y] && parent[v] != y) || (this->directed)){
process_edge(v,p);
}
if(finished) return;
p = p->next;
}
process_vertex_late(v);
exit_time[v] = ++time;
processed[v] = TRUE;
}
