数据结构之DFS与BFS

深度搜索(DFS) and  广度搜索(BFS)

代码如下:

  1 #include "stdafx.h"
  2 #include<iostream>
  3 #include<string>
  4 using namespace std;
  5 #define MAX 30
  6 #define MVNum 100
  7 #define ERROR 1
  8 typedef char VerTexType;
  9 typedef int Status;
 10 typedef int QElemType;
 11 #define MAXSIZE 100
 12 #define OK 1
 13 #define ERROR 0
 14 #define OVERFLOW -2
 15 typedef struct ArcNode                 //边结点
 16 {
 17     int adjvex;                        //改变所指向的顶点的位置
 18     struct ArcNode *nextarc;           //指向下一条边的指针
 19     string info;                       //和边相关的信息
 20 }ArcNode;
 21 typedef struct VNode                   //顶点信息
 22 {
 23     VerTexType data;
 24     struct ArcNode *link;              //指向第一条依附该顶点的边的指针
 25 }VNode;                                //AdList表示邻接表类型
 26 typedef struct                         //邻接表
 27 {
 28     VNode xlist[MAX];
 29     int vexnum, arcnum;                //图的当前顶点数和边数
 30 }ALGraph;
 31
 32 typedef struct Node                    //构造队列
 33 {
 34     int data;
 35     struct Node *next;
 36 }Node,*QNode;
 37 typedef struct
 38 {
 39     QNode front;                       //队头指针
 40     QNode rear;                        //对尾指针
 41 }Queue;
 42 Status InitQueue(Queue &Q)             //初始化队列
 43 {
 44     Q.front = Q.rear=new Node;         //生成新节点作为头节点,对头和队尾指针指向此节点
 45     if (!Q.front)
 46         exit(OVERFLOW);
 47     Q.front->next = NULL;               //头结点的指针域置空
 48     return OK;
 49 }
 50
 51 Status EnQueue(Queue &Q, int e)        //入队操作
 52 {
 53     QNode p = new Node;
 54     if (!p)                            //存储分配失败
 55         exit(OVERFLOW);
 56     p->data = e;
 57     p->next = NULL;
 58     Q.rear->next = p;
 59     Q.rear = p;                        //把当前的p设置尾对尾节点,rear指向p
 60     return OK;
 61 }
 62
 63 Status DeQueue(Queue &Q, int &e)       //出队操作
 64 {
 65     QNode p;
 66     p = Q.front->next;                 //将欲删除的对头结点暂存给p
 67     Q.front->next = p->next;           //将原队头节点后继p->next赋值给头结点后继
 68     if (Q.rear == p)                   //如果队头是队尾,则删除后将rear指向头节点
 69         Q.rear = Q.front;
 70     e = p->data;                       //将欲删除的对接点赋值给e
 71     delete p;
 72     return OK;
 73 }
 74
 75 Status QueueEmpty(Queue Q)             //队列判空
 76 {
 77     if (Q.rear == Q.front)
 78         return 1;
 79     else
 80         return 0;
 81 }
 82
 83 int LocateVex(ALGraph &G, char &v)     //定位函数
 84 {
 85     int i;
 86     for (i = 0; i < G.vexnum; i++)
 87     {
 88         if (G.xlist[i].data == v)
 89             return i;
 90     }
 91     if (i >= G.vexnum)
 92         return ERROR;
 93     else
 94         return 0;
 95 }
 96 void CreateUDG(ALGraph &G)             //创建无向图
 97 {
 98     ArcNode *p1, *p2;
 99     int i, j, k;
100     char v1, v2;
101     cout << "请输入图的顶点数、边数:" << endl;
102     cin >> G.vexnum >> G.arcnum;       //输入总顶点数,总边数
103     cout << "请输入顶点的值:(顶点之间用空格分离)" << endl;
104     for (i = 0; i < G.vexnum; i++)
105     {
106         cin >> G.xlist[i].data;        //输入顶点值
107         G.xlist[i].link = NULL;        //初始化表头结点的指针域为NULL
108     }
109     cout << "请输入弧尾和弧头:" << endl;
110     for (k = 0; k < G.arcnum; k++)
111     {
112         cin >> v1 >> v2;               //输入各边,构造邻接表
113         i = LocateVex(G, v1);
114         j = LocateVex(G, v2);
115         p1 = new ArcNode;              //生成一个新结点*p1
116         p1->adjvex = j;                //邻接点序号为j
117         p1->nextarc = G.xlist[i].link;
118         G.xlist[i].link = p1;
119         p2 = new ArcNode;
120         p2->adjvex = i;
121         p2->nextarc = G.xlist[j].link;
122         G.xlist[j].link = p2;
123     }
124     cout << "图构建成功!" << endl<<endl;
125 }
126
127 static bool visited[MAX];              //访问过visited,为1否则为0
128
129 void DFS(ALGraph G, int m)             //深度优先搜索
130 {
131     visited[m] = true;                 //标记已经遍历过
132     cout << G.xlist[m].data<<" ";
133     ArcNode *p = G.xlist[m].link;
134     while (p)
135     {
136         if (!visited[p->adjvex])
137             DFS(G, p->adjvex);
138         p = p->nextarc;
139     }
140 }
141
142 void BFS(ALGraph G,int n)              //广度优先搜索
143 {
144     ArcNode *p;
145     Queue Q;
146     for (int i = 0; i < G.vexnum; i++)
147         visited[i] = false;
148     InitQueue(Q);
149     for (int i = 0; i < G.vexnum; i++)
150     {
151         if (!visited[i])
152         {
153             visited[i] = true;
154             cout << G.xlist[i].data<<" ";
155             EnQueue(Q, i);
156             while (!QueueEmpty(Q))
157             {
158                 DeQueue(Q, i);
159                 p = G.xlist[i].link;   //找到当前顶点编表链表头指针
160                 while (p)
161                 {
162                     if (!visited[p->adjvex])//若此顶点未访问
163                     {
164                         visited[p->adjvex] = true;
165                         cout << G.xlist[p->adjvex].data<<" ";
166                         EnQueue(Q, p->adjvex);//将此顶点入队列
167                     }
168                     p = p->nextarc;    //指针指向下一个邻接点
169                 }
170             }
171         }
172     }
173 }
174
175 void coutGraphD(ALGraph G)             //深搜输出函数
176 {
177     for (int i = 0; i < G.vexnum; i++)
178         visited[i] = false;
179     cout << "深度优先搜索输出的顶点的结果为:" << endl;
180     for (int i = 0; i < G.vexnum; i++)
181         if (!visited[i])
182             DFS(G, i);
183     cout << endl;
184 }
185 void coutGraphW(ALGraph G)             //广搜输出函数
186 {
187     for (int i = 0; i < G.vexnum; i++)
188         visited[i] = false;
189     cout << "广度优先搜索输出的顶点的结果为:" << endl;
190     for (int i = 0; i < G.vexnum; i++)
191         if (!visited[i])
192             BFS(G, i);
193     cout << endl;
194
195 }
196 int main()
197 {
198     ALGraph MG;
199     CreateUDG(MG);
200     coutGraphD(MG);
201     coutGraphW(MG);
202     return 0;
203 }

