图的两种存储（邻接矩阵和邻接表）和两种遍历（DFS和BFS)

最新推荐文章于 2021-12-15 09:54:56 发布
最新推荐文章于 2021-12-15 09:54:56 发布
阅读量961 收藏 5
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/hyt-/p/7931845.html
版权

图的表示有很多，形式不固定，我暂时先记录我已经懂了的，能写的两种即大多数人应该都知道的邻接矩阵和邻接表。

 

邻接矩阵：

这里的邻接矩阵和离散数学说的有一点不同，至少有向图的邻接矩阵不同（离散书上的有向图的邻接矩阵求法到是有点像求任意两点的最短路径的Floyd算法）

以上都是（我现有知识认为的）废话；

重点 ： 

G : 表示图；

Nv:表示图的点数；

Ne:表示图的边数；

邻接矩阵 即是一个 Nv * Nv 的矩阵，矩阵是用来储存  权值的（如果是带权图且有边的话），如果是无权图的的话，如果两顶点有边就用 1表示 ；如果两个点之间无边则用  -1或无穷表示

这里的无穷表示的是 权值所用类型的最大边界。

 

图的遍历:

图有两种遍历，深度优先搜索（DFS）和广度优先搜索（BFS）；

DFS:类似树的先序遍历，就是每次都先打印当前要遍历的点，然后递归遍历它的邻接点，（就像二叉树中我们每次都先输出根，再遍历左右子树一样，不过图中变成了邻接点而已）

 

BFS：类似树的层次遍历，就是先将要遍历的起点先入队，之后就重复3件事，就是 先出队 ，再打印出队点，最后没入队的，与出队点有边的 入队，如此重复 直到遍历完；

 

 

代码如下：

头文件：


//Graph.h
#include <stdbool.h>
#define MaxVertexNum 100
#define INFINITY 65535
#define ERROR -1
typedef int Vertex;
typedef int WeightType;
typedef char DataType;

//图
typedef struct ENode *PtrToENode;
struct ENode{
    Vertex V1, V2;
    WeightType weight;

};
typedef PtrToENode Edge;

typedef struct GNode *PtrToGNode;
struct GNode{
    int Nv;
    int Ne;
    WeightType G[MaxVertexNum][MaxVertexNum];
    DataType Data[MaxVertexNum];

};
typedef PtrToGNode MGraph;

MGraph CreateGraph(int);
void InsertEdge(MGraph, Edge);
MGraph BuildGraph();

void DFS(MGraph, Vertex);
void BFS(MGraph ,Vertex);



//队列
struct QNode{
    int *Data;
    int front, rear;
    int MaxSize;
};

typedef struct QNode * Queue;

Queue CreateQ(int MaxSize);

bool IsFull(Queue Q);
bool AddQ(Queue Q, int data);

bool IsEmpty(Queue Q);
Vertex DeleteQ(Queue Q);

bool DestoryQ(Queue Q);

实现：

#include <stdio.h>
#include <stdlib.h>
#include "Graph.h"

//队列的实现
Queue CreateQ(int MaxSize)
{
    Queue Q = (Queue)malloc(sizeof (struct QNode));
    Q->Data = (int*)malloc(sizeof (int)*MaxSize);
    Q->front = Q->rear = 0;
    Q->MaxSize = MaxSize;

    return Q;
}

bool IsEmpty(Queue Q)
{
    return (Q->rear == Q->front);
}
bool IsFull(Queue Q)
{//告非
    return (Q->rear + 1) % Q->MaxSize == Q->front;
}
bool AddQ(Queue Q, Vertex data)
{
    if (IsFull(Q)){
        printf("满\n");
        exit(0);

    }
    else{
        Q->rear = (Q->rear + 1) % Q->MaxSize;
        Q->Data[Q->rear] = data;
        return true;
    }
}



Vertex DeleteQ(Queue Q)
{

    if (IsEmpty(Q)){
        printf("空\n");
        exit(0);
    }
        
    else{
        Q->front = (Q->front + 1) % Q->MaxSize;
        return Q->Data[Q->front];
    }

}

bool DestoryQ(Queue Q)
{
    free(Q->Data);
    free(Q);
    return true;
}



bool Visited[MaxVertexNum];   //遍历时用来标记是否已经访问过
MGraph CreateGraph(int VertexNum)   //先建一个无边图
{
    Vertex V, W;
    MGraph Graph;

    Graph = (MGraph)malloc(sizeof(struct GNode));
    Graph->Nv = VertexNum;
    Graph->Ne = 0;

    for (V = 0; V < Graph->Nv; ++V){
        for (W = 0; W < Graph->Nv; ++W)
            Graph->G[V][W] = INFINITY;
        
    }
        
        for (int i = 0; i < Graph->Nv; ++i)
            Visited[i] = false;
        return Graph;
}



