深搜广搜算法

深搜 DFS  --递归

从图中的某个顶点v出发，访问此顶点，然后从v的未被访问的邻接点出发深度优先遍历图，直到图中所有和v有相通的顶点都被访问到。（此时说的图为连通图）

对于非连通图，只需要对它的连通分量进行深度优先遍历，即在先前一个顶点进行一次深度优先遍历搜索后，若图中尚有顶点未被访问，则另选图中一个未曾被访问的顶点作为开始，重复上述过程，直至图中所有顶点都被访问到为止。

//邻接矩阵方式
typedef int Boolean;  //true false
Boolean visited[MAX]; //访问标志的数组

//邻接矩阵的深度优先递归算法
void DFS(MGraph G,int i)
{
    int j;
    visited[i] = True;
    cout<<G.vexs[i]<<endl;
    for(j = 0;j < G.numVertexes; j++)
    {
        if(G.arc[i][j] == 1 && !visited[j])
            DFS(G, j);    //递归调用邻接顶点
    }
     
}

//邻接矩阵的深度遍历
void DFSTraverse(MGraph G)
{
    int i;
    for(i = 0 ;i < G.numVertexes; i++)
        visited[i] = False;  //顶点初始状态设置为未访问过
    for(i = 0;i < G.numVertexes ;i++)
        if(!visited[i])
            DFS(G,i);
}



//邻接表
//邻接表的深度优先递归算法
void DFS(GraphAdjList GL, int i){
    EdgeNode *p;
    visited[i] = true;
    cout<<GL->adjList[i].data<<endl;
    p = GL->adjList[i].firstedge;
    while(p)
    {
        if(!visited[p->adjvex])
            DFS(GL,p->adjvex);
        p = p->next;
    }
}

//邻接表的深度遍历操作
void DFSTraverse(GraphAdjList GL)
{
    int i;
    for(i = 0;i < GL->numVertexes;i++)
    {
        visited[i] = FALSE;
    for(i = 0;i < GL->numVertexes;i++)
    {
        if(!visited[i])
            DFS(GL,i);
    }
    }
}

完整的代码：

//邻接矩阵实现

#include <iostream>
#include <cstdio>
using namespace std;
int vex[101],sum,n,vexarray[101][101];
sum = 0;

int def(int cur)
{
    int i;
    cout<<cur<<" ";
    sum++; //每访问一个节点sum就加一
    if(sum == n) return; //所有顶点已经全部访问直接退出
    for(int i = 1;i <= n;i++)
    {
        if(vexarray[cur][i] == i && vex[i] == 0)
            {
                vex[i] = 1;
                dfs(i);

            }
    }
    return;
}

int main()
{
    int a,b,m,n,i.j;
    
    //初始化二维矩阵
    cout<<"input vex's num："<<endl;
    cin>>n;
    cout<<"input edges' num:"<<endl;
    cin>>m;
    for(int i = 1;i <= n;i++)
        for(int j = 1;j <= n;j++)
        {
            if(i == j) vexarray[i][j] = 0;
            else vexarray[i][j] = 0x3f;
        }    

    //读入顶点之间的边
    for(int i = 1;i <= m;i++)
    {
        cout<<"input edges' vex"<<endl;
        cin>>a>>b;
        vexarray[a][b] = 1;
        vexarray[b][a] = 1;  //无向图
    }

    //从顶点1出发遍历
    vex[1] = 1; //标记 1 号顶点已经被访问
    def(1);  //从1号顶点开始遍历
    

    system("pause");
    return 0;
}

广度优先搜索 BFS  --  队列

如果说深度优先遍历类似树的前序遍历，那么图的广度优先遍历就类似与树的层序遍历。类似于下面的图

 变形原则为顶点A放在最上边的一层，让与它有边的顶点B、F为第二层，再让与B,F有边的顶点为第三层，依次放置好所有的顶点。

//邻接矩阵的广度遍历算法
void BFSTraverse(MGraph G)
{
    int i,j;
    Queue Q;
    for(i = 0;i<G.numVertexes;i++)
    {
        visited[i] = False;
    }
    InitQueue(&Q);  //初始化一辅助用的队列
    for(i = 0;i<G.numVertexes;i++)  //对每一个顶点做循环
    {
        if(!visited[i])       //若顶点未访问过就处理
        {
            visited[i] = true; //设置当前顶点访问过
            cout<<G.vexs[i]<<endl; //打印当前顶点
            EnQueue(&Q,i);  //将此顶点入队列
            while(!QueueEmpty(Q))  //当前队列不空
            {
                DeQueue(&Q,&i);  //将队中元素出队列，赋值给i
                for(j=0;j<G.numVertexes;j++)
                {
                    if(G.arc[i][j] == 1 && !visited[j])
                    {
                        visited[j]=true;
                        cout<<G.vexs[j]<<endl;
                        EnQueue(&Q,j);
                    }
                }
            }
        }
    }
}