不同存图方式下的DFS和BFS实现

常见的存图方式有 邻接矩阵，邻接表，链式前向星 等。

一. DFS：

  1.邻接矩阵：

（一定记住初始化或清空）

数据结构实验之图论二：图的深度遍历

#include <bits/stdc++.h>
using namespace std;

int mp[110][110];
int vis[110];
int n, m;
vector<int> ans;
void dfs(int x)
{
	vis[x] = 1;
	ans.push_back(x);
	for (int i = 0; i < n; i++)
	{
		if (mp[x][i] && !vis[i]) //保证进入递归的都是没被遍历过的
		{
			dfs(i);
		}
	}
}
/* void dfs(int x)
{
	if (vis[x] == 1)//vis也可以在新的递归中判断
		return;
	vis[x] = 1;
	ans.push_back(x);
	for (int i = 0; i < n; i++)
	{
		if (mp[x][i])
			dfs(i);
	}
} */
int main()
{
	int t;
	cin >> t;
	while (t--)
	{
		memset(vis, 0, sizeof vis);
		memset(mp, 0, sizeof mp);
		ans.clear(); //一定要记得清空，尤其是多组输入的时候
		cin >> n >> m;
		for (int i = 1; i <= m; i++)
		{
			int u, v;
			cin >> u >> v;
			mp[u][v] = mp[v][u] = 1;
		}
		dfs(0);
		for (int res : ans)
			cout << res << " ";
		cout << endl;
	}
	return 0;
}

2.邻接表：

对于某些题目来说，题目要求要在遍历时从小到大，故这时就要将vector存图改为优先队列存图，同时还要将排序方式改为升序排列。

而对于邻接矩阵来说就没有这样的问题，因为在遍历出边时是从按照编号从头开始，故可以保证编号从小到大。

数据结构实验之图论四：迷宫探索

#include <bits/stdc++.h>
using namespace std;

priority_queue<int,vector<int>,greater<int> > mp[1100];
int vis[1100];
int n, m, k;
vector<int> ans;

inline void clear(priority_queue<int,vector<int>,greater<int> > &q) {
    priority_queue<int,vector<int>,greater<int> > empty;
    swap(empty,q);
}//自定义队列清空函数

void dfs(int x)
{
	vis[x] = 1;
	ans.push_back(x);
	while(!mp[x].empty())
	{
		int g=mp[x].top();
		mp[x].pop();
		if (!vis[g]) //保证进入递归的都是没被遍历过的
		{
			dfs(g);
			ans.push_back(x);
		}
	}
}

int main()
{
	int t;
	cin >> t;
	while (t--)
	{
		memset(vis, 0, sizeof vis);
		for (int i = 0; i < 1100; i++)
		{
			 clear(mp[i]);
		}
		ans.clear(); //一定要记得清空，尤其是多组输入的时候
		cin >> n >> m >> k;
		for (int i = 1; i <= m; i++)
		{
			int u, v;
			cin >> u >> v;
			mp[u].push(v);
			mp[v].push(u);
		}
		dfs(k);
		for (int res : ans)
			cout << res << " ";
			 if (ans.size() != n * 2 - 1)
            cout << "0";
		cout << endl;
	}
	return 0;
}

3.链式前向星：

应当注意，由于链式前向星的存储原理是无序的，并且只能按照存好后的顺序进行遍历，故在某些要求遍历顺序的题目中尽量谨慎使用。

#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;

int vis[N];
int n, m, k;
vector<int> ans;
int e[N], ne[N], h[N], idx;

void add(int u, int v)
{
	e[idx] = v;		// e[i]代表第i条边的尾节点
	ne[idx] = h[u]; // ne[i]代表与第i条边同头节点的上一条边的编号
	h[u] = idx++;	// h[i]代表最新存入头节点为i的边的位置
	//链式前向星存图方式是将同一头节点的边的位置信息顺序存储下来，只记录最新的位置，遍历时从最新的位置就可逐步遍历
	// e:位置->节点
	// ne:位置->位置
	// h:节点->位置
}

void dfs(int x)
{
	vis[x] = 1;
	ans.push_back(x);
	for (int i = h[x]; i != -1; i = ne[i])
	{
		int t = e[i];
		if (!vis[t])
		{
			dfs(t);
		}
	}
}

