Java中链表相等性检查：常见陷阱与最佳实践

public static boolean checkEquality(Node n, Node m) {
    if(n != null && m != null) {
        boolean res = false;
        while(n!=null) { // 问题1：循环条件只检查了n
            if(n.getElem()==m.getElem()) { // 问题2：使用==比较对象，且未考虑m可能为null
                n = n.getNext();
                m = m.getNext();
                res = true; // 问题3：res在循环中被不当地覆盖
            }
            else
            {
                res = false; // 问题3：res在循环中被不当地覆盖
            }
        }
        return res; // 问题4：最终返回的res不准确
    }
    else // 处理空链表的情况
    {
        System.out.println("Lists empty!"); // 额外的输出，不影响逻辑，但非必要
        return true; // 问题5：两个链表都为空时返回true，但如果一个为空一个不为空，这里没有区分
    }
}

import java.util.Objects; // 引入Objects类，用于安全地比较可能为null的对象

public class LinkedListComparator {

    /**
     * 比较两个链表是否完全相等。
     * 两个链表相等当且仅当它们具有相同的长度，且在对应位置上的所有元素都相等。
     *
     * @param n 第一个链表的头节点
     * @param m 第二个链表的头节点
     * @return 如果两个链表完全相等则返回 true，否则返回 false
     */
    public static boolean checkEquality(Node n, Node m) {
        // 1. 同步遍历两个链表，只要其中一个到达末尾就停止
        while (n != null && m != null) {
            // 2. 比较当前节点元素。使用 Objects.equals() 确保安全处理 null 值。
            // 如果元素不相等，则链表不相等，立即返回 false。
            // 假设 Node.getElem() 返回的是 Object 类型，否则可直接使用 == 对于基本类型。
            if (!Objects.equals(n.getElem(), m.getElem())) {
                return false;
            }
            // 3. 移动到下一个节点
            n = n.getNext();
            m = m.getNext();
        }

        // 4. 循环结束后，检查两个链表是否都已到达末尾（即都为 null）。
        // 如果 n 和 m 都为 null，说明两个链表长度相同且所有元素都已比较完毕并相等。
        // 如果其中一个为 null 而另一个不为 null，说明它们长度不同，因此不相等。
        return n == null && m == null;
    }

    // 假设 Node 类定义如下，实际应用中可能有所不同
    static class Node {
        Object elem; // 节点元素可以是任意类型
        Node next;

        public Node(Object elem) {
            this.elem = elem;
            this.next = null;
        }

        public Object getElem() {
            return elem;
        }

        public Node getNext() {
            return next;
        }

        public void setNext(Node next) {
            this.next = next;
        }
    }

    // 示例用法
    public static void main(String[] args) {
        // 示例1: 相等的链表
        Node list1a = new Node(1);
        list1a.setNext(new Node(2));
        Node list1b = new Node(1);
        list1b.setNext(new Node(2));
        System.out.println("List1a == List1b: " + checkEquality(list1a, list1b)); // true

        // 示例2: 长度不同的链表
        Node list2a = new Node(1);
        list2a.setNext(new Node(2));
        Node list2b = new Node(1);
        list2b.setNext(new Node(2));
        list2b.getNext().setNext(new Node(3));
        System.out.println("List2a == List2b: " + checkEquality(list2a, list2b)); // false

        // 示例3: 元素不等的链表
        Node list3a = new Node(1);
        list3a.setNext(new Node(2));
        Node list3b = new Node(1);
        list3b.setNext(new Node(3));
        System.out.println("List3a == List3b: " + checkEquality(list3a, list3b)); // false

        // 示例4: 两个空链表
        Node list4a = null;
        Node list4b = null;
        System.out.println("List4a == List4b: " + checkEquality(list4a, list4b)); // true

        // 示例5: 一个空链表，一个非空链表
        Node list5a = null;
        Node list5b = new Node(1);
        System.out.println("List5a == List5b: " + checkEquality(list5a, list5b)); // false

        // 示例6: 链表包含null元素
        Node list6a = new Node("A");
        list6a.setNext(new Node(null));
        list66a.setNext(new Node("C"));

        Node list6b = new Node("A");
        list6b.setNext(new Node(null));
        list6b.getNext().setNext(new Node("C"));
        System.out.println("List6a == List6b: " + checkEquality(list6a, list6b)); // true

        Node list7a = new Node("A");
        list7a.setNext(new Node(null));
        list7a.getNext().setNext(new Node("C"));

        Node list7b = new Node("A");
        list7b.setNext(new Node("B")); // 这里不同
        list7b.getNext().setNext(new Node("C"));
        System.out.println("List7a == List7b: " + checkEquality(list7a, list7b)); // false
    }
}