深度优先搜索算法（有向图和无向图）

1.深度优先搜索的思想：给定图G=(V,E)。深度优先搜索的思想为：初始时，所有顶点均为未被访问过，任选一个顶点v作为源点。该方法先访问源点v，并将其标记为已访问过；然后从v点出发，选择v的下一个邻接点（子节点）w，如果w已被访问过，则选择v的另外一个邻接点；如果w未被访问过，则标记w为已访问过，并以w为新的出发点，继续进行深度优先搜索；如果w的及其子节点均已搜索完毕，则返回到v，再选择它的另外一个未曾访问过的邻接点继续搜索，直到图中的所有点和源点所有路径相同的顶点均已访问过为止；若此时图G中任然存在未被访问过的顶点，则另一个尚未访问过的顶点作为新的源点重复上述过程，直到图中所有的顶点均已被访问过为止。

一：对于有向图：

方法一：
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
using namespace std;
const int maxx=105;
const int inf=0x3f3f3f3f;
int e[maxx][maxx];//记录a和b之间是连通的 
int vis[maxx];//记录访问情况 
int ans[maxx];//记录访问的顺序 
int n,m;//顶点数和边数 
int index;
void dfs(int k){
	vis[k]=1;
	ans[index++]=k;
	for(int i=1;i<=n;i++){
		if(e[k][i]==1){
			if(vis[i]==0){
				dfs(i);
			}
		}
	}
}
void dfs_1(int n){
	index=1;
	for(int j=1;j<=n;j++){
		if(vis[j]==0){
			dfs(j);
		}
	}
	memset(vis,0,sizeof(vis));
	cout<<"以 "<<1<<"源点的访问顺序: ";
	for(int i=1;i<=n;i++){
		cout<<ans[i]<<" ";
	}
}
int main(){
	while(scanf("%d %d",&n,&m)!=EOF){
		memset(e,0,sizeof(e));
		memset(vis,0,sizeof(vis));
		memset(ans,0,sizeof(ans));
		for(int i=1;i<=m;i++){
			int a,b;
			scanf("%d %d",&a,&b);
			e[a][b]=1;
		}
		dfs_1(n);
	}
	return 0;
}
/*
7 8
1 2
2 5
1 3
3 4
4 5
4 2
1 4
6 7
*/

方法二：邻接表
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<vector>
using namespace std;
const int maxx=105;
const int inf=0x3f3f3f3f;
vector<int>G[maxx];//记录a和b之间是连通的 
int vis[maxx];//记录访问情况 
int ans[maxx];//记录访问的顺序 
int n,m;//顶点数和边数 
int index;
void dfs(int k){
	vis[k]=1;
	ans[index++]=k;
	for(int i=0;i<G[k].size();i++){
		int v=G[k][i];
		if(vis[v]==0){
			dfs(v);
		}
	}
}
void dfs_1(int n){
	index=1;
	for(int j=1;j<=n;j++){
		if(vis[j]==0){
			dfs(j);
		}
	}
	memset(vis,0,sizeof(vis));
	cout<<"以 "<<1<<"源点的访问顺序: ";
	for(int i=1;i<=n;i++){
		cout<<ans[i]<<" ";
	}
}
int main(){
	while(scanf("%d %d",&n,&m)!=EOF){
		memset(vis,0,sizeof(vis));
		memset(ans,0,sizeof(ans));
		for(int i=1;i<=n;i++){
			G[i].clear();
		}
		for(int i=1;i<=m;i++){
			int a,b;
			scanf("%d %d",&a,&b);
			G[a].push_back(b);
		}
		dfs_1(n);
	}
	return 0;
}
/*
7 8
1 2
2 5
1 3
3 4
4 5
4 2
1 4
6 7
*/

方法三：链式前向星写法
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<vector>
using namespace std;
const int maxx=105;
const int inf=0x3f3f3f3f;
int head[maxx];
struct node{
	int u,v;
	int next;
}e[maxx];
int vis[maxx];//记录访问情况 
int ans[maxx];//记录访问的顺序 
int n,m;//顶点数和边数 
int index;
int cnt;
void add(int u,int v){
	e[++cnt].u=u;
	e[cnt].v=v;
	e[cnt].next=head[u];
	head[u]=cnt;
}
void dfs(int k){
	vis[k]=1;
	ans[index++]=k;
	for(int i=head[k];i!=-1;i=e[i].next){
		int v=e[i].v;
		if(vis[v]==0){
			dfs(v);
		}
	}
}
void dfs_1(int n){
	index=1;
	for(int j=1;j<=n;j++){
		if(vis[j]==0){
			dfs(j);
		}
	}
	memset(vis,0,sizeof(vis));
	cout<<"以 "<<1<<"源点的访问顺序: ";
	for(int i=1;i<=n;i++){
		cout<<ans[i]<<" ";
	}
}
int main(){
	while(scanf("%d %d",&n,&m)!=EOF){
		memset(vis,0,sizeof(vis));
		memset(ans,0,sizeof(ans));
		memset(head,-1,sizeof(head));
		cnt=0;
		for(int i=1;i<=m;i++){
			int a,b;
			scanf("%d %d",&a,&b);
			add(a,b);
		}
		dfs_1(n);
	}
	return 0;
}
/*
7 8
1 2
2 5
1 3
3 4
4 5
4 2
1 4
6 7
*/

