Estructura de datos: la matriz de adyacencia del gráfico implementa
el primer recorrido en profundidad
** Primer paso: ** Construya una matriz de acceso con el mismo tamaño que el número de vértices. La inicialización se registra como 0, lo que significa que no se ha accedido al
segundo paso desde el primer vértice o El último vértice es el punto de partida para determinar si el vértice ha pasado, y luego realizar la función DFS. Finalmente, siga cada vértice por turno (utilizando la matriz de acceso para determinar si ha pasado). El
tercer paso es construir la función DFS: La
función DFS comienza desde un cierto vértice según si el borde es Existencia es juzgar el segundo borde y luego registrar el otro vértice de su borde como 1 (caminado)
Preparación preliminar
typedef int Boolean;//深度遍历的数组为布尔类型 用来标记
Boolean visited[MAXVER];//深度遍历的访问数组
Parte operativa
/*邻接矩阵的深度遍历算法 访问数组初始化，对每个顶点都可以走一遍 前提是没有走过的*/
Status DFS(MGhaph &G, int i)
{
int j;
visited[i] = true;
cout << "此时访问的顶点为： "<< endl;
cout << G.vexs[i]<< endl;
for (j = 0; j < G.numver; j++)
{
if (G.arc[j][i] != INF && !visited[j])//递归之处 从i为开始 又转到从j的0到顶点数都寻找一遍
DFS(G,j);
}
return 0;
}
Status DFSTraverse(MGhaph &G)
{
int i;
for (i = 0; i < G.numver; i++)//访问数组都记为0 意为 顶点没有被访问过
{
visited[i] = false;
}
for (i = 0; i < G.numver; i++)
{
if (!visited[i])//所有顶点都可以访问（前提是：之前没有被访问过） 且从该顶点开始循环
{
cout << "从" << i << "开始访问" << endl;
DFS(G, i);
}
}
return 0;
}
/*————————深度优先遍历————————*/
Pensando : El recorrido en profundidad puede recorrer cada vértice sin repetirlo. Puedes hacer algunas operaciones en el vértice (por supuesto se puede repetir pero la complejidad es mayor). Pertenece al algoritmo de búsqueda.
El primer recorrido de amplitud implica una cola
Primero defina una cola queue.h
#include<iostream>
//#include <iomanip>
using namespace std;
typedef char elementtype;
typedef int Status;
typedef struct QNode
{
char data;
struct QNode *next;
}QNode, *Queueptr;
typedef struct Queue
{
QNode *head;
QNode *tail;
}Queue;
//初始化队列
Status InitQueue(Queue &Q)
{
Q.head = Q.tail = (Queueptr)malloc(sizeof(QNode));
Q.head->next = NULL;
Q.tail->next = NULL;
return 0;
}
//头指针和尾指针只有一个
//插入元素
Status Enqueue(Queue &Q, elementtype x)
{
Queueptr p = (Queueptr)malloc(sizeof(QNode));//创建一个结点
p->data = x;
p->next = NULL;
Q.tail->next = p;
Q.tail = p;
return 0;
}
Status Dequeue(Queue &Q, elementtype &y)
{
if (Q.head == Q.tail)
{
return NULL;
}
Queueptr q;
q = Q.head->next;
y = q->data;
Q.head->next = q->next;
if (Q.tail == q)
{
Q.tail = Q.head;
}
free(q);
return 0;
}
Status QueueEmpty(Queue &Q)
{
if (Q.head != NULL || Q.tail != NULL)
{
return 1;
}
else
return 0;
}
Luego, agregue esto a la estructura de datos, la implementación de la matriz de adyacencia del gráfico,
y #incluya "queue.h" al mismo tiempo.
/*————————实现广度优先遍历————————*/
void BFS(MGhaph &G)
{
char x;
int i, j;
Queue Q;
for (i = 0; i < G.numver; i++)
{
visited[i] = false;//标记
}
InitQueue(Q);//初始化队列
for (i = 0; i < G.numver; i++)
{
if (!visited[i])//如果从未访问过
{
visited[i] = true;//标记 走过的顶点 并输出，并将此顶点存入队列
cout << "此时访问的顶点为： " << endl;
cout << G.vexs[i] << endl;
Enqueue(Q, G.vexs[i]);//将此顶点进入队列
while (!QueueEmpty(Q))//若此时队列不为空时 进入 空时弹出
{
Dequeue(Q,x);//把队列里的一个元素弹出
for (j = 0; j < G.numver; j++)
{
if (G.arc[j][i] != INF && !visited[j])//寻找和i所在的元素有弧的元素
{
visited[j] = true;//标记走过
cout << "从" << j << "开始访问" << endl;
cout <<G.vexs[j] << endl;
Enqueue(Q, G.vexs[j]);//将有联系的顶点元素入队列
}
}
}
}
}
}
Primer recorrido generalizado:
1. Construye una cola para almacenar elementos de vértice como un proceso intermedio
2. Construye una matriz de acceso para marcar los vértices que se han visitado
3. Configura un bucle for para almacenar los vértices que se visitan cada vez en la cola y
luego ingrese el bucle while (determine si la cola está vacía) ingrese el cuerpo del bucle cuando no esté vacío
Aparece un elemento en el equipo
Ingrese el bucle for para encontrar el vértice del borde
relacionado con el vértice. Después de encontrar el vértice del borde relacionado, guárdelo en la cola y marque el número visitado.
Una vez finalizado el ciclo for, todavía está en el ciclo while. En este momento, borre la cola para saltar fuera
de la cola del ciclo grande y volver a la inicialización.