深度优先遍历的思想：
沿着图的某一个分支遍历直到末端，然后回溯，再沿着另一条进行同样的遍历，直到所有的顶点都被访问过为止：首先以一个未被访问过的顶点作为起始顶点，沿着当前顶点的边走未访问过的顶点；当没有未访问过的顶点时，则回到上一个顶点，继续试探访问别的顶点，直到所有的顶点都被访问过。
求出上图各个顶点到各个顶点的路径
#include<iostream>
using namespace std;
int count=0;
int points,edgs;
int p1,p2;
int edg[10][10];
int infinity=99999999;
int flag[10];
void Dfs(int cur)
{
cout<<cur<<" ";
count++;
if (count==points)
{
return ;
}
for (int i=1;i<=points;i++)
{
if (edg[cur][i]==1&&flag[i]==0)
{
flag[i]=1;
Dfs(i);
}
}
return ;
}
int main()
{
cin>>points>>edgs;
for (int i=1;i<=points;i++)
{
for (int j=1;j<=points;j++)
{
if (i==j)
{
edg[i][j]=0;
}
else
{
edg[i][j]=infinity;
}
}
}
for (i=1;i<=edgs;i++)
{
cin>>p1>>p2;
edg[p1][p2]=1;
edg[p2][p1]=1;
}
for (int k=1;k<=points;k++)
{
for (i=1;i<=points;i++)
{
flag[i]=0;
}
flag[k]=1;
Dfs(k);
count=0;
cout<<endl;
}
}输出结果：
找出图中1号城市到5号城市的最短距离
<span style="font-size:18px;">#include<iostream>
using namespace std;
int count=0;
int points,edgs;
int destination;
int p1,p2;
int edg[10][10];
int infinity=99999999;
int flag[10];
int w;
int min=infinity;
void Dfs(int cur,int dis)
{
if (dis>min)
{
return;
}
if (cur==destination)//判断当前位置是否为目标城市
{
if (dis<min)
{
min=dis;
}
return ;
}
//每次递归邻接边按照相邻的顺序
//1-2-3-4-5 1-2-5 1-5按照此顺序反复递归
for (int i=1;i<=points;i++) //从1号城市到points依次尝试
{
if (edg[cur][i]!=infinity&&flag[i]==0)//满足有路径想通和为走过才执行
{
flag[i]=1;//标记城市i已经在路径中
Dfs(i,dis+edg[cur][i]);//从城市i再出发，继续寻找目标城市
flag[i]=0;//之前一步探索完毕后，取消对城市i的标记
}
}
return ;
}
int main()
{
cin>>destination>>points>>edgs;
for (int i=1;i<=points;i++)
{
for (int j=1;j<=points;j++)
{
if (i==j)
{
edg[i][j]=0;
}
else
{
edg[i][j]=infinity;
}
}
}
for (i=1;i<=edgs;i++)
{
cin>>p1>>p2>>w;
edg[p1][p2]=w;
}
flag[1]=1;
Dfs(1,0);
cout<<min<<endl;
}</span>输出结果：
设有n个点，e条边
邻接矩阵：矩阵包含n^2个元素，在算法中，共n个顶点，对每个顶点都要遍历n次，所以时间复杂度为O(n^2)
邻接表：包含n个头结点和e个表结点，算法中对所有结点都要遍历一次，所以时间复杂度为
O（n+e）
对于广度优先算法的时间复杂度，也是这样
