blocks|key|1477407|text|不可变列表最好通过两个元组来表示，没有一个表示NIL。要实现此类列表的简单表示，您可以使用此函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1477408|def+mklist(*args):
++++result+=+None
++++for+element+in+reversed(args):
++++++++result+=+(element,+result)
++++return+result|code-block|syntax|javascript|1477409|为了使用这样的列表，我宁愿提供LISP函数的整个集合(即first、second、nth等)，而不是引入方法。|1477410|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

<p>Immutable lists are best represented through two-tuples, with None representing NIL. To allow simple formulation of such lists, you can use this function:</p>

<pre><code>def mklist(*args):
    result = None
    for element in reversed(args):
        result = (element, result)
    return result
</code></pre>

<p>To work with such lists, I'd rather provide the whole collection of LISP functions (i.e. first, second, nth, etc), than introducing methods.</p>


blocks|key|1477438|text|前几天我写了这篇文章|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1477439|#!+/usr/bin/env+python

class+Node(object):
++++def+__init__(self):
++++++++self.data+=+None+#+contains+the+data
++++++++self.next+=+None+#+contains+the+reference+to+the+next+node


class+LinkedList:
++++def+__init__(self):
++++++++self.cur_node+=+None

++++def+add_node(self,+data):
++++++++new_node+=+Node()+#+create+a+new+node
++++++++new_node.data+=+data
++++++++new_node.next+=+self.cur_node+#+link+the+new+node+to+the+'previous'+node.
++++++++self.cur_node+=+new_node+#++set+the+current+node+to+the+new+one.

++++def+list_print(self):
++++++++node+=+self.cur_node+#+cant+point+to+ll!
++++++++while+node:
++++++++++++print+node.data
++++++++++++node+=+node.next



ll+=+LinkedList()
ll.add_node(1)
ll.add_node(2)
ll.add_node(3)

ll.list_print()|code-block|syntax|javascript|1477440|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>I wrote this up the other day</p>

<pre><code>#! /usr/bin/env python

class Node(object):
    def __init__(self):
        self.data = None # contains the data
        self.next = None # contains the reference to the next node


class LinkedList:
    def __init__(self):
        self.cur_node = None

    def add_node(self, data):
        new_node = Node() # create a new node
        new_node.data = data
        new_node.next = self.cur_node # link the new node to the 'previous' node.
        self.cur_node = new_node #  set the current node to the new one.

    def list_print(self):
        node = self.cur_node # cant point to ll!
        while node:
            print node.data
            node = node.next



ll = LinkedList()
ll.add_node(1)
ll.add_node(2)
ll.add_node(3)

ll.list_print()
</code></pre>


blocks|key|1692647|text|在使用不可变链表时，请考虑直接使用Python的元组。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1692648|ls+=+(1,+2,+3,+4,+5)

def+first(ls):+return+ls[0]
def+rest(ls):+return+ls[1:]|code-block|syntax|javascript|1692649|它真的很简单，而且你可以保留其他函数，比如len(ls)，x+in+ls，等等。|1692650|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

<p>When using immutable linked lists, consider using Python's tuple directly. </p>

<pre><code>ls = (1, 2, 3, 4, 5)

def first(ls): return ls[0]
def rest(ls): return ls[1:]
</code></pre>

<p>Its really that ease, and you get to keep the additional funcitons like len(ls), x in ls, etc.</p>


blocks|key|1477525|text|下面是一个稍微复杂一点的链表类版本，它的接口类似于python的序列类型(即，.支持索引、切片、连接任意序列等)。它应该有O(1)前缀，除非需要，否则不复制数据，并且可以与元组互换使用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1477526|它不会像lisp+cons单元格那样节省空间和时间，因为python类显然有点重量级(你可以用"__slots__+=+'_head','_tail'“来稍微改进一下，以减少内存使用)。然而，它将具有所需的大O性能特征。|offset|length|style|CODE|1477527|用法示例：|1477528|>>>+l+=+LinkedList([1,2,3,4])
>>>+l
LinkedList([1,+2,+3,+4])
>>>+l.head,+l.tail
(1,+LinkedList([2,+3,+4]))

#+Prepending+is+O(1)+and+can+be+done+with:
LinkedList.cons(0,+l)
LinkedList([0,+1,+2,+3,+4])
#+Or+prepending+arbitrary+sequences+(Still+no+copy+of+l+performed):
[-1,0]+%2B+l
LinkedList([-1,+0,+1,+2,+3,+4])

#+Normal+list+indexing+and+slice+operations+can+be+performed.
#+Again,+no+copy+is+made+unless+needed.
>>>+l[1],+l[-1],+l[2:]
(2,+4,+LinkedList([3,+4]))
>>>+assert+l[2:]+is+l.next.next

#+For+cases+where+the+slice+stops+before+the+end,+or+uses+a
#+non-contiguous+range,+we+do+need+to+create+a+copy.++However
#+this+should+be+transparent+to+the+user.
>>>+LinkedList(range(100))[-10::2]
LinkedList([90,+92,+94,+96,+98])|code-block|syntax|javascript|1477529|实施：|1477530|import+itertools

class+LinkedList(object):
++++"""Immutable+linked+list+class."""

++++def+__new__(cls,+l=[]):
++++++++if+isinstance(l,+LinkedList):+return+l+#+Immutable,+so+no+copy+needed.
++++++++i+=+iter(l)
++++++++try:
++++++++++++head+=+i.next()
++++++++except+StopIteration:
++++++++++++return+cls.EmptyList+++#+Return+empty+list+singleton.

++++++++tail+=+LinkedList(i)

++++++++obj+=+super(LinkedList,+cls).__new__(cls)
++++++++obj._head+=+head
++++++++obj._tail+=+tail
++++++++return+obj

++++@classmethod
++++def+cons(cls,+head,+tail):
++++++++ll+=++cls([head])
++++++++if+not+isinstance(tail,+cls):
++++++++++++tail+=+cls(tail)
++++++++ll._tail+=+tail
++++++++return+ll

++++#+head+and+tail+are+not+modifiable
++++@property++
++++def+head(self):+return+self._head

++++@property
++++def+tail(self):+return+self._tail

++++def+__nonzero__(self):+return+True

++++def+__len__(self):
++++++++return+sum(1+for+_+in+self)

++++def+__add__(self,+other):
++++++++other+=+LinkedList(other)

++++++++if+not+self:+return+other+++#+()+%2B+l+=+l
++++++++start=l+=+LinkedList(iter(self))++#+Create+copy,+as+we'll+mutate

++++++++while+l:
++++++++++++if+not+l._tail:+#+Last+element?
++++++++++++++++l._tail+=+other
++++++++++++++++break
++++++++++++l+=+l._tail
++++++++return+start

++++def+__radd__(self,+other):
++++++++return+LinkedList(other)+%2B+self

++++def+__iter__(self):
++++++++x=self
++++++++while+x:
++++++++++++yield+x.head
++++++++++++x=x.tail

++++def+__getitem__(self,+idx):
++++++++"""Get+item+at+specified+index"""
++++++++if+isinstance(idx,+slice):
++++++++++++#+Special+case:+Avoid+constructing+a+new+list,+or+performing+O(n)+length+
++++++++++++#+calculation+for+slices+like+l[3:].++Since+we're+immutable,+just+return
++++++++++++#+the+appropriate+node.+This+becomes+O(start)+rather+than+O(n).
++++++++++++#+We+can't+do+this+for++more+complicated+slices+however+(eg+[l:4]
++++++++++++start+=+idx.start+or+0
++++++++++++if+(start+>=+0)+and+(idx.stop+is+None)+and+(idx.step+is+None+or+idx.step+==+1):
++++++++++++++++no_copy_needed=True
++++++++++++else:
++++++++++++++++length+=+len(self)++#+Need+to+calc+length.
++++++++++++++++start,+stop,+step+=+idx.indices(length)
++++++++++++++++no_copy_needed+=+(stop+==+length)+and+(step+==+1)

++++++++++++if+no_copy_needed:
++++++++++++++++l+=+self
++++++++++++++++for+i+in+range(start):+
++++++++++++++++++++if+not+l:+break+#+End+of+list.
++++++++++++++++++++l=l.tail
++++++++++++++++return+l
++++++++++++else:
++++++++++++++++#+We+need+to+construct+a+new+list.
++++++++++++++++if+step+<+1:++#+Need+to+instantiate+list+to+deal+with+-ve+step
++++++++++++++++++++return+LinkedList(list(self)[start:stop:step])
++++++++++++++++else:
++++++++++++++++++++return+LinkedList(itertools.islice(iter(self),+start,+stop,+step))
++++++++else:+++++++
++++++++++++#+Non-slice+index.
++++++++++++if+idx+<+0:+idx+=+len(self)%2Bidx
++++++++++++if+not+self:+raise+IndexError("list+index+out+of+range")
++++++++++++if+idx+==+0:+return+self.head
++++++++++++return+self.tail[idx-1]

++++def+__mul__(self,+n):
++++++++if+n+<=+0:+return+Nil
++++++++l=self
++++++++for+i+in+range(n-1):+l+%2B=+self
++++++++return+l
++++def+__rmul__(self,+n):+return+self+*+n

++++#+Ideally+we+should+compute+the+has+ourselves+rather+than+construct
++++#+a+temporary+tuple+as+below.++I+haven't+impemented+this+here
++++def+__hash__(self):+return+hash(tuple(self))

++++def+__eq__(self,+other):+return+self._cmp(other)+==+0
++++def+__ne__(self,+other):+return+not+self+==+other
++++def+__lt__(self,+other):+return+self._cmp(other)+<+0
++++def+__gt__(self,+other):+return+self._cmp(other)+>+0
++++def+__le__(self,+other):+return+self._cmp(other)+<=+0
++++def+__ge__(self,+other):+return+self._cmp(other)+>=+0

++++def+_cmp(self,+other):
++++++++"""Acts+as+cmp():+-1+for+self<other,+0+for+equal,+1+for+greater"""
++++++++if+not+isinstance(other,+LinkedList):
++++++++++++return+cmp(LinkedList,type(other))++#+Arbitrary+ordering.

++++++++A,+B+=+iter(self),+iter(other)
++++++++for+a,b+in+itertools.izip(A,B):
+++++++++++if+a<b:+return+-1
+++++++++++elif+a+>+b:+return+1

++++++++try:
++++++++++++A.next()
++++++++++++return+1++#+a+has+more+items.
++++++++except+StopIteration:+pass

++++++++try:
++++++++++++B.next()
++++++++++++return+-1++#+b+has+more+items.
++++++++except+StopIteration:+pass

++++++++return+0++#+Lists+are+equal

++++def+__repr__(self):
++++++++return+"LinkedList([%25s])"+%25+',+'.join(map(repr,self))

class+EmptyList(LinkedList):
++++"""A+singleton+representing+an+empty+list."""
++++def+__new__(cls):
++++++++return+object.__new__(cls)

++++def+__iter__(self):+return+iter([])
++++def+__nonzero__(self):+return+False

++++@property
++++def+head(self):+raise+IndexError("End+of+list")

++++@property
++++def+tail(self):+raise+IndexError("End+of+list")

#+Create+EmptyList+singleton
LinkedList.EmptyList+=+EmptyList()
del+EmptyList|1477531|entityMap^0|0|1C|R|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@$D|W|E|X|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|Y|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|Z|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|11|8|@]|9|@]|A|$M|N]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

