广度优先遍历 (Breadth First Search)，又称为广度优先搜索，简称 BFS
图的广度优先遍历类似于树的层序遍历
无向图的广度优先搜索
- 代码一，面向过程思想写的，注意与代码二的区别
#include
using namespace std;
#define len 100
int visited[len];
struct fact{
char node[len]; // 顶点集合
int edge[len][len]; // 邻接矩阵
int n; // 节点个数
int e; // 边的个数
};
// 返回顶点下标
int get_Node_Index(struct fact *g, char number){
for(int i=0; i < g->n; i++){
if(number == g -> node[i]){
return i;
}
}
return -1; //这句话永远不会执行的
}
class Queue{
public:
int front;
int rear;
int count;
int data[len];
// 构造函数
Queue(){
front = 0;
rear = 0;
count = 0;
}
// 进入队列
void Enter_Queue(int number){
data[rear ++] = number;
count ++;
}
// 走出队列
int get_Queue(){
int temp = data[front ++];
count--;
return temp;
}
// 判断队列是否为空
// 为空则返回tue
bool Is_Empty(){
if(front == rear){
return true;
}
else{
return false;
}
}
};
void BFS(struct fact *g, int number, Queue& que){
que.Enter_Queue(number);
cout<<"广度优先遍历序列为: "<node[number]<n; i++){
if(g->edge[k][i]==1 && !visited[i]){
cout<<"广度优先 遍历序列为: "<node[i]< n = 7;
graph -> e = 7;
// 设置节点为默认数值
string nodes = "ABCDEFG";
// 输入节点
for(int i=0; i < graph->n; i++){
graph -> node[i] = nodes[i];
}
// 设置边为默认值
char edges[][2] = {
{'A', 'C'},
{'A', 'D'},
{'A', 'F'},
{'C', 'B'},
{'C', 'D'},
{'F', 'G'},
{'G', 'E'}
};
// 边初始化为０
for(int i=0; i < graph->n; i++){
for(int j=0; j < graph->n; j++){
graph -> edge[i][j] = 0;
}
}
for(int i=0; i < graph->e; i++){
int start = get_Node_Index(graph, edges[i][0]);
int end = get_Node_Index(graph, edges[i][1]);
// 无向图的建立
graph -> edge[start][end] = 1;
graph -> edge[end][start] = 1;
}
// 初始化 visited 数组
for(int i=0; i < graph->n; i++){
visited[i] = 0;
}
// 开始深度优先遍历
for(int i=0; i < graph->n; i++){
if(!visited[i]){
BFS(graph, i, que);
}
}
return 0;
}
- 代码二，面向对象思想书写
#include
using namespace std;
#define len 100
class Queue{
public:
int front;
int rear;
int count;
int data[len];
// 构造函数
Queue(){
front = 0;
rear = 0;
count = 0;
}
// 进入队列
void Enter_Queue(int number){
data[rear ++] = number;
count ++;
}
// 走出队列
int get_Queue(){
int temp = data[front ++];
count--;
return temp;
}
// 判断队列是否为空
// 为空则返回tue
bool Is_Empty(){
if(front == rear){
return true;
}
else{
return false;
}
}
};
class Graph{
public:
char node[len]; // 顶点集合
int edge[len][len]; // 邻接矩阵
int n; // 节点个数
int e; // 边的个数
int visited[len]; // 用来得知该节点是否被访问
Graph(Queue& que){
n = 7;
e = 7;
// 设置节点为默认数值
string nodes = "ABCDEFG";
// 输入节点
for(int i=0; i < n; i++){
node[i] = nodes[i];
}
// 设置边为默认值
char edges[][2] = {
{'A', 'C'},
{'A', 'D'},
{'A', 'F'},
{'C', 'B'},
{'C', 'D'},
{'F', 'G'},
{'G', 'E'}
};
// 边初始化为０
for(int i=0; i < n; i++){
for(int j=0; j < n; j++){
edge[i][j] = 0;
}
}
for(int i=0; i < e; i++){
int start = get_Node_Index(edges[i][0]);
int end = get_Node_Index(edges[i][1]);
// 无向图的建立
edge[start][end] = 1;
edge[end][start] = 1;
}
// 初始化 visited 数组
for(int i=0; i < n; i++){
visited[i] = 0;
}
// 开始深度优先遍历
for(int i=0; i < n; i++){
if(!visited[i]){
BFS(i, que);
}
}
}
// 返回顶点下标
int get_Node_Index(char number){
for(int i=0; i < n; i++){
if(number == node[i]){
return i;
}
}
return -1; //这句话永远不会执行的
}
// 广度优先搜索
void BFS(int number, Queue& que){
que.Enter_Queue(number);
cout<<"广度优先遍历序列为: "< - 备注，注意吸收代码二的优点，面向对象的思想
有向图的广度优先搜索
#include
using namespace std;
#define len 100
class Queue{
public:
int front;
int rear;
int count;
int data[len];
// 构造函数
Queue(){
front = 0;
rear = 0;
count = 0;
}
// 进入队列
void Enter_Queue(int number){
data[rear ++] = number;
count ++;
}
// 走出队列
int get_Queue(){
int temp = data[front ++];
count--;
return temp;
}
// 判断队列是否为空
// 为空则返回tue
bool Is_Empty(){
if(front == rear){
return true;
}
else{
return false;
}
}
};
class Graph{
public:
char node[len]; // 顶点集合
int edge[len][len]; // 邻接矩阵
int n; // 节点个数
int e; // 边的个数
int visited[len]; // 用来得知该节点是否被访问
Graph(Queue& que){
n = 7;
e = 9;
// 设置节点为默认数值
string nodes = "ABCDEFG";
// 输入节点
for(int i=0; i < n; i++){
node[i] = nodes[i];
}
// 设置边为默认值
char edges[][2] = {
{'A', 'B'},
{'B', 'C'},
{'B', 'E'},
{'B', 'F'},
{'C', 'E'},
{'D', 'C'},
{'E', 'B'},
{'E', 'D'},
{'F', 'G'}
};
// 边初始化为０
for(int i=0; i < n; i++){
for(int j=0; j < n; j++){
edge[i][j] = 0;
}
}
for(int i=0; i < e; i++){
int start = get_Node_Index(edges[i][0]);
int end = get_Node_Index(edges[i][1]);
// 有向图的建立
edge[start][end] = 1;
}
// 初始化 visited 数组
for(int i=0; i < n; i++){
visited[i] = 0;
}
// 开始深度优先遍历
for(int i=0; i < n; i++){
if(!visited[i]){
BFS(i, que);
}
}
}
// 返回顶点下标
int get_Node_Index(char number){
for(int i=0; i < n; i++){
if(number == node[i]){
return i;
}
}
return -1; //这句话永远不会执行的
}
// 广度优先搜索
void BFS(int number, Queue& que){
que.Enter_Queue(number);
cout<<"广度优先遍历序列为: "<