dfs深度优先搜索—邻接矩阵 + 邻接矩阵-递归版 + 邻接表

邻接矩阵

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

const int N = 1e2 + 10;
//n个顶点，m条边
int n, m;
//邻接矩阵
int g[N][N];
//标记数组
bool vis[N];//vis[2]=1/0  代表2号点   1-被标记  0-没被标记

//dfs-深度优先搜索
void dfs(int s/*搜索的起点*/) {
	stack<int> stk;
	//1.起点入栈，入栈即标记（防止重复搜索）
	stk.push(s);  vis[s] = 1;
	while (!stk.empty()) {
		//2.搜索栈顶元素并弹栈
		int v = stk.top();  stk.pop();
		cout << v << " ";
		//3.找到v的邻接点，沿着邻接点进行深度搜索
		for (int i = 1; i <= n; i++) {//7后入栈先出栈
      //for (int i = n; i >= 1; i--)//2后入栈先出栈
			if (!vis[i] && g[v][i] == 1) {//i没有走过且i是v的邻接点
				//入栈+标记
				stk.push(i);  vis[i] = 1;
			}
		}
	}
}
int main() {
	cin >> n >> m;
	for (int i = 1; i <= m; i++) {
		int u, v; cin >> u >> v;
		g[u][v] = g[v][u] = 1;
	}
	int s; cin >> s;
	dfs(s);//从起点s开始深搜
	return 0;
}
/*
输入：
7 6
1 2
2 3
3 4
1 5
5 6
1 7
1*/

 邻接矩阵-递归版

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

const int N = 1e2 + 10;
//n个顶点，m条边
int n, m;
//邻接矩阵
int g[N][N];
//标记数组
bool vis[N];//vis[2]=1/0  代表2号点   1-被标记  0-没被标记

//dfs-深度优先搜索
void dfs(int p/*搜索的起点*/) {

	//搜索+标记
	cout << p << " ";   vis[p] = 1;
	//找到当前搜索点p所有邻接点，沿着邻接点继续深搜
	for (int i = 1; i <= n; i++)
		if (!vis[i] && g[p][i] == 1)
			dfs(i);
}
//递归流程:
//      1 2 3 4 5 6 7 
//vis   1 1 1 1 1 1 1
//output: 1 2 3 4 5 6 7
//1. dfs(1)  cout<<1   vis[1]   dfs(2)  dfs(5)  dfs(7) X
//2. dfs(7)  cout<<7   vis[7]   X
//2. dfs(5)  cout<<5   vis[5]   dfs(6)  X
//3. dfs(6)  cout<<6   vis[6]   X
//2. dfs(2)  cout<<2   vis[2]   dfs(3)  X
//3. dfs(3)  cout<<3   vis[3]   dfs(4)  X
//4. dfs(4)  cout<<4   vis[4]   X
//!for循环结束之后才可以继续往下走
int main() {

	cin >> n >> m;

	for (int i = 1; i <= m; i++) {
		int u, v; cin >> u >> v;
		g[u][v] = g[v][u] = 1;
	}

	int s; cin >> s;
	dfs(s);//从起点s开始深搜
	return 0;
}

邻接表

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

const int N = 1e4 + 10;
vector<int> g[N];//邻接表存图
bool vis[N];//标记数组-防止重复搜索
int n, m, s;//n-点数  m-边数  s-搜索起点

//正在搜索顶点p
void dfs(int p/*正在搜索的点*/, int depth/*搜索深度*/) {
	//搜索当前点并标记
	cout << depth << " " << p << endl;   vis[p] = 1;
	//沿着当前点的邻接点继续深搜
	for (auto u : g[p]) {//g[p]里面存的每一个元素都是p的邻接点
		if (!vis[u]) {//没有被搜过
			dfs(u, depth + 1);//沿着邻接点u继续深搜
		}
	}
}

int main() {

	cin >> n >> m;
	for (int i = 1; i <= m; i++) {
		int u, v;  cin >> u >> v;
		g[u].push_back(v);  g[v].push_back(u);
	}
	cin >> s;
	dfs(s, 1);
	return 0;
}