C++实现图的搜索(DFS和BFS)

  1 #include<iostream>
  2 #include<stack>
  3
  4 #include<queue>
  5 #define Max 20
  6 using namespace std;
  7
  8 class Vertex
  9 {
 10 public:
 11     Vertex(char lab)
 12     {
 13         Label=lab;
 14     wasVisited=false;
 15     }
 16 public:
 17     bool wasVisited;
 18     char Label;
 19 };
 20
 21
 22 class Graph
 23 {
 24
 25 public:
 26     Graph();//构造函数
 27     ~Graph();//析构函数
 28     void addVertex(char lab);//增加一个节点
 29     void addEdge(int start,int end);//增加一条边,起点到终点
 30     void printMatrix();//打印出矩阵
 31     void showVertex(int v);
 32     void DFS();
 33     void BFS();
 34 private:
 35     Vertex* vertexList[Max];   //存放每个节点的指针的数组
 36     int nVerts;//实际数量
 37     int adjMat[Max][Max];//矩阵
 38     int getAdjUnvisitedVertex(int v);//获得其相邻的节点 在邻接矩阵里找其最近的
 39 };
 40
 41 void Graph::DFS()
 42 {
 43     stack<int>gStack;
 44     vertexList[0]->wasVisited=true;
 45     showVertex(0);
 46     gStack.push(0);
 47     int v;
 48     while(gStack.size()>0)
 49     {
 50         v=getAdjUnvisitedVertex(gStack.top());
 51         if(v==-1)
 52         {
 53             cout<<"出:"<<gStack.top()<<endl;//查看出栈情况
 54             gStack.pop();
 55         }
 56         else
 57         {
 58             vertexList[v]->wasVisited=true;
 59             showVertex(v);
 60             gStack.push(v);
 61         }
 62
 63     }
 64
 65     for(int j=0;j<nVerts;j++)        //重新置为未访问
 66         vertexList[j]->wasVisited=false;
 67
 68
 69 }
 70 void Graph::BFS()
 71 {
 72     queue<int> gQueue;
 73     vertexList[0]->wasVisited=true;
 74     showVertex(0);
 75     gQueue.push(0);
 76     int vert1,vert2;
 77     while(gQueue.size()>0)
 78     {
 79         vert1=gQueue.front();
 80         gQueue.pop();
 81         vert2=getAdjUnvisitedVertex(vert1);
 82         while(vert2!=-1)
 83         {
 84             vertexList[vert2]->wasVisited=true;
 85             showVertex(vert2);
 86             gQueue.push(vert2);
 87             vert2=getAdjUnvisitedVertex(vert1);
 88         }
 89     }
 90     cout<<endl;
 91     for(int j=0;j<nVerts;j++)        //重新置为未访问
 92         vertexList[j]->wasVisited=false;
 93
 94
 95 }
 96
 97 int Graph::getAdjUnvisitedVertex(int v)//得到其相邻节点
 98 {
 99     for(int j=0;j<nVerts;j++)
100     {
101         if((adjMat[v][j]==1)&&(vertexList[j]->wasVisited==false))//找其第一个相邻(邻接)的且没有被访问过的
102             return j;
103     }
104
105     return -1;
106
107 }
108 void Graph::showVertex(int v)   //展示该下标对应的节点
109 {
110     cout<<vertexList[v]->Label<<" ";
111 }
112 Graph::Graph()
113 {
114
115     nVerts=0;
116     for(int i=0;i<Max;i++)
117         for(int j=0;j<Max;j++)
118             adjMat[i][j]=0;
119
120 }
121 void Graph::addVertex(char lab)
122 {
123
124     vertexList[nVerts++]=new Vertex(lab);//
125
126 }
127 void Graph::addEdge(int start,int end)
128 {
129     adjMat[start][end]=adjMat[end][start]=1;
130
131 }
132
133 void Graph::printMatrix()
134 {
135
136     for(int i=0;i<nVerts;i++)
137     {
138         for(int j=0;j<nVerts;j++)
139         {
140             cout<<adjMat[i][j]<<" ";
141         }
142         cout<<endl;
143     }
144 }
145
146 Graph::~Graph()
147 {
148
149     for(int i=0;i<nVerts;i++)
150     {
151         delete vertexList[i];
152     }
153 }
154 int main()
155 {
156
157     Graph g;
158     g.addVertex(‘A‘);//0
159     g.addVertex(‘B‘);//1
160     g.addVertex(‘C‘);//2
161     g.addVertex(‘D‘);//3
162     g.addVertex(‘E‘);//4
163     g.addEdge(0,1);//A-B
164     g.addEdge(1,4);//B-E
165     g.addEdge(2,4);//C-E
166
167     g.addEdge(0,3);//A-D
168     g.addEdge(3,0);
169     g.addEdge(3,4);
170
171     g.printMatrix();
172
173
174     cout<<"DFS搜索"<<endl;
175     g.DFS();
176     cout<<endl;
177     cout<<"BFS搜索"<<endl;
178     g.BFS();
179     return 0;
180 }

原文地址:https://www.cnblogs.com/libin123/p/10420216.html

时间: 2024-10-15 14:45:18

C++实现图的搜索(DFS和BFS)的相关文章