<p>Here's a slightly more complex version of a linked list class, with a similar interface to python's sequence types (ie. supports indexing, slicing, concatenation with arbitrary sequences etc).  It should have O(1) prepend, doesn't copy data unless it needs to and can be used pretty interchangably with tuples.</p>

<p>It won't be as space or time efficient as lisp cons cells, as python classes are obviously a bit more heavyweight (You could improve things slightly with "<code>__slots__ = '_head','_tail'</code>" to reduce memory usage).  It will have the desired big O performance characteristics however.</p>

<p>Example of usage:</p>

<pre><code>&gt;&gt;&gt; l = LinkedList([1,2,3,4])
&gt;&gt;&gt; l
LinkedList([1, 2, 3, 4])
&gt;&gt;&gt; l.head, l.tail
(1, LinkedList([2, 3, 4]))

# Prepending is O(1) and can be done with:
LinkedList.cons(0, l)
LinkedList([0, 1, 2, 3, 4])
# Or prepending arbitrary sequences (Still no copy of l performed):
[-1,0] + l
LinkedList([-1, 0, 1, 2, 3, 4])

# Normal list indexing and slice operations can be performed.
# Again, no copy is made unless needed.
&gt;&gt;&gt; l[1], l[-1], l[2:]
(2, 4, LinkedList([3, 4]))
&gt;&gt;&gt; assert l[2:] is l.next.next

# For cases where the slice stops before the end, or uses a
# non-contiguous range, we do need to create a copy.  However
# this should be transparent to the user.
&gt;&gt;&gt; LinkedList(range(100))[-10::2]
LinkedList([90, 92, 94, 96, 98])
</code></pre>

<p>Implementation:</p>

<pre><code>import itertools

class LinkedList(object):
    """Immutable linked list class."""

    def __new__(cls, l=[]):
        if isinstance(l, LinkedList): return l # Immutable, so no copy needed.
        i = iter(l)
        try:
            head = i.next()
        except StopIteration:
            return cls.EmptyList   # Return empty list singleton.

        tail = LinkedList(i)

        obj = super(LinkedList, cls).__new__(cls)
        obj._head = head
        obj._tail = tail
        return obj

    @classmethod
    def cons(cls, head, tail):
        ll =  cls([head])
        if not isinstance(tail, cls):
            tail = cls(tail)
        ll._tail = tail
        return ll

    # head and tail are not modifiable
    @property  
    def head(self): return self._head

    @property
    def tail(self): return self._tail

    def __nonzero__(self): return True

    def __len__(self):
        return sum(1 for _ in self)

    def __add__(self, other):
        other = LinkedList(other)

        if not self: return other   # () + l = l
        start=l = LinkedList(iter(self))  # Create copy, as we'll mutate

        while l:
            if not l._tail: # Last element?
                l._tail = other
                break
            l = l._tail
        return start

    def __radd__(self, other):
        return LinkedList(other) + self

    def __iter__(self):
        x=self
        while x:
            yield x.head
            x=x.tail

    def __getitem__(self, idx):
        """Get item at specified index"""
        if isinstance(idx, slice):
            # Special case: Avoid constructing a new list, or performing O(n) length 
            # calculation for slices like l[3:].  Since we're immutable, just return
            # the appropriate node. This becomes O(start) rather than O(n).
            # We can't do this for  more complicated slices however (eg [l:4]
            start = idx.start or 0
            if (start &gt;= 0) and (idx.stop is None) and (idx.step is None or idx.step == 1):
                no_copy_needed=True
            else:
                length = len(self)  # Need to calc length.
                start, stop, step = idx.indices(length)
                no_copy_needed = (stop == length) and (step == 1)

            if no_copy_needed:
                l = self
                for i in range(start): 
                    if not l: break # End of list.
                    l=l.tail
                return l
            else:
                # We need to construct a new list.
                if step &lt; 1:  # Need to instantiate list to deal with -ve step
                    return LinkedList(list(self)[start:stop:step])
                else:
                    return LinkedList(itertools.islice(iter(self), start, stop, step))
        else:       
            # Non-slice index.
            if idx &lt; 0: idx = len(self)+idx
            if not self: raise IndexError("list index out of range")
            if idx == 0: return self.head
            return self.tail[idx-1]

    def __mul__(self, n):
        if n &lt;= 0: return Nil
        l=self
        for i in range(n-1): l += self
        return l
    def __rmul__(self, n): return self * n

    # Ideally we should compute the has ourselves rather than construct
    # a temporary tuple as below.  I haven't impemented this here
    def __hash__(self): return hash(tuple(self))

    def __eq__(self, other): return self._cmp(other) == 0
    def __ne__(self, other): return not self == other
    def __lt__(self, other): return self._cmp(other) &lt; 0
    def __gt__(self, other): return self._cmp(other) &gt; 0
    def __le__(self, other): return self._cmp(other) &lt;= 0
    def __ge__(self, other): return self._cmp(other) &gt;= 0

    def _cmp(self, other):
        """Acts as cmp(): -1 for self&lt;other, 0 for equal, 1 for greater"""
        if not isinstance(other, LinkedList):
            return cmp(LinkedList,type(other))  # Arbitrary ordering.

        A, B = iter(self), iter(other)
        for a,b in itertools.izip(A,B):
           if a&lt;b: return -1
           elif a &gt; b: return 1

        try:
            A.next()
            return 1  # a has more items.
        except StopIteration: pass

        try:
            B.next()
            return -1  # b has more items.
        except StopIteration: pass

        return 0  # Lists are equal

    def __repr__(self):
        return "LinkedList([%s])" % ', '.join(map(repr,self))

class EmptyList(LinkedList):
    """A singleton representing an empty list."""
    def __new__(cls):
        return object.__new__(cls)

    def __iter__(self): return iter([])
    def __nonzero__(self): return False

    @property
    def head(self): raise IndexError("End of list")

    @property
    def tail(self): raise IndexError("End of list")

# Create EmptyList singleton
LinkedList.EmptyList = EmptyList()
del EmptyList
</code></pre>


blocks|key|1692792|text|对于某些需要，deque可能也很有用。你可以在队列的两端添加和删除物品，成本为O(1)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1692793|from+collections+import+deque
d+=+deque([1,2,3,4])

print+d
for+x+in+d:
++++print+x
print+d.pop(),+d|code-block|syntax|javascript|1692794|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/library/collections.html#collections.deque^0|7|5|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

<p>For some needs, a <a href="https://docs.python.org/library/collections.html#collections.deque" rel="noreferrer">deque</a> may also be useful. You can add and remove items on both ends of a deque at O(1) cost.</p>

<pre><code>from collections import deque
d = deque([1,2,3,4])

print d
for x in d:
    print x
print d.pop(), d
</code></pre>


blocks|key|1692865|text|公认的答案是相当复杂的。下面是一个更标准的设计：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1692866|L+=+LinkedList()
L.insert(1)
L.insert(1)
L.insert(2)
L.insert(4)
print+L
L.clear()
print+L|code-block|syntax|javascript|1692867|它是一个简单的LinkedList类，它基于Thomas+Watnedal推荐的简单的C%2B%2B设计和Chapter+17:+Linked+lists。|offset|length|style|CODE|1692868|class+Node:
++++def+__init__(self,+value+=+None,+next+=+None):
++++++++self.value+=+value
++++++++self.next+=+next

++++def+__str__(self):
++++++++return+'Node+['%2Bstr(self.value)%2B']'

class+LinkedList:
++++def+__init__(self):
++++++++self.first+=+None
++++++++self.last+=+None

++++def+insert(self,+x):
++++++++if+self.first+==+None:
++++++++++++self.first+=+Node(x,+None)
++++++++++++self.last+=+self.first
++++++++elif+self.last+==+self.first:
++++++++++++self.last+=+Node(x,+None)
++++++++++++self.first.next+=+self.last
++++++++else:
++++++++++++current+=+Node(x,+None)
++++++++++++self.last.next+=+current
++++++++++++self.last+=+current

++++def+__str__(self):
++++++++if+self.first+!=+None:
++++++++++++current+=+self.first
++++++++++++out+=+'LinkedList+[\n'+%2Bstr(current.value)+%2B'\n'
++++++++++++while+current.next+!=+None:
++++++++++++++++current+=+current.next
++++++++++++++++out+%2B=+str(current.value)+%2B+'\n'
++++++++++++return+out+%2B+']'
++++++++return+'LinkedList+[]'

++++def+clear(self):
++++++++self.__init__()|1692869|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/280243/python-linked-list/280280#280280|1|http://greenteapress.com/thinkpython/html/chap17.html^0|0|0|7|A|M|F|0|1D|O|1|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@$I|11|J|12|K|L]]|9|@$I|13|J|14|1|15]|$I|16|J|17|1|18]]|A|$]]|$1|M|3|N|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]|W|$5|R|S|T|A|$U|X]]]]

