Python双向链表练习

# 双向链表的节点
class Node:
    def __init__(self, elem):
        self.elem = elem
        self.next = None     # 后继，根据后继可以找到下一个节点
        self.prev = None     # 前驱，根据前驱可以找到前一个节点


class DoubleLinkList:
    # 初始化方法
    def __init__(self, node=None):
        # 判断node是否为空
        if node != None:
            headNode = Node(node)
            self.__head = headNode
        else:
            self.__head = node

    # 在头部添加元素
    def add(self, item):
        # 将传入的值构造成节点
        node = Node(item)
        # 判断是否为空列表
        if self.is_empty():
            self.__head = node
        else:
            # 将新节点的链接域next指向头节点
            node.next = self.__head
            # 将__head的头节点的prev指向node
            self.__head.prev = node
            # 将链表的头__head指向新节点
            self.__head = node

    # 在链表尾部追加元素
    def append(self, item):
        # 将传入的值构造成节点
        node = Node(item)
        if self.is_empty():  # 单链表为空
            self.__head == node
        else:  # 链表不为空
            curNode = self.__head
            while curNode.next != None:
                curNode = curNode.next
            # 修改节点指向，最后一个节点的next指向node
            curNode.next = node
            # 将node节点的前驱指向当前节点
            node.prev = curNode.next

    # 在指定位置添加元素
    def insert(self, pos, item):
        # 如果传入的pos值是小于等于0的数，默认的将节点插入头部
        if pos <= 0:
            self.add(item)
        # 如果pos的值大于链表的长度，直接将节点添加到尾部
        elif pos > (self.length() - 1):
            self.append(item)
        else:
            # 构造节点
            node = Node(item)
            count = 0
            curNode = self.__head
            while count < (pos - 1):  # 找前一个节点，根据前一个节点获取下一个节点
                count += 1
                curNode = curNode.next
            # 修改指向
            # 将node节点的前驱指向当前节点
            node.prev = curNode
            # 将node节点的后继指向当前节点的下一个节点
            node.next = curNode.next
            # 将当前节点的下一个节点的前驱指向node节点
            curNode.next.prev = node
            # 将当前节点的后继指向node节点
            curNode.next = node

    # 删除节点
    def remove(self, item):
        curcor = self.__head
        while curNode != None:
            if curNode.elem == item:
                # 判断是否为头节点
                if curNode == self.__head:  # 是头节点
                    self.__head = curNode.next
                    # 判断当前节点是否只有一个节点，如果只有一个节点，则不需要移动下一个结点的前驱
                    if curNode.next is not None:
                        curNode.next.prev = None
                else:
                    # 删除
                    curNode.prev.next = curNode.next
                    # 判断当前节点是否为最后一个节点，如果是最后一个节点，最后一个节点的下一个节点指向None
                    if curNode.next is not None:
                        curNode.next.prev = curNode.prev
                break  # 删除对应元素后退出，避免死循环
            else:
                curNode = curNode.next

    # 查找节点是否存在
    def search(self, item):
        curNode = self.__head
        while curNode != None:
            if curNode.elem == item:
                return True
            curNode = curNode.next
        return False

    # 判断单项链表是否为空
    def is_empty(self):
        # 判断head指向是否为None，如果是None则就是空链表
        # if self.__head == None:
        #     return True
        # else:
        #     return False
        return self.__head == None

    # 计算单向链表的长度
    def length(self):
        count = 0
        curNode = self.__head
        while curNode != None:
            count += 1
            curNode = curNode.next
        return count

    # 遍历链表
    def travel(self):
        curNode = self.__head
        while curNode != None:
            print(curNode.elem, end='\t')
            curNode = curNode.next
        print("")


if __name__ == '__main__':
    double = DoubleLinkList()
    print('-----头部插入-----')
    double.add(11)
    double.add(22)
    double.add(33)
    double.travel()
    print('-----尾部追加-----')
    double.append(100)
    double.append(200)
    double.append(300)
    double.travel()
    print('-----指定位置插入-----')
    double.insert(-1, 44)
    double.travel()
    double.insert(100, 400)
    double.travel()
    double.insert(2, 1000)
    double.travel()
    print('-----删除节点-----')
    double.remove(44)
    double.travel()
    double.remove(400)
    double.travel()

代码没少没报错，但运行之后总是删不掉最后节点，不知道哪里出错了，有啥解决办法

-----头部插入-----
33    22    11    
-----尾部追加-----
33    22    11    100    200    300    
-----指定位置插入-----
44    33    22    11    100    200    300    
44    33    22    11    100    200    300    400    
44    33    1000    22    11    100    200    300    400    
-----删除节点-----
33    1000    22    11    100    200    300    400    
33    1000    22    11    100    200    300    400