1.py

import random
import timeit


class Node:
    def __init__(self, value=None, next=None):
        self.value = value
        self.next = next


class LinkedList:
    def __init__(self):
        self.first = None
        self.last = None
        self.length = 0
        self.ins = 0
        self.old = None
        self.curr = None
        self.items = set()

    def RemoveDuplicates(self):
        if (self.first == None):
            return
        old = curr = self.first
        while curr != None:
            _del = 0
            if curr.next != None:
                if curr.value == curr.next.value:
                    curr.next = curr.next.next
                    _del = 1
            if _del == 0:
                curr = curr.next

    def __str__(self):
        if self.first != None:
            current = self.first
            out = 'LinkedList = ' + str(current.value) + ' '
            while current.next != None:
                current = current.next
                out += str(current.value) + ' '
            return out + ''
        return ''


def loadlist():
    L = LinkedList()
    for i in range(0, 2500):
        _r = int(random.uniform(0, 100))
        if _r in L.items:
            continue
        if L.first == None:
            L.first = Node(i, None)
        elif L.first.value > _r:
            L.first = Node(_r, L.first)
        else:
            L.old = L.curr = L.first
            L.ins = 0
            while L.curr != None:
                if L.curr.value > _r:
                    L.curr = Node(_r, L.curr)
                    L.old.next = L.curr
                    L.items.add(_r)
                    L.ins = 1
                    break
                L.old = L.curr
                L.curr = L.curr.next
            if L.ins == 0:
                L.curr = Node(_r, None)
                L.old.next = L.curr
                L.items.add(_r)

    #L.RemoveDuplicates()

if __name__ == '__main__':
    t = timeit.Timer('loadlist()', "from __main__ import loadlist")
    print t.timeit(10)

2.py

#import profile
import random
import timeit


class Node(object):
    __slots__ = ('value', 'next')

    def __init__(self, value=None, next=None):
        self.value = value
        self.next = next

    def __str__(self):
        return self.value.__str__()


class LIIter(object):
    __slots__ = ('lst', 'current')

    def __init__(self, lst):
        self.lst = lst
        self.current = self.lst.first

    def __iter__(self):
        return self

    def next(self):
        r = self.current
        if r is None:
            raise StopIteration
        self.current = r.next
        return r


class LinkedList(object):
    __slots__ = ('first', 'last', 'length', 'ins', 'old', 'curr',
        'insert', 'items')

    def __init__(self):
        self.first = None
        self.last = None
        self.length = 0
        self.ins = 0
        self.old = None
        self.curr = None
        self.insert = self.insert_zero
        self.items = set()

    def __iter__(self):
        return LIIter(self)

    def __str__(self):
        l = []
        for x in self:
            l.append(str(x))
        return 'LinkedList = {0}'.format(', '.join(l))

    def insert_zero(self, somevalue):
        self.items.add(somevalue)
        self.first = self.last = Node(somevalue, None)
        self.insert = self.insert_nonzero

    def insert_nonzero(self, somevalue):
        if somevalue in self.items:
            return
        if self.first.value > somevalue:
            self.first = Node(somevalue, self.first)
        elif self.last.value < somevalue:
            self.last.next = Node(somevalue, None)
            self.last = self.last.next
        else:
            old = self.first
            for curr in self:
                if curr.value > somevalue:
                    old.next = Node(somevalue, curr)
                    break
                old = curr
        self.items.add(somevalue)


def loadlist():
    L = LinkedList()
    for i in range(0, 2500):
        L.insert(int(random.uniform(0, 100)))

if __name__ == '__main__':
    t = timeit.Timer('loadlist()', 'from __main__ import loadlist')
    print t.timeit(10)

out

$ python 2.py
0.0410687923431
$ python 2.py
0.0413589477539
$ python 2.py
0.0426070690155
$ python 1.py
0.0659329891205
$ python 1.py
0.0689270496368
$ python 1.py
0.0660810470581