链表头节点：理解、初始化与LeetCode 83去重算法中的最佳实践

// 假设 ListNode 类已定义，包含 val 和 next 字段
// 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) {
        // 在 main 方法中初始化一个链表：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 类的实例并调用 deleteDuplicates 方法
        Solution solution = new Solution();
        ListNode distinctHead = solution.deleteDuplicates(head);

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

    // 辅助方法：打印链表内容
    public static void printList(ListNode node) {
        while (node != null) {
            System.out.print(node.val + (node.next != null ? " -> " : ""));
            node = node.next;
        }
        System.out.println();
    }
}

// Solution 类将包含 deleteDuplicates 方法
class Solution {
    // ... deleteDuplicates 方法将在此处实现 ...
}

public ListNode deleteDuplicates(ListNode head) {
    if(head==null || head.next==null)return head;
    ListNode node=head; // 备份原始头节点
    while(head!=null && head.next!=null){ // 直接使用 head 进行遍历和修改
        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) {
        // 1. 处理基本情况：链表为空或只有一个节点，无需去重
        if (head == null || head.next == null) {
            return head;
        }

        // 2. 创建一个局部变量作为遍历指针，保留原始头节点引用
        //    currentNode 将用于遍历和修改链表，而 head 始终指向链表起点。
        ListNode currentNode = head;

        // 3. 遍历链表，直到 currentNode 或其下一个节点为空
        //    确保在访问 currentNode.next 时不会出现空指针异常
        while (currentNode != null && currentNode.next != null) {
            // 4. 检查当前节点和下一个节点的值是否相同
            if (currentNode.val == currentNode.next.val) {
                // 5. 如果相同，则删除下一个重复节点
                //    通过将当前节点的 next 指针跳过下一个重复节点，直接指向下下个节点。
                //    此时 currentNode 不移动，因为它可能还有更多与当前值相同的重复项紧随其后。
                currentNode.next = currentNode.next.next;
            } else {
                // 6. 如果不相同，则移动到下一个节点继续检查
                currentNode = currentNode.next;
            }
        }
        // 7. 循环结束后，返回原始的头节点。
        //    由于 head 引用从未被修改，它仍然指向去重后的链表的第一个节点。
        return head;
    }
}