邻接矩阵、邻接表（深度优先搜索、广度优先搜索）

1.邻接矩阵

#include <iostream>
#include <queue>
#define MaxVertexNum 100
using namespace std;
typedef int WeightType;
typedef int Datatype;
typedef int Vertex;
typedef struct GNode* ptrToGNode;
//图
struct GNode
{
	int Nv;//顶点
	int Ne;//边
	WeightType G[MaxVertexNum][MaxVertexNum];//矩阵元素
	Datatype Data[MaxVertexNum];//存储顶点数据
};
typedef ptrToGNode MGraph;

typedef struct ENode* ptrToENode;
//边
struct ENode
{
	Vertex V1, V2;//有向边<v1，v2>
	WeightType Weight;//权重
};
typedef ptrToENode Edge;

//初始化图
MGraph Create(int VertexNum)
{
	Vertex v, w;
	MGraph Graph = new GNode;
	Graph->Nv = VertexNum;//顶点
	Graph->Ne = 0;//边
	for (v = 0; v < VertexNum; v++)
		for (w = 0; w < VertexNum; w++)
			Graph->G[v][w] = 0;//矩阵所有元素为0
	return Graph;
}
//插入边
void Insert(MGraph Graph, Edge E)
{
	//插入边<v1,v2>,权重代表边
	Graph->G[E->V1][E->V2] = E->Weight;
	//如果是无向图还得插入边<v2,v1>
	Graph->G[E->V2][E->V1] = E->Weight;
}
//建图
MGraph BuildGraph()
{
	MGraph Graph;
	Edge E;
	Vertex V;
	int Nv,i;

	cout << "输入顶点数：";
	cin >> Nv;
	Graph = Create(Nv);
	cout << "输入边数：";
	cin >> Graph->Ne;//如果边为0直接返回
	if (Graph->Ne != 0)
	{
		E = new ENode;
		cout << "输入边[v1,v2]和相应权重（权重为1表示存在边）："<<endl;//权重为0：无边
		for (i = 0; i < Graph->Ne; i++)
		{
			cin >> E->V1 >> E->V2 >> E->Weight;
			Insert(Graph, E);
		}

	}
	//如果顶点有数据
	cout << "输入顶点要存储的数据：";
	for (V = 0; V < Nv; V++)
	{
		cin >> Graph->Data[V];
	}
	
	return Graph;
}
//输出邻接矩阵
void Traversal(MGraph Graph)
{
	Vertex v, w;
	cout << "邻接矩阵："<<endl;
	for (v = 0; v < Graph->Nv; v++)
		cout << "  " << 'V' << v;
	cout << endl;
	for (v = 0; v < Graph->Nv; v++) 
	{
		cout << 'V' << v << " ";
		for (w = 0; w < Graph->Nv; w++)
		{
			cout << Graph->G[v][w] << "   ";
		}
		cout << endl;
	}
}
bool visited[MaxVertexNum];//访问标记
//深度优先搜索算法
void DFS(MGraph Graph, Vertex v)
{
	Vertex w;
	visited[v] = true;//标志已访问
	cout << Graph->Data[v]<<" ";//输出
	for (w = 0; w < Graph->Nv; w++)
		if (Graph->G[v][w] != 0 && !visited[w])//如果当前顶点的边存在，且没有访问
			DFS(Graph, w);//递归继续访问
}
//深度优先搜索遍历操作（与二叉树先序遍历类似）
void DFSTraversal(MGraph Graph)
{
	int i;
	cout << "深度遍历：";
	for (i = 0; i < Graph->Nv; i++)//所有顶点标记未访问
		visited[i] = false;
	for (i = 0; i < Graph->Nv; i++)
	{
		if (!visited[i])
			DFS(Graph, i);
	}
}
//广度优先搜索(与二叉树层序遍历类似）
void BFSTraversal(MGraph Graph)
{
	queue<Vertex>q;//顶点类型
	int i,j;
	cout << "广度遍历：";
	for (i = 0; i < Graph->Nv; i++)
		visited[i] = false;
	for (i = 0; i < Graph->Nv; i++)//对每个顶点循环
	{
		if (!visited[i])//如果没访问过
		{
			visited[i] = true;
			cout << Graph->Data[i] << " ";
			q.push(i);//入列
			while (!q.empty())//队列不空
			{
				i = q.front();//赋值给i
				q.pop();//出列
				for (j = 0; j < Graph->Nv; j++)
				{
					if (Graph->G[i][j] != 0 && !visited[j])//如果存在边，且没被访问过
					{
						visited[j] = true;
						cout << Graph->Data[j]<<" ";
						q.push(j);
					}
				}
			}
		}
	}
}

int main()
{
	MGraph Graph;
	Graph = BuildGraph();
	cout << endl;
	/*
	0--1---2--5
	 \    /
	  3--4
	*/
	Traversal(Graph);
	cout << endl;
	DFSTraversal(Graph);
	cout << endl;
	BFSTraversal(Graph);
	cout << endl;
	return 0;
}

运行：

2.邻接表

#include <iostream>
#include <queue>
#define MaxVertexNum 100
typedef int DataType;
typedef int Vertex;
typedef int WeightType;
using namespace std;

typedef struct ENode* PtrToENode;
//边
struct ENode
{
	Vertex V1, V2;//有向边V1,V2
	WeightType Weight;//权重
};
typedef PtrToENode Edge;

