跨越编程界限：Java、C++与Rust征服LeetCode 817

2023-09-11 12:49:02

Java Vs. C++ Vs. Rust：LeetCode 817的编程语言大比拼

跨越编程界限，我们以LeetCode 817题（链表组件）为试炼场，检验Java、C++和Rust这三大编程语言的优异表现。这道题要求计算链表中连通分量的个数，让我们一探它们在这场比拼中的精彩表现！

Java：优雅与简洁并存

Java以其简洁的语法、面向对象的设计以及庞大的社区而著称，它在LeetCode 817题中的解决方案体现了这些优势。从定义LinkedList类到使用深度优先搜索算法，Java的代码行云流水，优雅且高效。

class Solution {
    public int numComponents(ListNode head) {
        int components = 0;
        Set<ListNode> visited = new HashSet<>();
        ListNode current = head;
        while (current != null) {
            if (!visited.contains(current)) {
                components++;
                dfs(current, visited);
            }
            current = current.next;
        }
        return components;
    }

    private void dfs(ListNode node, Set<ListNode> visited) {
        if (node == null || visited.contains(node)) {
            return;
        }
        visited.add(node);
        dfs(node.next, visited);
    }
}

C++：力量与速度兼备

C++以其强大的性能和对底层硬件的直接访问而闻名，它在LeetCode 817题中的解决方案充分展现了这些优势。C++的代码简洁高效，充分利用了指针和引用，同时使用unordered_set数据结构来存储已访问的节点，确保算法的快速执行。

class Solution {
public:
    int numComponents(ListNode* head) {
        int components = 0;
        unordered_set<ListNode*> visited;
        ListNode* current = head;
        while (current) {
            if (!visited.count(current)) {
                components++;
                dfs(current, visited);
            }
            current = current->next;
        }
        return components;
    }

private:
    void dfs(ListNode* node, unordered_set<ListNode*>& visited) {
        if (!node || visited.count(node)) {
            return;
        }
        visited.insert(node);
        dfs(node->next, visited);
    }
};

Rust：新星的闪耀与活力

Rust以其内存安全、高性能以及丰富的标准库而备受关注，它在LeetCode 817题中的解决方案展示了这些特性。Rust的代码清晰易读，使用HashSet数据结构来存储已访问的节点，同时使用递归来遍历链表，让算法更加简洁高效。

struct Solution;

impl Solution {
    pub fn num_components(head: Option<&ListNode>) -> i32 {
        let mut visited = HashSet::new();
        let mut components = 0;

        for node in head {
            if !visited.contains(node) {
                components += 1;
                Self::dfs(node, &mut visited);
            }
        }

        components
    }

    fn dfs(node: &ListNode, visited: &mut HashSet<&ListNode>) {
        visited.insert(node);
        if let Some(next) = &node.next {
            if !visited.contains(next) {
                Self::dfs(next, visited);
            }
        }
    }
}