python实现双向循环链表

'''每个节点有两个链接：一个指向前一个节点，当此节点为第一个节点时，指向空值；
而另一个指向下一个节点，当此节点为最后一个节点时，指向空值。'''
class Node(object):
    def __init__(self,item):
        self.item=item#存放数据
        self.next=None#下一个节点的地址
        self.prev=None#上一节点的地址
class SinCycLinkedlist(object):
    #双向链表
    def __init__(self):
        self._head = None

    #判断是否为空
    def is_empty(self):
        return self._head == None

    #返回链表长度
    def length(self):
        cur=self._head
        count=0
        while cur!=None:
            count += 1
            cur = cur.next
        return  count


    #遍历链表
    def travel(self):
        cur = self._head
        while cur!=None:
            print(cur.item)
            cur=cur.next

    #头部添加元素
    def add(self,item):
        node = Node(item)
        if self.is_empty():
            self._head = node
        else:
            node.next = self._head
            self._head.prev = node
            self._head=node

    #尾部添加元素
    def append(self,item):
        node = Node(item)
        if self.is_empty():
            self._head = node
        else:
            p = self._head
            while p.next!=None:
                p=p.next
            p.next = node
            node.prev = p

    #查找元素
    def search(self,item):
        p = self._head
        while p!=None:
            if p.item == item:
                return True
            p=p.next
        return  False

    #在指定位置添加
    def insert(self,pos,item):
        if pos < 0:
            self.add(item)
        elif pos>(self.length()-1):
            self.append(item)
        else:
            node = Node(item)
            p = self._head
            count=1
        #移动至指定位置的前一个位置
        while count < (pos-1):
            count += 1
            p = p.next
        #将node的prev--》p
        node.prev=p
        #将node的next--》p的下一个节点
        node.next = p.next
        #将p的下一个节点的prev--》node
        p.next.prev = node
        #将p的next指向node
        p.next = node

    #删除
    def remove(self, item):
        if self.is_empty():
            return
        else:
            p = self._head
            if p.item == item:
                # 如果首节点的元素即是要删除的元素
                if p.next == None:
                    # 如果链表只有这一个节点
                    self._head = None
                else:
                    # 将第二个节点的prev设置为None
                    p.next.prev = None
                    # 将_head指向第二个节点
                    self._head = p.next
                return
            while p != None:
                if p.item == item:
                    # 将cur的前一个节点的next指向cur的后一个节点
                    p.prev.next = p.next
                    # 将cur的后一个节点的prev指向cur的前一个节点
                    p.next.prev = p.prev
                    break
                p = p.next