How will you delete duplicate odd numbers from a linked list?

问题

Requirements/constraint:

delete only duplicates
keep one copy
list is not initially sorted

How can this be implemented in C? (An algorithm and/or code would be greatly appreciated!)

回答1:

If the list is very long and you want reasonable performances and you are OK with allocating an extra log(n) of memory, you can sort in nlog(n) using qsort or merge sort:

http://swiss-knife.blogspot.com/2010/11/sorting.html

Then you can remove duplicates in n (the total is: nlog(n) + n)

If your list is very tiny, you can do like jswolf19 suggest, and you will get: n(n-1)/2 worst.

回答2:

There are several different ways of detecting/deleting duplicates:

Nested loops

Take the next value in sequence, then scan until the end of the list to see if this value occurs again. This is O(n²) -- although I believe the bounds can be argued lower? -- but the actual performance may be better as only scanning from i to end (not 0 to end) is done and it may terminate early. This does not require extra data aside from a few variables.

(See Christoph's answer as how this could be done just using a traversal of the linked list and destructive "appending" to a new list -- e.g. the nested loops don't have to "feel" like nested loops.)

Sort and filter

Sort the list (mergesort can be modified to work on linked lists) and then detect duplicate values (they will be side-by-side now). With a good sort this is O(n*lg(n)). The sorting phase usually is/can be destructive (e.g. you have "one copy") but it has been modified ;-)

Scan and maintain a look-up

Scan the list and as the list is scanned add the values to a lookup. If the lookup already contains said values then there is a duplicate! This approach can be O(n) if the lookup access is O(1). Generally a "hash/dictionary" or "set" is used as the lookup, but if only a limited range of integrals are used then an array will work just fine (e.g. the index is the value). This requires extra storage but no "extra copy" -- at least in the literal reading.

For small values of n, big-O is pretty much worthless ;-)

Happy coding.

回答3:

I'd either

mergesort the list followed by a linear scan to remove duplicates
use an insertion-sort based algorithm which already removes duplicates when re-building the list

The former will be faster, the latter is easier to implement from scratch: Just construct a new list by popping off elements from your old list and inserting them into the new one by scanning it until you hit an element of greater value (in which case you insert the element into the list) or equal value (in which case you discard the element).

回答4:

Well, you can sort the list first and then check for duplicates, or you could do one of the following:

for i from 0 to list.length-1
    for j from i+1 to list.length-1
        if list[i] == list[j]
            //delete one of them
        fi
    loop
loop

回答5:

This is probably the most unoptimized piece of crap, but it'll probably work.

Iterate through the list, holding a pointer to the previous object every time you go on to the next one. Inside your iteration loop iterate through it all to check for a duplicate. If there is a duplicate, now back in the main iteration loop, get the next object. Set the previous objects pointer to the next object to the object you just retrieved, then break out of the loop and restart the whole process till there are no duplicates.

回答6:

You can do this in linear time using a hash table.

You'd want to scan through the list sequentially. Each time you encounter an odd numbered element, look it up in your hash table. If that number is already in the hash table, delete it from the list, if not add it to the hash table and continue.

Basically the idea is that for each element you scan in the list, you are able to check in constant time whether it is a duplicate of a previous element that you've seen. This takes only a single pass through your list and will take at worst a linear amount of memory (worst case is that every element of the list is a unique odd number, thus your hash table is as long as your list).

来源：https://stackoverflow.com/questions/4976765/how-will-you-delete-duplicate-odd-numbers-from-a-linked-list

标签

data-structures

linked-list