二：对于无向图：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<vector>
using namespace std;
const int maxx=105;
const int inf=0x3f3f3f3f;
int e[maxx][maxx];//记录a和b之间是连通的 
int vis[maxx];//记录访问情况 
int ans[maxx];//记录访问的顺序 
int n,m;//顶点数和边数 
int index;
void dfs(int k){
	vis[k]=1;
	ans[index++]=k;
	for(int i=1;i<=n;i++){
		if(e[k][i]==1){
			if(vis[i]==0){
				dfs(i);
			}
		}
	}
}
void dfs_1(int n){
	index=1;
	for(int j=1;j<=n;j++){
		if(vis[j]==0){
			dfs(j);
		}
	}
	memset(vis,0,sizeof(vis));
	cout<<"以 "<<1<<"源点的访问顺序: ";
	for(int i=1;i<=n;i++){
		cout<<ans[i]<<" ";
	}
}
int main(){
	while(scanf("%d %d",&n,&m)!=EOF){
		memset(e,0,sizeof(e));
		memset(vis,0,sizeof(vis));
		memset(ans,0,sizeof(ans));
		for(int i=1;i<=m;i++){
			int a,b;
			scanf("%d %d",&a,&b);
			e[a][b]=e[b][a]=1;
		}
		dfs_1(n);
	}
	return 0;
}
/*
7 8
1 2
2 5
1 3
3 4
4 5
4 2
1 4
6 7
*/

方法二：邻接表
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<vector>
using namespace std;
const int maxx=105;
const int inf=0x3f3f3f3f;
vector<int>G[maxx];//记录a和b之间是连通的 
int vis[maxx];//记录访问情况 
int ans[maxx];//记录访问的顺序 
int n,m;//顶点数和边数 
int index;
void dfs(int k){
	vis[k]=1;
	ans[index++]=k;
	for(int i=0;i<G[k].size();i++){
		int v=G[k][i];
		if(vis[v]==0){
			dfs(v);
		}
	}
}
void dfs_1(int n){
	index=1;
	for(int j=1;j<=n;j++){
		if(vis[j]==0){
			dfs(j);
		}
	}
	memset(vis,0,sizeof(vis));
	cout<<"以 "<<1<<"源点的访问顺序: ";
	for(int i=1;i<=n;i++){
		cout<<ans[i]<<" ";
	}
}
int main(){
	while(scanf("%d %d",&n,&m)!=EOF){
		memset(vis,0,sizeof(vis));
		memset(ans,0,sizeof(ans));
		for(int i=1;i<=n;i++){
			G[i].clear();
		}
		for(int i=1;i<=m;i++){
			int a,b;
			scanf("%d %d",&a,&b);
			G[a].push_back(b);
			G[b].push_back(a);
		}
		dfs_1(n);
	}
	return 0;
}

方法三：链式前向星
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<vector>
using namespace std;
const int maxx=105;
const int inf=0x3f3f3f3f;
int head[maxx];
struct node{
	int u,v;
	int next;
}e[maxx];
int vis[maxx];//记录访问情况 
int ans[maxx];//记录访问的顺序 
int n,m;//顶点数和边数 
int index;
int cnt;
void add(int u,int v){
	e[++cnt].u=u;
	e[cnt].v=v;
	e[cnt].next=head[u];
	head[u]=cnt;
}
void dfs(int k){
	vis[k]=1;
	ans[index++]=k;
	for(int i=head[k];i!=-1;i=e[i].next){
		int v=e[i].v;
		if(vis[v]==0){
			dfs(v);
		}
	}
}
void dfs_1(int n){
	index=1;
	for(int j=1;j<=n;j++){
		if(vis[j]==0){
			dfs(j);
		}
	}
	memset(vis,0,sizeof(vis));
	cout<<"以 "<<1<<"源点的访问顺序: ";
	for(int i=1;i<=n;i++){
		cout<<ans[i]<<" ";
	}
}
int main(){
	while(scanf("%d %d",&n,&m)!=EOF){
		memset(vis,0,sizeof(vis));
		memset(ans,0,sizeof(ans));
		memset(head,-1,sizeof(head));
		cnt=0;
		for(int i=1;i<=m;i++){
			int a,b;
			scanf("%d %d",&a,&b);
			add(a,b);
			add(b,a);
		}
		dfs_1(n);
	}
	return 0;
}

/*
7 8
1 2
2 5
1 3
3 4
4 5
4 2
1 4
6 7
*/