图（邻接表）的遍历——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）是一个逐层遍历的过程。