void InsertEdge(MGraph Graph, Edge E)   //向图中加入一条边
{
    
    Graph->G[E->V1][E->V2] = E->weight;
    Graph->G[E->V2][E->V1] = E->weight;
}

MGraph BuildGraph()             //建立完整的图
{
    MGraph Graph;
    Edge E;
    Vertex V;
    int Nv, i;

    printf("输入顶点数: \n");
    scanf_s("%d", &Nv);
    Graph = CreateGraph(Nv);

    printf("输入边数\n");
    scanf_s("%d", &(Graph->Ne));
    if (Graph->Ne != 0){
        E = (Edge)malloc(sizeof(struct ENode));

        printf("输入%d条边\n",Graph->Ne);
        for (i = 0; i < Graph->Ne; ++i){
            scanf_s("%d %d %d", &E->V1, &E->V2, &E->weight);
            InsertEdge(Graph, E);
        }
    }
    printf("输入顶点值\n");
    for (V = 0; V < Graph->Nv; V++)
        scanf_s("%c", &Graph->Data[V]);
    return Graph;
}


void DFS(MGraph G, Vertex V)          //深度优先搜索
{
    printf("正在访问的是%d\n", V);
    Visited[V] = true;

    Vertex W;
    for (W = 0; W < G->Nv; ++W){
        if (!Visited[W] && G->G[V][W] < INFINITY)
            DFS(G, W);
    }
}




void BFS(MGraph Graph,Vertex S)    //广度优先搜索
{
    Queue Q = CreateQ(MaxVertexNum);
    Vertex V, W;

    printf("正在访问的点是:%d\n", S);
    Visited[S] = true;
    AddQ(Q, S);

    while (!IsEmpty(Q)){
        V = DeleteQ(Q);
        for (W = 0; W < Graph->Nv; ++W){
            if (!Visited[W] && Graph->G[V][W] < INFINITY){
                printf("正在访问的点是:%d\n", W);
                Visited[W] = true;
                AddQ(Q, W);
            }
        }
        
    }
    
}

int main()
{
    printf("创建邻接矩阵表示图\n");
    MGraph Graph = BuildGraph();
    

    printf("打印矩阵\n");
    for (int i = 0; i < Graph->Nv; ++i){
        for (int j = 0; j < Graph->Nv; ++j)
            printf("%d\t", Graph->G[i][j]);
        putchar('\n');
    }
    printf("\n\n");
    //printf("DFS遍历\n");
    //DFS(Graph, 0);

    printf("BFS遍历\n");
    BFS(Graph, 0);
    system("pause");
    return 0;
}

 

 

 

邻接表：是用结构数组加链表形式表示，先创建一个大小为Nv的结构数组表示Nv个点，以每一个结构为头结点，再在它们后面接它们各自的邻接点；

 

代码如下：

头文件

//Graph.h

#include <stdbool.h>
#define MaxVertexNum 100
#define INFINITY 65535
#define ERROR -1
typedef int Vertex;
typedef int WeightType;
typedef char DataType;

//图
typedef struct ENode *PtrToENode;
struct ENode{
    Vertex V1, V2;
    WeightType weight;

};
typedef PtrToENode Edge;

typedef struct GNode *PtrToGNode;
struct GNode{
    int Nv;
    int Ne;
    WeightType G[MaxVertexNum][MaxVertexNum];
    DataType Data[MaxVertexNum];

};
typedef PtrToGNode MGraph;

MGraph CreateGraph(int);
void InsertEdge(MGraph, Edge);
MGraph BuildGraph();

void DFS(MGraph, Vertex);
void BFS(MGraph ,Vertex);



//队列
struct QNode{
    int *Data;
    int front, rear;
    int MaxSize;
};

typedef struct QNode * Queue;

Queue CreateQ(int MaxSize);

bool IsFull(Queue Q);
bool AddQ(Queue Q, int data);

bool IsEmpty(Queue Q);
Vertex DeleteQ(Queue Q);

bool DestoryQ(Queue Q);

 

实现

#include <stdio.h>
#include <stdlib.h>
#include "Graph.h"

//队列实现

