数据结构--图（上） 建图、BFS、DFS

图

什么是图？

• 表示多对多的关系

• 包含：
  一组顶点：通常用V（Vertex）表示顶点集合
  一组边： 通常用E(Edge)表示边的集合
  边是顶点对：无向边（v,w）∈E ，v，w，∈V
  有向边<v,w>表示从v指向w的边
  不考虑重边和自回路

  抽象数据类型定义
  
  图的操作集很多，后面会慢慢接触。

如何表示图?

邻接矩阵表示

从上面的矩阵可以发现，主对角线上全是0，矩阵由对角线对称，但是这个图优点是可以快速访问连接情况，缺点是浪费了大量空间，特别是如果点特别多，边很少，这样就会存在大量的空间浪费。

还有一种是开一个一维数组，这样空间可以剩下一半，但是缺点是访问没有那么方便了，需要转换。

下面总结下邻接矩阵表示图的好处：

缺点:

这里以这个无向无权图为例：

矩阵实现：

#include <iostream>
#include <string.h>
#include <queue>
#include <stdlib.h>
#define Max 1000
#define DateType int 
using namespace std ;
typedef int Vertex ; 
typedef struct node{
	int Mat[Max][Max];
	int Numberv ;
	int Numbere ;
	DateType Date[Max];//记录顶点的一些信息 
}*MGraph;
 
MGraph creatGraph(int vertexnum) // 先初始化点 无边 
{
	MGraph mat = (MGraph) malloc (sizeof (struct node));
	mat->Numberv = 0 ;
	mat->Numbere = vertexnum ;
	
	for (int i=0;i<vertexnum;i++)
		for (int j=0;j<vertexnum ;j++) 
			mat->Mat[i][j] = 0 ;
	return mat ; 
}

void insert (MGraph mat ,int x1 ,int x2)
{
	mat->Mat[x1][x2] = 1 ;
	mat->Mat[x2][x1] = 1 ;
}

void BFS (MGraph mat)
{
	cout <<"BFS:"<<endl;
	int flag[mat->Numbere] ;
	memset (flag , 0,sizeof (flag));
	for (int i=0 ;i <mat->Numbere ;i++)
	{
		if(flag[i] ==0)
		{
			queue<int> q ;
			q.push (i);
			while (!q.empty())
			{
				int item = q.front();
				q.pop(); 
				if (flag [item]==0)
				{
					cout << item <<" ";
					flag [item] = 1 ;
				}
				for (int j=0;j<mat->Numbere;j++)
					if (mat->Mat[item][j]!=0 && flag[j]==0)
						q.push (j); 
			}
			cout << endl ;
		} 
	} 
}

void DFS(MGraph M ,int i, int flag[])
{
	if (flag[i] ==0)
	{
		cout << i<<" ";
		flag[i] = 1;
	}
	else 
	return ;
	for (int j=0;j< M->Numbere ;j++)
	{
		if (flag[j] ==0 && M->Mat[i][j] ==1)
		{
			DFS (M,j,flag);
		}
	}
	
}
int main ()
{
	//这里以无向图为例 
	/*
	10
	17
	0 1 
	0 3
	1 2 
	1 3
	1 5
	2 4 
	2 5
	3 6 
	3 7
	4 9
	4 5
	5 6
	5 8 
	5 9
	6 8
	6 7
	8 9
	*/ 
	int n ;
	cout <<"顶点数：";
	cin >> n ; 
	MGraph  mat = creatGraph(n);
	int e ;
	cout <<"边数:" ;
	cin  >>e;
	int v1 ,v2 , weight ;
	for (int i=0;i<e;i++)
	{
		cin >> v1 >>v2 ;
		insert (mat, v1,v2);
	}
	BFS (mat);
	int flag[mat->Numbere] ;
	memset (flag , 0,sizeof (flag));
	cout <<"DFS:"<<endl;
	for (int i=0;i<mat->Numbere;i++)
	{
		if (flag[i] ==0)
			DFS (mat,i ,flag);
		cout <<endl;
	}
	return 0;
}

BFS路径：

DFS路径：

邻接表表示
G[N]为指针数组，对应矩阵每行一个链表，只存非0元素。这样就可以很好的解决空间浪费的现象。

优缺点评价:

邻接表实现：
这里结合 数组加vector就可以实现邻接表的功能，而且代码实现简单。
只需要 vector Mat[Max] ;即可，方便好用。

#include <iostream>
#include <string.h>
#include <queue>
#include <algorithm>
#include <stdlib.h>
#include <vector>
#define Max 1000
#define DateType int 
using namespace std;
typedef int Vertex;
vector <int> Mat[Max];
int n;
void insert(int x1, int x2)
{
	Mat[x1].push_back(x2);
	Mat[x2].push_back(x1);
}

void BFS()
{
	cout << "BFS:" << endl;
	int flag[n];
	memset(flag, 0, sizeof(flag));
	for (int i = 0; i < n; i++)
	{
		if (flag[i] == 0)
		{
			queue<int> q;
			q.push(i);
			while (!q.empty())
			{
				int item = q.front();
				q.pop();
				if (flag[item] == 0)
				{
					cout << item << " ";
					flag[item] = 1;
				}
				for (int j = 0; j < Mat[item].size(); j++)
					if (flag[Mat[item][j]] == 0)
						q.push(Mat[item][j]);
			}
			cout << endl;
		}
	}
}