<p>The accepted answer is rather complicated. Here is a more standard design:</p>

<pre><code>L = LinkedList()
L.insert(1)
L.insert(1)
L.insert(2)
L.insert(4)
print L
L.clear()
print L
</code></pre>

<p>It is a simple <code>LinkedList</code> class based on the straightforward C++ design and <a href="http://greenteapress.com/thinkpython/html/chap17.html" rel="noreferrer">Chapter 17: Linked lists</a>, as recommended by <a href="https://stackoverflow.com/questions/280243/python-linked-list/280280#280280">Thomas Watnedal</a>.</p>

<pre><code>class Node:
    def __init__(self, value = None, next = None):
        self.value = value
        self.next = next

    def __str__(self):
        return 'Node ['+str(self.value)+']'

class LinkedList:
    def __init__(self):
        self.first = None
        self.last = None

    def insert(self, x):
        if self.first == None:
            self.first = Node(x, None)
            self.last = self.first
        elif self.last == self.first:
            self.last = Node(x, None)
            self.first.next = self.last
        else:
            current = Node(x, None)
            self.last.next = current
            self.last = current

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

    def clear(self):
        self.__init__()
</code></pre>


blocks|key|1477704|text|我将这个额外的函数建立在Nick+Stinemates之上|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1477705|def+add_node_at_end(self,+data):
++++new_node+=+Node()
++++node+=+self.curr_node
++++while+node:
++++++++if+node.next+==+None:
++++++++++++node.next+=+new_node
++++++++++++new_node.next+=+None
++++++++++++new_node.data+=+data
++++++++node+=+node.next|code-block|syntax|javascript|1477706|他的方法在开始时添加了新节点，而我见过很多实现，通常在末尾添加一个新节点，但不管怎样，这样做很有趣。|1477707|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/users/4960/nick-stinemates^0|C|F|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

<p>I based this additional function on <a href="https://stackoverflow.com/users/4960/nick-stinemates">Nick Stinemates</a></p>

<pre><code>def add_node_at_end(self, data):
    new_node = Node()
    node = self.curr_node
    while node:
        if node.next == None:
            node.next = new_node
            new_node.next = None
            new_node.data = data
        node = node.next
</code></pre>

<p>The method he has adds the new node at the beginning while I have seen a lot of implementations which usually add a new node at the end but whatever, it is fun to do.</p>


blocks|key|1693042|text|我认为下面的实现很好地满足了这个要求。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1693043|'''singly+linked+lists,+by+Yingjie+Lan,+December+1st,+2011'''

class+linkst:
++++'''Singly+linked+list,+with+pythonic+features.
The+list+has+pointers+to+both+the+first+and+the+last+node.'''
++++__slots__+=+['data',+'next']+#memory+efficient
++++def+__init__(self,+iterable=(),+data=None,+next=None):
++++++++'''Provide+an+iterable+to+make+a+singly+linked+list.
Set+iterable+to+None+to+make+a+data+node+for+internal+use.'''
++++++++if+iterable+is+not+None:+
++++++++++++self.data,+self.next+=+self,+None
++++++++++++self.extend(iterable)
++++++++else:+#a+common+node
++++++++++++self.data,+self.next+=+data,+next

++++def+empty(self):
++++++++'''test+if+the+list+is+empty'''
++++++++return+self.next+is+None

++++def+append(self,+data):
++++++++'''append+to+the+end+of+list.'''
++++++++last+=+self.data
++++++++self.data+=+last.next+=+linkst(None,+data)
++++++++#self.data+=+last.next

++++def+insert(self,+data,+index=0):
++++++++'''insert+data+before+index.
Raise+IndexError+if+index+is+out+of+range'''
++++++++curr,+cat+=+self,+0
++++++++while+cat+<+index+and+curr:
++++++++++++curr,+cat+=+curr.next,+cat%2B1
++++++++if+index<0+or+not+curr:
++++++++++++raise+IndexError(index)
++++++++new+=+linkst(None,+data,+curr.next)
++++++++if+curr.next+is+None:+self.data+=+new
++++++++curr.next+=+new

++++def+reverse(self):
++++++++'''reverse+the+order+of+list+in+place'''
++++++++current,+prev+=+self.next,+None
++++++++while+current:+#what+if+list+is+empty?
++++++++++++next+=+current.next
++++++++++++current.next+=+prev
++++++++++++prev,+current+=+current,+next
++++++++if+self.next:+self.data+=+self.next
++++++++self.next+=+prev

++++def+delete(self,+index=0):
++++++++'''remvoe+the+item+at+index+from+the+list'''
++++++++curr,+cat+=+self,+0
++++++++while+cat+<+index+and+curr.next:
++++++++++++curr,+cat+=+curr.next,+cat%2B1
++++++++if+index<0+or+not+curr.next:
++++++++++++raise+IndexError(index)
++++++++curr.next+=+curr.next.next
++++++++if+curr.next+is+None:+#tail
++++++++++++self.data+=+curr+#current+==+self?

++++def+remove(self,+data):
++++++++'''remove+first+occurrence+of+data.
Raises+ValueError+if+the+data+is+not+present.'''
++++++++current+=+self
++++++++while+current.next:+#node+to+be+examined
++++++++++++if+data+==+current.next.data:+break
++++++++++++current+=+current.next+#move+on
++++++++else:+raise+ValueError(data)
++++++++current.next+=+current.next.next
++++++++if+current.next+is+None:+#tail
++++++++++++self.data+=+current+#current+==+self?

++++def+__contains__(self,+data):
++++++++'''membership+test+using+keyword+'in'.'''
++++++++current+=+self.next
++++++++while+current:
++++++++++++if+data+==+current.data:
++++++++++++++++return+True
++++++++++++current+=+current.next
++++++++return+False

++++def+__iter__(self):
++++++++'''iterate+through+list+by+for-statements.
return+an+iterator+that+must+define+the+__next__+method.'''
++++++++itr+=+linkst()
++++++++itr.next+=+self.next
++++++++return+itr+#invariance:+itr.data+==+itr

++++def+__next__(self):
++++++++'''the+for-statement+depends+on+this+method
to+provide+items+one+by+one+in+the+list.
return+the+next+data,+and+move+on.'''
++++++++#the+invariance+is+checked+so+that+a+linked+list
++++++++#will+not+be+mistakenly+iterated+over
++++++++if+self.data+is+not+self+or+self.next+is+None:
++++++++++++raise+StopIteration()
++++++++next+=+self.next
++++++++self.next+=+next.next
++++++++return+next.data

++++def+__repr__(self):
++++++++'''string+representation+of+the+list'''
++++++++return+'linkst(%25r)'%25list(self)

++++def+__str__(self):
++++++++'''converting+the+list+to+a+string'''
++++++++return+'->'.join(str(i)+for+i+in+self)

++++#note:+this+is+NOT+the+class+lab!+see+file+linked.py.
++++def+extend(self,+iterable):
++++++++'''takes+an+iterable,+and+append+all+items+in+the+iterable
to+the+end+of+the+list+self.'''
++++++++last+=+self.data
++++++++for+i+in+iterable:
++++++++++++last.next+=+linkst(None,+i)
++++++++++++last+=+last.next
++++++++self.data+=+last

++++def+index(self,+data):
++++++++'''TODO:+return+first+index+of+data+in+the+list+self.
++++Raises+ValueError+if+the+value+is+not+present.'''
++++++++#must+not+convert+self+to+a+tuple+or+any+other+containers
++++++++current,+idx+=+self.next,+0
++++++++while+current:
++++++++++++if+current.data+==+data:+return+idx
++++++++++++current,+idx+=+current.next,+idx%2B1
++++++++raise+ValueError(data)|code-block|syntax|javascript|1693044|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>I think the implementation below fill the bill quite gracefully.</p>

<pre><code>'''singly linked lists, by Yingjie Lan, December 1st, 2011'''

class linkst:
    '''Singly linked list, with pythonic features.
The list has pointers to both the first and the last node.'''
    __slots__ = ['data', 'next'] #memory efficient
    def __init__(self, iterable=(), data=None, next=None):
        '''Provide an iterable to make a singly linked list.
Set iterable to None to make a data node for internal use.'''
        if iterable is not None: 
            self.data, self.next = self, None
            self.extend(iterable)
        else: #a common node
            self.data, self.next = data, next

    def empty(self):
        '''test if the list is empty'''
        return self.next is None

    def append(self, data):
        '''append to the end of list.'''
        last = self.data
        self.data = last.next = linkst(None, data)
        #self.data = last.next

    def insert(self, data, index=0):
        '''insert data before index.
Raise IndexError if index is out of range'''
        curr, cat = self, 0
        while cat &lt; index and curr:
            curr, cat = curr.next, cat+1
        if index&lt;0 or not curr:
            raise IndexError(index)
        new = linkst(None, data, curr.next)
        if curr.next is None: self.data = new
        curr.next = new

    def reverse(self):
        '''reverse the order of list in place'''
        current, prev = self.next, None
        while current: #what if list is empty?
            next = current.next
            current.next = prev
            prev, current = current, next
        if self.next: self.data = self.next
        self.next = prev

    def delete(self, index=0):
        '''remvoe the item at index from the list'''
        curr, cat = self, 0
        while cat &lt; index and curr.next:
            curr, cat = curr.next, cat+1
        if index&lt;0 or not curr.next:
            raise IndexError(index)
        curr.next = curr.next.next
        if curr.next is None: #tail
            self.data = curr #current == self?

    def remove(self, data):
        '''remove first occurrence of data.
Raises ValueError if the data is not present.'''
        current = self
        while current.next: #node to be examined
            if data == current.next.data: break
            current = current.next #move on
        else: raise ValueError(data)
        current.next = current.next.next
        if current.next is None: #tail
            self.data = current #current == self?

    def __contains__(self, data):
        '''membership test using keyword 'in'.'''
        current = self.next
        while current:
            if data == current.data:
                return True
            current = current.next
        return False

    def __iter__(self):
        '''iterate through list by for-statements.
return an iterator that must define the __next__ method.'''
        itr = linkst()
        itr.next = self.next
        return itr #invariance: itr.data == itr

    def __next__(self):
        '''the for-statement depends on this method
to provide items one by one in the list.
return the next data, and move on.'''
        #the invariance is checked so that a linked list
        #will not be mistakenly iterated over
        if self.data is not self or self.next is None:
            raise StopIteration()
        next = self.next
        self.next = next.next
        return next.data

    def __repr__(self):
        '''string representation of the list'''
        return 'linkst(%r)'%list(self)

    def __str__(self):
        '''converting the list to a string'''
        return '-&gt;'.join(str(i) for i in self)

    #note: this is NOT the class lab! see file linked.py.
    def extend(self, iterable):
        '''takes an iterable, and append all items in the iterable
to the end of the list self.'''
        last = self.data
        for i in iterable:
            last.next = linkst(None, i)
            last = last.next
        self.data = last

    def index(self, data):
        '''TODO: return first index of data in the list self.
    Raises ValueError if the value is not present.'''
        #must not convert self to a tuple or any other containers
        current, idx = self.next, 0
        while current:
            if current.data == data: return idx
            current, idx = current.next, idx+1
        raise ValueError(data)
