如何在Java中实现高效的图算法：从Dijkstra到Bellman-Ford的应用-CSDN博客

本文链接：https://blog.csdn.net/weixin_44409190/article/details/141108931

如何在Java中实现高效的图算法：从Dijkstra到Bellman-Ford的应用

大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！今天我们来探讨如何在Java中实现高效的图算法，重点关注Dijkstra和Bellman-Ford算法的应用与实现。

一、图算法简介

图算法是计算机科学中处理图结构（如网络、路径、关系等）的重要工具。在图算法中，Dijkstra和Bellman-Ford是最常用的两种单源最短路径算法。它们被广泛应用于网络路由、地图导航、社交网络分析等领域。

1.1 Dijkstra算法

Dijkstra算法是一种贪心算法，专门用于解决加权图中单源最短路径问题。它的时间复杂度为O(V^2)（V为顶点数），在使用优先队列时，可以降低到O(E + V log V)（E为边数）。

示例代码：

import cn.juwatech.graph.DijkstraExample;
import java.util.*;

public class DijkstraExample {
    private static final int INF = Integer.MAX_VALUE;

    public static class Node implements Comparable<Node> {
        int vertex;
        int distance;

        public Node(int vertex, int distance) {
            this.vertex = vertex;
            this.distance = distance;
        }

        @Override
        public int compareTo(Node other) {
            return Integer.compare(this.distance, other.distance);
        }
    }

    public static void dijkstra(int[][] graph, int source) {
        int V = graph.length;
        int[] dist = new int[V];
        boolean[] visited = new boolean[V];
        Arrays.fill(dist, INF);
        dist[source] = 0;

        PriorityQueue<Node> pq = new PriorityQueue<>();
        pq.add(new Node(source, 0));

        while (!pq.isEmpty()) {
            int u = pq.poll().vertex;

            if (visited[u]) continue;
            visited[u] = true;

            for (int v = 0; v < V; v++) {
                if (!visited[v] && graph[u][v] != 0 && dist[u] + graph[u][v] < dist[v]) {
                    dist[v] = dist[u] + graph[u][v];
                    pq.add(new Node(v, dist[v]));
                }
            }
        }

        // 输出结果
        System.out.println("顶点 " + source + " 到各个顶点的最短距离：");
        for (int i = 0; i < V; i++) {
            System.out.println("到顶点 " + i + " 的距离: " + (dist[i] == INF ? "无法到达" : dist[i]));
        }
    }

    public static void main(String[] args) {
        int[][] graph = {
                {0, 10, 0, 30, 100},
                {10, 0, 50, 0, 0},
                {0, 50, 0, 20, 10},
                {30, 0, 20, 0, 60},
                {100, 0, 10, 60, 0},
        };
        dijkstra(graph, 0);
    }
}

1.2 Bellman-Ford算法

Bellman-Ford算法是一种动态规划算法，用于解决单源最短路径问题，特别是可以处理包含负权边的图。它的时间复杂度为O(VE)，适用于边数较少的图。

示例代码：

import cn.juwatech.graph.BellmanFordExample;

public class BellmanFordExample {
    private static final int INF = Integer.MAX_VALUE;

    public static class Edge {
        int src, dest, weight;

        public Edge(int src, int dest, int weight) {
            this.src = src;
            this.dest = dest;
            this.weight = weight;
        }
    }

    public static void bellmanFord(Edge[] edges, int V, int E, int source) {
        int[] dist = new int[V];
        for (int i = 0; i < V; i++) {
            dist[i] = INF;
        }
        dist[source] = 0;

        for (int i = 1; i < V; i++) {
            for (int j = 0; j < E; j++) {
                int u = edges[j].src;
                int v = edges[j].dest;
                int weight = edges[j].weight;
                if (dist[u] != INF && dist[u] + weight < dist[v]) {
                    dist[v] = dist[u] + weight;
                }
            }
        }

        // 检查负权环
        for (int j = 0; j < E; j++) {
            int u = edges[j].src;
            int v = edges[j].dest;
            int weight = edges[j].weight;
            if (dist[u] != INF && dist[u] + weight < dist[v]) {
                System.out.println("图中包含负权环");
                return;
            }
        }

        // 输出结果
        System.out.println("顶点 " + source + " 到各个顶点的最短距离：");
        for (int i = 0; i < V; i++) {
            System.out.println("到顶点 " + i + " 的距离: " + (dist[i] == INF ? "无法到达" : dist[i]));
        }
    }

    public static void main(String[] args) {
        int V = 5;  // 顶点数
        int E = 8;  // 边数
        Edge[] edges = {
                new Edge(0, 1, -1),
                new Edge(0, 2, 4),
                new Edge(1, 2, 3),
                new Edge(1, 3, 2),
                new Edge(1, 4, 2),
                new Edge(3, 2, 5),
                new Edge(3, 1, 1),
                new Edge(4, 3, -3)
        };

        bellmanFord(edges, V, E, 0);
    }
}