Chapter 2 Linked Lists - 2.1

2.1 Write code to remove duplicates from an unsorted linked list.
FOLLOW UP
How would you solve this problem if a temporary buffer is not allowed?

First of all, we should ask the interviewer which kind of linked list is used, single linked list or doubly linked list? 

I will use single linked list here. The definition of a node is given below:

class node:
    def __init__(self, data = None):
        self.data = data
        self.next = None

Brute force solution takes O(n^2):

def delete_duplicates(head):
    # For each node in the linked list
    while head != None:
        # Iterate all nodes after it and
        # delete the duplicates
        p = head.next
        pre = head
        while p != None:
            next = p.next
            if p.data == head.data:
                # Delete p from linked list
                pre.next = p.next
            else:
                pre = p
            p = next
        head = head.next

if __name__ == "__main__":
    n1 = node(4)
    n2 = node(1)
    n3 = node(1)
    n4 = node(1)
    n5 = node(2)
    n1.next = n2
    n2.next = n3
    n3.next = n4
    n4.next = n5
    
    n = n1
    print "Before deleting duplicates"
    while n != None:
        print n.data
        n = n.next
    delete_duplicates(n1)
    n = n1
    print "After deleting duplicates"
    while n != None:
        print n.data
        n = n.next

Inspired by the word "unsorted" in the problem, I tried to sort a linked list with quicksort, which is the key part of a solution that costs O(nlgn). However, the quicksort for linked list is very difficult to implement (I am still trying). Furthermore, Wikipedia says that quicksort for linked list suffers from poor pivot choices without random access.

Then I turned to the answer page and found that hashtable showed its magic again:

def delete_duplicates(head):
    # Hashtable for marking the ocurrence of data
    dic = {}
    dic[head.data] = True
    
    # The node right before the one under processing
    node_pre = head
    
    while node_pre.next != None:
        node_current = node_pre.next
        if dic.has_key(node_current.data):
            # Delete the node
            node_pre.next = node_current.next
            del node_current
        else:
            dic[node_current.data] = True
            node_pre = node_current

If the hash function is good enough, the solution above only takes O(n).