图的存储和遍历C++实现

最新推荐文章于 2024-05-24 01:41:01 发布
最新推荐文章于 2024-05-24 01:41:01 发布
阅读量4.4k 收藏 3
点赞数
分类专栏： 数据结构 文章标签： 结构 c++ 图
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a375849201893857/article/details/46549561
版权

最近在做一些OJ题目时，感觉自己图的应用还不够熟练。所以又翻书看别人的博客复习了一下，现把图的常用内容总结如下：

图的常用存储方法有：邻接矩阵和邻接表

遍历方法有：按深度遍历（DFS）,按广度遍历（BFS）

下面的代码都是C++写的，用了一些STL库的容器：

邻接矩阵：

#include <stdio.h>
#include <stdlib.h>
 
typedef structGraph
{
     char vexs[100];             //顶点表
     int   arc[100][100];          //邻接矩阵，可看作边
     int numVertexes, numEdges;      //图中当前的顶点数和边数
}g;
 
//定位
int locates(Graph *g, char ch)
{
     int i = 0;
     for (i = 0; i < g->numVertexes; i++)
     {
         if (g->vexs[i] == ch)
         {
             break ;
         }
     }
     if (i >= g->numVertexes)
     {
         return -1;
     }
     
     return i;
}
 
//建立一个无向网图的邻接矩阵表示
void CreateGraph(Graph *g)
{
     int i, j, k, w;
     printf ( "输入顶点数和边数:\n" );
     scanf ( "%d,%d" , &(g->numVertexes), &(g->numEdges));
 
     for (i = 0; i < g->numVertexes; i++)
     {
         g->vexs[i] = getchar ();
         while (g->vexs[i] == '\n' )
         {
             g->vexs[i] = getchar ();
         }
     }
     
     for (i = 0; i < g->numEdges; i++)
     {
         for (j = 0; j < g->numEdges; j++)
         {
             g->arc[i][j] = INFINITY; //邻接矩阵初始化
         }
     }
     for (k = 0; k < g->numEdges; k++)
     {
         char p, q;
         printf ( "输入边(vi,vj)上的下标i，下标j和权值:\n" );
         
         p = getchar ();
         while (p == '\n' )
         {
             p = getchar ();
         }
         q = getchar ();
         while (q == '\n' )
         {
             q = getchar ();
         }
         scanf ( "%d" , &w);   
         
         int m = -1;
         int n = -1;
         m = locates(g, p);
         n = locates(g, q);
         if (n == -1 || m == -1)
         {
             fprintf (stderr, "there is no this vertex.\n" );
             return ;
         }
         //getchar();
         g->arc[m][n] = w;
         g->arc[n][m] = g->arc[m][n];  //因为是无向图，矩阵对称
     }
}
 
//打印图
void printGraph(Graph g)
{
     int i, j;
     for (i = 0; i < g.numVertexes; i++)
     {
         for (j = 0; j < g.numVertexes; j++)
         {
             printf ( "%d  " , g.arc[i][j]);
         }
         printf ( "\n" );
     }
}
 
int main( int argc, char **argv)
{
     Graph g;
     
     //邻接矩阵创建图
     CreateGraph(&g);
     printGraph(g);
     return 0;
}


基于邻接矩阵的深度优先遍历（DFS）(类似二叉树的前序遍历)（用递归）：
#define MAXVEX  100     //最大顶点数
int visited[MAXVEX];         //访问标志数组
#define TRUE 1
#define FALSE 0
//邻接矩阵的深度优先递归算法
void DFS(Graph g, int i)
{
     int j;
     visited[i] = TRUE;
     printf ( "%c " , g.vexs[i]);                            //打印顶点，也可以其他操作
     for (j = 0; j < g.numVertexes; j++)
     {
         if (g.arc[i][j] == 1 && !visited[j])
         {
             DFS(g, j);                  //对为访问的邻接顶点递归调用
         }
     }
}
 
