数据结构之DFS与BFS

 

深度搜索（DFS） and  广度搜索（BFS）

代码如下:

#include "stdafx.h"
#include<iostream>
#include<string>
using namespace std;
#define MAX 30
#define MVNum 100
#define ERROR 1 
typedef char VerTexType;
typedef int Status;
typedef int QElemType;
#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef struct ArcNode                 //边结点
{
    int adjvex;                        //改变所指向的顶点的位置
    struct ArcNode *nextarc;           //指向下一条边的指针
    string info;                       //和边相关的信息
}ArcNode;
typedef struct VNode                   //顶点信息
{
    VerTexType data;
    struct ArcNode *link;              //指向第一条依附该顶点的边的指针
}VNode;                                //AdList表示邻接表类型
typedef struct                         //邻接表
{
    VNode xlist[MAX];
    int vexnum, arcnum;                //图的当前顶点数和边数
}ALGraph;

typedef struct Node                    //构造队列
{
    int data;
    struct Node *next;
}Node,*QNode;
typedef struct
{
    QNode front;                       //队头指针
    QNode rear;                        //对尾指针
}Queue;
Status InitQueue(Queue &Q)             //初始化队列
{
    Q.front = Q.rear=new Node;         //生成新节点作为头节点，对头和队尾指针指向此节点
    if (!Q.front)                      
        exit(OVERFLOW);
    Q.front->next = NULL;               //头结点的指针域置空
    return OK;
}

Status EnQueue(Queue &Q, int e)        //入队操作
{
    QNode p = new Node;
    if (!p)                            //存储分配失败
        exit(OVERFLOW);
    p->data = e;
    p->next = NULL;
    Q.rear->next = p;                  
    Q.rear = p;                        //把当前的p设置尾对尾节点，rear指向p
    return OK;
}

Status DeQueue(Queue &Q, int &e)       //出队操作
{
    QNode p;
    p = Q.front->next;                 //将欲删除的对头结点暂存给p
    Q.front->next = p->next;           //将原队头节点后继p->next赋值给头结点后继       
    if (Q.rear == p)                   //如果队头是队尾，则删除后将rear指向头节点
        Q.rear = Q.front;
    e = p->data;                       //将欲删除的对接点赋值给e
    delete p;
    return OK;
}

Status QueueEmpty(Queue Q)             //队列判空
{
    if (Q.rear == Q.front)
        return 1;
    else
        return 0;
}

int LocateVex(ALGraph &G, char &v)     //定位函数   
{
    int i;
    for (i = 0; i < G.vexnum; i++)
    {
        if (G.xlist[i].data == v)
            return i;
    }
    if (i >= G.vexnum)
        return ERROR;
    else
        return 0;
}
void CreateUDG(ALGraph &G)             //创建无向图
{
    ArcNode *p1, *p2;
    int i, j, k;
    char v1, v2;
    cout << "请输入图的顶点数、边数：" << endl;
    cin >> G.vexnum >> G.arcnum;       //输入总顶点数，总边数
    cout << "请输入顶点的值:(顶点之间用空格分离)" << endl;
    for (i = 0; i < G.vexnum; i++)
    {
        cin >> G.xlist[i].data;        //输入顶点值
        G.xlist[i].link = NULL;        //初始化表头结点的指针域为NULL
    }
    cout << "请输入弧尾和弧头：" << endl;
    for (k = 0; k < G.arcnum; k++)
    {
        cin >> v1 >> v2;               //输入各边，构造邻接表
        i = LocateVex(G, v1);
        j = LocateVex(G, v2);
        p1 = new ArcNode;              //生成一个新结点*p1
        p1->adjvex = j;                //邻接点序号为j
        p1->nextarc = G.xlist[i].link;
        G.xlist[i].link = p1;
        p2 = new ArcNode;
        p2->adjvex = i;
        p2->nextarc = G.xlist[j].link;
        G.xlist[j].link = p2;
    }
    cout << "图构建成功！" << endl<<endl;
}

static bool visited[MAX];              //访问过visited，为1否则为0

void DFS(ALGraph G, int m)             //深度优先搜索
{
    visited[m] = true;                 //标记已经遍历过
    cout << G.xlist[m].data<<" ";
    ArcNode *p = G.xlist[m].link;
    while (p)
    {
        if (!visited[p->adjvex])
            DFS(G, p->adjvex);
        p = p->nextarc;
    }
}

void BFS(ALGraph G,int n)              //广度优先搜索
{
    ArcNode *p;
    Queue Q;
    for (int i = 0; i < G.vexnum; i++)
        visited[i] = false;
    InitQueue(Q);
    for (int i = 0; i < G.vexnum; i++)
    {
        if (!visited[i])
        {
            visited[i] = true;
            cout << G.xlist[i].data<<" ";
            EnQueue(Q, i);
            while (!QueueEmpty(Q))
            {
                DeQueue(Q, i);
                p = G.xlist[i].link;   //找到当前顶点编表链表头指针
                while (p)
                {
                    if (!visited[p->adjvex])//若此顶点未访问
                    {
                        visited[p->adjvex] = true;
                        cout << G.xlist[p->adjvex].data<<" ";
                        EnQueue(Q, p->adjvex);//将此顶点入队列
                    }
                    p = p->nextarc;    //指针指向下一个邻接点
                }
            }
        }
    }
}

void coutGraphD(ALGraph G)             //深搜输出函数
{
    for (int i = 0; i < G.vexnum; i++)
        visited[i] = false;
    cout << "深度优先搜索输出的顶点的结果为:" << endl;
    for (int i = 0; i < G.vexnum; i++)
        if (!visited[i])
            DFS(G, i);
    cout << endl;
}
void coutGraphW(ALGraph G)             //广搜输出函数
{
    for (int i = 0; i < G.vexnum; i++)
        visited[i] = false;
    cout << "广度优先搜索输出的顶点的结果为:" << endl;
    for (int i = 0; i < G.vexnum; i++)
        if (!visited[i])
            BFS(G, i);
    cout << endl;

}
int main()
{
    ALGraph MG;
    CreateUDG(MG);
    coutGraphD(MG);
    coutGraphW(MG);
    return 0;
}

 

运行结果：