运行结果:

原文地址:https://www.cnblogs.com/Trojan00/p/8970894.html

时间: 2024-10-07 12:50:28

数据结构之DFS与BFS的相关文章

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

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

数据结构(12) -- 图的邻接矩阵的DFS和BFS

//////////////////////////////////////////////////////// //图的邻接矩阵的DFS和BFS //////////////////////////////////////////////////////// #include <iostream> #include <stdlib.h> #include <queue> #define MaxVertexNum 100 //最大顶点数 //#define INFINI

《数据结构》C++代码 BFS与DFS

       BFS,广度优先搜索,一层一层去遍历图,故称广度优先.实现方式:队列.        DFS,深度优先搜索,撞墙才回头的遍历,称为深度优先.实现方式:递归(栈).        这两种遍历方式,是访问图的基本方式.如果拿树做对比的话,BFS对应层次遍历,DFS则对应三种基本遍历方法(先序.中序.后序):遍历树起点只有一个根,而图则需要以每个没被遍历过的点作为起点,方能遍历完全.        没啥可说的,直接看代码. 题目描述:输入一个图,第一行N.M表示N个点.M条边,下面M行每

数据结构基础(21) --DFS与BFS

DFS 从图中某个顶点V0 出发,访问此顶点,然后依次从V0的各个未被访问的邻接点出发深度优先搜索遍历图,直至图中所有和V0有路径相通的顶点都被访问到(使用堆栈). //使用邻接矩阵存储的无向图的深度优先遍历 template <typename Type> void Graph<Type>::DFS() { stack<int> iStack; showVertex(0); vertexList[0]->wasVisted = true; iStack.push

图的DFS与BFS遍历

一.图的基本概念 1.邻接点:对于无向图无v1 与v2之间有一条弧,则称v1与v2互为邻接点:对于有向图而言<v1,v2>代表有一条从v1到v2的弧,则称v2为v1的邻接点. 2.度:就是与该顶点相互关联的弧的个数. 3.连通图:无向图的每个顶点之间都有可达路径,则称该无向图为连通图.有向图每个顶点之间都有<v1,v2>和<v2,v1>,则称此有向图为强连通图. 二.存储结构 1.邻接矩阵存储(Adjacency Matrix) 对无权图,顶点之间有弧标1,无弧标0:

图的 DFS 与 BFS 复杂度分析

DFS的复杂度分析: 对于邻接表的存储方式:因为邻接表中每条链表上的从第2个结点到表尾结点一定是表头结点的邻接点,所以遍历表头结点的邻接的过程中只需要遍历这些顶点即可,无需遍历其他的顶点,所以遍历某个顶点的所有邻接点的复杂度为O(ei), ei为每个顶点的邻接点个数,也就是每条链表的边数.所以邻接表版的 dfs 遍历所有邻接点的时间复杂度为 O(e1 + e2 + e3 + .... + en) ,因为所有边数之和为 E , 所以时间复杂度为 O(E) , 又因为访问每个顶点都必须被访问一次,

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

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

递归,回溯,DFS,BFS的理解和模板【摘】

递归:就是出现这种情况的代码: (或者说是用到了栈) 解答树角度:在dfs遍历一棵解答树 优点:结构简洁缺点:效率低,可能栈溢出 递归的一般结构: 1 void f() { 2 if(符合边界条件) { 3 /////// 4 return; 5 } 6 7 //某种形式的调用 8 f(); 9 } 回溯:递归的一种,或者说是通过递归这种代码结构来实现回溯这个目的.回溯法可以被认为是一个有过剪枝的DFS过程.解答树角度:带回溯的dfs遍历一棵解答树回溯的一般结构: 1 void dfs(int

搜索分析(DFS、BFS、递归、记忆化搜索)

搜索分析(DFS.BFS.递归.记忆化搜索) 1.线性查找 在数组a[]={0,1,2,3,4,5,6,7,8,9,10}中查找1这个元素. (1)普通搜索方法,一个循环从0到10搜索,这里略. (2)递归(从中间向两边) 1 //递归一定要写成记忆化递归 2 #include <bits/stdc++.h> 3 using namespace std; 4 bool vis[11]; 5 int count1=0; 6 7 void search(int n){ 8 count1++; 9