Question

我正在解决有关链表的Leetcode问题。我想知道为什么下面的代码中返回值必须为head而不是result。

Input: 1->1->2
Output: 1->2

如果我返回结果，则输出为2。

public static ListNode deleteDuplicates(ListNode head) {
    ListNode result = head;

    if (head == null)
        return head;
    // System.out.println(listNodetoString(result));

    while (result.next != null) {
        if (result.val == result.next.val)
            result.next = result.next.next;
        else
            result = result.next;
    }
    return head;
}

Answer 1

如果我很了解您的问题，那么困扰您的是可变性（和指针）
根据您的方法：

public static ListNode deleteDuplicates(ListNode head) {
    ListNode result = head;

    if (head == null)
        return head;
    // System.out.println(ListNodetoString(result));

    while (result.next != null) {
        if (result.val == result.next.val)
            result.next = result.next.next;
        else
            result = result.next;
    }
    return head;
}

（简化响应），
在方法开始时，内存仅包含指向列表的head指针：

         1-next->1-next->2
         ↑
head:----┘

当您这样做：

ListNode result = head;

您正在创建一个指向与head所指向的值相同的指针，例如：

         1-next->1-next->2
         ↑
head:----┘
result:--┘

然后开始迭代列表，if条件的分支会产生不同的效果。
如果result.val == result.next.val为真，则使用

修改ListNode的内部状态

result.next = result.next.next;

当您引用.next所指向的值的字段result时，它正在更改列表的指针，例如：

                 1-next--┐
                         ↓ 
         1-----next----->2
         ↑
head:----┘
result:--┘

由于result.next被更改，第二个节点（第一行的1）不再被任何指针引用。然后，您的while重新开始，如果条件为false，则该方法将执行以下操作：

result = result.next;

通过这种方式，您可以更改result指向的对象，例如：

           1-next┐
                 ↓ 
         1-next->2
         ↑       ↑
head:----┘       |
result:----------┘

因此，当您返回head时，您将返回列表中的第一个元素head指向的值。同时，在迭代result期间，每次if返回false时都进行更改，如果初始列表为：

1-next->1-next->2-next->3

下一次迭代将再次更改结果，如：

           1-next┐
                 ↓ 
         1-next->2-next->3
         ↑               ↑
head:----┘               |
result:------------------┘

但是head始终保持在顶部元素。
事实是，您不需要返回值，对于我从您的代码中了解的值，它也可以用作：

public static void deleteDuplicates(ListNode head) {
    ListNode result = head;

    if (head == null)
        return;
    // System.out.println(listNodetoString(result));

    while (result.next != null) {
        if (result.val == result.next.val)
            result.next = result.next.next;
        else
            result = result.next;
    }
}

然后，您可以尝试使用类似的方法：

ListNode list = new ListNode(1, new ListNode(1, new ListNode(2, null)));
deleteDuplicates(list);
System.out.println(listNodetoString(list));

因为这是因为list也指向列表的第一个值，所以在方法开始时，内存类似于：

list:----┐
         ↓
         1-next->1-next->2
         ↑
head:----┘

Answer 2

清洁方法是：

 public static ListNode deleteDuplicateas(ListNode head) {

    while (head != null) {
        if (head.val == head.next.val)
            head.next = head.next.next;
        else
            head= head.next;
    }
}

链表返回值

2 个答案: