Java中链表相等性判断的正确实践与常见陷阱

public static boolean checkEquality(Node n, Node m) {
    if (n != null && m != null) {
        boolean res = false; // 初始值不应为 false
        while (n != null) { // 仅检查了 n 的非空性
            if (n.getElem() == m.getElem()) { // 对象比较应使用 .equals()
                n = n.getNext();
                m = m.getNext();
                res = true; // 即使后续不匹配，也可能被设为 true
            } else {
                res = false; // 无法及时返回，且可能被覆盖
            }
        }
        return res;
    } else {
        // 这里的逻辑可能意味着一个或两个为空，但返回 true 并不总是正确
        System.out.println("Lists empty!");
        return true;
    }
}

import java.util.Objects; // 引入 Objects 类用于安全的元素比较

/**
 * 比较两个链表是否完全相等。
 * 链表相等意味着它们具有相同的长度，且在每个对应位置上的元素值都相等。
 *
 * @param n 第一个链表的头节点。
 * @param m 第二个链表的头节点。
 * @return 如果两个链表相等则返回 true，否则返回 false。
 */
public class LinkedListComparator {

    // 假设 Node 类定义如下，包含一个泛型元素和指向下一个节点的引用
    static class Node<T> {
        T elem;
        Node<T> next;

        public Node(T elem, Node<T> next) {
            this.elem = elem;
            this.next = next;
        }

        public T getElem() {
            return elem;
        }

        public Node<T> getNext() {
            return next;
        }
    }

    public static <T> boolean checkEquality(Node<T> n, Node<T> m) {
        // 循环条件：只要两个链表中的任何一个还有节点，就继续
        while (n != null && m != null) {
            // 比较当前节点的元素。使用 Objects.equals() 可以安全地处理 null 值。
            // 对于基本数据类型，直接使用 != 也可以，但 Objects.equals() 更通用且安全。
            if (!Objects.equals(n.getElem(), m.getElem())) {
                return false; // 发现不匹配，立即返回 false
            }
            // 移动到下一个节点
            n = n.getNext();
            m = m.getNext();
        }
        // 循环结束后，如果两个链表都同时到达末尾（都为 null），则表示它们相等。
        // 这同时检查了长度是否一致。
        return n == null && m == null;
    }

    // 示例用法
    public static void main(String[] args) {
        // 示例 1: 两个相等的链表
        Node<Integer> list1_1 = new Node<>(1, new Node<>(2, new Node<>(3, null)));
        Node<Integer> list1_2 = new Node<>(1, new Node<>(2, new Node<>(3, null)));
        System.out.println("List1_1 == List1_2: " + checkEquality(list1_1, list1_2)); // true

        // 示例 2: 元素不相等的链表
        Node<Integer> list2_1 = new Node<>(1, new Node<>(2, new Node<>(3, null)));
        Node<Integer> list2_2 = new Node<>(1, new Node<>(2, new Node<>(4, null)));
        System.out.println("List2_1 == List2_2: " + checkEquality(list2_1, list2_2)); // false

        // 示例 3: 长度不相等的链表
        Node<Integer> list3_1 = new Node<>(1, new Node<>(2, null));
        Node<Integer> list3_2 = new Node<>(1, new Node<>(2, new Node<>(3, null)));
        System.out.println("List3_1 == List3_2: " + checkEquality(list3_1, list3_2)); // false

        // 示例 4: 包含 null 元素的链表
        Node<String> list4_1 = new Node<>("A", new Node<>(null, new Node<>("C", null)));
        Node<String> list4_2 = new Node<>("A", new Node<>(null, new Node<>("C", null)));
        System.out.println("List4_1 == List4_2: " + checkEquality(list4_1, list4_2)); // true

        // 示例 5: 一个空链表，一个非空链表
        Node<Integer> list5_1 = null;
        Node<Integer> list5_2 = new Node<>(1, null);
        System.out.println("List5_1 == List5_2: " + checkEquality(list5_1, list5_2)); // false

        // 示例 6: 两个空链表
        Node<Integer> list6_1 = null;
        Node<Integer> list6_2 = null;
        System.out.println("List6_1 == List6_2: " + checkEquality(list6_1, list6_2)); // true
    }
}