//邻接矩阵的深度遍历操作
void DFSTraverse(Graph g)
{
     int i;
     for (i = 0; i < g.numVertexes; i++)
     {
         visited[i] = FALSE;         //初始化所有顶点状态都是未访问过状态
     }
     for (i = 0; i < g.numVertexes; i++)
     {
         if (!visited[i])             //对未访问的顶点调用DFS，若是连通图，只会执行一次
         {
             DFS(g,i);
         }
     }
}


基于邻接矩阵的广度优先遍历（BFS）(类似二叉树的层次遍历)（不用递归）：

//邻接矩阵的广度遍历算法
#include<queue>
void BFSTraverse(Graph g)
{
     int i, j;
    q ueue<int> q;
     for (i = 0; i < g.numVertexes; i++)
     {
         visited[i] = FALSE;
     }

     for (i = 0; i < g.numVertexes; i++) //对每个顶点做循环
     {
         if (!visited[i])               //若是未访问过
         {
             visited[i] = TRUE;
             printf ( "%c " , g.vexs[i]); //打印结点，也可以其他操作
             q.push(i);           //将此结点入队列
             while (!q.empty())     //将队中元素出队列，赋值给
             {
                 int m;
                 m=q.front();
q.pop();       
                 for (j = 0; j < g.numVertexes; j++)
                 {
                     //判断其他顶点若与当前顶点存在边且未访问过
                     if (g.arc[m][j] == 1 && !visited[j])
                     {
                         visited[j] = TRUE;
                         printf ( "%c " , g.vexs[j]);
                         q.push(j);
                     }
                 }
             }
         }
     }
}


邻接表结构：

#include <stdio.h>
#include<stdlib.h>
#define MAXVEX 1000         //最大顶点数
 
typedef struct EdgeNode         //边表结点
{
     int adjvex;         //邻接点域，存储该顶点对应的下标
     int weigth;        //用于存储权值，对于非网图可以不需要
     struct EdgeNode *next;      //链域，指向下一个邻接点
}EdgeNode;
 
typedef struct VertexNode       //顶点表结构
{
     char data;        //顶点域，存储顶点信息
     EdgeNode *firstedge;        //边表头指针
}VertexNode, AdjList[MAXVEX];
 
typedef struct
{
     AdjList adjList;
     int numVertexes, numEdges;  //图中当前顶点数和边数
}GraphList;
 
int Locate(GraphList *g, char ch)
{
     int i;
     for (i = 0; i < MAXVEX; i++)
     {
         if (ch == g->adjList[i].data)
         {
             break ;
         }
     }
     if (i >= MAXVEX)
     {
         fprintf (stderr, "there is no vertex.\n" );
         return -1;
     }
     return i;
}
 
//建立图的邻接表结构
void CreateGraph(GraphList *g)
{
     int i, j, k;
     EdgeNode *e;
     EdgeNode *f;
     printf ( "输入顶点数和边数:\n" );
     scanf ( "%d,%d" , &g->numVertexes, &g->numEdges);
      //建立顶点表
     for (i = 0; i < g->numVertexes; i++)
     {
         printf ( "请输入顶点%d:\n" , i);
         g->adjList[i].data = getchar ();          //输入顶点信息
         g->adjList[i].firstedge = NULL;          //将边表置为空表
         while (g->adjList[i].data == '\n' )
         {
             g->adjList[i].data = getchar ();
         }
     }
     //建立边表
     for (k = 0; k < g->numEdges; k++)
     {
         printf ( "输入边(vi,vj)上的顶点序号:\n" );
         char p, q;
         p = getchar ();
         q = getchar ();
         int m, n;
         m = Locate(g, p);
         n = Locate(g, q);
     
         e = (EdgeNode *) malloc ( sizeof (EdgeNode));//向内存申请空间，生成边表结点
         e->adjvex = n; 
         e->next = g->adjList[m].firstedge;//将e指针指向当前顶点指向的结构
         g->adjList[m].firstedge = e;//将当前顶点的指针指向e
        
f = (EdgeNode *) malloc ( sizeof (EdgeNode));
         f->adjvex = m;
         f->next = g->adjList[n].firstedge;
         g->adjList[n].firstedge = f;
     }
}

