图的邻接矩阵,邻接表，DFS，BFS的实现

#include <iostream>
#include <queue>
using namespace std;

#define MAXVEX 10	//最大顶点数
#define INFINITY 65535	//65535代表∞

//----------------邻接矩阵---------------//
typedef struct
{
	char vexs[MAXVEX];	//顶点表
	int arc[MAXVEX][MAXVEX];	// 邻接矩阵，看作边表
	int numVertexes, numEdges;	// 图中的顶点数和边数
}MGraph;


// 建立无向网图的邻接矩阵表示	时间复杂度0(n^2)
void createMGraph(MGraph *G)
{
	int i, j, k, w;
	cout << "输入顶点数和边数:" << endl;
	cin >> G->numVertexes >> G->numEdges;
	cout << "输入顶点信息" << endl;
	for (i = 0; i < G->numVertexes; i++)
	{
		cin >> G->vexs[i];
	}
	
	for (i = 0; i < G->numVertexes; i++)
		for (j = 0; j < G->numVertexes; j++)
			G->arc[i][j] = INFINITY;	// 邻接矩阵初始化

	for (k = 0; k < G->numEdges; k++)
	{
		cout << "输入边（vi.vj)上的下标i，下标j和权值w:" << endl;
		cin >> i >> j >> w;
		G->arc[i][j] = w;
		G->arc[j][i] = G->arc[i][j];	// 因为是无向图，矩阵对称
	}
}

void printMGraph(MGraph &G)
{
	for (int i = 0; i < G.numVertexes; ++i)
	{
		for (int j = 0; j < G.numVertexes; ++j) {
			if (G.arc[i][j] == INFINITY) cout << "∞";
			else cout << G.arc[i][j];
			cout << " ";
		}
		cout << endl;
	}
}


//----------------邻接表法---------------//

// 边表结点
typedef struct EdgeNode
{
	int adjvex;	// 邻接点域， 存储该项顶点对应的下标
	struct EdgeNode *next;	// 链域，指向下一个邻接点
}EdgeNode;


// 顶点表结点
typedef struct VertexNode
{
	char data;	//顶点域， 存储顶点信息
	EdgeNode *firstedge;	// 边表头指针
}VertexNode, AdjList[MAXVEX];


typedef struct
{
	AdjList adjList;	// 顶点表
	int numVertexes, numEdges;	//图中当前顶点数和边数
}GraphAdjList;


// 建立无向图的邻接表结构	时间复杂度O(n+e)
void CreateALGraph(GraphAdjList *G)
{
	int i, j, k;
	EdgeNode *e;
	cout << "输入顶点数和边数" << endl;
	cin >> G->numVertexes >> G->numEdges;
	cout << "输入顶点信息" << endl;
	for (i = 0; i < G->numVertexes; i++)	// 建立顶点表
	{
		cin >> G->adjList[i].data;	// 输入顶点信息
		G->adjList[i].firstedge = NULL;		// 将边表初始化为空表
	}

	for (k = 0; k < G->numEdges; k++)
	{
		cout << "输入边（vi.vj)上的顶点序号:" << endl;
		cin >> i >> j;
		e = new EdgeNode;		// 生成边表结点
		e->adjvex = j;		// 邻接序号为j
		// 头插法连接顶点表和边表
		e->next = G->adjList[i].firstedge;
		G->adjList[i].firstedge = e;

		e = new EdgeNode;
		e->adjvex = i;
		e->next = G->adjList[j].firstedge;
		G->adjList[j].firstedge = e;
	}
}

void printALGraph(GraphAdjList &G)
{
	for (int i = 0; i < G.numVertexes; ++i) {
		cout << G.adjList[i].data;
		EdgeNode* e = G.adjList[i].firstedge;
		while (e) {
			cout << "->" << G.adjList[e->adjvex].data;
			e = e->next;
		}
		cout << endl;
	}
}

#define MAX 256
bool visited[MAX];

// 邻接表的深度优先递归算法
void DFS(GraphAdjList GL, int i)
{
	EdgeNode *p;
	visited[i] = true;
	cout << GL.adjList[i].data << " ";
	p = GL.adjList[i].firstedge;
	while (p)
	{
		if (!visited[p->adjvex])
			DFS(GL, p->adjvex);		// 对未访问过的邻接顶点递归调用
		p = p->next;
	}
}

// 邻接表的深度遍历操作
void DFSTraverse(GraphAdjList GL)
{
	int i;
	for (i = 0; i < GL.numVertexes; i++)
		visited[i] = false;
	for (i = 0; i < GL.numVertexes; i++)
		if (!visited[i])		// 对未访问过的顶点调用DFS，若是连通图，只会执行一次
			DFS(GL, i);
	cout << endl;
}

void BFS(GraphAdjList GL, int i) 
{
	visited[i] = true;
	queue<VertexNode> que;
	que.push(GL.adjList[i]);
	while (!que.empty()) {
		VertexNode ver = que.front();
		que.pop();
		cout << ver.data << " ";

		EdgeNode* e = ver.firstedge;	// 边表
		while(e) {		// 循环遍历与ver邻接的顶点，并压住队列que中
			int w = e->adjvex;
			if (!visited[w]) {
				visited[w] = true;
				que.push(GL.adjList[w]);
			}
			e = e->next;
		}
	}
}

void BFSTraverse(GraphAdjList GL)
{
	for (int i = 0; i < GL.numVertexes; ++i) {
		visited[i] = false;
	}
	for (int i = 0; i < GL.numVertexes; ++i) {
		if (!visited[i]) {
			BFS(GL, i);
		}
	}
	cout << endl;
}

int main()
{
	//MGraph G;
	//createMGraph(&G);
	//printMGraph(G);

	GraphAdjList G;
	CreateALGraph(&G);
	printALGraph(G);

	DFSTraverse(G);
	BFSTraverse(G);

	return 0;
}