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()) { // 使用 == 比较元素，不适用于对象类型
                n = n.getNext();
                m = m.getNext();
                res = true; // 即使之前不匹配，也会被覆盖为true
            }
            else
            {
                res = false; // 发现不匹配后，继续循环，res可能被后续操作覆盖
            }
        }
        return res; // 返回最后一次循环的结果
    }
    else
    {
        System.out.println("Lists empty!"); // 打印信息
        return true; // 如果一个或两个列表初始为空，则返回true，这对于一个为空一个不为空的情况是错误的
    }
}

import java.util.Objects; // 导入Objects类以使用Objects.equals()

// 假设Node类的定义如下：
// class Node {
//     Object elem; // 元素可以是任意类型
//     Node next;
//
//     public Node(Object elem, Node next) {
//         this.elem = elem;
//         this.next = next;
//     }
//
//     public Object getElem() {
//         return elem;
//     }
//
//     public Node getNext() {
//         return next;
//     }
// }

public class LinkedListEqualityChecker {

    /**
     * 检查两个链表是否完全相等。
     * 两个链表相等意味着它们具有相同的长度，并且在每个对应位置上的元素值也完全一致。
     *
     * @param n 第一个链表的头节点
     * @param m 第二个链表的头节点
     * @return 如果两个链表相等则返回 true，否则返回 false
     */
    public static boolean checkEquality(Node n, Node m) {
        // 只要两个链表中的任何一个还未到达末尾，就继续循环
        while (n != null && m != null) {
            // 比较当前节点存储的元素。
            // 使用 Objects.equals() 是最安全的方式，它能正确处理元素为 null 的情况，
            // 并且会调用元素的 equals() 方法进行内容比较，而非引用比较。
            if (!Objects.equals(n.getElem(), m.getElem())) {
            // 如果确定 getElem() 返回的总是基本类型或其包装类，
            // 且不考虑元素本身可能为null的情况，也可以使用 if (n.getElem() != m.getElem())
            // 但 Objects.equals() 更通用和健壮。
                return false; // 发现任何不匹配，立即返回 false
            }
            // 移动到下一个节点
            n = n.getNext();
            m = m.getNext();
        }

        // 循环结束后，两个链表都必须同时到达末尾才算相等。
        // 这解决了长度不一致的问题：
        // 如果 n 和 m 同时为 null，表示两个链表长度相同且元素都匹配。
        // 如果一个为 null 另一个不为 null，表示长度不一致，则返回 false。
        return n == null && m == null;
    }

    // 示例用法
    public static void main(String[] args) {
        // 链表1: 1 -> 2 -> 3
        Node list1_3 = new Node(3, null);
        Node list1_2 = new Node(2, list1_3);
        Node list1_1 = new Node(1, list1_2);

        // 链表2: 1 -> 2 -> 3 (与链表1相同)
        Node list2_3 = new Node(3, null);
        Node list2_2 = new Node(2, list2_3);
        Node list2_1 = new Node(1, list2_2);

        // 链表3: 1 -> 2 -> 4 (与链表1不同)
        Node list3_3 = new Node(4, null);
        Node list3_2 = new Node(2, list3_3);
        Node list3_1 = new Node(1, list3_2);

        // 链表4: 1 -> 2 (比链表1短)
        Node list4_2 = new Node(2, null);
        Node list4_1 = new Node(1, list4_2);

        // 链表5: 1 -> 2 -> 3 -> 4 (比链表1长)
        Node list5_4 = new Node(4, null);
        Node list5_3 = new Node(3, list5_4);
        Node list5_2 = new Node(2, list5_3);
        Node list5_1 = new Node(1, list5_2);

        // 空链表
        Node emptyList = null;

        System.out.println("List1 == List2? " + checkEquality(list1_1, list2_1)); // true
        System.out.println("List1 == List3? " + checkEquality(list1_1, list3_1)); // false
        System.out.println("List1 == List4? " + checkEquality(list1_1, list4_1)); // false
        System.out.println("List1 == List5? " + checkEquality(list1_1, list5_1)); // false
        System.out.println("EmptyList == EmptyList? " + checkEquality(emptyList, emptyList)); // true
        System.out.println("List1 == EmptyList? " + checkEquality(list1_1, emptyList)); // false
        System.out.println("EmptyList == List1? " + checkEquality(emptyList, list1_1)); // false

        // 包含null元素的链表
        Node listWithNull_2 = new Node(null, null);
        Node listWithNull_1 = new Node(1, listWithNull_2);

        Node listWithNull_B_2 = new Node(null, null);
        Node listWithNull_B_1 = new Node(1, listWithNull_B_2);

        Node listWithNull_C_2 = new Node(2, null);
        Node listWithNull_C_1 = new Node(1, listWithNull_C_2);

        System.out.println("ListWithNull_A == ListWithNull_B? " + checkEquality(listWithNull_1, listWithNull_B_1)); // true
        System.out.println("ListWithNull_A == ListWithNull_C? " + checkEquality(listWithNull_1, listWithNull_C_1)); // false
    }
}