void printGraph(GraphList *g)
{
     int i = 0; 
     while (g->adjList[i].firstedge != NULL && i < MAXVEX)
     {
         printf ( "顶点:%c  " , g->adjList[i].data);
         EdgeNode *e = NULL;
         e = g->adjList[i].firstedge;
         while (e != NULL)
         {
             printf ( "%d  " , e->adjvex);
             e = e->next;
         }
         i++;
         printf ( "\n" );
     }
}
 
int main( int argc, char **argv)
{
     GraphList g;
     CreateGraph(&g);
     printGraph(&g);
     return 0;
}
基于邻接表存储结构的深度优先遍历
//邻接表的深度递归算法
void DFS(GraphList g,int i)
{
EdgeNode *p;
visit[i] = 1;
printf("%c",g->adjList[i].data);
p = g->adjList[i].firstedge;
while(p)
{
if(!visited[p->adjvex])
{
DFS(g,p->adjvex);
}
p = p->next;
}
}

//邻接表的深度遍历操作
void DFSTraverse(GraphList g)
{

int i;

for(i=0;i<g.numVertexes;i++)

{

visited[i] = 0;

}

for(i=0;i<g.numVertexes;i++)

{

if(!visited[i])

{

DFS(g,i);

}

}

}

对比两个不同的存储结构的深度优先遍历算法，对于n个顶点e条边的图来说，邻接矩阵由于是二维数组，要查找某个顶点的邻接点需要访问矩阵中的所有元素，因为需要O(n2)的时间。而邻接表做存储结构时，找邻接点所需的时间取决于顶点和边的数量，所以是O(n+e)。显然对于点多边少的稀疏图来说，邻接表结构使得算法在时间效率上大大提高。


基于邻接表的广度优先遍历：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
//邻接表的广度遍历算法
#include<queue>
void BFSTraverse(GraphList g)
{
     int i;
     EdgeNode *p;
     queue q;
     for (i = 0; i < g.numVertexes; i++)
     {
         visited[i] = 0;
     }
      for (i = 0; i < g.numVertexes; i++)
     {
         if (!visited[i])
         {
             visited[i] = 1;
             printf ( "%c " , g.adjList[i].data);   //打印顶点，也可以其他操作
             q.push(i);
             while (!q.empty())
             {
                 int m;
m = q.front();
q.pop();
                 p = g.adjList[m].firstedge;     找到当前顶点边表链表头指针
                 while (p)
                 {
                     if (!visited[p->adjvex])
                     {
                         visited[p->adjvex] = 1;
                         printf ( "%c " , g.adjList[p->adjvex].data);
                         q.push(p->adjvex);
                     }
                     p = p->next;
                 }
             }
         }
     }
}