</code></pre>


blocks|key|1477838|text|下面是我想出来的。在这个线程中，它类似于Riccardo+C.'s，只是它按顺序而不是反向打印数字。我还将LinkedList对象设为Python+Iterator，以便像打印普通Python列表一样打印出列表。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1477839|class+Node:

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

++++def+__str__(self):
++++++++return+str(self.data)


class+LinkedList:

++++def+__init__(self):
++++++++self.head+=+None
++++++++self.curr+=+None
++++++++self.tail+=+None

++++def+__iter__(self):
++++++++return+self

++++def+next(self):
++++++++if+self.head+and+not+self.curr:
++++++++++++self.curr+=+self.head
++++++++++++return+self.curr
++++++++elif+self.curr.next:
++++++++++++self.curr+=+self.curr.next
++++++++++++return+self.curr
++++++++else:
++++++++++++raise+StopIteration

++++def+append(self,+data):
++++++++n+=+Node(data)
++++++++if+not+self.head:
++++++++++++self.head+=+n
++++++++++++self.tail+=+n
++++++++else:
++++++++++++self.tail.next+=+n
++++++++++++self.tail+=+self.tail.next


#+Add+5+nodes
ll+=+LinkedList()
for+i+in+range(1,+6):
++++ll.append(i)

#+print+out+the+list
for+n+in+ll:
++++print+n

"""
Example+output:
$+python+linked_list.py
1
2
3
4
5
"""|code-block|syntax|javascript|1477840|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/280286/176611^0|K|D|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

<p>The following is what I came up with. It's similer to <a href="https://stackoverflow.com/a/280286/176611">Riccardo C.'s</a>, in this thread, except it prints the numbers in order instead of in reverse. I also made the LinkedList object a Python Iterator in order to print the list out like you would a normal Python list.</p>

<pre><code>class Node:

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

    def __str__(self):
        return str(self.data)


class LinkedList:

    def __init__(self):
        self.head = None
        self.curr = None
        self.tail = None

    def __iter__(self):
        return self

    def next(self):
        if self.head and not self.curr:
            self.curr = self.head
            return self.curr
        elif self.curr.next:
            self.curr = self.curr.next
            return self.curr
        else:
            raise StopIteration

    def append(self, data):
        n = Node(data)
        if not self.head:
            self.head = n
            self.tail = n
        else:
            self.tail.next = n
            self.tail = self.tail.next


# Add 5 nodes
ll = LinkedList()
for i in range(1, 6):
    ll.append(i)

# print out the list
for n in ll:
    print n

"""
Example output:
$ python linked_list.py
1
2
3
4
5
"""
</code></pre>


blocks|key|1477855|text|class+LinkedList:
++++def+__init__(self,+value):
++++++++self.value+=+value
++++++++self.next+=+None

++++def+insert(self,+node):
++++++++if+not+self.next:
++++++++++++self.next+=+node
++++++++else:
++++++++++++self.next.insert(node)

++++def+__str__(self):
++++++++if+self.next:
++++++++++++return+'%25s+->+%25s'+%25+(self.value,+str(self.next))
++++++++else:
++++++++++++return+'+%25s+'+%25+self.value

if+__name__+==+"__main__":
++++items+=+['a',+'b',+'c',+'d',+'e']++++
++++ll+=+None
++++for+item+in+items:
++++++++if+ll:
++++++++++++next_ll+=+LinkedList(item)
++++++++++++ll.insert(next_ll)
++++++++else:
++++++++++++ll+=+LinkedList(item)
++++print('[+%25s+]'+%25+ll)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1477856|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>class LinkedList:
    def __init__(self, value):
        self.value = value
        self.next = None

    def insert(self, node):
        if not self.next:
            self.next = node
        else:
            self.next.insert(node)

    def __str__(self):
        if self.next:
            return '%s -&gt; %s' % (self.value, str(self.next))
        else:
            return ' %s ' % self.value

if __name__ == "__main__":
    items = ['a', 'b', 'c', 'd', 'e']    
    ll = None
    for item in items:
        if ll:
            next_ll = LinkedList(item)
            ll.insert(next_ll)
        else:
            ll = LinkedList(item)
    print('[ %s ]' % ll)
</code></pre>


blocks|key|1477903|text|我只是把this当做一个有趣的玩具。只要你不接触以下划线为前缀的方法，它就应该是不可变的，并且它实现了一大堆Python魔术，比如索引和len。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1477904|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/tlevine/cons.py/blob/master/cons.py^0|1W|3|4|4|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@$9|Q|A|R|1|S]]|E|$]]|$1|F|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

<p>I just did <a href="https://github.com/tlevine/cons.py/blob/master/cons.py" rel="nofollow">this</a> as a fun toy. It should be immutable as long as you don't touch the underscore-prefixed methods, and it implements a bunch of Python magic like indexing and <code>len</code>.</p>


blocks|key|1693246|text|首先，我假设你想要链表。在实践中，您可以使用collections.deque，它当前的CPython实现是一个双向链接块列表(每个块包含一个包含62个货物对象的数组)。它包含了链表的功能。您还可以在pypi上搜索名为llist的C扩展。如果您想要一个纯Python且易于遵循的链表ADT实现，您可以看看我下面的最小实现。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1693247|class+Node+(object):
++++"""+Node+for+a+linked+list.+"""
++++def+__init__+(self,+value,+next=None):
++++++++self.value+=+value
++++++++self.next+=+next

class+LinkedList+(object):
++++"""+Linked+list+ADT+implementation+using+class.+
++++++++A+linked+list+is+a+wrapper+of+a+head+pointer
++++++++that+references+either+None,+or+a+node+that+contains+
++++++++a+reference+to+a+linked+list.
++++"""
++++def+__init__+(self,+iterable=()):
++++++++self.head+=+None
++++++++for+x+in+iterable:
++++++++++++self.head+=+Node(x,+self.head)

++++def+__iter__+(self):
++++++++p+=+self.head
++++++++while+p+is+not+None:
++++++++++++yield+p.value
++++++++++++p+=+p.next

++++def+prepend+(self,+x):++#+'appendleft'
++++++++self.head+=+Node(x,+self.head)

++++def+reverse+(self):
++++++++"""+In-place+reversal.+"""
++++++++p+=+self.head
++++++++self.head+=+None
++++++++while+p+is+not+None:
++++++++++++p0,+p+=+p,+p.next
++++++++++++p0.next+=+self.head
++++++++++++self.head+=+p0

if+__name__+==+'__main__':
++++ll+=+LinkedList([6,5,4])
++++ll.prepend(3);+ll.prepend(2)
++++print+list(ll)
++++ll.reverse()
++++print+list(ll)|code-block|syntax|javascript|1693248|entityMap^0|M|H|31|5|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

<p>First of all, I assume you want linked lists. In practice, you can use <code>collections.deque</code>, whose current CPython implementation is a doubly linked list of blocks (each block contains an array of 62 cargo objects). It subsumes linked list's functionality. You can also search for a C extension called <code>llist</code> on pypi. If you want a pure-Python and easy-to-follow implementation of the linked list ADT, you can take a look at my following minimal implementation.</p>

<pre><code>class Node (object):
    """ Node for a linked list. """
    def __init__ (self, value, next=None):
        self.value = value
        self.next = next

class LinkedList (object):
    """ Linked list ADT implementation using class. 
        A linked list is a wrapper of a head pointer
        that references either None, or a node that contains 
        a reference to a linked list.
    """
    def __init__ (self, iterable=()):
        self.head = None
        for x in iterable:
            self.head = Node(x, self.head)

    def __iter__ (self):
        p = self.head
        while p is not None:
            yield p.value
            p = p.next

    def prepend (self, x):  # 'appendleft'
        self.head = Node(x, self.head)

    def reverse (self):
        """ In-place reversal. """
        p = self.head
        self.head = None
        while p is not None:
            p0, p = p, p.next
            p0.next = self.head
            self.head = p0

if __name__ == '__main__':
    ll = LinkedList([6,5,4])
    ll.prepend(3); ll.prepend(2)
    print list(ll)
    ll.reverse()
    print list(ll)
</code></pre>


blocks|key|1477961|text|class+LL(object):
++++def+__init__(self,val):
++++++++self.val+=+val
++++++++self.next+=+None

++++def+pushNodeEnd(self,top,val):
++++++++if+top+is+None:
++++++++++++top.val=val
++++++++++++top.next=None
++++++++else:
++++++++++++tmp=top
++++++++++++while+(tmp.next+!=+None):
++++++++++++++++tmp=tmp.next++++++++
++++++++++++newNode=LL(val)
++++++++++++newNode.next=None
++++++++++++tmp.next=newNode

++++def+pushNodeFront(self,top,val):
++++++++if+top+is+None:
++++++++++++top.val=val
++++++++++++top.next=None
++++++++else:
++++++++++++newNode=LL(val)
++++++++++++newNode.next=top
++++++++++++top=newNode

