Java从链表中删除重复项答案

【问题标题】：Java remove duplicates from linked listJava从链表中删除重复项
【发布时间】：2012-02-27 03:08:21
【问题描述】：

我想从排序的链表 {0 1 2 2 3 3 4 5} 中删除重复项。

`

public Node removeDuplicates(Node header)
{
    Node tempHeader = null;
    if(header != null) 
        tempHeader = header.next;
    else return header;
    Node prev = header;
    if((tempHeader == null)) return header ;

    while(tempHeader != null)
    {
        if(tempHeader.data != prev.data)
        {
            prev.setNext(tempHeader);
        }
    tempHeader = tempHeader.next;
    }
    prev = header;
    printList(prev);
    return tempHeader;
}

`

prev.setNext(tempHeader) 在 while 循环中无法正常工作。理想情况下，当 prev = 2 和 tempHeader = 3 时，prev.next 应该是数据 = 3 的节点。

Printlist 函数只获取标题指针并打印列表。

节点定义如下。

public class Node
{
    int data;
    Node next;

    public Node getNext() {
        return next;
    }
    public void setNext(Node next) {
        this.next = next;
    }
}

【问题讨论】：

这是作业吗？如果是这样，请用 [homework] 标签标记它。
这是作业还是你为什么不用java.util.*
不，这不是家庭作业。我在 stanford 网站上找到了一份 PDF，其中包含 18 个链表问题，其中之一是 removeDuplicate 程序。链接在这里; cslibrary.stanford.edu/105/LinkedListProblems.pdf
你没有在任何地方调用 prev.next。您只是在 while 循环中调用 prev.setNext(tempHeader)。

标签： java

【解决方案1】：

循环已排序，因此您知道重复项将彼此相邻。如果您想就地编辑列表，则必须有两个列表指针（您可以这样做）。你称之为 tempHeader 和 prev 的那个，你必须在你去的时候在列表中推进它们（我在代码中没有看到）。否则，如果您不前进 prev 指针，那么您总是将 tempHeader 下的元素与列表中的第一项进行比较，这是不正确的。

不过，一种更简单的方法是在进行时构建一个新列表。只需记住您添加到列表中的最后一项的值。然后，如果您要插入的那个是相同的，那么干脆不插入它，当您完成后，只需返回您的新列表。

【讨论】：

【解决方案2】：

对于上述建议，我可以给你 2 条建议 1）将链接列表转换为集合，这将消除重复和从设置返回到链接列表完成这项工作的代码是

linkedList = new LinkedList<anything>(new HashSet<anything>(origList));

2) 如果你不想重复，你可以使用 LinkedHashSet

【讨论】：

这听起来不错，但我们可以按照我想做的方式去做。我认为，我们可以通过这种方式在 C/C++ 中进行操作。不是吗？
-1：这完全忽略了列表已排序的事实，并且需要事后排序（当然，除非您使用 LinkedHashSet，但无论哪种方式，它都比单个线性传递更昂贵） .

【解决方案3】：

在这种情况下不需要返回值。

public void removeDuplicates(Node list) {
    while (list != null) {
        // Walk to next unequal node:
        Node current = list.next;
        while (current != null && current.data.equals(list.data)) {
            current = current.next;
        }
        // Skip the equal nodes:
        list.next = current;
        // Take the next unequal node:
        list = current;

    }
}

【讨论】：

+1 这将完成这项工作，除了 current.data.equals(list.data) 应该更改为 current.data == list.data

【解决方案4】：

public ListNode removeDuplicateElements(ListNode head) {
  if (head == null || head.next == null) {
        return null;
    }
    if (head.data.equals(head.next.data)) {
        ListNode next_next = head.next.next;
        head.next = null;
        head.next = next_next;
        removeDuplicateElements(head);
    } else {
        removeDuplicateElements(head.next);
    }
    return head;
}

【讨论】：

【解决方案5】：

通过双向链表并使用HashSet，

  public static void deleteDups(Node n) {
    HashSet<Integer> set = new HashSet<Integer>();
    Node previous = null;
    while (n != null) {
        if (set.contains(n.data)) {
            previous.next = n.next;
        } else {
            set.add(n.data);
            previous = n;
        }
        n = n.next;
    }
}

双向链表

class Node{

public Node next;
public Node prev;
public Node last;
public int data;
public Node (int d, Node n, Node p) {
    data = d;
    setNext(n);
    setPrevious(p);
}

public Node() { }

public void setNext(Node n) {
    next = n;
    if (this == last) {
        last = n;
    }
    if (n != null && n.prev != this) {
        n.setPrevious(this);
    }
}

public void setPrevious(Node p) {
    prev = p;
    if (p != null && p.next != this) {
        p.setNext(this);
    }
}}

【讨论】：