O que é travessia de gráfico na computação gráfica? Por favor, explique sua função e métodos comuns.
A travessia do gráfico refere-se ao processo de percorrer os vértices e arestas do gráfico de acordo com certas regras na estrutura de dados do gráfico. A função da travessia do grafo é obter as informações estruturais do grafo percorrendo os vértices e arestas do grafo, como encontrar vértices ou arestas específicas, calcular o caminho mais curto, determinar a conectividade do grafo, etc. Os métodos de passagem de gráfico comumente usados incluem pesquisa em profundidade (DFS) e pesquisa em largura (BFS).
A pesquisa em profundidade (DFS) é um método comum para travessia de gráfico. Sua ideia básica é começar a partir de um determinado vértice do gráfico, continuar a detalhar ao longo de uma aresta até que ela não possa continuar, e então voltar ao nó anterior e continuar para detalhar outros nós.caminho até que todos os vértices sejam percorridos. O DFS geralmente é implementado usando recursão ou pilha.
A seguir está um exemplo de código Java para demonstrar a aplicação do algoritmo de pesquisa em profundidade no gráfico:
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
public class DepthFirstSearch {
// 图的顶点数
private int numVertices;
// 图的邻接矩阵表示
private int[][] adjacencyMatrix;
public DepthFirstSearch(int numVertices) {
this.numVertices = numVertices;
this.adjacencyMatrix = new int[numVertices][numVertices];
}
// 添加边
public void addEdge(int source, int destination) {
adjacencyMatrix[source][destination] = 1;
adjacencyMatrix[destination][source] = 1;
}
// 深度优先搜索
public List<Integer> dfs(int startVertex) {
List<Integer> visited = new ArrayList<>();
Stack<Integer> stack = new Stack<>();
stack.push(startVertex);
while (!stack.isEmpty()) {
int currentVertex = stack.pop();
if (!visited.contains(currentVertex)) {
visited.add(currentVertex);
for (int i = numVertices - 1; i >= 0; i--) {
if (adjacencyMatrix[currentVertex][i] == 1 && !visited.contains(i)) {
stack.push(i);
}
}
}
}
return visited;
}
public static void main(String[] args) {
DepthFirstSearch dfs = new DepthFirstSearch(6);
dfs.addEdge(0, 1);
dfs.addEdge(0, 2);
dfs.addEdge(1, 3);
dfs.addEdge(1, 4);
dfs.addEdge(2, 4);
dfs.addEdge(3, 4);
dfs.addEdge(3, 5);
dfs.addEdge(4, 5);
List<Integer> result = dfs.dfs(0);
System.out.println("Depth First Traversal: " + result);
}
}
No código acima, primeiro criamos uma DepthFirstSearchclasse que inclui a contagem de vértices e a representação da matriz de adjacência do gráfico. Em seguida, addEdgeadicionamos relacionamentos de borda por meio de métodos. Por fim, usamos dfso método para fazer uma pesquisa em profundidade e imprimir os resultados da travessia.
A saída da pesquisa em profundidade é: Depth First Traversal: [0, 2, 4, 1, 3, 5]. Isso significa começar do vértice 0 e percorrer todos os vértices do gráfico em profundidade.
Além da pesquisa em profundidade, a pesquisa em largura (BFS) também é um método de passagem de gráfico comumente usado. A ideia básica da pesquisa em largura é começar a partir de um determinado vértice do gráfico, primeiro visitar todos os vértices vizinhos e, em seguida, visitar os vizinhos do vizinho em sequência até que todos os vértices sejam percorridos. O BFS geralmente é implementado usando filas.
A seguir está um exemplo de código Java para demonstrar a aplicação do algoritmo de pesquisa em largura ao gráfico:
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
public class BreadthFirstSearch {
// 图的顶点数
private int numVertices;
// 图的邻接矩阵表示
private int[][] adjacencyMatrix;
public BreadthFirstSearch(int numVertices) {
this.numVertices = numVertices;
this.adjacencyMatrix = new int[numVertices][numVertices];
}
// 添加边
public void addEdge(int source, int destination) {
adjacencyMatrix[source][destination] = 1;
adjacencyMatrix[destination][source] = 1;
}
// 广度优先搜索
public List<Integer> bfs(int startVertex) {
List<Integer> visited = new ArrayList<>();
Queue<Integer> queue = new LinkedList<>();
queue.add(startVertex);
visited.add(startVertex);
while (!queue.isEmpty()) {
int currentVertex = queue.poll();
for (int i = 0; i < numVertices; i++) {
if (adjacencyMatrix[currentVertex][i] == 1 && !visited.contains(i)) {
queue.add(i);
visited.add(i);
}
}
}
return visited;
}
public static void main(String[] args) {
BreadthFirstSearch bfs = new BreadthFirstSearch(6);
bfs.addEdge(0, 1);
bfs.addEdge(0, 2);
bfs.addEdge(1, 3);
bfs.addEdge(1, 4);
bfs.addEdge(2, 4);
bfs.addEdge(3, 4);
bfs.addEdge(3, 5);
bfs.addEdge(4, 5);
List<Integer> result = bfs.bfs(0);
System.out.println("Breadth First Traversal: " + result);
}
}
No código acima, criamos uma BreadthFirstSearchclasse que inclui a contagem de vértices e a representação da matriz de adjacência do gráfico. Em seguida, addEdgeadicionamos relacionamentos de borda por meio de métodos. Por fim, usamos bfso método para fazer uma pesquisa ampla e imprimir os resultados do percurso.
A saída da pesquisa em largura é: Amplitude primeiro Traversal: [0, 1, 2, 3, 4, 5]. Isso significa começar do vértice 0 e percorrer todos os vértices do gráfico em largura.