typedef struct AdjVNode* PtrToAdjVNode;
//邻接表内元素
struct AdjVNode
{
	Vertex AdjV;//邻接表内顶点下标
	WeightType Weight;//边权重（非网图可不用）
	PtrToAdjVNode Next;//指向下一个邻接点

};
//邻接表头（图的顶点）
typedef struct VNode
{
	PtrToAdjVNode FirstEdge;//指向第一个边
	DataType Data;//存顶点数据
}AdjList[MaxVertexNum];//关键字为数组

typedef struct GNode* PtrToGNode;
//图
struct GNode
{
	int Nv;//顶点
	int Ne;//边数
	AdjList G;//邻接表数组
};
typedef PtrToGNode LGraph;

//初始化
LGraph Create(int VertexNum)
{
	Vertex V;
	LGraph Graph = new GNode;
	Graph->Nv = VertexNum;//顶点
	Graph->Ne = 0;//边
	for (V = 0; V < Graph->Nv; V++)
	{
		Graph->G[V].FirstEdge = NULL;//从0开始每个顶点都指向空
	}
	return Graph;
}
//插入边,每次都插入在表头
void InsertEdge(LGraph Graph, Edge E)
{
	PtrToAdjVNode NewNode = new AdjVNode;//建立新邻接点
	NewNode->AdjV = E->V2;
	NewNode->Weight = E->Weight;
	NewNode->Next = Graph->G[E->V1].FirstEdge;//新结点插入表头
	Graph->G[E->V1].FirstEdge = NewNode;//表头指向新结点

	//如果是无向图则还要插入边<V2，V1>
	PtrToAdjVNode NewNode1 = new AdjVNode;//建立新结点
	NewNode1->AdjV = E->V1;
	NewNode1->Weight = E->Weight;
	NewNode1->Next = Graph->G[E->V2].FirstEdge;//新结点插入表头
	Graph->G[E->V2].FirstEdge = NewNode1;//表头指向新结点
}
//建立
LGraph BuildGraph()
{
	LGraph Graph;
	Edge E;
	int Nv,i;
	cout << "输入顶点数：";
	cin >> Nv;
	Graph = Create(Nv);
	cout << "输入边数：";
	cin >> Graph->Ne;
	if (Graph->Ne != 0)
	{
		cout << "输入边[v1,v2]和相应权重："<<endl;
		for (i = 0; i < Graph->Ne; i++)
		{
			E = new ENode;
			cin >> E->V1 >> E->V2 >> E->Weight;
			InsertEdge(Graph, E);
		}
	}
	//如果顶点有数据
	cout << "输入顶点要存储的数据：";
	for (i = 0; i < Graph->Nv; i++)
	{
		cin >> Graph->G[i].Data;
	}
	return Graph;
}
//输出邻接表
void Traversal(LGraph Graph)
{
	Vertex v;
	PtrToAdjVNode tmp;
	cout << "邻接表：" << endl;
	for (v = 0; v < Graph->Nv; v++)
	{
		tmp=Graph->G[v].FirstEdge;
		cout << v<<" ";
		while (tmp)
		{
			cout << tmp->AdjV<<" ";
			tmp = tmp->Next;
		}
		cout << endl;
	}
}

bool visited[MaxVertexNum];//访问标志
//深度优先搜索递归算法(与二叉树先序遍历同理)
void DFS(LGraph Graph, Vertex v)
{
	PtrToAdjVNode tmp;//声明邻接点指针
	visited[v] = true;//已访问
	cout << Graph->G[v].Data << " ";//输出当前顶点数据
	tmp = Graph->G[v].FirstEdge;//p指向当前表头
	while (tmp)//p不空
	{
		if (!visited[tmp->AdjV])//如果当前邻接点没有访问
			DFS(Graph, tmp->AdjV);//继续递归搜索
		tmp = tmp->Next;//tmp移向下一个邻接点
	}
}
//深度优先搜索遍历操作
void DFSTraversal(LGraph Graph)
{
	int i;
	cout << "深度优先搜索：";
	for (i = 0; i < Graph->Nv; i++)
		visited[i] = false;//所有结点初始化未访问
	for (i = 0; i < Graph->Nv; i++)
	{
		if (!visited[i])
			DFS(Graph, i);
	}
}
//广度优先搜索遍历（与二叉树层序遍历同理）
void BFSTraversal(LGraph Graph)
{
	int i;
	PtrToAdjVNode tmp;//声明邻接点指针
	queue<Vertex> q;//顶点类型队列
	cout << "广度优先搜索：";
	for (i = 0; i < Graph->Nv; i++)
		visited[i] = false;
	for (i = 0; i < Graph->Nv; i++)
	{
		if (!visited[i])//当前顶点未访问
		{
			visited[i] = true;
			cout << Graph->G[i].Data<<" ";//输出当前顶点
			q.push(i);//访问后入列
			while (!q.empty())//队列不空
			{
				i = q.front();//i赋值为当前队头
				q.pop();//出列
				tmp = Graph->G[i].FirstEdge;//tmp指向当前出列顶点
				while (tmp)//tmp不空
				{
					if (!visited[tmp->AdjV])//当前顶点未访问
					{
						visited[tmp->AdjV] = true;
						cout << Graph->G[tmp->AdjV].Data<<" ";
						q.push(tmp->AdjV);//访问后入列
					}
					tmp = tmp->Next;
				}
			}
		}
	}
}
int main()
{
	LGraph Graph;
	Graph = BuildGraph();
	cout << endl;
	/*
	0--1---2--5
	 \    /
	  3--4
	*/
	Traversal(Graph);
	cout << endl;
	DFSTraversal(Graph);
	cout << endl;
	BFSTraversal(Graph);
	cout << endl;
	return 0;
}

运行：