深入理解链表头节点：初始化、使用与最佳实践

public class ListNode {
    int val;
    ListNode next;

    // 构造函数
    ListNode() {}
    ListNode(int val) { this.val = val; }
    ListNode(int val, ListNode next) { this.val = val; this.next = next; }
}

public class Main {
    public static void main(String[] args) {
        // 创建一个链表: 1 -> 1 -> 2 -> 3 -> 3
        ListNode head = new ListNode(1);
        head.next = new ListNode(1);
        head.next.next = new ListNode(2);
        head.next.next.next = new ListNode(3);
        head.next.next.next.next = new ListNode(3);

        // 调用去重方法
        Solution solution = new Solution(); // 假设 deleteDuplicates 在 Solution 类中
        ListNode distinctHead = solution.deleteDuplicates(head);

        // 打印去重后的链表
        printList(distinctHead); // 预期输出: 1 -> 2 -> 3 -> null
    }

    public static void printList(ListNode node) {
        while (node != null) {
            System.out.print(node.val + " -> ");
            node = node.next;
        }
        System.out.println("null");
    }
}

public class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        // 处理链表为空或只有一个节点的情况
        if (head == null || head.next == null) {
            return head;
        }

        ListNode node = head; // 存储原始头节点引用

        // 循环遍历链表
        while (head != null && head.next != null) {
            if (head.val == head.next.val) {
                // 如果当前节点与下一个节点值相同，则跳过下一个节点（删除重复项）
                head.next = head.next.next;
            } else {
                // 如果不同，则移动到下一个节点
                head = head.next;
            }
        }
        return node; // 返回原始头节点引用
    }
}

public class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        // 处理链表为空或只有一个节点的情况
        if (head == null || head.next == null) {
            return head;
        }

        // 使用一个独立的指针 'current' 来遍历链表，
        // 保持 'head' 指针不变，它始终指向链表的原始头部。
        ListNode current = head;

        while (current != null && current.next != null) {
            if (current.val == current.next.val) {
                // 如果当前节点与下一个节点值相同，跳过下一个节点
                // 注意：这里修改的是 current.next，而不是 current 本身，
                // 这样 current 仍然指向当前节点，下次循环会再次检查新的 current.next
                current.next = current.next.next;
            } else {
                // 如果不同，则移动 'current' 到下一个节点
                current = current.next;
            }
        }
        // 返回原始的 head 引用
        return head;
    }
}