数据结构：双(向)链表(Python实现)

定义了双向链表的结点类，双向链表类（尾结点指向头结点）及其一些方法，以及有一些测试

class node(object):
    def __init__(self,value):
        self.item=value
        self.prev=None
        self.next=None
#链表的处理完整性考虑顺序：
# 一般结点(中间点)，空链表，头结点，单个节点头结点，尾结点，单个尾结点。
# [单个节点既可以被看成头结点也可以看成尾结点]
# (明显例子：单向循环链表的remove)
class doublelinklist(object):
    '''双链表其实可以继承单链表，然后更新单链表的一些方法，
        通过建立创建双链表（子类）的实例来使用新的方法'''
    def __init__(self,node=None):
        self.__head=node
    def isempty(self):
        '''判断链表是否为空'''
        return self.__head is None
    def len(self):
        '''返回链表长度'''
        '''指针遍历计数'''
        count=0
        cur=self.__head
        while cur!=None:
            count+=1
            cur=cur.next
        return count
    def travel(self):
        cur=self.__head
        while cur!=None:
            print(cur.item,end=" ")
            cur=cur.next
        print('')
    def append(self,value):
        '''尾部添加结点'''
        newnode=node(value)
        cur=self.__head
        if self.isempty():
            self.__head=newnode
        else:
            while cur.next!=None:
                cur=cur.next
            cur.next=newnode
            newnode.prev=cur
    def add(self,value):
        '''头部添加结点'''
        newnode=node(value)
        newnode.next=self.__head
        self.__head=newnode
        if newnode.next:
            newnode.next.prev=newnode
    def insert(self,index,value):
        '''指定位置插入节点'''
        newnode = node(value)
        n = self.len()
        if index <= 0:
            self.add(value)
            return
        if index > n - 1:
            self.append(value)
            return
        cur = self.__head
        count = 0
        while count<index-1:
            count+=1
            cur=cur.next
        newnode.next=cur.next
        cur.next.prev=newnode
        cur.next = newnode
        newnode.prev=cur
    def remove(self,value):
        '''删除左边第一个与指定值相同的结点'''
        cur=self.__head
        while cur!=None:
            if cur.item==value:
                if cur==self.__head:
                    self.__head=cur.next
                    if cur.next:
                        cur.next.prev=None
                else:
                    cur.prev.next=cur.next
                    if cur.next:
                        cur.next.prev=cur.prev
                break
            else:
                cur=cur.next
    def search(self,value):
        '''查找某结点是否在链表中,返回TRUE/False'''
        cur = self.__head
        while cur!=None:
            if cur.item==value:
                return True
            cur = cur.next
        return False
    def found(self,value):
        '''找到指定元素的下标（实际链表无下标）'''
        cur = self.__head
        count=0
        while cur!=None:
            if cur.item == value:
                return count
            cur = cur.next
            count += 1

if __name__=='__main__':
    ll = doublelinklist()
    print(ll.isempty())
    print(ll.len())

    ll.append(1)
    print(ll.isempty())
    print(ll.len())

    ll.append(2)
    ll.add(8)
    ll.append(3)
    ll.append(4)
    ll.append(5)
    ll.append(6)  # 8 1 2 3 4 5 6
    ll.travel()
    ll.insert(-1, 9)  # 9 8 1 2 3 4 5 6
    ll.travel()
    ll.insert(3, 100)  # 9 8 1 100 2 3 4 5 6
    ll.travel()
    ll.insert(10, 200)  # 9 8 1 100 2 3 4 5 6 200
    ll.travel()
    ll.remove(100)  # 9 8 1 2 3 4 5 6 200
    ll.travel()
    ll.remove(9)  # 8 1 100 2 3 4 5 6 200
    ll.travel()
    ll.remove(200)  # 8 1  2 3 4 5 6
    ll.travel()
    print(ll.search(55))#False
    print(ll.search(5))#True
    print(ll.found(5))  # 5

测试结果