contenido:
El gráfico se almacena en forma de matriz de adyacencia y se realiza el recorrido en profundidad del gráfico.
paso:
Análisis de algoritmos :
En primer lugar, la estructura de almacenamiento de la matriz de adyacencia del gráfico consiste en utilizar una matriz unidimensional para almacenar la información de los vértices del gráfico y utilizar una matriz para representar la relación de adyacencia entre los vértices del gráfico. Suponiendo que el grafo G=(V, E) tiene n vértices inciertos, es decir, V={v0, v1, ..., vn-1}, significa que la relación de adyacencia de cada vértice en G es un n* n matrix , los elementos de la matriz son:
Los arcos de matriz generalmente se denominan matriz de adyacencia.
Use una matriz unidimensional para almacenar la información de los vértices en el gráfico, por ejemplo, la matriz de vértices vertex[5]={v0, v1, v2, v3, v4}, después de almacenar los vértices en la matriz, el se determina la posición de cada vértice. El arreglo arcs[i][j] se usa para almacenar la relación entre vértices, si arcs[i][j]=1, significa que hay una arista entre los vértices vi y vj, si arcs[i][j] =0 , significa que no hay arista entre los vértices vi y vj.
Además, si G es una red, también necesitamos almacenar el peso de cada borde, entonces la matriz de adyacencia se puede definir como:
Entre ellos, Wij representa el peso en el borde (vi, vj) o arco <vi, vj>
El recorrido primero en profundidad es similar al recorrido primero en la raíz de un árbol, y es una extensión del recorrido primero en la raíz de un árbol. El proceso transversal es el siguiente:
(1) Marque todos los vértices del gráfico como no visitados
(2) Elija un vértice no visitado v en el gráfico como punto de partida del recorrido
(3) Visite el nodo v y luego visite primero en profundidad el primer punto adyacente no visitado w1 de v
(4) Acceso en profundidad al primer punto adyacente no visitado w2 de w1 a partir de w1, ... y así sucesivamente, hasta llegar a un vértice donde todos los puntos adyacentes han sido visitados
(5) Luego regrese una vez para averiguar si el nodo anterior Wi-1 tiene un punto adyacente no visitado, y si existe, visite este punto adyacente y comience desde este nodo para visitar de acuerdo con la regla de profundidad primero. Si no hay ningún nodo no visitado en el nodo Wi-1, retroceda un paso hasta encontrar todos los vértices de los puntos adyacentes no visitados.
(6) Repita el proceso anterior hasta que se hayan visitado todos los vértices del gráfico que están conectados a v por un camino.
(7) Si todavía hay vértices no visitados en el gráfico en este momento, regrese a (2); de lo contrario, el recorrido termina
Obviamente, este algoritmo se puede implementar usando recursividad.El algoritmo para el recorrido en profundidad de un gráfico a partir de un cierto nodo v adopta la forma recursiva de la siguiente manera :
- Visita el nodo V
- Encuentre el primer vecino w de v
- Si el punto adyacente w existe y no ha sido visitado, comience desde w para recorrer el gráfico en profundidad primero; de lo contrario, finalice
- Encuentre el siguiente punto adyacente del vértice v con respecto a w, devuelva (3)
Diseño del esquema:
| Función CreateMGraph() |
Construya la matriz de adyacencia del gráfico |
| Función DFS() |
función recursiva |
| Función DFSTraverse() |
Travesía primero en profundidad |
resultado de la operación:
el código se muestra a continuación:
#include <stdio.h>
#define MAXSIZE 20
typedef char VertexType;
typedef int EdgeType;
//访问数组
int visited[MAXSIZE];
//图结构
typedef struct MGraph {
VertexType vexs[MAXSIZE]; //定义顶点数组，储存顶点信息
EdgeType arc[MAXSIZE][MAXSIZE]; //定义边数组，储存边关系
int numNodes, numEdqes; //当前图中的顶点数、边数
}MGraph;
//创建图
void CreatMGraph(MGraph* G) {
int i, j, k;
printf("请输入要创建图的顶点数和边数：\n");
scanf("%d %d", &G->numNodes, &G->numEdqes);
getchar();
printf("请输入顶点信息：\n");
for (i = 0; i < G->numNodes; i++) {
scanf("%c",&G->vexs[i]); //键入顶点信息保存入顶点数组
getchar();
}
for (i = 0; i < G->numNodes; i++) {
for (j = 0; j < G->numEdqes; j++) {
G->arc[i][j] = 0; //初始化邻接矩阵的元素为0
}
}
printf("请输入邻接顶点的下标：\n");
for (k = 0; k < G->numEdqes; k++) {
scanf("%d %d", &i, &j);
G->arc[i][j] = 1; //将边关系录入数组
G->arc[j][i] = G->arc[i][j]; //对称矩阵
}
}
//递归函数
void DFS(MGraph G, int i) {
int j; //数组下标j，用来遍历图中顶点
visited[i] = 1; //标志下标为i的顶点已经被访问
printf("%c", G.vexs[i]); //打印该结点
for (j = 0; j < G.numNodes; j++) {
if (G.arc[i][j] == 1 && !visited[j]) { //如果下标ij的顶点邻接且j没有被访问过
DFS(G, j);
}
}
}
//深度优先遍历
void DFSTraverse(MGraph G) {
int i;
for (i = 0; i < G.numNodes; i++) {
visited[i] = 0; //初始化所有结点为未访问
}
for (i = 0; i < G.numNodes; i++) {
if (!visited[i]) {
DFS(G, i); //选用下标j对应的顶点作为新的起始点，递归直到图中所有顶点都被访问过为止
}
}
}
int main(void) {
MGraph G;
CreatMGraph(&G);
DFSTraverse(G);
return 0;
}