//同样的两种不同的时候判断是否遍历过
/* void dfs(int x)
{
	if(vis[x])
	return;
	vis[x]=1;
	ans.push_back(x);
	for(int i=h[x];i!=-1;i=ne[i])
	{
		int t=e[i];
		dfs(t);
	}
} */
void init()
{
	memset(h, -1, sizeof(h));
	idx = 0;
}
int main()
{
	int t;
	cin >> t;
	while (t--)
	{
		init();
		memset(vis, 0, sizeof vis);
		ans.clear(); //一定要记得清空，尤其是多组输入的时候
		cin >> n >> m /* >> k */;
		for (int i = 1; i <= m; i++)
		{
			int u, v;
			cin >> u >> v;
			add(u, v);
			add(v, u);
		}
		dfs(1);
		for (int res : ans)
			cout << res << " ";
		cout << endl;
	}
	return 0;
}

二. BFS：

1.邻接矩阵：

邻接矩阵适合存顶点数量级不大的稠密图。

数据结构实验之图论一：基于邻接矩阵的广度优先搜索遍历

#include <bits/stdc++.h>
using namespace std;
const int N=1e6+10;

int vis[N];
int n,m,k;
int mp[1010][1010];//邻接矩阵存不了太大的图
vector<int> ans;
void init()
{
	ans.clear();
	memset(vis,0,sizeof vis);
	memset(mp,0,sizeof mp);
}
void bfs(int x)
{
	queue<int> q;
	q.push(x);
	vis[x]=1;
	while(!q.empty())
	{
		int t=q.front();
		q.pop();
		ans.push_back(t);
		for(int i=0;i<n;i++)
		{
			if(mp[t][i]==1&&vis[i]==0)
			{
				vis[i]=1;
				q.push(i);
			}
		}
	}
}
int main()
{	
	int t;
	cin>>t;
	while(t--)
	{
		init();
		cin>>n>>m>>k;
		for(int i=1;i<=m;i++)
		{
			int u,v;
			cin>>u>>v;
			mp[u][v]=1;
			mp[v][u]=1;
		}
		bfs(k);
		for(int res:ans)
		cout<<res<<" ";
		cout<<endl;
	}
	return 0;
}

2. 邻接表

（个人感觉邻接表是最好用的，空间够大，还可以利用堆优化。）

数据结构实验之图论二：基于邻接表的广度优先搜索遍历

#include <bits/stdc++.h>
using namespace std;
const int N=1e6+10;

int vis[N];
int n,m,k;
vector<int> mp[N];
vector<int> ans;
void init()
{
	ans.clear();
	memset(vis,0,sizeof vis);
	memset(mp,0,sizeof mp);
}
void bfs(int x)
{
	queue<int> q;
	q.push(x);
	vis[x]=1;
	while(!q.empty())
	{
		int t=q.front();
		q.pop();
		ans.push_back(t);
		for(int r:mp[t])
		{
			if(vis[r]==0)
			{
				vis[r]=1;
				q.push(r);
			}
		}
	}
}
int main()
{	
	int t;
	cin>>t;
	while(t--)
	{
		init();
		cin>>n>>m>>k;
		for(int i=1;i<=m;i++)
		{
			int u,v;
			cin>>u>>v;
			mp[u].push_back(v);
			mp[v].push_back(u);
		}
		bfs(k);
		for(int res:ans)
		cout<<res<<" ";
		cout<<endl;
	}
	return 0;
}

3.链式前向星

（链式前向星还是要多练）

#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int vis[N];
int n, m, k;
struct edge
{
    int to;
    int ne;
} e[N];
int h[N];
int idx;
void add(int u, int v)
{
    e[idx].to = v;
    e[idx].ne = h[u];
    h[u] = idx++;
}
vector<int> ans;
void init()
{
    memset(vis, 0, sizeof(vis));
    ans.clear();
    memset(h, -1, sizeof(h));
    idx =0;
}

void bfs(int x)
{
    queue<int> q;
    q.push(x);
    vis[x] = 1;
    while (!q.empty())
    {
        int t = q.front();
        q.pop();
        ans.push_back(t);
        for (int i = h[t]; i != -1; i = e[i].ne)
        {
            int r = e[i].to;
            if (!vis[r])
            {
                vis[r] = 1;
                q.push(r);
            }
        }
    }
}
int main()
{
    int t;
    cin >> t;
    while (t--)
    {
        init();
        cin >> n >> m >> k;
        for (int i = 1; i <= m; i++)
        {
            int u, v;
            cin >> u >> v;
            add(u, v);
            add(v, u);
        }
        bfs(k);
        for (int res : ans)
            cout << res << " ";
        cout << endl;
    }
    return 0;
}