深度优先算法+广度优先算法

一 深度优先算法

1.无向图

 　

2.有向图

 

第1步：访问A。 
第2步：访问B。 
    在访问了A之后，接下来应该访问的是A的出边的另一个顶点，即顶点B。 
第3步：访问C。 
    在访问了B之后，接下来应该访问的是B的出边的另一个顶点，即顶点C,E,F。在本文实现的图中，顶点ABCDEFG按照顺序存储，因此先访问C。 
第4步：访问E。 
    接下来访问C的出边的另一个顶点，即顶点E。 
第5步：访问D。 
    接下来访问E的出边的另一个顶点，即顶点B,D。顶点B已经被访问过，因此访问顶点D。 
第6步：访问F。 
    接下应该回溯"访问A的出边的另一个顶点F"。 
第7步：访问G。

因此访问顺序是：A -> B -> C -> E -> D -> F -> G

bool visited[MaxVnum];
void DFS(Graph G,int v)
{
    visited[v]= true; //从V开始访问，flag它
    printf("%d",v);    //打印出V
    for(int j=0;j<G.vexnum;j++) 
        if(G.arcs[v][j]==1&&visited[j]== false) //这里可以获得V未访问过的邻接点
            DFS(G,j); //递归调用，如果所有节点都被访问过，就回溯，而不再调用这里的DFS
}

void DFSTraverse(Graph G) {
    for (int v = 0; v < G.vexnum; v++)
        visited[v] = false; //刚开始都没有被访问过

    for (int v = 0; v < G.vexnum; ++v)
        if (visited[v] == false) //从没有访问过的第一个元素来遍历图
            DFS(G, v);
}

二 广度优先算法

#include <queue>
using namespace std;
....
void BFSTraverse(Graph G)
{
    for (int v=0;v<G.vexnum;v++) //先将其所有顶点都设为未访问状态
        visited[v]=false;
    queue<int> Q;
    for(int v=0;v<G.vexnum;v++)    
    {
        if(visited[v]==false)   //若该点没有访问
        {
            Q.push(v);　　　　//将其加入到队列中
            visited[v]=true;
            while (!Q.empty())　　//只要队列不空，遍历就没有结束
            {
                int t =Q.front();　　//取出对头元素
                Q.pop();
                printf(" %d ",t+1);  
                for(int j=0;j<G.vexnum;j++) //将其未访问过的邻接点加进入队列
                    if(G.arcs[t][j]==1&&visited[j]== false)
                    {
                        Q.push(j);
                        visited[j]=true; //在这里要设置true，因为这里该顶点我们已经加入到了队列，为了防止重复加入！
                    }
            }
        }
    }
}

 2.1 无向图

第1步：访问A。 
第2步：依次访问C,D,F。 
    在访问了A之后，接下来访问A的邻接点。前面已经说过，在本文实现中，顶点ABCDEFG按照顺序存储的，C在"D和F"的前面，因此，先访问C。再访问完C之后，再依次访问D,F。 
第3步：依次访问B,G。 
    在第2步访问完C,D,F之后，再依次访问它们的邻接点。首先访问C的邻接点B，再访问F的邻接点G。 
第4步：访问E。 
    在第3步访问完B,G之后，再依次访问它们的邻接点。只有G有邻接点E，因此访问G的邻接点E。

因此访问顺序是：A -> C -> D -> F -> B -> G -> E

2.2 有向图

第1步：访问A。 
第2步：访问B。 
第3步：依次访问C,E,F。 
    在访问了B之后，接下来访问B的出边的另一个顶点，即C,E,F。前面已经说过，在本文实现中，顶点ABCDEFG按照顺序存储的，因此会先访问C，再依次访问E,F。 
第4步：依次访问D,G。 
    在访问完C,E,F之后，再依次访问它们的出边的另一个顶点。还是按照C,E,F的顺序访问，C的已经全部访问过了，那么就只剩下E,F；先访问E的邻接点D，再访问F的邻接点G。

因此访问顺序是：A -> B -> C -> E -> F -> D -> G