++++def+popNodeFront(self,top):
++++++++if+top+is+None:
++++++++++++return
++++++++else:
++++++++++++sav=top
++++++++++++top=top.next
++++++++return+sav

++++def+popNodeEnd(self,top):
++++++++if+top+is+None:
++++++++++++return
++++++++else:
++++++++++++tmp=top
++++++++++++while+(tmp.next+!=+None):
++++++++++++++++prev=tmp
++++++++++++++++tmp=tmp.next
++++++++++++prev.next=None
++++++++return+tmp

top=LL(10)
top.pushNodeEnd(top,+20)
top.pushNodeEnd(top,+30)
pop=top.popNodeEnd(top)
print+(pop.val)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1477962|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>class LL(object):
    def __init__(self,val):
        self.val = val
        self.next = None

    def pushNodeEnd(self,top,val):
        if top is None:
            top.val=val
            top.next=None
        else:
            tmp=top
            while (tmp.next != None):
                tmp=tmp.next        
            newNode=LL(val)
            newNode.next=None
            tmp.next=newNode

    def pushNodeFront(self,top,val):
        if top is None:
            top.val=val
            top.next=None
        else:
            newNode=LL(val)
            newNode.next=top
            top=newNode

    def popNodeFront(self,top):
        if top is None:
            return
        else:
            sav=top
            top=top.next
        return sav

    def popNodeEnd(self,top):
        if top is None:
            return
        else:
            tmp=top
            while (tmp.next != None):
                prev=tmp
                tmp=tmp.next
            prev.next=None
        return tmp

top=LL(10)
top.pushNodeEnd(top, 20)
top.pushNodeEnd(top, 30)
pop=top.popNodeEnd(top)
print (pop.val)
</code></pre>


blocks|key|1478019|text|我在https://pypi.python.org/pypi/linked_list_mod/上放了一个Python2.x和3.x的单向链表类|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1478020|它已经在Pypy2.7、CPython+3.4、Pypy+2.3.1、Pypy3+2.3.1和Jython2.7b2上进行了测试，并附带了一个很好的自动化测试套件。|1478021|它还包括LIFO和FIFO类。|1478022|但它们并不是一成不变的。|1478023|entityMap|0|LINK|mutability|MUTABLE|url|https://pypi.python.org/pypi/linked_list_mod/^0|2|19|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@$A|S|B|T|1|U]]|C|$]]|$1|D|3|E|5|6|7|V|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@]|C|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@]|C|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|K|$L|$5|M|N|O|C|$P|Q]]]]

<p>I've put a Python 2.x and 3.x singly-linked list class at <a href="https://pypi.python.org/pypi/linked_list_mod/" rel="nofollow">https://pypi.python.org/pypi/linked_list_mod/</a></p>

<p>It's tested with CPython 2.7, CPython 3.4, Pypy 2.3.1, Pypy3 2.3.1, and Jython 2.7b2, and comes with a nice automated test suite.</p>

<p>It also includes LIFO and FIFO classes.</p>

<p>They aren't immutable though.</p>


blocks|key|1693306|text|我的2分|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1693307|class+Node:
++++def+__init__(self,+value=None,+next=None):
++++++++self.value+=+value
++++++++self.next+=+next

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


class+LinkedList:
++++def+__init__(self):
++++++++self.first+=+None
++++++++self.last+=+None

++++def+add(self,+x):
++++++++current+=+Node(x,+None)
++++++++try:
++++++++++++self.last.next+=+current
++++++++except+AttributeError:
++++++++++++self.first+=+current
++++++++++++self.last+=+current
++++++++else:
++++++++++++self.last+=+current

++++def+print_list(self):
++++++++node+=+self.first
++++++++while+node:
++++++++++++print+node.value
++++++++++++node+=+node.next

ll+=+LinkedList()
ll.add("1st")
ll.add("2nd")
ll.add("3rd")
ll.add("4th")
ll.add("5th")

ll.print_list()

#+Result:+
#+1st
#+2nd
#+3rd
#+4th
#+5th|code-block|syntax|javascript|1693308|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>My 2 cents </p>

<pre><code>class Node:
    def __init__(self, value=None, next=None):
        self.value = value
        self.next = next

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


class LinkedList:
    def __init__(self):
        self.first = None
        self.last = None

    def add(self, x):
        current = Node(x, None)
        try:
            self.last.next = current
        except AttributeError:
            self.first = current
            self.last = current
        else:
            self.last = current

    def print_list(self):
        node = self.first
        while node:
            print node.value
            node = node.next

ll = LinkedList()
ll.add("1st")
ll.add("2nd")
ll.add("3rd")
ll.add("4th")
ll.add("5th")

ll.print_list()

# Result: 
# 1st
# 2nd
# 3rd
# 4th
# 5th
</code></pre>


blocks|key|1478050|text|enter+code+here
enter+code+here

class+node:
++++def+__init__(self):
++++++++self.data+=+None
++++++++self.next+=+None
class+linked_list:
++++def+__init__(self):
++++++++self.cur_node+=+None
++++++++self.head+=+None
++++def+add_node(self,data):
++++++++new_node+=+node()
++++++++if+self.head+==+None:
++++++++++++self.head+=+new_node
++++++++++++self.cur_node+=+new_node
++++++++new_node.data+=+data
++++++++new_node.next+=+None
++++++++self.cur_node.next+=+new_node
++++++++self.cur_node+=+new_node
++++def+list_print(self):
++++++++node+=+self.head
++++++++while+node:
++++++++++++print+(node.data)
++++++++++++node+=+node.next
++++def+delete(self):
++++++++node+=+self.head
++++++++next_node+=+node.next
++++++++del(node)
++++++++self.head+=+next_node
a+=+linked_list()
a.add_node(1)
a.add_node(2)
a.add_node(3)
a.add_node(4)
a.delete()
a.list_print()|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1478051|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>enter code here
enter code here

class node:
    def __init__(self):
        self.data = None
        self.next = None
class linked_list:
    def __init__(self):
        self.cur_node = None
        self.head = None
    def add_node(self,data):
        new_node = node()
        if self.head == None:
            self.head = new_node
            self.cur_node = new_node
        new_node.data = data
        new_node.next = None
        self.cur_node.next = new_node
        self.cur_node = new_node
    def list_print(self):
        node = self.head
        while node:
            print (node.data)
            node = node.next
    def delete(self):
        node = self.head
        next_node = node.next
        del(node)
        self.head = next_node
a = linked_list()
a.add_node(1)
a.add_node(2)
a.add_node(3)
a.add_node(4)
a.delete()
a.list_print()
</code></pre>


