第7章 图

addEdge()

/*
A C++ Program to demonstrate adjacency list representation of graphs
Create a adjacency list representation of graphs
BFS based on adjacency list representation of graphs
BFS based on adjacency list representation of graphs
*/
#include <iostream>
#include <queue>
#include <vector>
using namespace std;

// A structure to represent an adjacency list node
struct AdjListNode
{
int dest;
AdjListNode* next;
AdjListNode(int d): dest(d), next(NULL) {}
};

// A structure to represent an adjacency list
struct AdjList
{
AdjListNode *head;  // pointer to head node of list
AdjList(): head(NULL) {}
};

// A structure to represent a graph. A graph is an array of adjacency lists.
// Size of array will be V (number of vertices in graph)
struct Graph
{
int V;
AdjList* array;
Graph(int vertex): V(vertex)
{
array = new AdjList[V];
for(int i = 0; i < vertex; i++)
array[i].head = new AdjListNode(i);
}
~Graph()
{
AdjListNode* it;
AdjListNode* prev;
for(int i = 0; i < V; i++)
{
it = array[i].head;
while(it)
{
prev = it;
it = it->next;
delete prev;
}
}
delete[] array;
}
};

// A utility function to create a new adjacency list node
AdjListNode* newAdjListNode(int dest)
{
AdjListNode* node = new AdjListNode(dest);
return node;
}

// A utility function that creates a graph of V vertices
Graph* createGraph(int V)
{
Graph* graph = new Graph(V);
return graph;
}

// Adds an edge to an directed graph
void addEdge(struct Graph* graph, int src, int dest)
{
//src to dest
AdjListNode* node = newAdjListNode(dest);
node->next = graph->array[src].head->next;
graph->array[src].head->next = node;
/*
//dest to src (if it's an undirected graph)
node = newAdjListNode(src);
node->next = graph->array[dest].head;
graph->array[dest].head = node;
*/
}

// A utility function to print the adjacenncy list representation of graph
void printGraph(struct Graph* graph)
{
for (int v = 0; v < graph->V; ++v)
{
AdjListNode* pCrawl = graph->array[v].head;
cout << endl << " Adjacency list of vertex " << v << endl << " ";
while (pCrawl)
{
cout << pCrawl->dest << "-> ";
pCrawl = pCrawl->next;
}
cout << "#" << endl;
}
}

void BreadthFirstSearch(Graph* graph)
{
cout << "BreadthFirstSearch print: " << endl;
queue<AdjListNode*> q;
vector<bool> visited(graph->V, false);
AdjListNode* cur = NULL;
for(int i = 0; i < graph->V; i++)
{
if(!visited[i])
{
visited[i] = true;
cout << i << " -> ";
cur = graph->array[i].head;
q.push(cur);
while(!q.empty())
{
cur = q.front();
if(cur->dest < graph->V)
cur = graph->array[cur->dest].head;
q.pop();
while(cur)
{
if(!visited[cur->dest])
{
visited[cur->dest] = true;
cout << cur->dest << " -> ";
q.push(cur);
}
cur = cur->next;
}
}
}
}
cout << "#" << endl;
}

void DFS_helper(Graph* graph, int v, vector<bool>& visited)
{
cout << v << " -> ";
if(v >= graph->V || v < 0)
return;
visited[v] = true;
AdjListNode* cur = graph->array[v].head->next;
while(cur)
{
DFS_helper(graph, cur->dest, visited);
cur = cur->next;
}
}

void DepthFirstSearch(Graph* graph)
{
cout << "DepthFirstSearch print: " << endl;
vector<bool> visited(graph->V, false);
for(int i = 0; i < graph->V; i++)
{
if(!visited[i])
DFS_helper(graph, i, visited);
}
cout << "#" << endl;
}

// Driver program to test above functions
int main()
{
// create the graph given in above fugure
int V = 7;
struct Graph* graph = createGraph(V);
addEdge(graph, 0, 2);
addEdge(graph, 0, 1);
addEdge(graph, 1, 4);
addEdge(graph, 1, 3);
addEdge(graph, 2, 6);
addEdge(graph, 2, 5);
addEdge(graph, 3, 7);

// print the adjacency list representation of the above graph
printGraph(graph);
//BFS and DFS
BreadthFirstSearch(graph);
DepthFirstSearch(graph);
return 0;
}