fuliguo
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构-图(c++)
快乐小半半的博客
03-26 7163
图在数据结构中有重要作用
数据结构-图详解（C++图基本概念、图的存储结构、图的遍历、最小生成树Kruskal、 Prim算法、最短路径问题-Dijkstra，Bellman-Ford，Floyd-Warshall算法 ）
dodamce的博客
07-14 1496
图是由顶点集合及顶点间的关系组成的一种数据结构. 表示为 G = (V， E)。V代表的是顶点集合，E代表边集合树也是一种特殊的图，这个图无环. 树关注的时节点存的值，图更关注的是顶点及边的权值。 权值：边中的附带的数据信息.顶点和边：图中结点称为顶点，第i个顶点记作vi。两个顶点vi和vj相关联称作顶点vi和顶点vj之间有一条边，图中的第k条边记作ek，ek = (vi，vj)或.有向图：顶点对是有序的，顶点对称为顶点x到顶点y的一条边(弧)，和.....................
C++实现图的存储和遍历
最新发布
Beau_Will的博客
05-24 375
许多新手友友在初学算法和数据结构时，会被图论支配过。我这里整理了一下图论常见的存储和遍历方式，仅供参考。如有问题，欢迎大佬们批评指正。存储我将提到四种方式：邻接矩阵、vector实现邻接表、数组模拟单链表实现的前向星实现邻接表、结构体数组直接存储边。遍历我将提到三种方式：dfs、bfs、按照边的权重值大小遍历输出。
图的C++实现
01-18
利用C++对图进行封装（图类），包括有向图和无向图，提供常用的对图的操作，如：获取图大小、添加节点、打印邻接矩阵、深度遍历和宽度遍历、最小生成树计算（Prim和Kruskal算法）等，并提供了简单的调用示例。
图的存储结构的实现(C/C++实现)
weixin_33888907的博客
11-26 711
存档： 1 #include &lt;stdio.h&gt; 2 #include &lt;stdlib.h&gt; 3 #define maxv 10 4 #define max 10 5 typedef char elem; 6 typedef int elemtype; 7 #include "queue.h" 8 #include "mgraph.h" ...
图的存储结构与遍历
01-04
（1）画出如图（1）所示无向图的邻接矩阵和邻接表，列出该图的广度优先遍历和深度优先遍历结果（选定A为出发点进行遍历）。 （2）画出如图（2）所示有向图的邻接矩阵和邻接表，列出该图的广度优先遍历和深度优先遍历结果（选定A为出发点进行遍历）。
C++实现图的邻接表存储和广度优先遍历实例分析
09-03
这个实例提供了实现图的邻接表存储和广度优先遍历的基本框架，可以作为理解这两种概念的起点。在实际应用中，可能需要根据具体需求进行修改和优化，例如处理带权重的图、使用优先队列进行最短路径搜索等。总的来说，...
数据结构 图的遍历 C++实现.pdf
05-20
本实验报告主要探讨了图的邻接表存储结构及其在C++中的遍历算法实现，特别是广度优先搜索（BFS）。 一、图的基本概念与邻接表存储结构 图是由顶点（Vertex）和边（Edge）组成的非线性数据结构。顶点代表数据，边...
C++实现图的邻接矩阵存储和广度、深度优先遍历实例分析
09-03
在C++编程中，处理图的数据结构通常涉及两种主要的存储方法：邻接矩阵和邻接表。本实例重点讨论了邻接矩阵的实现，并展示了如何进行广度优先遍历(BFS)和深度优先遍历(DFS)。邻接矩阵是一种二维数组，其中的每个元素...
图的建立与遍历c++实现（邻接矩阵存储）
10-14
这是一个关于图的建立与遍历的问题，用的是c++实现，邻接矩阵作为存储
c++中图的遍历，dfs和bfs的简单实现
disking的博客
06-06 6576
c++中关于图的遍历的算法，bfs和dfs的基本实现
C++实现图的遍历！！！
08-25
1）创建一个图； 2）图的深度优先遍历的递归算法； 3）图的深度优先遍历的迭代算法； 4）图的广度优先遍历算法。
邻接表 实现图的遍历 C++
若风
11-29 3464
#include #include using namespace std; const int MaxSize = 5; struct ArcNode //边表节点 { int adjvex; ArcNode* next; }; template struct VertexNode //定义顶点表节点 { T vertex; ArcNode* firstedge; }
图的遍历-邻接矩阵实现DFS和BFS，c语言实现
Mrs_fanshuishui的博客
08-12 5044
首先是我个渣对两种遍历方法的看法 BFS:寻找最优解,比如最短路径.时间复杂度更低，一圈一圈搜索,深度不大的时候比较适用，但是 DFS:不撞南墙不回头,所以相对于BFS 找到的不一定是最优解,但是其对于空间的消耗较少,因为不需要存储临时节点   对于DFS，其实现方法类似于先序遍历，不断递归的调用DFS函数，依次向下搜寻。   首先是图结构体的实现 struct GNode { ...
数据结构之C++实现图的遍历（无主函数）
manonghouyiming的博客
03-11 847
图的遍历：从图的任意一个顶点出发，按照某一种次序，对图中的所有顶点访问一次并且只能访问一次，遍历经常用两种方法：广度优先遍历和深度优先遍历，在遍历中为了说明当前节点被访问过，则定义一个数组visited作为标识。广度优先遍历：类似于树的层次遍历思想：从任意一个节点vi开始，首先访问vi，并将其标记为已访问过，接着依次访问vi的所有未被访问过的邻接顶点vi1,vi2..vin，直到所有顶点都被标记过...
图的遍历和创建
学习的路上，永不停止
04-19 496
import java.util.Scanner; /* * 图的遍历和创建 */ public class GraphMatrixCS { static Scanner input =new Scanner(System.in); //创建邻接矩阵图 static void CreateGraph(GraphMatrix GM){ int i,j,...
C++ 图的遍历（广度优先遍历）
nightwizard2030的博客
05-07 3119
上篇深度优先遍历（DFS）的时候，在二维矩阵中，把标识放在了side上，在上面还感觉没有啥子影响，但由于广度遍历的时候，标记的设置要放在push到queue中的时候，就比较难受，所以最好还是把访问标识放在vertex中。广度优先遍历（BFS）借助stl deque实现，借用上篇的代码修改实现，还是采用二维矩阵和邻接表实现 #include #include #define MAX_VER
用c++实现图的深度遍历和广度遍历
05-13
图的深度遍历和广度遍历是图论中比较基础的算法，下面是C++实现的代码： ```cpp #include <iostream> #include <vector> #include <queue> #include <stack> using namespace std; // 定义一个无向图类 class Graph { private: int V; // 图中顶点的数量 vector<int> *adj; // 邻接表 public: Graph(int V); // 构造函数 void addEdge(int v, int w); // 添加边 void DFS(int v); // 深度优先遍历 void BFS(int v); // 广度优先遍历 }; Graph::Graph(int V) { this->V = V; adj = new vector<int>[V]; } void Graph::addEdge(int v, int w) { adj[v].push_back(w); adj[w].push_back(v); } void Graph::DFS(int v) { // 创建一个 bool 类型的数组，表示每个顶点是否被访问 bool *visited = new bool[V]; for (int i = 0; i < V; i++) { visited[i] = false; } // 创建一个栈，用于存储已经经过的顶点 stack<int> s; // 将起始顶点加入栈中 s.push(v); while (!s.empty()) { // 取出栈顶元素 v = s.top(); s.pop(); // 如果该顶点还没有被访问过，就将其标记为已访问 if (!visited[v]) { cout << v << " "; visited[v] = true; } // 遍历该顶点的所有邻接顶点 for (auto it = adj[v].begin(); it != adj[v].end(); ++it) { if (!visited[*it]) { // 如果邻接顶点还没有被访问过，就将其加入栈中 s.push(*it); } } } delete[] visited; } void Graph::BFS(int v) { // 创建一个 bool 类型的数组，表示每个顶点是否被访问 bool *visited = new bool[V]; for (int i = 0; i < V; i++) { visited[i] = false; } // 创建一个队列，用于存储已经经过的顶点 queue<int> q; // 将起始顶点加入队列中 q.push(v); while (!q.empty()) { // 取出队首元素 v = q.front(); q.pop(); // 如果该顶点还没有被访问过，就将其标记为已访问 if (!visited[v]) { cout << v << " "; visited[v] = true; } // 遍历该顶点的所有邻接顶点 for (auto it = adj[v].begin(); it != adj[v].end(); ++it) { if (!visited[*it]) { // 如果邻接顶点还没有被访问过，就将其加入队列中 q.push(*it); } } } delete[] visited; } int main() { Graph g(5); g.addEdge(0, 1); g.addEdge(0, 2); g.addEdge(1, 2); g.addEdge(1, 3); g.addEdge(2, 3); g.addEdge(3, 4); cout << "DFS: "; g.DFS(0); cout << endl; cout << "BFS: "; g.BFS(0); cout << endl; return 0; } ``` 上面的代码中，我们定义了一个 `Graph` 类来表示一个无向图，其中包含了两个成员函数 `DFS()` 和 `BFS()` 分别用于实现深度优先遍历和广度优先遍历。在 `DFS()` 和 `BFS()` 函数中，我们都创建了一个 bool 类型的数组 `visited`，用于表示每个顶点是否被访问过。然后分别使用栈和队列来存储已经经过的顶点，从而实现遍历整个图的过程。 最后我们在 `main()` 函数中创建了一个 `Graph` 对象 `g`，并添加了一些边。然后分别调用 `DFS()` 和 `BFS()` 函数来遍历整个图。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值