blocks|key|1693377|text|如果您只想创建一个简单的点赞列表，请参考以下代码|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1693378|l=[1，[2，[3，[4，[5，[6，[7，[8，[9，10]|1693379|有关此代码的可视化执行，请访问http://www.pythontutor.com/visualize.html#mode=edit|offset|length|1693380|entityMap|0|LINK|mutability|MUTABLE|url|http://www.pythontutor.com/visualize.html#mode=edit^0|0|0|F|1F|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@$F|S|G|T|1|U]]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

<p>If you want to just create a simple liked list then refer this code</p>

<p>l=[1,[2,[3,[4,[5,[6,[7,[8,[9,[10]]]]]]]]]]</p>

<p>for visualize execution for this cod Visit <a href="http://www.pythontutor.com/visualize.html#mode=edit" rel="nofollow">http://www.pythontutor.com/visualize.html#mode=edit</a>  </p>


blocks|key|1693384|text|class+LinkedStack:
'''LIFO+Stack+implementation+using+a+singly+linked+list+for+storage.'''

_ToList+=+[]

#----------+nested+_Node+class+-----------------------------
class+_Node:
++++'''Lightweight,+nonpublic+class+for+storing+a+singly+linked+node.'''
++++__slots__+=+'_element',+'_next'+++++#streamline+memory+usage

++++def+__init__(self,+element,+next):
++++++++self._element+=+element
++++++++self._next+=+next

#---------------+stack+methods+---------------------------------
def+__init__(self):
++++'''Create+an+empty+stack.'''
++++self._head+=+None
++++self._size+=+0

def+__len__(self):
++++'''Return+the+number+of+elements+in+the+stack.'''
++++return+self._size

def+IsEmpty(self):
++++'''Return+True+if+the+stack+is+empty'''
++++return++self._size+==+0

def+Push(self,e):
++++'''Add+element+e+to+the+top+of+the+Stack.'''
++++self._head+=+self._Node(e,+self._head)++++++#create+and+link+a+new+node
++++self._size+%2B=1
++++self._ToList.append(e)

def+Top(self):
++++'''Return+(but+do+not+remove)+the+element+at+the+top+of+the+stack.
+++++++Raise+exception+if+the+stack+is+empty
++++'''

++++if+self.IsEmpty():
++++++++raise+Exception('Stack+is+empty')
++++return++self._head._element+++++++++++++#top+of+stack+is+at+head+of+list

def+Pop(self):
++++'''Remove+and+return+the+element+from+the+top+of+the+stack+(i.e.+LIFO).
+++++++Raise+exception+if+the+stack+is+empty
++++'''
++++if+self.IsEmpty():
++++++++raise+Exception('Stack+is+empty')
++++answer+=+self._head._element
++++self._head+=+self._head._next+++++++#bypass+the+former+top+node
++++self._size+-=1
++++self._ToList.remove(answer)
++++return+answer

def+Count(self):
++++'''Return+how+many+nodes+the+stack+has'''
++++return+self.__len__()

def+Clear(self):
++++'''Delete+all+nodes'''
++++for+i+in+range(self.Count()):
++++++++self.Pop()

def+ToList(self):
++++return+self._ToList|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1693385|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>class LinkedStack:
'''LIFO Stack implementation using a singly linked list for storage.'''

_ToList = []

#---------- nested _Node class -----------------------------
class _Node:
    '''Lightweight, nonpublic class for storing a singly linked node.'''
    __slots__ = '_element', '_next'     #streamline memory usage

    def __init__(self, element, next):
        self._element = element
        self._next = next

#--------------- stack methods ---------------------------------
def __init__(self):
    '''Create an empty stack.'''
    self._head = None
    self._size = 0

def __len__(self):
    '''Return the number of elements in the stack.'''
    return self._size

def IsEmpty(self):
    '''Return True if the stack is empty'''
    return  self._size == 0

def Push(self,e):
    '''Add element e to the top of the Stack.'''
    self._head = self._Node(e, self._head)      #create and link a new node
    self._size +=1
    self._ToList.append(e)

def Top(self):
    '''Return (but do not remove) the element at the top of the stack.
       Raise exception if the stack is empty
    '''

    if self.IsEmpty():
        raise Exception('Stack is empty')
    return  self._head._element             #top of stack is at head of list

def Pop(self):
    '''Remove and return the element from the top of the stack (i.e. LIFO).
       Raise exception if the stack is empty
    '''
    if self.IsEmpty():
        raise Exception('Stack is empty')
    answer = self._head._element
    self._head = self._head._next       #bypass the former top node
    self._size -=1
    self._ToList.remove(answer)
    return answer

def Count(self):
    '''Return how many nodes the stack has'''
    return self.__len__()

def Clear(self):
    '''Delete all nodes'''
    for i in range(self.Count()):
        self.Pop()

def ToList(self):
    return self._ToList
</code></pre>


blocks|key|1478124|text|class+Node(object):
++++def+__init__(self,+data=None,+next=None):
++++++++self.data+=+data
++++++++self.next+=+next

++++def+setData(self,+data):
++++++++self.data+=+data
++++++++return+self.data

++++def+setNext(self,+next):
++++++++self.next+=+next

++++def+getNext(self):
++++++++return+self.next

++++def+hasNext(self):
++++++++return+self.next+!=+None


class+singleLinkList(object):

++++def+__init__(self):
++++++++self.head+=+None

++++def+isEmpty(self):
++++++++return+self.head+==+None

++++def+insertAtBeginning(self,+data):
++++++++newNode+=+Node()
++++++++newNode.setData(data)

++++++++if+self.listLength()+==+0:
++++++++++++self.head+=+newNode
++++++++else:
++++++++++++newNode.setNext(self.head)
++++++++++++self.head+=+newNode

++++def+insertAtEnd(self,+data):
++++++++newNode+=+Node()
++++++++newNode.setData(data)

++++++++current+=+self.head

++++++++while+current.getNext()+!=+None:
++++++++++++current+=+current.getNext()

++++++++current.setNext(newNode)

++++def+listLength(self):
++++++++current+=+self.head
++++++++count+=+0

++++++++while+current+!=+None:
++++++++++++count+%2B=+1
++++++++++++current+=+current.getNext()
++++++++return+count

++++def+print_llist(self):
++++++++current+=+self.head
++++++++print("List+Start.")
++++++++while+current+!=+None:
++++++++++++print(current.getData())
++++++++++++current+=+current.getNext()

++++++++print("List+End.")



if+__name__+==+'__main__':
++++ll+=+singleLinkList()
++++ll.insertAtBeginning(55)
++++ll.insertAtEnd(56)
++++ll.print_llist()
++++print(ll.listLength())|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1478125|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>class Node(object):
    def __init__(self, data=None, next=None):
        self.data = data
        self.next = next

    def setData(self, data):
        self.data = data
        return self.data

    def setNext(self, next):
        self.next = next

    def getNext(self):
        return self.next

    def hasNext(self):
        return self.next != None


class singleLinkList(object):

    def __init__(self):
        self.head = None

    def isEmpty(self):
        return self.head == None

    def insertAtBeginning(self, data):
        newNode = Node()
        newNode.setData(data)

        if self.listLength() == 0:
            self.head = newNode
        else:
            newNode.setNext(self.head)
            self.head = newNode

    def insertAtEnd(self, data):
        newNode = Node()
        newNode.setData(data)

        current = self.head

        while current.getNext() != None:
            current = current.getNext()

        current.setNext(newNode)

    def listLength(self):
        current = self.head
        count = 0

        while current != None:
            count += 1
            current = current.getNext()
        return count

    def print_llist(self):
        current = self.head
        print("List Start.")
        while current != None:
            print(current.getData())
            current = current.getNext()

        print("List End.")



if __name__ == '__main__':
    ll = singleLinkList()
    ll.insertAtBeginning(55)
    ll.insertAtEnd(56)
    ll.print_llist()
    print(ll.listLength())
</code></pre>


blocks|key|1693427|text|下面是我的简单实现：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1693428|class+Node:
++++def+__init__(self):
++++++++self.data+=+None
++++++++self.next+=+None
++++def+__str__(self):
++++++++return+"Data+%25s:+Next+->+%25s"%25(self.data,+self.next)

class+LinkedList:
++++def+__init__(self):
++++++++self.head+=+Node()
++++++++self.curNode+=+self.head
++++def+insertNode(self,+data):
++++++++node+=+Node()
++++++++node.data+=+data
++++++++node.next+=+None
++++++++if+self.head.data+==+None:
++++++++++++self.head+=+node
++++++++++++self.curNode+=+node
++++++++else:
++++++++++++self.curNode.next+=+node
++++++++++++self.curNode+=+node
++++def+printList(self):
++++++++print+self.head

l+=+LinkedList()
l.insertNode(1)
l.insertNode(2)
l.insertNode(34)|code-block|syntax|javascript|1693429|输出：|1693430|Data+1:+Next+->+Data+2:+Next+->+Data+34:+Next+->+Data+4:+Next+->+None|1693431|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<p>Here is my simple implementation: </p>

<pre><code>class Node:
    def __init__(self):
        self.data = None
        self.next = None
    def __str__(self):
        return "Data %s: Next -&gt; %s"%(self.data, self.next)

class LinkedList:
    def __init__(self):
        self.head = Node()
        self.curNode = self.head
    def insertNode(self, data):
        node = Node()
        node.data = data
        node.next = None
        if self.head.data == None:
            self.head = node
            self.curNode = node
        else:
            self.curNode.next = node
            self.curNode = node
    def printList(self):
        print self.head

l = LinkedList()
l.insertNode(1)
l.insertNode(2)
l.insertNode(34)
</code></pre>

<p>Output:</p>

<pre><code>Data 1: Next -&gt; Data 2: Next -&gt; Data 34: Next -&gt; Data 4: Next -&gt; None
</code></pre>


blocks|key|1693548|text|Python的列表-链接列表数据类型|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1693549|llist模块实现了链表数据结构。它支持双向链表，即dllist和单链数据结构sllist。|offset|length|style|CODE|1693550|dllist对象|1693551|此对象表示双向链表数据结构。|1693552|first|1693553|列表中的第一个dllistnode对象。如果列表为空，则返回None。|1693554|last|1693555|列表中的最后一个dllistnode对象。如果list为空，则为None。|1693556|dllist对象还支持以下方法：|1693557|append(x)|1693558|在列表右侧添加x并返回插入的dllistnode。|1693559|appendleft(x)|1693560|在列表左侧添加x并返回插入的dllistnode。|1693561|appendright(x)|1693562|1693563|clear()|1693564|从列表中删除所有节点。|1693565|extend(iterable)|1693566|将元素从iterable追加到列表的右侧。|1693567|extendleft(iterable)|1693568|将元素从iterable追加到列表的左侧。|1693569|extendright(iterable)|1693570|1693571|insert(x[,+before])|1693572|如果未指定x，则将before添加到列表的右侧，或将x插入到dllistnode+before的左侧。返回插入的dllistnode。|1693573|nodeat(index)|1693574|返回index处的节点(类型为dllistnode)。|1693575|pop()|1693576|从列表的右侧移除并返回元素的值。|1693577|popleft()|1693578|从列表的左侧移除并返回元素的值。|1693579|popright()|1693580|从列表的右侧移除并返回元素的值|1693581|remove(node)|1693582|从列表中删除node并返回存储在其中的元素。|1693583|dllistnode对象|1693584|llist.dllistnode([value])类|1693585|返回一个新的双向链接列表节点，使用value初始化(可选)。|1693586|dllistnode对象提供以下属性：|1693587|next|1693588|列表中的下一个节点。此属性是只读的。|1693589|prev|1693590|列表中的上一个节点。此属性是只读的。|1693591|value|1693592|此节点中存储的值。Compiled+from+this+reference|1693593|sllist|1693594|类llist.sllist([iterable])返回一个用iterable中的元素初始化的新的单向链表。如果未指定iterable，则新的sllist为空。|1693595|为这个sllist对象定义了一组类似的属性和操作。See+this+reference+for+more+information.|1693596|entityMap|0|LINK|mutability|MUTABLE|url|https://pythonhosted.org/llist/|1|https://pythonhosted.org/llist/#llist.sllist^0|0|Q|6|13|6|0|0|0|0|5|0|7|A|U|4|0|0|4|0|8|A|0|0|0|9|0|7|1|E|A|0|0|D|0|7|1|E|A|0|0|E|0|7|1|E|A|0|0|7|0|0|0|G|0|4|8|0|0|K|0|4|8|0|0|L|0|4|8|0|0|J|0|5|1|9|6|Q|1|U|H|1K|A|0|0|D|0|2|5|F|A|0|0|5|0|0|0|9|0|0|0|A|0|0|0|C|0|6|4|0|0|A|0|0|P|0|H|5|0|0|A|0|0|4|0|0|0|4|0|0|0|5|0|9|S|0|0|0|1|O|U|8|1Y|6|0|3|6|P|14|1|0^^$0|@$1|2|3|4|5|6|7|39|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|3A|8|@$D|3B|E|3C|F|G]|$D|3D|E|3E|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|3F|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|3G|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|3H|8|@$D|3I|E|3J|F|G]]|9|@]|A|$]]|$1|N|3|O|5|6|7|3K|8|@$D|3L|E|3M|F|G]|$D|3N|E|3O|F|G]]|9|@]|A|$]]|$1|P|3|Q|5|6|7|3P|8|@$D|3Q|E|3R|F|G]]|9|@]|A|$]]|$1|R|3|S|5|6|7|3S|8|@$D|3T|E|3U|F|G]]|9|@]|A|$]]|$1|T|3|U|5|6|7|3V|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|3W|8|@$D|3X|E|3Y|F|G]]|9|@]|A|$]]|$1|X|3|Y|5|6|7|3Z|8|@$D|40|E|41|F|G]|$D|42|E|43|F|G]]|9|@]|A|$]]|$1|Z|3|10|5|6|7|44|8|@$D|45|E|46|F|G]]|9|@]|A|$]]|$1|11|3|12|5|6|7|47|8|@$D|48|E|49|F|G]|$D|4A|E|4B|F|G]]|9|@]|A|$]]|$1|13|3|14|5|6|7|4C|8|@$D|4D|E|4E|F|G]]|9|@]|A|$]]|$1|15|3|Y|5|6|7|4F|8|@$D|4G|E|4H|F|G]|$D|4I|E|4J|F|G]]|9|@]|A|$]]|$1|16|3|17|5|6|7|4K|8|@$D|4L|E|4M|F|G]]|9|@]|A|$]]|$1|18|3|19|5|6|7|4N|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|6|7|4O|8|@$D|4P|E|4Q|F|G]]|9|@]|A|$]]|$1|1C|3|1D|5|6|7|4R|8|@$D|4S|E|4T|F|G]]|9|@]|A|$]]|$1|1E|3|1F|5|6|7|4U|8|@$D|4V|E|4W|F|G]]|9|@]|A|$]]|$1|1G|3|1H|5|6|7|4X|8|@$D|4Y|E|4Z|F|G]]|9|@]|A|$]]|$1|1I|3|1J|5|6|7|50|8|@$D|51|E|52|F|G]]|9|@]|A|$]]|$1|1K|3|1D|5|6|7|53|8|@$D|54|E|55|F|G]]|9|@]|A|$]]|$1|1L|3|1M|5|6|7|56|8|@$D|57|E|58|F|G]]|9|@]|A|$]]|$1|1N|3|1O|5|6|7|59|8|@$D|5A|E|5B|F|G]|$D|5C|E|5D|F|G]|$D|5E|E|5F|F|G]|$D|5G|E|5H|F|G]|$D|5I|E|5J|F|G]]|9|@]|A|$]]|$1|1P|3|1Q|5|6|7|5K|8|@$D|5L|E|5M|F|G]]|9|@]|A|$]]|$1|1R|3|1S|5|6|7|5N|8|@$D|5O|E|5P|F|G]|$D|5Q|E|5R|F|G]]|9|@]|A|$]]|$1|1T|3|1U|5|6|7|5S|8|@$D|5T|E|5U|F|G]]|9|@]|A|$]]|$1|1V|3|1W|5|6|7|5V|8|@]|9|@]|A|$]]|$1|1X|3|1Y|5|6|7|5W|8|@$D|5X|E|5Y|F|G]]|9|@]|A|$]]|$1|1Z|3|20|5|6|7|5Z|8|@]|9|@]|A|$]]|$1|21|3|22|5|6|7|60|8|@$D|61|E|62|F|G]]|9|@]|A|$]]|$1|23|3|24|5|6|7|63|8|@]|9|@]|A|$]]|$1|25|3|26|5|6|7|64|8|@$D|65|E|66|F|G]]|9|@]|A|$]]|$1|27|3|28|5|6|7|67|8|@$D|68|E|69|F|G]]|9|@]|A|$]]|$1|29|3|2A|5|6|7|6A|8|@$D|6B|E|6C|F|G]]|9|@]|A|$]]|$1|2B|3|2C|5|6|7|6D|8|@$D|6E|E|6F|F|G]]|9|@]|A|$]]|$1|2D|3|2E|5|6|7|6G|8|@$D|6H|E|6I|F|G]]|9|@]|A|$]]|$1|2F|3|2G|5|6|7|6J|8|@$D|6K|E|6L|F|G]]|9|@]|A|$]]|$1|2H|3|2I|5|6|7|6M|8|@$D|6N|E|6O|F|G]]|9|@]|A|$]]|$1|2J|3|2K|5|6|7|6P|8|@]|9|@]|A|$]]|$1|2L|3|2M|5|6|7|6Q|8|@$D|6R|E|6S|F|G]]|9|@]|A|$]]|$1|2N|3|2O|5|6|7|6T|8|@]|9|@]|A|$]]|$1|2P|3|2Q|5|6|7|6U|8|@$D|6V|E|6W|F|G]]|9|@]|A|$]]|$1|2R|3|2S|5|6|7|6X|8|@]|9|@$D|6Y|E|6Z|1|70]]|A|$]]|$1|2T|3|2U|5|6|7|71|8|@]|9|@]|A|$]]|$1|2V|3|2W|5|6|7|72|8|@$D|73|E|74|F|G]|$D|75|E|76|F|G]|$D|77|E|78|F|G]]|9|@]|A|$]]|$1|2X|3|2Y|5|6|7|79|8|@$D|7A|E|7B|F|G]]|9|@$D|7C|E|7D|1|7E]]|A|$]]|$1|2Z|3|-4|5|6|7|7F|8|@]|9|@]|A|$]]]|30|$31|$5|32|33|34|A|$35|36]]|37|$5|32|33|34|A|$35|38]]]]

<h1>llist — Linked list datatypes for Python</h1>

<p>llist module implements linked list data structures. It supports a doubly linked list, i.e. <code>dllist</code> and a singly linked data structure <code>sllist</code>.</p>

<h2>dllist objects</h2>

<p>This object represents a doubly linked list data structure.  </p>

<h3><code>first</code></h3>

<p>First <code>dllistnode</code> object in the list. <code>None</code> if list is empty. </p>

<h3><code>last</code></h3>

<p>Last <code>dllistnode</code> object in the list. None if list is empty. </p>

<p>dllist objects also support the following methods:</p>

<h3><code>append(x)</code></h3>

<p>Add <code>x</code> to the right side of the list and return inserted <code>dllistnode</code>.</p>

<h3><code>appendleft(x)</code></h3>

<p>Add <code>x</code> to the left side of the list and return inserted <code>dllistnode</code>.</p>

<h3><code>appendright(x)</code></h3>

<p>Add <code>x</code> to the right side of the list and return inserted <code>dllistnode</code>.</p>

<h3><code>clear()</code></h3>

<p>Remove all nodes from the list.</p>

<h3><code>extend(iterable)</code></h3>

<p>Append elements from <code>iterable</code> to the right side of the list.</p>

<h3><code>extendleft(iterable)</code></h3>

<p>Append elements from <code>iterable</code> to the left side of the list. </p>

<h3><code>extendright(iterable)</code></h3>

<p>Append elements from <code>iterable</code> to the right side of the list.</p>

<h3><code>insert(x[, before])</code></h3>

<p>Add <code>x</code> to the right side of the list if <code>before</code> is not specified, or insert <code>x</code> to the left side of <code>dllistnode before</code>. Return inserted <code>dllistnode</code>.</p>

<h3><code>nodeat(index)</code></h3>

<p>Return node (of type <code>dllistnode</code>) at <code>index</code>.</p>

<h3><code>pop()</code></h3>

<p>Remove and return an element’s value from the right side of the list.</p>

<h3><code>popleft()</code></h3>

<p>Remove and return an element’s value from the left side of the list.</p>

<h3><code>popright()</code></h3>

<p>Remove and return an element’s value from the right side of the list </p>

<h3><code>remove(node)</code></h3>

<p>Remove <code>node</code> from the list and return the element which was stored in it.</p>

<h2><code>dllistnode</code> objects</h2>

<h3>class <code>llist.dllistnode([value])</code></h3>

<p>Return a new doubly linked list node, initialized (optionally) with <code>value</code>.</p>

<h3><code>dllistnode</code> objects provide the following attributes:</h3>

<h3><code>next</code></h3>

<p>Next node in the list. This attribute is read-only.</p>

<h3><code>prev</code></h3>

<p>Previous node in the list. This attribute is read-only.</p>

<h3><code>value</code></h3>

<p>Value stored in this node.
<a href="https://pythonhosted.org/llist/" rel="noreferrer">Compiled from this reference</a></p>

<h1>sllist</h1>

<p>class <code>llist.sllist([iterable])</code>
Return a new singly linked list initialized with elements from <code>iterable</code>. If iterable is not specified, the new <code>sllist</code> is empty.</p>

<p>A similar set of attributes and operations are defined for this <code>sllist</code> object. <a href="https://pythonhosted.org/llist/#llist.sllist" rel="noreferrer">See this reference for more information.</a></p>


blocks|key|1478272|text|我的双向链表可能是新手可以理解的。如果您熟悉C语言中的DS，那么这篇文章的可读性非常好。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1478273|#+LinkedList..

class+node:
++++def+__init__(self):+++++++++++##Cluster+of+Nodes'+properties+
++++++++self.data=None
++++++++self.next=None
++++++++self.prev=None

class+linkedList():
++++def+__init__(self):
++++++++self.t+=+node()++++++++++++++++++++//+for+future+use
++++++++self.cur_node+=+node()+++++++++++++//+current+node
++++++++self.start=node()

++++def+add(self,data):++++++++++++++++++++++++++//+appending+the+LL

++++++++self.new_node+=+node()
++++++++self.new_node.data=data
++++++++if+self.cur_node.data+is+None:++++++++++
++++++++++++self.start=self.new_node+++++++++++++++//For+the+1st+node+only

++++++++self.cur_node.next=self.new_node
++++++++self.new_node.prev=self.cur_node
++++++++self.cur_node=self.new_node


++++def+backward_display(self):++++++++++++++++++//Displays+LL+backwards
++++++++self.t=self.cur_node
++++++++while+self.t.data+is+not+None:
++++++++++++print(self.t.data)
++++++++++++self.t=self.t.prev

++++def+forward_display(self):+++++++++++++++++++//Displays+LL+Forward
++++++++self.t=self.start
++++++++while+self.t.data+is+not+None:
++++++++++++print(self.t.data)
++++++++++++self.t=self.t.next
++++++++++++if+self.t.next+is+None:
++++++++++++++++print(self.t.data)
++++++++++++++++break

++++def+main(self):++++++++++++++++++++++++++//This+is+kind+of+the+main+
+++++++++++++++++++++++++++++++++++++++++++++++function+in+C
++++++++ch=0
++++++++while+ch+is+not+4:++++++++++++++++++++//Switch-case+in+C+
++++++++++++ch=int(input("Enter+your+choice:"))
++++++++++++if+ch+is+1:
++++++++++++++++data=int(input("Enter+data+to+be+added:"))
++++++++++++++++ll.add(data)
++++++++++++++++ll.main()
++++++++++++elif+ch+is+2:
++++++++++++++++ll.forward_display()
++++++++++++++++ll.main()
++++++++++++elif+ch+is+3:
++++++++++++++++ll.backward_display()
++++++++++++++++ll.main()
++++++++++++else:
++++++++++++++++print("Program+ends!!")
++++++++++++++++return


ll=linkedList()
ll.main()|code-block|syntax|javascript|1478274|虽然可以在代码中添加更多的简化，但我认为原始的实现会更容易抓取。|1478275|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

<p>my double Linked List might be understandable to noobies. 
If you are familiar with DS in C, this is quite readable.</p>

<pre><code># LinkedList..

class node:
    def __init__(self):           ##Cluster of Nodes' properties 
        self.data=None
        self.next=None
        self.prev=None

class linkedList():
    def __init__(self):
        self.t = node()                    // for future use
        self.cur_node = node()             // current node
        self.start=node()

    def add(self,data):                          // appending the LL

        self.new_node = node()
        self.new_node.data=data
        if self.cur_node.data is None:          
            self.start=self.new_node               //For the 1st node only

        self.cur_node.next=self.new_node
        self.new_node.prev=self.cur_node
        self.cur_node=self.new_node


    def backward_display(self):                  //Displays LL backwards
        self.t=self.cur_node
        while self.t.data is not None:
            print(self.t.data)
            self.t=self.t.prev

    def forward_display(self):                   //Displays LL Forward
        self.t=self.start
        while self.t.data is not None:
            print(self.t.data)
            self.t=self.t.next
            if self.t.next is None:
                print(self.t.data)
                break

    def main(self):                          //This is kind of the main 
                                               function in C
        ch=0
        while ch is not 4:                    //Switch-case in C 
            ch=int(input("Enter your choice:"))
            if ch is 1:
                data=int(input("Enter data to be added:"))
                ll.add(data)
                ll.main()
            elif ch is 2:
                ll.forward_display()
                ll.main()
            elif ch is 3:
                ll.backward_display()
                ll.main()
            else:
                print("Program ends!!")
                return


ll=linkedList()
ll.main()
</code></pre>

<p>Though many more simplifications can be added to this code, I thought a raw implementation would me more grabbable.</p>


blocks|key|1478493|text|扩展Nick+Stinemates's答案|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1478494|class+Node(object):
++++def+__init__(self):
++++++++self.data+=+None
++++++++self.next+=+None

class+LinkedList:
++++def+__init__(self):
++++++++self.head+=+None

++++def+prepend_node(self,+data):
++++++++new_node+=+Node()
++++++++new_node.data+=+data
++++++++new_node.next+=+self.head
++++++++self.head+=+new_node

++++def+append_node(self,+data):
++++++++new_node+=+Node()
++++++++new_node.data+=+data
++++++++current+=+self.head
++++++++while+current.next:
++++++++++++current+=+current.next
++++++++current.next+=+new_node

++++def+reverse(self):
++++++++"""+In-place+reversal,+modifies+exiting+list"""
++++++++previous+=+None
++++++++current_node+=+self.head

++++++++while+current_node:
++++++++++++temp+=++current_node.next
++++++++++++current_node.next+=+previous
++++++++++++previous+=+current_node
++++++++++++current_node+=+temp
++++++++self.head+=+previous

++++def+search(self,+data):
++++++++current_node+=+self.head
++++++++try:
++++++++++++while+current_node.data+!=+data:
++++++++++++++++current_node+=+current_node.next
++++++++++++return+True
++++++++except:
++++++++++++return+False

++++def+display(self):
++++++++if+self.head+is+None:
++++++++++++print("Linked+list+is+empty")
++++++++else:
++++++++++++current_node+=+self.head
++++++++++++while+current_node:
++++++++++++++++print(current_node.data)
++++++++++++++++current_node+=+current_node.next

++++def+list_length(self):
++++++++list_length+=+0
++++++++current_node+=+self.head
++++++++while+current_node:
++++++++++++list_length+%2B=+1
++++++++++++current_node+=+current_node.next
++++++++return+list_length


def+main():
++++linked_list+=+LinkedList()

++++linked_list.prepend_node(1)
++++linked_list.prepend_node(2)
++++linked_list.prepend_node(3)
++++linked_list.append_node(24)
++++linked_list.append_node(25)
++++linked_list.display()
++++linked_list.reverse()
++++linked_list.display()
++++print(linked_list.search(1))
++++linked_list.reverse()
++++linked_list.display()
++++print("Lenght+of+singly+linked+list+is:+"+%2B+str(linked_list.list_length()))


if+__name__+==+"__main__":
++++main()|code-block|syntax|javascript|1478495|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/280286^0|2|H|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

<p>Expanding <a href="https://stackoverflow.com/a/280286">Nick Stinemates's</a> answer</p>

<pre><code>class Node(object):
    def __init__(self):
        self.data = None
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = None

    def prepend_node(self, data):
        new_node = Node()
        new_node.data = data
        new_node.next = self.head
        self.head = new_node

    def append_node(self, data):
        new_node = Node()
        new_node.data = data
        current = self.head
        while current.next:
            current = current.next
        current.next = new_node

    def reverse(self):
        """ In-place reversal, modifies exiting list"""
        previous = None
        current_node = self.head

        while current_node:
            temp =  current_node.next
            current_node.next = previous
            previous = current_node
            current_node = temp
        self.head = previous

    def search(self, data):
        current_node = self.head
        try:
            while current_node.data != data:
                current_node = current_node.next
            return True
        except:
            return False

    def display(self):
        if self.head is None:
            print("Linked list is empty")
        else:
            current_node = self.head
            while current_node:
                print(current_node.data)
                current_node = current_node.next

    def list_length(self):
        list_length = 0
        current_node = self.head
        while current_node:
            list_length += 1
            current_node = current_node.next
        return list_length


def main():
    linked_list = LinkedList()

    linked_list.prepend_node(1)
    linked_list.prepend_node(2)
    linked_list.prepend_node(3)
    linked_list.append_node(24)
    linked_list.append_node(25)
    linked_list.display()
    linked_list.reverse()
    linked_list.display()
    print(linked_list.search(1))
    linked_list.reverse()
    linked_list.display()
    print("Lenght of singly linked list is: " + str(linked_list.list_length()))


if __name__ == "__main__":
    main()

</code></pre>


blocks|key|1478589|text|当前在Python中实现链表需要创建一个单独的类，称为Node，这样它们就可以使用主链表类进行连接。在所提供的实现中，在没有为节点定义单独的类的情况下创建链表。使用所提出的实现，链表更容易理解，并且可以使用打印功能简单地可视化。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1478590|class+Linkedlist:
+++++def+__init__(self):
+++++++++self.outer+=+None

+++++def+add_outermost(self,+dt):
+++++++++self.outer+=+[dt,+self.outer]

+++++def+add_innermost(self,+dt):
+++++++++p+=+self.outer
+++++++++if+not+p:
+++++++++++++self.outer+=+[dt,+None]
+++++++++++++return
+++++++++while+p[1]:
+++++++++++++p+=+p[1]
+++++++++p[1]+=+[dt,+None]

+++++def+visualize(self):
+++++++++p+=+self.outer
+++++++++l+=+'Linkedlist:+'
+++++++++while+p:
+++++++++++++l+%2B=+(str(p[0])%2B'->')
+++++++++++++p+=+p[1]
+++++++++print(l+%2B+'None')

+ll+=+Linkedlist()
+ll.add_innermost(8)
+ll.add_outermost(3)
+ll.add_outermost(5)
+ll.add_outermost(2)
+ll.add_innermost(7)
+print(ll.outer)
+ll.visualize()|code-block|syntax|javascript|1478591|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Current Implementation of Linked List in Python requires for creation of a separate class, called Node, so that they can be connected using a main Linked List class. In the provided implementation, the Linked List is created without defining a separate class for a node. Using the proposed implementation, Linked Lists are easier to understand and can be simply visualized using the print function.</p>
<pre><code>class Linkedlist:
     def __init__(self):
         self.outer = None

     def add_outermost(self, dt):
         self.outer = [dt, self.outer]

     def add_innermost(self, dt):
         p = self.outer
         if not p:
             self.outer = [dt, None]
             return
         while p[1]:
             p = p[1]
         p[1] = [dt, None]

     def visualize(self):
         p = self.outer
         l = 'Linkedlist: '
         while p:
             l += (str(p[0])+'-&gt;')
             p = p[1]
         print(l + 'None')

 ll = Linkedlist()
 ll.add_innermost(8)
 ll.add_outermost(3)
 ll.add_outermost(5)
 ll.add_outermost(2)
 ll.add_innermost(7)
 print(ll.outer)
 ll.visualize()
</code></pre>


<p>What's the easiest way to use a linked list in python? In scheme, a linked list is defined simply by <code>'(1 2 3 4 5)</code>. Python's lists, <code>[1, 2, 3, 4, 5]</code>, and tuples, <code>(1, 2, 3, 4, 5)</code>, are not, in fact, linked lists, and linked lists have some nice properties such as constant-time concatenation, and being able to reference separate parts of them. Make them immutable and they are really easy to work with!</p>


Python Linked List

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

在python中使用链表的最简单方法是什么？在方案中，链表简单地由'(1 2 3 4 5)定义。事实上，Python的列表[1, 2, 3, 4, 5]和元组(1, 2, 3, 4, 5)并不是链表，并且链表具有一些很好的属性，比如常量时间连接，并且能够引用它们的不同部分。让它们成为不可变的，它们真的很容易使用！

问Python链表
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python链表EN