Queue CreateQ()
{
    Queue Q;
    Q = (Queue)malloc(sizeof (struct QNode));
    Q->front = (item)malloc(sizeof (struct INode));
    Q->front->next = NULL;
    Q->rear = Q->front;

    return Q;
}

bool IsEmptyQ(Queue Q)
{
    return Q->front->next == NULL;
}

bool AddQ(Queue Q, Vertex X)
{
    item tmp = (item)malloc(sizeof(struct INode));
    tmp->V = X;
    tmp->next = NULL;

    Q->rear->next = tmp;
    Q->rear = tmp;
    return true;
}

Vertex DeleteQ(Queue Q)
{
    if (IsEmptyQ(Q)){
        printf("队空\n");
        exit(0);
    }
    Vertex X;
    item tmp = Q->front->next;
    if (tmp == Q->rear)
        Q->rear = Q->front;
    Q->front->next = tmp->next;
    X = tmp->V;

    return X;
}

bool Destory(Queue Q)
{
    while (!IsEmptyQ(Q))
        DeleteQ(Q);
    free(Q->front);
    free(Q);

    return true;
}





//邻接表实现
bool Visited[MaxVertexNum];
LGraph CreateGraph(int VertexNum)
{
    Vertex V;
    LGraph Graph;

    Graph = (LGraph)malloc(sizeof(struct GNode));
    Graph->Nv = VertexNum;
    Graph->Ne = 0;
    for (V = 0; V < Graph->Nv; ++V)
        Graph->G[V].FirstEdge = NULL;
    
    for (int i = 0; i < MaxVertexNum; ++i)
        Visited[i] = false;
    return Graph;
}

