2024年Java最新Brandes算法计算无向图节点最短路径之和-Java代码实现，hash、set、zset的底层数据结构原理

读者福利

由于篇幅过长，就不展示所有面试题了，感兴趣的小伙伴

更多笔记分享

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

  "source": "4.1",
  "target": "2.3"
 },
{
  "id":"e5",
  "source": "4.4",
  "target": "1.1"
 },
{
  "id":"e6",
  "source": "1.2",
  "target": "1.1"
 }
]

}

        这是示例数组对应的无向图：


![](https://img-blog.csdnimg.cn/direct/d62526d64f364164a559506e1acde436.png)


        我们假设上图中每个节点间的距离均为“1”，如下图所示，例如，我们选取节点“3.1”计算其到其他节点最短路径之和：


![](https://img-blog.csdnimg.cn/direct/97684309c32a4aeeb8d053030afea0d1.png)


        “3.1”到“4.1”和“4.4”距离均为“1”，“3.1”到“1.1”和“2.3”距离均为“2”，“3.1”到“1.2”距离为“3”


        那么，节点“3.1”计算其到其他节点最短路径之和为：1+1+2+2+3=9


        同理，我们可以计算出其他节点的相应的最短路径之和。


## 三、Java代码实现


        利用Brandes算法，我们能够在无向图中更轻松地计算出每个节点到其他节点最短路径之和。


        以下是Java代码：

// 导入必要的库，用于处理JSON数据及集合操作
import org.json.JSONArray;
import org.json.JSONObject;
import java.util.*;

public class Main {

public static void main(String[] args) {
    // 获取JSON对象，该对象包含了图的节点和边信息
    JSONObject graphJson = getJsonObject();

    // 创建邻接表表示图结构，键为节点ID，值为连接到该节点的所有节点ID列表
    Map<String, List<String>> adjacencyList = new HashMap<>();
    // 创建一个HashSet存储所有节点ID
    Set<String> nodesSet = new HashSet<>();

    // 解析JSON对象中的"nodes"数组，获取所有节点ID并添加到nodesSet中
    JSONArray nodesArray = graphJson.getJSONArray("nodes");
    for (int i = 0; i < nodesArray.length(); i++) {
        JSONObject nodeObj = nodesArray.getJSONObject(i);
        String nodeId = nodeObj.getString("id");
        nodesSet.add(nodeId);
    }

    // 解析JSON对象中的"edges"数组，构建邻接表
    JSONArray edgesArray = graphJson.getJSONArray("edges");
    for (int i = 0; i < edgesArray.length(); i++) {
        JSONObject edgeObj = edgesArray.getJSONObject(i);
        String source = edgeObj.getString("source");
        String target = edgeObj.getString("target");

        // 假设图是无向的，所以在邻接表中双向添加边
        adjacencyList.computeIfAbsent(source, k -> new ArrayList<>()).add(target);
        adjacencyList.computeIfAbsent(target, k -> new ArrayList<>()).add(source);
    }

    // 计算并存储每个节点的中介中心性
    Map<String, Double> nodeCentralities = new HashMap<>();
    for (String nodeId : nodesSet) {
        double centrality = calculateBetweennessCentrality(adjacencyList, nodeId);
        nodeCentralities.put(nodeId, centrality);
    }

    // 将节点按照其中介中心性降序排列
    List<Map.Entry<String, Double>> sortedNodes = new ArrayList<>(nodeCentralities.entrySet());
    sortedNodes.sort(Map.Entry.comparingByValue(Comparator.reverseOrder()));

    // 输出每个节点及其对应的中介中心性
    System.out.println("节点：该节点到其他节点最短路径距离之和：");
    for (Map.Entry<String, Double> entry : sortedNodes) {
        System.out.println(entry.getKey() + ": " + entry.getValue());
    }
}

// 从固定JSON字符串中创建并返回JSONObject
private static JSONObject getJsonObject() {
    String jsonData = "{\"nodes\":[\n" +
            "{\"id\":\"3.1\"},\n" +
            "{\"id\":\"4.1\"},\n" +
            "{\"id\":\"4.4\"},\n" +
            "{\"id\":\"2.3\"},\n" +
            "{\"id\":\"1.1\"},\n" +
            "{\"id\":\"1.2\"}\n" +
            "],\n" +
            "\"edges\": [\n" +
            " {\n" +
            " \"id\":\"e1\",\n" +
            " \"source\": \"3.1\",\n" +
            " \"target\": \"4.1\"\n" +
            " },\n" +
            " {\n" +
            " \"id\":\"e2\",\n" +
            " \"source\": \"4.4\",\n" +
            " \"target\": \"4.1\"\n" +
            " },\n" +
            " {\n" +
            " \"id\":\"e3\",\n" +
            " \"source\": \"3.1\",\n" +
            " \"target\": \"4.4\"\n" +
            " },\n" +
            " {\n" +
            " \"id\":\"e4\",\n" +
            " \"source\": \"4.1\",\n" +
            " \"target\": \"2.3\"\n" +
            " },\n" +
            " {\n" +
            " \"id\":\"e5\",\n" +
            " \"source\": \"4.4\",\n" +
            " \"target\": \"1.1\"\n" +
            " },\n" +
            " {\n" +
            " \"id\":\"e6\",\n" +
            " \"source\": \"1.2\",\n" +
            " \"target\": \"1.1\"\n" +
            " }\n" +
            " ]\n}";

    JSONObject graphJson = new JSONObject(jsonData);
    return graphJson;
}


// 根据给定的邻接表和节点ID，计算该节点的中介中心性
private static double calculateBetweennessCentrality(Map<String, List<String>> graph, String node) {
    // 初始化用于计算中介中心性的三个HashMap
    Map<String, Integer> sigma = new HashMap<>();
    Map<String, Double> delta = new HashMap<>();
    Map<String, Double> betweenness = new HashMap<>();

    // 初始化所有节点的sigma、delta和betweenness值
    for (String v : graph.keySet()) {
        sigma.put(v, 0);
        delta.put(v, 0.0);
        betweenness.put(v, 0.0);
    }

    // 设置当前节点的sigma值为1
    sigma.put(node, 1);

    // 创建队列（BFS）和栈（用于回溯），以及预处理器列表和距离映射表
    Queue<String> queue = new LinkedList<>();
    Stack<String> stack = new Stack<>();
    Map<String, List<String>> predecessors = new HashMap<>();
    Map<String, Integer> distances = new HashMap<>();

    // 初始化所有节点的预处理器列表和距离值
    for (String v : graph.keySet()) {
        predecessors.put(v, new ArrayList<>());
        distances.put(v, -1);
    }

    // 将当前节点加入队列，并设置距离为0
    queue.offer(node);
    distances.put(node, 0);

    // 开始广度优先搜索（BFS）
    while (!queue.isEmpty()) {

面试题总结

其它面试题（springboot、mybatis、并发、java中高级面试总结等）

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

[外链图片转存中…(img-OlLGFfJM-1714905836754)]

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取