Java 无向图无权两点最短路径

原创

mob64ca12d1a59e 2024-09-06 04:10:15 ©著作权

©著作权归作者所有：来自51CTO博客作者mob64ca12d1a59e的原创作品，请联系作者获取转载授权，否则将追究法律责任

Java 无向图无权两点最短路径

在计算机科学中，图是一种重要的数据结构，广泛用于表示事物之间的关系。无向图是一种特殊的图，边没有方向。无权图则指的是边没有特定的权重。在实际应用中，常常需要找到无权图中两个节点之间的最短路径。本文将介绍如何使用Java实现这一目标，结合代码示例和视觉化状态图进行说明。

基本概念

在图论中，无向图由节点（顶点）和连接节点的边组成。我们可以使用邻接表或邻接矩阵来表示图。无权图的最短路径通常可以通过广度优先搜索（BFS）算法来实现，因其能有效找到最短路径。

BFS 算法原理

广度优先搜索从起始节点开始，逐层向外扩展，直到找到目标节点。由于无权图的特点，BFS 可以确保第一次到达目标节点时，这条路径就是最短路径。

实现步骤

1. 定义图的结构

我们使用邻接列表来表示无向图。使用 HashMap 或 ArrayList 可以方便实现。

import java.util.*;

class Graph {
    private Map<Integer, List<Integer>> adjList;

    public Graph() {
        this.adjList = new HashMap<>();
    }

    public void addEdge(int src, int dest) {
        adjList.putIfAbsent(src, new ArrayList<>());
        adjList.putIfAbsent(dest, new ArrayList<>());
        adjList.get(src).add(dest);
        adjList.get(dest).add(src); // 无向图双向添加
    }

    public List<Integer> getAdj(int node) {
        return adjList.getOrDefault(node, new ArrayList<>());
    }
}

2. 实现 BFS 算法

BFS 算法需要一个队列来跟踪正在探索的节点和它们的路径。

class ShortestPath {
    public List<Integer> bfs(Graph graph, int start, int target) {
        Queue<Integer> queue = new LinkedList<>();
        Map<Integer, Integer> prevNode = new HashMap<>();
        Set<Integer> visited = new HashSet<>();

        queue.add(start);
        visited.add(start);
        
        while (!queue.isEmpty()) {
            int current = queue.poll();
            if (current == target) {
                return buildPath(prevNode, target);
            }
            for (int neighbor : graph.getAdj(current)) {
                if (!visited.contains(neighbor)) {
                    visited.add(neighbor);
                    queue.add(neighbor);
                    prevNode.put(neighbor, current);
                }
            }
        }
        return Collections.emptyList(); // 找不到路径
    }

    private List<Integer> buildPath(Map<Integer, Integer> prevNode, int target) {
        List<Integer> path = new LinkedList<>();
        for (Integer at = target; at != null; at = prevNode.get(at)) {
            path.add(at);
        }
        Collections.reverse(path);
        return path;
    }
}

3. 主方法及示例

最后，我们在主方法中创建图，并调用 BFS 方法，找到最短路径。

public class Main {
    public static void main(String[] args) {
        Graph graph = new Graph();
        
        // 添加边
        graph.addEdge(1, 2);
        graph.addEdge(1, 3);
        graph.addEdge(2, 4);
        graph.addEdge(3, 4);
        graph.addEdge(3, 5);
        graph.addEdge(4, 5);
        
        ShortestPath sp = new ShortestPath();
        List<Integer> path = sp.bfs(graph, 1, 5);
        
        System.out.println("最短路径: " + path);
    }
}

结果分析

通过运行上述代码，我们可以得到从节点 1 到节点 5 的最短路径。可能的输出为 最短路径: [1, 3, 5]，这表明节点 1 到 3 是最短路径之一，接着再到 5。

状态图

以下是使用 Mermaid 语法描述 BFS 算法的状态图，便于理解算法的流程。

stateDiagram
    [*] --> Start
    Start --> CheckQueue
    CheckQueue --> ProcessNode : 队列不为空
    ProcessNode --> CheckForTarget
    CheckForTarget --> AddNeighbors : 未找到目标
    AddNeighbors --> CheckQueue
    CheckForTarget --> PathFound : 找到目标
    PathFound --> [*]
    ProcessNode --> End : 队列为空