void InsertEdge(LGraph Graph, Edge E)
{
    PtrToAdjVNode NewNode;

    NewNode = (PtrToAdjVNode)malloc(sizeof(struct AdjVNode));

    NewNode->AdjV = E->V2;
    NewNode->Weight = E->weight;
    NewNode->Next = Graph->G[E->V1].FirstEdge;
    Graph->G[E->V1].FirstEdge = NewNode;

    NewNode = (PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
    
    NewNode->AdjV = E->V1;
    NewNode->Weight = E->weight;
    NewNode->Next = Graph->G[E->V2].FirstEdge;
    Graph->G[E->V2].FirstEdge = NewNode;


}

LGraph BuildGraph()
{
    LGraph Graph;
    Edge E;
    Vertex V;
    int Nv, i;

    printf("创建图（邻接表）:\n");
    printf("输入顶点数\n");
    scanf_s("%d", &Nv);
    Graph = CreateGraph(Nv);

    printf("输入边数\n");
    scanf_s("%d", &(Graph->Ne));
    if (Graph->Ne != 0){
        E = (Edge)malloc(sizeof(struct ENode));
        printf("输入%d边\n", Graph->Ne);
        for (i = 0; i < Graph->Ne; ++i){
            scanf_s("%d %d %d", &E->V1, &E->V2, &E->weight);
            InsertEdge(Graph, E);
        }
    }
    printf("输入顶点值\n");
    for (V = 0; V < Graph->Nv; V++)
        scanf_s("%D", &(Graph->G[V].Data));
    return Graph;

}




void DFS(LGraph Graph, Vertex S)
{
    PtrToAdjVNode W;
    printf("正在访问的顶点是%d\n", S);
    Visited[S] = true;
    for (W = Graph->G[S].FirstEdge; W;W=W->Next)
        if (!Visited[W->AdjV])
            DFS(Graph, W->AdjV);
    
}

void BFS(LGraph Graph, Vertex S)
{
    Queue Q = CreateQ();
    Vertex V;
    PtrToAdjVNode W;
    printf("正在访问的点是:%d\n", S);
    Visited[S] = true;
    AddQ(Q, S);

    while (!IsEmptyQ(Q)){
        V = DeleteQ(Q);
        for (W = Graph->G[V].FirstEdge; W; W = W->Next)
            if (!Visited[W->AdjV]){
                printf("正在访问的点是:%d\n", W->AdjV);
                Visited[W->AdjV] = true;
                AddQ(Q, W->AdjV);
            }
    }
}

void PrintGraph(LGraph Graph)
{
    PtrToAdjVNode tmp;
    for (int i = 0; i < Graph->Nv; ++i){
        tmp = Graph->G[i].FirstEdge;
        while (tmp){
            printf("%d\t", tmp->AdjV);
            tmp = tmp->Next;
        }
            
        putchar('\n');
    }
}

int main()
{
    LGraph Graph;
    Graph = BuildGraph();

    printf("打印邻接表\n");
    PrintGraph(Graph);

    printf("DFS遍历:\n");
    //DFS(Graph, 1);

    printf("\n\n");
    printf("BFS遍历:\n");
    BFS(Graph,1);

    
    system("pause");

    return 0;
}

 

注意这里的代码实现默认都是无向图；若是有向图，只要改动 InsertEdge(Graph,E) 函数即可；即按方向只添加一条边就行了。

 

补充：当图不连通，即有一个或多个连通分量时可用以下函数实现;

按顺序检查没有被访问的，然后调用DFS()或BFS()

void ListComponents(LGraph Graph)
{
    Vertex V;
    for (V = 0; V < Graph->Nv; ++V){
        if (!Visited[V])
            DFS(Graph, V);  
            //BFS(Graph, V);
    }
}

 

转载于:https://www.cnblogs.com/hyt-/p/7931845.html

图的两种结构（邻接矩阵、邻接表）DFS、BFS算法
編程如戀 『暧昧』
11-12 2559
#include #include #include #include #include using namespace std; #define MAXSIZE 20 bool flag = false; class MGraph { public: MGraph(int vertex, int side); ~MGraph(){}; void DFSTraverse(i
分别用邻接矩阵和邻接表实现图的深度优先遍历和广度优先遍历_图的BFS、DFS
weixin_39527768的博客
11-23 4280
BFS、DFS分别为广度优先搜索和深度优先搜索的英文首字母缩写。先考虑树的BFS、DFS。树的BFS即层序遍历。层序遍历先访问根结点，再逐个访问根结点的子结点，再逐个访问上述子结点的子结点，以此类推，直至访问过所有结点。树的DFS有三种（先序遍历、中序遍历、后序遍历），这里只说先序遍历。先序遍历先访问根结点，再逐个先序遍历根结点的所有子树。（由递归的定义可知，容易用递归算法实现（函数的递归用到了调...
数据结构之 图的操作
weixin_30517001的博客
10-01 919
一、图的存储结构 1.1 邻接矩阵 图的邻接矩阵存储方式是用两个数组来表示图。一个一维数组存储图中顶点信息，一个二维数组（邻接矩阵）存储图中的边或弧的信息。 设图G有n个顶点，则邻接矩阵是一个n*n的方阵，定义为： 看一个实例，下图左就是一个无向图。 从上面可以看...
邻接矩阵存储图的两种遍历方式
lovecontry
08-05 406
下面是用邻接矩阵存储一个无向图的深度优先遍历和广度优先遍历代码，深度优先遍历就是树的先根遍历的一种推广，而广度优先也是和树的层次遍历相似的，用邻接矩阵存储，进行这两种遍历的实现，是比较容易的。 因为用了自己写的循环队列的模版，所以代码看起来有点冗长. #include&lt;iostream&gt; #include&lt;string&gt; using namespace std; //...
数据结构-图的存储(邻接矩阵,邻接表)及遍历(dfs,bfs)
weixin_43590593的博客
01-30 1917
今天刷leetcode也是碰见了跟图有关的问题，那么今天就来介绍一下图的存储和遍历 图存储的两种方式：邻接矩阵和邻接表 邻接矩阵，顾名思义，本身是一个矩阵也就是二维数组，用一个二维数组的索引作为点与点之间的关系，用二维数组实际存储的数据储存是否相通或边权。 用邻接矩阵存储时，遍历方式也分两种 邻接矩阵的深度优先搜索 /* * start：现在所在的点 * visit：判断当前点是否来过 * edges：储存边的数组 * points：储存点的数组 * */ p
邻接矩阵实现图的存储，DFS，BFS遍历
weixin_30585437的博客
09-02 736
图的遍历一般由两者方式：深度优先搜索(DFS)，广度优先搜索(BFS)，深度优先就是先访问完最深层次的数据元素，而BFS其实就是层次遍历，每一层每一层的遍历。 1.深度优先搜索(DFS) 我一贯习惯有举例的方法来讲，示例如下：红色代表的是正搜索，蓝色代表回溯，最下面为标志数组。 注意：DFS的搜索出来的序列不是每个人都是一样的，根据具体的程...
邻接矩阵，邻接表实现图的创建，遍历(DFS,BFS)
05-12
本文将深入探讨如何使用邻接矩阵和邻接表这两种方法来创建图，并实现深度优先搜索（DFS）和广度优先搜索（BFS）算法。 首先，我们来看邻接矩阵。邻接矩阵是一个二维数组，其中的元素代表图中节点之间的连接状态。...
数据结构图的邻接矩阵,邻接表存储表示，图的深度优先搜索遍历，广度优先搜索遍历
10-07
本主题将深入探讨图的两种常见存储方式——邻接矩阵和邻接表，以及如何进行深度优先搜索（DFS）和广度优先搜索（BFS）遍历。 **邻接矩阵**是一种直观且简单的图存储方法。对于一个有n个顶点的图，邻接矩阵是一个n×...
邻接表或者邻接矩阵为存储结构实现连通无向图的深度优先和广度优先遍历
12-06
总之，这个程序设计任务要求我们理解并实现无向图的两种主要遍历方法，以及如何利用邻接表或邻接矩阵存储图。通过这些方法，我们可以有效地探索图的结构，找出路径，解决许多实际问题，如搜索、最短路径计算等。
C++实现图的邻接矩阵存储和广度、深度优先遍历实例分析
09-03
在C++编程中，处理图的数据结构通常涉及两种主要的存储方法：邻接矩阵和邻接表。本实例重点讨论了邻接矩阵的实现，并展示了如何进行广度优先遍历(BFS)和深度优先遍历(DFS)。邻接矩阵是一种二维数组，其中的每个元素...
基于邻接表存储的图的dfs与bfs遍历
11-26
基于邻接表存储的图的dfs与bfs遍历，对学习数据结构很有帮助
定义采用邻接矩阵存储的图结构封装DFS、BFS算法
12-13
定义采用邻接矩阵存储的图结构封装DFS、BFS算法
邻接表存储的图的DFS，BFS遍历
04-06
邻接表存储的图的DFS，BFS遍历。文档描述： http://blog.csdn.net/qq_16912257/article/details/45848935
实现带权图的邻接表存储+图的遍历算法
11-14
带权图的临接表存储程序代码+详细注释，实现图的深度优先搜索和广度优先搜索
邻接表存储有向图的两种遍历方式
lovecontry
08-05 605
用邻接表存储的有向图，因为在建立邻接表的时候，建的链表都是头插入的，所以遍历出来的顺序和原先设想的是相反的，就是从下往上的。为了减少一些无谓的操作，所以在程序中加入了一个全局变量 Vex_Num 来记录输出顶点的数目，一旦全部顶点都已经输出，就跳出函数，不再继续进行下去，节省一点时间。 下面是代码 #include&lt;iostream&gt; #include&lt;string&gt; ...
图的储存（矩阵+邻接表）+两种遍历方式(基于邻接表)
qq_45856311的博客
12-09 323
#include<stdio.h> #include<iostream> #include<queue> #include<stack> using namespace std; struct Graph { char vertex[20];//顶点集合 int vertexNum;//顶点数 int matrix[20][20];//矩阵 }; void Init(Graph* g) { for (int i = 0;i < 20;i++)
第六章：图。（邻接矩阵实现图的存储及dfs、bfs）
weixin_30371875的博客
10-29 218
//bfs后续补充； #include <stdio.h> #include <string.h> #define N 100 /* 创建邻接矩阵：以无向图为例: 需要数据类型： 1.顶点数据类型，顶点数组； 2.二维数组,表示是否有边； 3.图的总结点数目和边数； 实现：深度优先遍...
图的DFS和BFS遍历算法（采用邻接矩阵的存储结构创建无向图G）
qq_54467680的博客
12-15 587
#include<iostream> using namespace std; #define MaxInt 0 #define MVNum 8 //顶点的个数 typedef char VerTexType; //顶点的数据类型 typedef int ArcType; //边的权值的数据类型 typedef struct { VerTexType vexs[MVNum]; //顶点表 ArcType arcs[MVNum][MVNum]; //...
邻接表实现图的储存，遍历
weixin_30414635的博客
09-02 167
邻接表是图的一种链式存储结构。对图的每个顶点建立一个单链表（n个顶点建立n个单链表），第i个单链表中的结点包含顶点Vi的所有邻接顶点。又称链接表。 1.在有向图的邻接表中不易找到指向该顶点的弧。 2.在有向图的邻接表中，对每个顶点，链接的是以该顶点为弧尾的邻接点。 #include <stdio.h> #include <malloc.h...
图数据结构：邻接矩阵与邻接表存储及其遍历算法实现
在本资源中，我们将探讨图的两种主要存储结构——邻接矩阵和邻接表，以及图的基本运算算法和遍历算法。 一、图的存储结构 1. 邻接矩阵：邻接矩阵是一种表示图中顶点之间相邻关系的二维数组。如果两个顶点之间存在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值