链表头节点：初始化、作用与去重算法实践

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 ListNode createLinkedList(int[] values) {
    if (values == null || values.length == 0) {
        return null;
    }
    ListNode head = new ListNode(values[0]);
    ListNode current = head;
    for (int i = 1; i < values.length; i++) {
        current.next = new ListNode(values[i]);
        current = current.next;
    }
    return head;
}

// 在某个地方调用
public static void main(String[] args) {
    Solution solution = new Solution(); // 假设deleteDuplicates在一个名为Solution的类中
    int[] nums = {1, 1, 2, 3, 3};
    ListNode originalHead = solution.createLinkedList(nums); // originalHead 就是传入 deleteDuplicates 的 head

    ListNode processedHead = solution.deleteDuplicates(originalHead);
    // ... 对 processedHead 进行操作或打印
}

public ListNode deleteDuplicates(ListNode head) {
    // 1. 基本情况处理：如果链表为空或只有一个节点，则没有重复元素可删除，直接返回
    if (head == null || head.next == null) {
        return head;
    }

    // 2. 使用一个辅助指针 `node` 来遍历链表。
    //    这里将 `head` 赋值给 `node`，以便在遍历过程中修改 `node`，而 `head` 保持不变。
    //    这种做法是良好的编程实践，下面会详细解释。
    ListNode node = head;

    // 3. 遍历链表，直到 `node` 或 `node.next` 为空
    while (node != null && node.next != null) {
        // 4. 检查当前节点 `node` 的值是否与下一个节点 `node.next` 的值相同
        if (node.val == node.next.val) {
            // 5. 如果值相同，说明 `node.next` 是一个重复节点。
            //    通过将 `node.next` 指向 `node.next.next`，有效地跳过并删除了重复节点。
            //    注意：`node` 本身不移动，因为下一个节点可能仍然是重复的。
            node.next = node.next.next;
        } else {
            // 6. 如果值不同，说明 `node.next` 不是重复节点。
            //    将 `node` 移动到下一个节点，继续检查。
            node = node.next;
        }
    }

    // 7. 返回原始的头节点，因为我们只是修改了链表的结构，头节点本身没有改变。
    return head;
}

// 原始实现片段
// ...
// while(head!=null && head.next!=null){
//    if(head.val==head.next.val){
//       head.next=head.next.next;
//     }
//    else head=head.next; // 这里直接修改了传入的 head 引用
//  }      
// return node; // 返回的是原始的头节点引用

public ListNode deleteDuplicates(ListNode head) {
    // 1. 基本情况处理：如果链表为空或只有一个节点，直接返回
    if (head == null || head.next == null) {
        return head;
    }

    // 2. 创建一个辅助指针 `current`，从头节点开始遍历。
    //    `head` 引用保持不变，始终指向链表的起点。
    ListNode current = head;

    // 3. 遍历链表，直到 `current` 或 `current.next` 为空
    while (current != null && current.next != null) {
        // 4. 检查当前节点 `current` 的值是否与下一个节点 `current.next` 的值相同
        if (current.val == current.next.val) {
            // 5. 如果值相同，跳过重复的 `current.next` 节点。
            //    `current` 保持不变，因为可能有多个连续重复。
            current.next = current.next.next;
        } else {
            // 6. 如果值不同，移动 `current` 到下一个节点。
            current = current.next;
        }
    }

    // 7. 返回原始的头节点 `head`，它现在指向的是去重后的链表的起点。
    return head;
}