Java&C++编程复习：链式前向星解leetcode310最小高度树

前言

大家好，我是技术博客创作专家，今天我将与大家分享一篇关于Java&C++编程复习的文章，题目是leetcode310.最小高度树，使用链式前向星数据结构进行求解。

正文

leetcode310.最小高度树

leetcode310.最小高度树是一道经典的图论题目，题目如下：

给定一个无向图，找到该图的最小高度树。

最小高度树的定义

最小高度树是指一棵树，从树的根节点到任何一个叶子节点的最长路径长度是最短的。

链式前向星数据结构

链式前向星数据结构是一种存储图信息的常见数据结构，它使用数组和链表来存储图中的边。链式前向星数据结构的特点是空间复杂度低，查询效率高，非常适合存储稀疏图。

Java代码

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

public class Solution {

    public TreeNode findMinHeightTree(int n, int[][] edges) {
        // 创建图
        List<List<Integer>> graph = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            graph.add(new ArrayList<>());
        }
        for (int[] edge : edges) {
            int u = edge[0], v = edge[1];
            graph.get(u).add(v);
            graph.get(v).add(u);
        }

        // 找到图的直径
        int[] diameter = findDiameter(graph);
        int start = diameter[0], end = diameter[1];

        // 找到从start到end的最长路径
        int[] path = findLongestPath(graph, start, end);
        int root = path[0];

        // 返回根节点
        return new TreeNode(root);
    }

    private int[] findDiameter(List<List<Integer>> graph) {
        // 广度优先搜索
        Queue<Integer> queue = new LinkedList<>();
        boolean[] visited = new boolean[graph.size()];
        int[] distance = new int[graph.size()];

        // 从第一个节点开始搜索
        queue.offer(0);
        visited[0] = true;

        // 记录最远节点和距离
        int maxDistance = 0, farthestNode = 0;
        while (!queue.isEmpty()) {
            int u = queue.poll();
            for (int v : graph.get(u)) {
                if (!visited[v]) {
                    queue.offer(v);
                    visited[v] = true;
                    distance[v] = distance[u] + 1;
                    if (distance[v] > maxDistance) {
                        maxDistance = distance[v];
                        farthestNode = v;
                    }
                }
            }
        }

        // 返回最远节点和距离
        return new int[]{farthestNode, maxDistance};
    }

    private int[] findLongestPath(List<List<Integer>> graph, int start, int end) {
        // 广度优先搜索
        Queue<Integer> queue = new LinkedList<>();
        boolean[] visited = new boolean[graph.size()];
        int[] distance = new int[graph.size()];

        // 从start节点开始搜索
        queue.offer(start);
        visited[start] = true;

        // 记录最远节点和距离
        int maxDistance = 0, farthestNode = 0;
        while (!queue.isEmpty()) {
            int u = queue.poll();
            for (int v : graph.get(u)) {
                if (!visited[v]) {
                    queue.offer(v);
                    visited[v] = true;
                    distance[v] = distance[u] + 1;
                    if (distance[v] > maxDistance) {
                        maxDistance = distance[v];
                        farthestNode = v;
                    }
                }
            }
        }

        // 返回最远节点和距离
        return new int[]{farthestNode, maxDistance};
    }

    public static void main(String[] args) {
        Solution solution = new Solution();

        // 测试用例
        int n = 6;
        int[][] edges = {{0, 1}, {0, 2}, {1, 3}, {1, 4}, {2, 5}};
        TreeNode root = solution.findMinHeightTree(n, edges);

        // 打印结果
        System.out.println(root.val);
    }
}

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int val) {
        this.val = val;
    }
}

C++代码

#include <vector>
#include <queue>
#include <iostream>

using namespace std;

class Solution {
public:
    TreeNode* findMinHeightTree(int n, vector<vector<int>>& edges) {
        // 创建图
        vector<vector<int>> graph(n);
        for (auto& edge : edges) {
            int u = edge[0], v = edge[1];
            graph[u].push_back(v);
            graph[v].push_back(u);
        }

        // 找到图的直径
        int[] diameter = findDiameter(graph);
        int start = diameter[0], end = diameter[1];

        // 找到从start到end的最长路径
        int[] path = findLongestPath(graph, start, end);
        int root = path[0];

        // 返回根节点
        return new TreeNode(root);
    }

private:
    int[] findDiameter(vector<vector<int>>& graph) {
        // 广度优先搜索
        queue<int> queue;
        vector<bool> visited(graph.size(), false);
        vector<int> distance(graph.size(), 0);

        // 从第一个节点开始搜索
        queue.push(0);
        visited[0] = true;

        // 记录最远节点和距离