C++图的广度优先遍历算法

最新推荐文章于 2024-07-11 16:30:46 发布

赵延超

最新推荐文章于 2024-07-11 16:30:46 发布

阅读量2.2k

点赞数 1

分类专栏： # C++ ++++++++Algorithm++++++

本文链接：https://blog.csdn.net/SoftpaseFar/article/details/102061756

版权

++++++++Algorithm++++++ 同时被 2 个专栏收录

82 篇文章 0 订阅

订阅专栏

C++

81 篇文章 4 订阅

订阅专栏

图的结构

在这里插入图片描述

算法实现

#include <iostream>

using namespace std;
#define MaxSize 15
//定义顶点和边类型
typedef int VertexType;
typedef int EdgeType;
//定义顶点数和边数
#define vNums 7
#define eNums 7
//顶点是否被访问
bool visited[vNums];


//邻接矩阵定义
struct MGraph {
    VertexType vex[vNums];
    EdgeType edge[vNums][vNums];
    int vexNum, edgeNum;

    MGraph(const VertexType *vs, const EdgeType (*es)[vNums]) : vexNum(vNums), edgeNum(eNums) {
        for (int i = 0; i < vNums; i++) {
            vex[i] = vs[i];
        }
        for (int j = 0; j < vNums; j++) {
            for (int k = 0; k < vNums; k++) {
                edge[j][k] = es[j][k];
            }
        }
    }
};

//定义队列
struct SqQueue {
    int data[MaxSize];
    int front, rear;

};
SqQueue Q;


//队列相关操作
//初始化
void InitQueue(SqQueue &Q) {
    Q.rear = Q.front = 0;
}

//判队空
bool isEmpty(SqQueue Q) {
    if (Q.front == Q.rear) return true;
    else return false;
}

//入队
bool EnQueue(SqQueue &Q, int x) {
    if ((Q.rear + 1) % MaxSize == Q.front) return false;
    Q.data[Q.rear] = x;
    Q.rear = (Q.rear + 1) % MaxSize;
    return true;
}

//出队
bool DeQueue(SqQueue &Q, int &x) {
    if (Q.rear == Q.front) return false;
    x = Q.data[Q.front];
    Q.front = (Q.front + 1) % MaxSize;
    return true;
}


//寻找和v相连的第一个未访问节点
int FirstNeighbor(MGraph G, int u) {
    for (int i = 0; i < vNums; i++) {
        if (G.edge[u][i] == 1 && !visited[i]) {
            return i;
        }
    }
    return -1;
}


//寻找和v相连除w的下一个未访问相连节点
int NextNeighbor(MGraph G, int u, int w) {
    if (w == vNums - 1) {
        return -1;
    }
    for (int i = w + 1; i < vNums; i++) {
        if (G.edge[u][i] == 1 && !visited[i]) {
            return i;
        }
    }
    return -1;
}

//广度优先遍历核心算法
void BFS(MGraph G) {
    while (!isEmpty(Q)) {
        int u;
        DeQueue(Q, u);
        if (!visited[u]) {
            cout << u << " ";
            visited[u] = true;

        }
        for (int w = FirstNeighbor(G, u); w >= 0; w = NextNeighbor(G, u, w)) {
            if (!visited[w]) {
                cout << w << " ";
                visited[w] = true;
                EnQueue(Q, w);
            }
        }
    }

}

//广度优先遍历整体布局
void BFSTravel(MGraph G) {
    int v;
    for (v = 0; v < G.vexNum; ++v) {
        visited[v] = false;
    }
    InitQueue(Q);
    EnQueue(Q, G.vex[v]);

    for (v = 0; v < G.vexNum; ++v) {
        if (!visited[v]) {
            BFS(G);
        }
    }
}


int main() {

    //构造图（邻接矩阵）
    VertexType vex[vNums] = {0, 1, 2, 3, 4, 5, 6};
    EdgeType edge[vNums][vNums] = {
            {0, 1, 1, 0, 0, 1, 1},
            {1, 0, 0, 0, 0, 0, 0},
            {1, 0, 0, 0, 0, 0, 0},
            {0, 0, 0, 0, 1, 1, 0},
            {0, 0, 0, 1, 0, 1, 1},
            {1, 0, 0, 1, 1, 0, 0},
            {1, 0, 0, 0, 1, 0, 0}
    };
    //初始化图
    MGraph G(vex, edge);
    //广度优先遍历输出
    BFSTravel(G);
    
    return 0;
}