Python双向链表

prev，pre	前驱节点
curr	当前节点
later，next	后继节点

class Node():
    def __init__(self,item):
        self.item=item
        #前驱
        self.pre=None
        #后继
        self.next=None

class Bilaterallinklist():
    #链表长度大小
    size=0
    def __init__(self):
        self.head=None
        self.size=0

    def is_empty(self):
        return self.head is None


    def length(self):
        return self.size

    def items(self):
        curr=self.head
        #遍历
        while curr is not None:
            #返回生成器
            yield curr.item
            curr=curr.next

    def add(self,item):
        """在头部添加节点"""
        #新建节点
        node=Node(item)
        if self.is_empty():
            self.head=node
        else:
            #新节点指向head
            node.next=self.head
            #head的pre指向node
            self.head.pre=node
            #更新头节点
            self.head=node
        #长度自增
        self.size+=1

    def append(self,item):
        """在尾部添加节点"""
        # 新建节点
        node=Node(item)
        #判空
        if self.is_empty():
            self.head=node
        else:
            #找到尾节点
            curr=self.head
            while curr.next is not None:
                curr=curr.next
            #尾节点的next指向node
            curr.next=node
            #node的pre指向curr
            node.pre=curr
        #长度自增
        self.size += 1

    def insert(self, index, data):
        """在指定位置添加结点"""
        if index < 0 or index > self.length():
            print("结点位置错误！")
            return False
        #头插
        elif index == 0:
            self.add(data)
        #尾插
        elif index == self.length():
            self.append(data)
        #中间插
        else:
            node = Node(data)
            curr = self.head
            prev = None
            # 移动到要添加的位置
            for i in range(index):
                prev=curr
                curr=curr.index
            # 新结点和它前面的结点互指
            prev.next = node
            node.pre = prev
            # 新结点和它后面的结点互指
            node.next = curr
            curr.pre = node
        #长度自增
        self.size += 1


    def remove(self,index):
        if index<0 or index>self.size:
            print("out of range")
            return
        if self.is_empty():
            return
        #删除第一个
        if index==0:
            self.head=self.head.next
            self.pre=None
        #删除最后一个
        elif index==self.size-1:
            #找到prev，
            prev=self.head
            for i in range(index-1):
                prev=prev.next
            curr=prev.next
            #prev的next指空
            prev.next=None
            #curr的pre指空
            curr.pre=None
        else:
            #找到prev和curr
            prev=self.head
            for i in range(index-1):
                prev=prev.next
            curr=prev.next
            prev.next=curr.next
            later=curr.next
            later.pre=curr.pre
        self.size-=1

    def find(self,index):
        curr=self.head
        for i in range(index):
            curr=curr.next
        return curr.item

    def update(self,index,item):
        curr=self.head
        for i in range(index):
            curr=curr.next
        curr.item=item

    def out(self):
        curr=self.head
        while curr is not None:
            print(curr.item,end=' ')
            curr=curr.next
        print()



if __name__=='__main__':
    l=Bilaterallinklist()
    l.append(10)
    l.append(20)
    l.append(30)
    #10 20 30
    l.add(520)
    #520 10 20 30
    l.insert(0,1314)
    #1314 520 10 20 30
    l.update(4,888)
    #1314 520 10 20 888
    l.out()
    for i in l.items():
        print(i,end=" ")
    print()
    #1314 520 10 20 888

 

# curr=self.head
# #找到链表的尾节点停止,最终curr指向最后一个节点
# while cur.next is not None:
#     cur = cur.next
# #遍历链表，最终curr指向尾节点的下一个，即None
# while curr is not None:
#     curr=curr.next