void DFS(int i, int flag[])
{
	if (flag[i] == 0)
	{
		cout << i << " ";
		flag[i] = 1;
	}
	else
		return;
	for (int j = 0; j < Mat[i].size(); j++)
	{
		if (flag[Mat[i][j]] == 0)
		{
			DFS(Mat[i][j], flag);
		}
	}
}
int main()
{
	//这里以无向图为例 
	/*
	10
	17
	0 1
	0 3
	1 2
	1 3
	1 5
	2 4
	2 5
	3 6
	3 7
	4 9
	4 5
	5 6
	5 8
	5 9
	6 8
	6 7
	8 9
	*/

	cout << "顶点数：";
	cin >> n;
	int e;
	cout << "边数:";
	cin >> e;
	int v1, v2, weight;
	for (int i = 0; i < e; i++)
	{
		cin >> v1 >> v2;
		insert(v1, v2);
	}
	//为了达到先遍历数字小的结点，对所有vector进行排序下
	for (int i=0;i<n;i++)
	{
		if (!Mat[i].empty())
			sort(Mat[i].begin(),Mat[i].end());
	 }
	  
	BFS();
	int flag[Max];
	memset(flag, 0, sizeof(flag));
	cout << "DFS:" << endl;
	for (int i = 0; i < n; i++)
	{
		if (flag[i] == 0)
			DFS(i, flag);
		cout << endl;
	}
	return 0;
}

图有很多种表示方法，图只是一个抽象的概念，具体的表示方法，要结合问题去设计。

结果与二维数组实现一致，如果不要求从小到大遍历的话，可以免去：

for (int i=0;i<n;i++)
	{
		if (!Mat[i].empty())
			sort(Mat[i].begin(),Mat[i].end());
	 }

这步排序，这样的话效率会远远高于直接用二维数组储存，因为不需要每个结点都遍历，只需要遍历自身有关联的点即可。

for (int j = 0; j < Mat[item].size(); j++)

除了用vector 外紫书上还有一种用数组模拟邻接表的方法

int first[maxn] , next[maxn]; //first[i] = e 记录 i点的第一条边的编号e  next[e] 表示e编号的下一条边的编号
int u[maxn] , v[maxn] , w[maxn] ;//记录 起点 终点  权值
for (e = 0 ;e<m;e++)
{
	cin >> u[e]>>v[e]>>w[e];
	next[e] = first[u[e]];
	first[u[e]] = e ;
}

关于深搜和宽搜的讲解参考：https://blog.csdn.net/weixin_40953222/article/details/80544928

习题：7-9 列出连通集 (25分)

给定一个有N个顶点和E条边的无向图，请用DFS和BFS分别列出其所有的连通集。假设顶点从0到N−1编号。进行搜索时，假设我们总是从编号最小的顶点出发，按编号递增的顺序访问邻接点。

输入格式:
输入第1行给出2个整数N(0<N≤10)和E，分别是图的顶点数和边数。随后E行，每行给出一条边的两个端点。每行中的数字之间用1空格分隔。

输出格式:
按照"{ v1v​2 … v​k​​ }"的格式，每行输出一个连通集。先输出DFS的结果，再输出BFS的结果。

输入样例:
8 6
0 7
0 1
2 0
4 1
2 4
3 5

输出样例:
{ 0 1 4 2 7 }
{ 3 5 }
{ 6 }
{ 0 1 2 7 4 }
{ 3 5 }
{ 6 }

这题就是dfs bfs 的模板题啦！因为数据不大，我用二维数组保存图。大家也可以用vector a[x] 的方法去试试，熟练对vector的使用。

#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
#include <queue>
using namespace std ;

int a[11][11];
int Hash[11]; 
	int n, m ;
void dfs (int i)
{
	if (Hash[i]==0)
	{
		cout <<" "<<i;
		Hash[i] = 1;
		for (int j=i;j<n;j++)
		{
			if (a[i][j] ==1 && Hash[j]==0)
				dfs(j);
		}
	}	
}

int main ()
{
	memset(a,0,sizeof (a));
	memset(Hash,0,sizeof (Hash));
	cin >> n >> m ;
	int x1 , x2;
	for (int i=0;i<m;i++)
	{
		cin >>x1 >>x2 ;
		a[x1][x2] = 1 ;
		a[x2][x1] = 1 ;
	}
	for (int i=0;i<n;i++)
	{
		if (Hash[i]==0)
		{
		cout <<"{";
		dfs(i);
		cout <<" }"<<endl;
		}
	}
	memset(Hash,0,sizeof (Hash));
	for (int i=0;i<n;i++)  //BFS
	{
		queue<int> q ;
		if (Hash[i] == 0)
		{
			cout << "{";
			q.push (i);
			while (!q.empty())
			{
				int item = q.front(); q.pop();
				if (Hash[item] ==0)
				cout <<" "<<item;
				Hash[item] = 1 ;
				for (int j=item;j<n;j++)
					if (Hash[j]==0 && a[item][j]==1 )
						q.push(j);
			}
			cout <<" }"<<endl;
		}
	}
	return 0;
}