C++实现图的遍历算法(DFS,BFS)的示例代码

目录

• 图的定义
• 图的相关术语
• 图的创建(邻接矩阵)---结构体
• 图的创建(邻接矩阵)---邻接矩阵的创建
• 图的创建(邻接表)---结构体
• 图的创建(邻接表)---邻接表的创建
• 对邻接矩阵进行深度优先遍历
• 对邻接矩阵进行广度优先遍历
• 对邻接表进行深度优先遍历 
• 对邻接表进行广度优先遍历 
• 整体代码
• 结果展示

图的定义

图由顶点集V(G)和边集E(G)组成，记为G=(V,E)。其中E(G)是边的有限集合，边是顶点的无序对（无向图）或有序对（有向图）。对于有向图来说，E(G)是有向边（也称弧(Arc)）的有限集合，弧是顶点的有序对，记为<v,w>，v、w是顶点，v为弧尾（箭头根部），w为弧头（箭头处）。对于无向图来说，E(G)是边的有限集合，边是顶点的无序对，记为(v, w)或者(w, v)，并且(v, w)=(w,v)。

图的相关术语

①顶点(Vertex)：图中的数据元素。

②顶点v的度：与v相关联的边的数目；

③顶点v的出度：以v为起点有向边数；

④顶点v的入度：以v为终点有向边数。

⑤边：顶点之间的逻辑关系用边来表示，边集可以是空的。

⑥无向边(Edge)：若顶点V1到V2之间的边没有方向，则称这条边为无向边。

⑦无向图(Undirected graphs)：图中任意两个顶点之间的边都是无向边。（A,D）=（D,A）

⑧有向边：若从顶点V1到V2的边有方向，则称这条边为有向边，也称弧(Arc)。用<V1,V2>表示，V1为狐尾(Tail)，V2为弧头(Head)。（V1，V2）≠（V2，V1）。

⑨有向图(Directed graphs)：图中任意两个顶点之间的边都是有向边。

注意：无向边用“（）”，而有向边用“< >”表示。

⑩简单图：图中不存在顶点到其自身的边，且同一条边不重复出现。

⑪无向完全图：无向图中，任意两个顶点之间都存在边。

⑫有向完全图：有向图中，任意两个顶点之间都存在方向互为相反的两条弧。

⑬稀疏图：有很少条边。

⑭稠密图：有很多条边。

⑮权（Weight）：与图的边或弧相关的数。

⑯网（Network）：带权的图。

⑰连通图：图中任意两个顶点都是连通的。

⑱极大连通子图：该子图是G连通子图，将G的任何不在该子图的顶点加入，子图将不再连通。

⑲极小连通子图：该子图是G的连通子图，在该子图中删除任何一条边，子图都将不再连通。

图的创建(邻接矩阵)---结构体

typedef struct
{
    //用来存放顶点
    int vexs[MAX];
    //二维数组：用来存放两点之间的关系
    int arcs[MAX][MAX];
    //图的顶点数和边数
    int vexsum, arcsnum;
}AMGraph,*StrAMGraph;

图的创建(邻接矩阵)---邻接矩阵的创建

int locate(AMGraph&G, int n)
{
    for (int i = 0; i < G.vexsum; i++)
    {
        if (G.vexs[i] == n)
        {
            return i;
        }
    }
}
 
//创建邻接矩阵
void Creat(AMGraph&G)
{
    int v1 = 0, v2 = 0, w = 0;
    cin >> G.vexsum >> G.arcsnum;
    for (int i = 0; i < G.vexsum; i++)
    {
        cin >> G.vexs[i];
    }
    for (int i = 0; i < G.vexsum; i++)
    {
        for (int j = 0; j < G.vexsum; j++)
        {
            G.arcs[i][j] = 0;
        }
    }
    for (int k = 0; k < G.arcsnum; k++)
    {
        cin >> v1 >> v2 >> w;
        int i = locate(G, v1);
        int j = locate(G, v2);
        G.arcs[i][j] = w;
    }
}

图的创建(邻接表)---结构体

typedef struct ArcNode
{
    int Adjust;
    struct ArcNode *next;
}AcrNode,*StrAcrNode;
 
 
typedef struct
{
    int data;
    StrAcrNode next;
}HeadNode, *StrHeadNode;
 
 
typedef struct 
{
    HeadNode arr[MAX];
    int acsrnum, vexsnum;
}ALGraph, *StrALGraph;

图的创建(邻接表)---邻接表的创建

int locate1(ALGraph&G, int n)
{
    for (int i = 0; i < G.vexsnum; i++)
    {
        if (G.arr[i].data == n)
        {
            return i;
        }
    }
}
 
