图（邻接表）的遍历——DFS（深度优先搜索）和BFS（广度优先搜索）和连通图

深度优先搜索（DFS）是一个不断探查和回溯的过程。在探查的每一步，算法都有一个当前顶点。————意味着要用递归咯。

最初的当前顶点就是指定的起始点。
每一步探查过程中，首先对当前顶点v进行访问，并立即设置该顶点的访问标志为true，表示该顶点已经被访问过。
接着在v的所有邻接顶点中找出尚未访问过的一个，将其视为下一步探查的当前顶点，直到所有顶点都被访问过。



核心代码：
void DFS(T x)//
         {
                   bool *remvisite;
                   remvisite = newbool[numVertexs];
                   for(inti=0;i<numVertexs;++i)
                            remvisite[i] =false;
                   DFS(x,remvisite);
                   delete []remvisite;
         }
         void DFS(T x,bool remvisite[])
         {
                   int v = GetVerticespos(x);
                   remvisite[v] = true; 
                   cout<<myv[v].data<<"-->";
                   int next =GetFirstNeighbor(myv[v].data);
                   while(next != -1)
                   {
                            if(remvisite[next]== false)
                                     DFS(myv[next].data,remvisite);
                            next =GetNextNeighbor(myv[v].data,myv[next].data);
                   }
         }广度优先搜索（BFS）是一个逐层遍历的过程。



代码：
         void BFS(T x)
         {
                   bool *remvisite = newbool[numVertexs];
                   for(inti=0;i<numVertexs;++i)
                            remvisite[i] =false;
                   BFS(x,remvisite);
                   delete []remvisite;
         }
         void BFS(T x,bool remvisite[])
         {
                   queue<int> qu;
                   int v = GetVerticespos(x);
                   qu.push(v);
                   while(!qu.empty())
                   {
                            int i = qu.front();
                            cout<<myv[i].data<<"-->";
                            remvisite[i] = true;
                            qu.pop();
                            int v1 =GetFirstNeighbor(myv[i].data);
                            while(v1 != -1)
                            {
                                     if(remvisite[v1]== false)
                                     {
                                        qu.push(v1);
                                        remvisite[v1] = true;
                                     }
                                     v1 =GetNextNeighbor(myv[i].data,myv[v1].data); 
                            }
                   }
         }
连通分量：

当无向图为非连通图时，从图中某一顶点出发，利用深度优先算法或广度优先算法无法遍历图中所有顶点，而只能访问到该顶点所在的最大连通子图的所有顶点，这些顶点构成了一个连通分量。若在无向图的所有连通分量。
在实际算法中需要对图中顶点逐一检测，若已被访问过，则该顶点一定是落在图中以求得的某一连通分量上；若尚未被访问，则从该顶点出发遍历图，则可求得图的另一个连通分量。



代码：
         void Connected_Graph()//连通图
         {
                   int i=0;
                   bool *remvisite = newbool[numVertexs];
                   for(i =0;i<numVertexs;++i)
                            remvisite[i] =false;
                   for(i =0;i<numVertexs;++i)
                   {
                            if(!remvisite[i])
                            {
                                     DFS(myv[i].data,remvisite);
                                     cout<<endl;
                            }
                   }
         }

广度优先搜索（BFS）是一个逐层遍历的过程。

void DFS(T x)//
{
bool *remvisite;
remvisite = new bool[numVertexs];
for(int i=0;i<numVertexs;++i)
remvisite[i] = false;
DFS(x,remvisite);
delete []remvisite;
}

void DFS(T x,bool remvisite[])
{
int v = GetVerticespos(x);
remvisite[v] = true;
cout<<myv[v].data<<"-->";
int next = GetFirstNeighbor(myv[v].data);
while(next != -1)
{
if(remvisite[next] == false)
DFS(myv[next].data,remvisite);
next = GetNextNeighbor(myv[v].data,myv[next].data);
}
}

广度优先搜索（BFS）是一个逐层遍历的过程。