Adjacency List表示下Depth-First-Search(DFS)及Breadth-First-Search(BFS)的c++实现

1. Interface (Graph.h, listQueue.h)

#ifndef GRAPH_H_INCLUDED
#define GRAPH_H_INCLUDED

class Graph
{
private:
struct adjListNode{
int node;
adjListNode* next;
adjListNode(int x, adjListNode* t) : node(x), next(t) {}
};
typedef adjListNode* vtx;
vtx* adjList; // adjacency list
int countV; // number of vertices in the graph
void dfsUtil(int, bool*); // recursive procedure in DFS
public:
Graph(int);
~Graph();
void addEdge(int, int);
void removeEdge(int, int);
bool isConnected(int, int);
void showConnected(int);
void dfs(int);
void bfs(int);
};

#endif // GRAPH_H_INCLUDED

#ifndef LISTQUEUE_H_INCLUDED
#define LISTQUEUE_H_INCLUDED

template <class Item>
class Queue
{
private:
struct node{
Item item;
node *next;
node(Item x) : item(x), next(0) {}
};
typedef node *link;
link head, tail;	// enqueue to the tail, dequeue from the head
public:
Queue();
~Queue();
bool isEmpty() const;
void enqueue(Item);	// push item into the queue
Item dequeue();		// retrieve item back from the queue
};

template <class Item>
Queue<Item>::Queue()
{
head = 0;
tail = 0;
}

template <class Item>
Queue<Item>::~Queue()
{
delete head;
}

template <class Item>
bool Queue<Item>::isEmpty() const
{
return head == 0;
}

template <class Item>
void Queue<Item>::enqueue(Item x)
{
link t = tail;
tail = new node(x);
if (head == 0)
head = tail;
else t->next = tail;
}

template <class Item>
Item Queue<Item>::dequeue()
{
Item v = head->item;
link t = head->next;
delete head;
head = t;
return v;
}

#endif // LISTQUEUE_H_INCLUDED

2. Implementation (Graph.cpp)
/* Represent graphs by adjacency list without dummy head node. */

#include"Graph.h"
#include"listQueue.h"
#include<iostream>
using namespace std;

Graph::Graph(int N)
{
countV = N;
adjList = new vtx[countV];
for (int i = 0; i < N; ++i){
adjList[i] = new adjListNode(i, 0);
}
}

Graph::~Graph()
{
for (int i = 0; i < countV; ++i)
delete[] adjList[i];
delete[] adjList;
}

void Graph::addEdge(int x, int y)
{
if (x >= 0 && x < countV && y >= 0 && y < countV){
adjList[x] = new adjListNode(y, adjList[x]);
}
}

bool Graph::isConnected(int x, int y)
{
int check = 0;
if (x >= 0 && x < countV && y >= 0 && y < countV){
vtx newNode = adjList[x];
while (newNode->next != 0){
if (newNode->node == y){
check = 1;
break;
}
else newNode = newNode->next;
}
}
return check;
}

void Graph::removeEdge(int x, int y)
{
if (x >= 0 && x < countV && y >= 0 && y < countV){
vtx newNode1 = adjList[x], newNode2 = adjList[x];
int countLoop = 0;
while (newNode1->node != y && newNode1->next != 0){
newNode2 = newNode1;
newNode1 = newNode2->next;
++countLoop;
}
if (!countLoop){
newNode2 = newNode1->next;
adjList[x] = newNode2;
}
else{
newNode2->next = newNode1->next;
adjList[x] = newNode2;
}
}
}

void Graph::showConnected(int x)
{
cout << "The connection of vertex " << x << ":" << endl;
vtx newNode = adjList[x];
while (newNode->next != 0){
cout << newNode->node << " -> ";
newNode = newNode->next;
}
cout << x << endl;
}

void Graph::dfsUtil(int v, bool* visited)
{
visited[v] = true;

vtx newNode1 = adjList[v];
while (newNode1->next != 0){
if (!visited[newNode1->node]){
// output the node (v, newNode1->node)
cout << "(" << v << ", " << newNode1->node << ")" << endl;
// recursion
dfsUtil(newNode1->node, visited);
}
else{
newNode1 = newNode1->next;
}
}
}

void Graph::dfs(int v)
{
bool* visited = new bool[countV];
for (int i = 0; i < countV; ++i)
visited[i] = false;
dfsUtil(v, visited);
}

void Graph::bfs(int v)
{
Queue<int> q;
bool* visited = new bool[countV];
for (int i = 0; i < countV; ++i)
visited[i] = false;

q.enqueue(v);
visited[v] = true;

while (!q.isEmpty()){
int temp = q.dequeue();
while (adjList[temp]->next != 0){
if (!visited[adjList[temp]->node]){
q.enqueue(adjList[temp]->node);
visited[adjList[temp]->node] = true;
cout << "(" << temp << ", " << adjList[temp]->node << ")" << endl;
}
adjList[temp] = adjList[temp]->next;
}
}

delete[] visited;
}

3. Client (main.cpp)
#include<iostream>
#include"Graph.h"
using namespace std;

int main(int argc, char* argv[])
{
int V = atoi(argv[1]);
Graph *g = new Graph(V);
for (int i = 0; i < V; ++i){
cout << "Enter the connections of vertex " << i << ":" << endl;
int j;
while (cin >> j){
if (j >= 0 && j < V && j != i){
g->addEdge(i, j);
}
else if (j == i){

// if the input vertex is the same as the given vertex
break;
}
else cout << "Out of range." << endl;
}
}

for (int i = 0; i < V; ++i)
g->showConnected(i);
// DFS
int start = 0;
cout << "Enter the DFS starting node:";
cin >> start;
g->dfs(start);

// BFS
cout << "Enter the BFS starting node:";
cin >> start;
g->bfs(start);

return 0;
}

测试用图：



执行：

Enter the connections of vertex 0:

1 0

Enter the connections of vertex 1:

0 2 3 4 1

Enter the connections of vertex 2:

1 2

Enter the connections of vertex 3:

1 4 3

Enter the connections of vertex 4:

1 3 4

The connection of vertex 0:

1 -> 0

The connection of vertex 1:

4 -> 3 -> 2 -> 0 -> 1

The connection of vertex 2:

1 -> 2

The connection of vertex 3:

4 -> 1 -> 3

The connection of vertex 4:

3 -> 1 -> 4

Enter the DFS starting node:0

(0, 1)

(1, 4)

(4, 3)

(1, 2)

Enter the BFS starting node:4

(4, 3)

(4, 1)

(1, 2)

(1, 0)