void CreatALGraph(ALGraph&G)
{
    int v1 = 0, v2 = 0, w = 0;
    cin >> G.vexsnum >> G.acsrnum;
    for (int i = 0; i < G.vexsnum; i++)
    {
        cin >> G.arr[i].data;
        G.arr[i].next = NULL;
    }
    for (int k = 0; k < G.acsrnum; k++)
    {
        cin >> v1 >> v2;
        int i = locate1(G, v1);
        int j = locate1(G, v2);
        StrAcrNode p1;
        p1 = new AcrNode;
        p1->next = G.arr[i].next;
    }
}

对邻接矩阵进行深度优先遍历

//对邻接矩阵进行深度优先遍历
void DFS(AMGraph&G, int n)
{
    cout << G.vexs[n] << " ";
    visit[n] = 1;
    for (int i = 0; i < G.vexsum; i++)
    {
        if (G.arcs[n][i] != 1 && visit[i] != 1)
        {
            DFS(G, G.arcs[n][i]);
        }
    }
}

对邻接矩阵进行广度优先遍历

queue<int> qu;
//对邻接矩阵进行广度优先遍历
void BFS(AMGraph&G, int n)
{
    cout << G.vexs[n] << " ";
    qu.push(n);
    while (!qu.empty())
    {
        int m = qu.front();
        qu.pop();
        for (int i = 0; i < G.vexsum; i++)
        {
            if (visit[i] != 1 && G.arcs[m][i] != 1)
            {
                cout << G.vexs[i] << " ";
                visit[i] = 1;
                qu.push(i);
            }
        }
    }
}

对邻接表进行深度优先遍历 

void DFS1(ALGraph&G, int n)
{
    cout << G.arr[n].data << " ";
    visit3[n] = 1;
    StrAcrNode p1;
    p1 = G.arr[n].next;
    while (p1)
    {
        int w = p1->Adjust;
        if (visit3[w] != 1)
        {
            DFS1(G, w);
        }
        p1 = p1->next;
    }
}
 
queue<int> qu1;

对邻接表进行广度优先遍历 

queue<int> qu1;
void BFS(ALGraph&G, int n)
{
    cout << G.arr[n].data << " ";
    visit4[n] = 1;
    qu1.push(n);
    StrAcrNode p1;
    p1 = G.arr[n].next;
    while (!qu1.empty())
    {
        qu1.pop();
        int w = p1->Adjust;
        while (p1)
        {
            if (visit4[w] != 1)
            {
                qu1.push(w);
                visit4[w] = 1;
            }
            p1 = p1->next;
        }
    }
}

整体代码

#include<iostream>
#include<queue>
using namespace std;
const int MAxInt = 10;
int visit[MAxInt];
 
typedef struct
{
    int vexs[MAxInt];
    int arcs[MAxInt][MAxInt];
    int arcnum, vexsnum;
}AMGraph;
 
int locate(AMGraph&G, int n)
{
    for (int i = 0; i < G.vexsnum; i++)
    {
        if (G.vexs[i] == n)
        {
            return i;
        }
    }
}
 
void Creat(AMGraph&G)
{
    int v1 = 0, v2 = 0, w = 0;
    cin >> G.vexsnum >> G.arcnum;
    for (int i = 0; i < G.vexsnum; i++)
    {
        cin >> G.vexs[i];
    }
    for (int i = 0; i < G.vexsnum; i++)
    {
        for (int j = 0; j < G.vexsnum; j++)
        {
            G.arcs[i][j] = MAxInt;
        }
    }
    for (int k = 0; k < G.arcnum; k++)
    {
        cin >> v1 >> v2 >> w;
        int i = locate(G, v1);
        int j = locate(G, v2);
        G.arcs[i][j] = w;
        G.arcs[j][i] = w;
    }
}
 
 
 
queue<int> qu;
void BFS(AMGraph G, int v)
{
    cout << G.vexs[v];
    qu.push(v);
    visit[v] = 1;
    while (!qu.empty())
    {
        int w = qu.front();
        qu.pop();
        for (int i = 0; i < G.vexsnum; i++)
        {
            if (visit[i] != 1 && G.arcs[w][i] != MAxInt)
            {
                cout << G.vexs[i] << " ";
                visit[i] = 1;
                qu.push(i);
            }
        }
    }
}
 
int main()
{
    AMGraph G;
    Creat(G);
    cout << "对图进行广度优先遍历的结果为" << endl;
    BFS(G, 1);
    return 0;
}

注意 ：这里的代码是创建一个邻接矩阵来对图进行广度优先遍历，对图进行深度优先遍历以及临界表实现对图进行广度优先遍历，对图进行深度优先遍历大家都可以通过上面的代码块进行自由组合实现，这里就不进行一一实现。

结果展示

以上就是C++实现图的遍历算法(DFS,BFS)的示例代码的详细内容，更多关于C++ DFS BFS的资料请关注自由互联其它相关文章！