python实现单向链表和双向链表

链表是数据结构中最基本常用的，python作为面向对象编程的，可以使用创建一个Node类来实现链表， 可以先创建一个节点类，然后再创建一个链表类，接着实现一些功能，包括尾部加入，可迭代，插入，删除，等

首先是单向链表实现append 方法和可迭代：

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


    def __repr__(self):
        return '<{} --> {}>'.format(self.item,
                  self.next.item if self.next else 'None')


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


    def append(self,item):
        node = Node(item)

        if self.head is None:
            self.head = node
        else:
            self.tail.next = node

        self.tail = node
        return self

    def iternodes(self):
        current = self.head
        while current:
            yield current
            current = current.next 

接下来实现双向链表，和insert，pop，remove，方法

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

    def __repr__(self):
        return '<{} <-- {} --> {}>'.format(
                    self.prev.item if self.prev else 'None',
                    self.item,
                    self.next.item if self.next else 'None')


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


    def append(self,item):
        node = Node(item)

        if self.head is None:
            self.head = node
        else:
            node.prev = self.tail
            self.tail.next = node

        self.tail = node
        return self


    def insert(self,index,item):
        if index < 0:
            raise IndexError('Not negative index {}'.format(index))

        current = None
        for i,node in enumerate(self.iterLinked()) :
            if i == index:
                current = node
                break
        else:
            self.append(item)
            return

        node = Node(item)
        prev = current.prev
        next = current

        if prev is None:
            self.head = node
        else:
            prev.next = node
            node.prev = prev
        node.next = next
        next.prev = node


    def pop(self):
        if self.head is None:
            raise Exception('Empty')

        node = self.tail
        item = node.item
        prev = node.prev

        if prev is None:
            self.head = None
            self.tail = None
        else:
            prev.next = None
            self.tail = prev
        return item


    def remove(self,index):
        if self.tail is None:
            raise Exception('Empty')

        if index < 0:
            raise IndexError('Not negative index {}'.format(index))

        current = None
        for i,node in enumerate(ll.iterLinked()) :
            if i == index:
                current = node
                break
        else:
            raise IndexError('Wrong index {}'.format(index))

        prev = current.prev
        next = current.next

        if prev is None and next is None: #only one
            self.head = None
            self.tail = None

        elif prev is None:  #head
            self.head = next
            self.prev = None

        elif next is None:  #tail
            self.tail = prev
            prev.next = None

        else:         #middle
            prev.next = next
            next.prev = prev

        del current



    def iterLinked(self,reverse=False):
        current = self.tail if reverse else self.head
        while current:
            yield current
            current = current.next if not reverse else current.prev