邻接矩阵表示图的深度优先搜索和广度优先搜索

 图的深度优先搜索（DFS）：

可以被形象的描述为“打破沙锅问到底”，具体一点就是访问一个顶点之后，我继而访问它的下一个邻接的顶点，如此往复，直到当前顶点一被访问或者它不存在邻接的顶点。同样，算法导论采用了“聪明的做法”，用三种颜色来标记三种状态。但这三种状态不同于广度优先搜索：WHITE 未访问顶点GRAY 一条深度搜索路径上的顶点，即被发现时BLACK 此顶点的邻接顶点被全部访问完之后——结束访问次顶点。

DFS(G,s)
    for each vertex v in V(G)
        status[v] = WHITE
        /******其他初始化******/
    for each vertex v in V(G)
        if(status[v]==WHITE)
            DFS-VISIT(v)
 
DFS-VISIT(v)
    status[v] = GRAY
    for each vertex t in Adj(v)
        if status[t] = WHITE
            DFS-VISIT(t)
            /******其他操作******/
    status[v] = BLACK

图的广度优先搜索（BFS）：

可以被形象的描述为“浅尝辄止”，具体一点就是每个顶点只访问它的邻接节点（如果它的邻接节点没有被访问）并且记录这个邻接节点，当访问完它的邻接节点之后就结束这个顶点的访问。广度优先用到了“先进先出”队列，通过这个队列来存储第一次发现的节点，以便下一次的处理；而对于再次发现的节点，我们不予理会——不放入队列，因为再次发现的节点：无非是已经处理完的了；或者是存储在队列中尚未处理的。

BFS(G,s)
    for each vertex v in V[G]
        status[v] = WHITE
        /******其他初始化******/
    status[s] = GRAY    //s是原点
    queue q
    入队(q,s);
    while q非空
        t = 出队(q);
        for each vertex v in Adj[t] //与t邻接的点
            if status[v] = WHITE    //只对未访问的操作
                status[v] = GRAY    //标记为第一次访问
                /******其他操作******/
                入队(q,v)
        status[t] = BLACK   //此点已经处理完了

代码：

/***********************
用邻接矩阵表示的图的深度优先搜索和广度优先搜索
Author：herongwei
Time:2017/2/26 15:00
language：C++
http://blog.csdn.net/u013050857
[input]
5
6
abcde
0 1 1
0 2 1
0 3 1
2 3 1
2 4 1
1 4 1

***********************/
#pragma comment(linker,"/STACK:102400000,102400000")
#include <bits/stdc++.h>
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
typedef long long LL;
const int  MAX_GRAPH =102;
const int  MAX_QUEUE =30;
const LL MOD = 999999997;
int dir4[4][2]= {{1,0},{0,1},{-1,0},{0,-1}};
int dir8[8][2]= {{1,0},{1,1},{0,1},{-1,1},{-1,0},{-1,-1},{0,-1},{1,-1}};
inline LL read()
{
    int  c=0,f=1;
    char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1; ch=getchar(); }
    while(ch>='0'&&ch<='9'){ c=c*10+ch-'0'; ch=getchar();}
    return c*f;
}
typedef struct
{
    char vet[MAX_GRAPH];           /* 顶点 */
    int edge[MAX_GRAPH][MAX_GRAPH];/* 邻接矩阵 */
    int v_num;                         /* 当前的顶点数 */
    int e_num;                         /* 当前的边数 */
} graph;

bool vis[MAX_GRAPH];   /*0表示未被访问，1表示被访问  */

void Init()           /*初始化*/
{
    for(int i=0; i<MAX_QUEUE; ++i)
    {
        vis[i]=false;
    }
}

void Create(graph *G) /* 图的邻接矩阵表示法 */
{
    printf("输入顶点数:\n");
    scanf("%d",&G->v_num);
    printf("输入边数:\n");
    scanf("%d",&G->e_num);

    getchar();

    printf("请输入端点(char型)：\n");
    for(int i=0; i<G->v_num; ++i) /* 建立表头 */
        scanf("%c",&G->vet[i]);

    for(int i=0; i<G->v_num; ++i)/* 初始化邻接矩阵 */
        for(int j=0; j<G->v_num; ++j)
            G->edge[i][j]=0;
    printf("请输入边：\n");
    for(int k = 0 ; k < G->e_num ; ++k)
    {
        int va,vb,w;
        scanf("%d%d%d",&va,&vb,&w); /* 输入(vi,vj)上的权w */
        G->edge[va][vb] = w;
        G->edge[vb][va] = w;
    }
}

void BFS_Q(graph *G,int k)/* 广度优先遍历 +队列*/
{
    for(int i=0; i<MAX_GRAPH; ++i) vis[i]=false;
    printf("访问顶点: %c\n",G->vet[k]);
    vis[k]=true; /*标记顶点i被访问*/
    queue<int>q;
    q.push(k);     /*此顶点如队列*/
    while(!q.empty()) /*当前队列不空*/
    {
        int p=q.front();
        q.pop();

        for(int j=1; j<=G->v_num; ++j) /*遍历所有顶点*/
        {
            if(G->edge[p][j]==1&&!vis[j]) /*判断其他顶点若与当前顶点存在边且未被访问过*/
            {
                vis[j]=true;             /*将找到的此点标记已经访问*/
                printf("访问顶点: %c\n",G->vet[j]); /*打印*/
                q.push(j);              /*将找到的此点入队*/
            }
        }
    }
}

void BFS(graph *G,int k)/* 广度优先遍历+模拟队列 */
{
    int queue[MAX_GRAPH];
    int front=-1,rear=-1,c=0;

    for(int i=0; i<MAX_GRAPH; ++i) vis[i]=false;

    printf("访问顶点%c\n",G->vet[k]);
    vis[k]=true;

    rear=(rear+1)%MAX_QUEUE;
    queue[rear]=k;
    front = rear;
    ++c;

    while(c>0)
    {
        int p=queue[front];
        front = (front+1)%MAX_QUEUE;
        --c;

        for(int j=0; j<G->v_num; ++j)
        {
            if(G->edge[p][j]!=0 &&vis[j] ==false)
            {
                printf("访问顶点%c\n",G->vet[j]);
                vis[j]=true;
                rear = (rear + 1) % MAX_QUEUE; /* 入队 */
                queue[rear] = j;
                ++c;
            }
        }
    }
    printf("遍历结束\n");
}
void DFS(graph *G,int k)/* 深度优先遍历 */
{
    printf("访问顶点：%c\n",G->vet[k]);
    vis[k]=true;         /*标记顶点i被访问*/
    for(int j=0; j<G->v_num; ++j)
    {
        if(G->edge[k][j]!=0 &&vis[j]==false)
            DFS(G,j);
    }
    /*printf("遍历结束\n");*/
}

int main()
{
    freopen("in.txt","r",stdin);
    Init();
    graph G;
    Create(&G);
    BFS_Q(&G,0);
    //DFS(&G,0);
    return 0;
}

参考博客： http://www.cnblogs.com/daoluanxiaozi/archive/2012/05/18/2507212.html