链表 - C#/Java 中的删除重复算法

Question

我正在学习 C#/Java 中的数据结构和算法。遇到Linked List去重问题的解决方法后，一直在努力理解。

解决方案是名著Cracking the coding Interview（第5版，第208页）提出的解决方案。

void RemoveDuplicates_HashSet(Node n)
{
    HashSet<object> set = new HashSet<object>();

    Node previous = null;
    while (n != null)
    {
        if (set.Contains(n.Data))       // Condition 1
            previous.Next = n.Next;
        else                            // Condition 2
        {
            set.Add(n.Data);
            previous = n;
        }
            
        n = n.Next;
    }
}

使用以下链表A->B->A->B运行代码：

// Creating test Singly LinkedList
Node n = new Node("A");
n.Next = new Node("B");
n.Next.Next = new Node("A");
n.Next.Next.Next = new Node("B");

RemoveDuplicates_HashSet(n);

工作得很好：方法后n的值是A->B。

通过使用调试器跟踪代码，我可以看到方法循环中发生的情况如下：

| Pass | HashSet | n          | previous   | Comment                  |
| ---- | ------- | ---------- | ---------- | ------------------------ |
| –    | –       | A->B->A->B | null       |                          |
| 1    | A       | B->A->B    | A->B->A->B | Condition 2 is triggered |
| 2    | A,B     | A->B       | B->A->B    | Condition 2 is triggered |
| 3    | A,B     | B          | B->B       | Condition 1 is triggered |
| 4    | A,B     | null       | B          | Condition 1 is triggered |

我无法理解这实际上是如何导致的：

1. 从n 删除的重复项在哪里/如何准确删除？我知道 HashSet 只包含唯一的元素，因此它会检测是否已经遇到了一个元素，但是我仍然看不到该算法的整体工作原理。

2. n指向的值怎么更新为A->B？它在哪里，鉴于本质上循环只是在链接列表上迭代执行n = n.Next，n 实际上是用最终值A->B 更新的？我知道列表是通过引用传递的，但我看不到它实际上是如何修改的。

Answer 1

在哪里/如何准确地从 n 中删除重复项？

Set 的一个属性，如果它不能包含重复的元素。

if (set.Contains(n.Data))
            previous.Next = n.Next;
else
{
            set.Add(n.Data);
            previous = n;
}
n = n.Next;

这里首先检查当前节点n的数据是否包含在集合中。如果是，则前一个节点的后继节点是当前节点n的下一个节点。 所以：

[previous]->[n]->[next]
[previous]->[next]

否则，数据将添加到集合中，然后继续下一个节点。

n 指向的值怎么更新为 A->B？考虑到循环本质上是简单地在链表上迭代 n = n。接下来，n 实际上是用最终值 A->B 更新的？

我真的不明白这个问题。您的意思是“为什么要修改列表？” 如果是，那么因为它是通过引用传递的（有点 simplified ）。所以你只是不做复制，就像原始类型（int，long，...）一样，但你修改了对象本身。

Answer 2

@Slaw's comment 指出了我认为正确的方向。

• 问题 2) 的关键 - 更改实际上是如何从方法传播到原始列表的 - 是要了解 C#/Java objects are passed by reference, but the reference itself is passed by value: while the object can be modified by the method, the reference cannot be modified.
  一旦方法结束（方法上下文的终止），n 指针将再次指向链接列表的开始。在方法内不断推进n 指针（通过执行n = n.Next）不会影响“外部指针”（方法外的原始n 引用）。

• 根据问题 1) - 算法的内部机制 - 关键是要了解修改 previous.Next 确实修改了 n 指向的列表。引用@Slaw's comment:

此代码：if (set.Contains(n.Data)) previous.Next = n.Next 检查是否已遇到该元素，如果已遇到，则从链表中删除 n。 它通过将n.Next分配给previous.Next（这意味着previous.Next不再指向n）来删除节点。

因此，我试图详尽地描绘算法中发生的事情。