图的遍历——DFS和BFS模板(一般的图)

关于图的遍历,通常有深度优先搜索(DFS)和广度优先搜索(BFS),本文结合一般的图结构(邻接矩阵和邻接表),给出两种遍历算法的模板 1.深度优先搜索(DFS) #include<iostream> #include<unordered_map> #include<queue> #include<cstring> #include<cstdlib> #include<cmath> #include<algorithm> #

图的遍历 DFS和BFS

深度优先搜索 (Depth First Search, DFS): void DFS ( Vertex V ) { visited[ V ] = true; for ( V 点 的每个邻接点 W ) if ( !visited[ W ] ) DFS( W ); } 若有N 个顶点.E 条边,时间复杂度是 用邻接表存储图,有O(N+E) 用邻接矩阵存储图,有O(N 2 ) 广度优先搜索 (Breadth First Search, BFS) void BFS ( Vertex V ) { visi

图的遍历(DFS、BFS)

理论: 深度优先搜索(Depth_Fisrst Search)遍历类似于树的先根遍历,是树的先根遍历的推广: 广度优先搜索(Breadth_First Search) 遍历类似于树的按层次遍历的过程: java实现 Vertex.java package 图; public class Vertex{ String value; boolean isVisited; Vertex(String value) { this.value=value; this.isVisited=false; }

785. 判断二分图——本质上就是图的遍历 dfs或者bfs

785. 判断二分图 给定一个无向图graph,当这个图为二分图时返回true. 如果我们能将一个图的节点集合分割成两个独立的子集A和B,并使图中的每一条边的两个节点一个来自A集合,一个来自B集合,我们就将这个图称为二分图. graph将会以邻接表方式给出,graph[i]表示图中与节点i相连的所有节点.每个节点都是一个在0到graph.length-1之间的整数.这图中没有自环和平行边: graph[i] 中不存在i,并且graph[i]中没有重复的值. 示例 1: 输入: [[1,3], [

学习笔记:图的DFS和BFS的两种搜索办法

  在学习图结构的过程中,DFS和BFS是两种不同的遍历方式,其寻找元素具有不同的优点和缺陷. BFS被称作广度优先算法, 在遍历整个图的过程中,BFS将采用入队的方式进行,值得一提的是,这和树结构中的层序遍历有很大的相似之处. 在层序遍历中,将父亲节点入队后,在父亲节点出队后,将其儿子节点入队. 同理在图的BFS遍历中,先让BFS的首元素入队,在收元素入队后将他的儿子节点入队,放能够实现BFS搜索,他们的整体思想是一样的. 1 void TraversalGraph_BFS(LGraph Gr

算法导论--图的遍历(DFS与BFS)

转载请注明出处:勿在浮沙筑高台http://blog.csdn.net/luoshixian099/article/details/51897538 图的遍历就是从图中的某个顶点出发,按某种方法对图中的所有顶点访问且仅访问一次.为了保证图中的顶点在遍历过程中仅访问一次,要为每一个顶点设置一个访问标志.通常有两种方法:深度优先搜索(DFS)和广度优先搜索(BFS).这两种算法对有向图与无向图均适用. 以下面无向图为例: 1.深度优先搜索(DFS) 基本步骤: 1.从图中某个顶点v0出发,首先访问v

数据结构(11) -- 邻接表存储图的DFS和BFS

/////////////////////////////////////////////////////////////// //图的邻接表表示法以及DFS和BFS /////////////////////////////////////////////////////////////// #include <iostream> #include <stdlib.h> #include <queue> using namespace std; //图的邻接表表示法

建图方式之“邻接链表” BFS搜索

继续校赛前的建图任务,当时只写了DFS遍历,今天把BFS也写了一下. #include <iostream> #include <cstdio> #include <cstdlib> #include <cstring> #include <algorithm> const int maxe = 10001; using namespace std; struct node{ int to,w; node *next; }*head[maxe];

树的常见算法&amp;图的DFS和BFS

树及二叉树: 树:(数据结构中常见的树) 树的定义 树的存储:下面介绍三种不同的树的表示法:双亲表示法,.孩子表示法,.孩子兄弟表示法. 双亲表示法 我们假设以一组连续空间存储树的结点,同时在每个结点中,附设一个指示器指向其双亲结点到链表中的位置.也就是说每个结点除了知道自己之外还需要知道它的双亲在哪里. 它的结构特点是如图所示: 以下是我们的双亲表示法的结构定义代码: /*树的双亲表示法结点结构定义 */ #define MAXSIZE 100 typedef int ElemType; //

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

图的表示有很多,形式不固定,我暂时先记录我已经懂了的,能写的两种即大多数人应该都知道的邻接矩阵和邻接表. 邻接矩阵: 这里的邻接矩阵和离散数学说的有一点不同,至少有向图的邻接矩阵不同(离散书上的有向图的邻接矩阵求法到是有点像求任意两点的最短路径的Floyd算法) 以上都是(我现有知识认为的)废话: 重点 : G : 表示图: Nv:表示图的点数: Ne:表示图的边数: 邻接矩阵 即是一个 Nv * Nv 的矩阵,矩阵是用来储存  权值的(如果是带权图且有边的话),如果是无权图的的话,如果两顶点有