递归-从列表中删除重复项

Question

The question is to write a recursive function that Removes duplicates from the list.

Hint: it can be implemented with two auxiliary functions.

The list contains one and only one of each value formerly present in the list. The first occurrence of each value is preserved.

Implement and test a recursive version of this method

def clean(self):

    key_node = self._front

    while key_node is not None:
        # Loop through every node - compare each node with the rest
        previous = key_node
        current = key_node._next

        while current is not None:
            # Always search to the end of the list (may have > 1 duplicate)
            if current._value == key_node._value:
                # Remove the current node by connecting the node before it
                # to the node after it.
                previous._next = current._next
                self._count -= 1
            else:
                previous = current
            # Move to the _next node.
            current = current._next
        # Check for duplicates of the _next remaining node in the list
        key_node = key_node._next
    return

And this is what I have so far, I don't understand what is auxiliary functions:

def clean(list):
   i = 1
   if len(list) == 0:
     return []
   elif len(list) == 1:
      return list
   elif list[i] == list[i-1]:
       del list[i]
    return clean(list[i:])

Example: for list = [1,2,2,3,3,3,4,5,1,1,1] , the answer is [1,2,3,4,5,1]

Answer 1

Here is one function that calls a another, recursive function and produces the result you want. I suppose you could call clean2 an auxiliary function, although, like you, I don't know exactly what that's supposed to mean. It's a rather ridiculous piece of code but it doesn't use any standard library functions and it modifies x in place. I would expect it to be horribly inefficient. If I wrote this for my day job I'd probably resign.

def clean(x):
    clean2(x, 1)

def clean2(x, i):
    if i >= len(x):
        return
    if x[i] == x[i - 1]:
        del x[i]
        clean2(x, i)
    else:
        clean2(x,i+1)


the_list = [1,2,2,3,3,3,4,5,1,1,1]
clean(the_list)
print(the_list)

>>> [1,2,3,4,5,1]

Answer 2

Here's a recursive definition using an auxiliary function go to actually implement the recursion. The idea is that the outer clean function can take any iterable object (eg a list) and it always produces a list of values:

def clean(iterable):
    def go(iterator, result):
        try:
            x = next(iterator)
            if result == [] or result[-1] != x:
                result.append(x)
            return go(iterator, result)
        except StopIteration:
            return result

    return go(iter(iterable), [])

clean just invokes a locally-defined go function, passing an iterator and the eventual result value (initially an empty list). go then tries to advance the iterator and compares the referenced value with the end of the result : if it's different (or if the result is empty), the value is appended. go then recurses.