python---循环双向链表实现

这个方案里的尾插入，就使用了更高效的prev指标。

但感觉remove的代码不够和前面统一，

我有代码洁癖了？？？？

# coding = utf-8

# 双向链表
class Node:

    # 双向链表存在两个指标，一个向前，一个向后
    def __init__(self, new_data):
        self.data = new_data
        self.prev = None
        self.next = None

    def get_data(self):
        return self.data

    def set_data(self, new_data):
        self.data = new_data

    def get_next(self):
        return self.next

    def set_next(self, new_next):
        self.next = new_next

    def get_prev(self):
        return self.prev

    def set_prev(self, new_prev):
        self.prev = new_prev

class DoubleCycleList:

    def __init__(self):
        self.head = None

    # 作头插入时，需要要注意插入顺序，
    # 总之。要注意不要丢失next和prev。
    def add(self, item):
        node = Node(item)

        # 如果链表是空的，则node的next和prev都指向自己(因为是双向循环)
        if self.is_empty():
            node.set_next(node)
            node.set_prev(node)
            # 将head指向node
            self.head = node
        else:
            # node的next设为现在的head
            node.set_next(self.head)
            # node的prev 设为现在head的prev
            node.set_prev(self.head.get_prev())
            # 现在head的前一个元素的next设为node
            self.head.get_prev().set_next(node)
            # 现在head的前驱 改为node
            self.head.set_prev(node)
            # 将head指向node
            self.head = node

    # 作尾插入
    def append(self, item):
        node = Node(item)
        if self.is_empty():
            # 如果当前链表是空的 那就调用头部插入方法
            self.add(item)
        else:
            # #因为是双向循环链表，所以head的prev其实就是链表的尾部
            # node的下一个设为头
            node.set_next(self.head)
            # node的前驱设为现在头部的前驱
            node.set_prev(self.head.get_prev())
            # 头部前驱的后继设为node
            self.head.get_prev().set_next(node)
            # 头部自己的前驱改为node
            self.head.set_prev(node)

    # 指定位置插入节点
    def insert(self, pos, item):
        # 相当于头插入
        if pos <= 0:
            self.add(item)
        # 相当于尾插入
        elif pos >= self.size():
            self.append(item)
        else:
            node = Node(item)
            count = 0
            current = self.head
            # 在要插入位置的前一个元素，这时候停下
            while count < pos - 1:
                count += 1
                current = current.get_next()
            # node的后继设为cur的后继
            node.set_next(current.get_next())
            # node的前驱设为cur
            node.set_prev(current)
            # cur后继的前驱改为node
            current.get_next().set_prev(node)
            # cur后继改为node
            current.set_next(node)

    # 删除指定节点数据
    def remove(self, item):
        if self.is_empty():
            # 如果链表为空 直接不操作
            return
        else:
            current = self.head
            if current.get_data == item:
                # 如果头结点就是 要删除的元素
                if self.size() == 1:
                    # 如果只有一个节点 链表就空了 head设为None
                    self.head = None
                else:
                    # 头指针指向cur的下一个
                    self.head = current.get_next()
                    # cur后继的前驱改为cur的前驱
                    current.get_next().set_prev(current.get_prev())
                    # cur前驱的后继改为cur的后继
                    current.get_prev().set_next(current.get_next())
            else:
                current = current.get_next()
                # 循环让cur后移一直到链表尾元素位置，期间如果找得到就删除节点，找不到就跳出循环
                while current is not self.head:
                    if current.get_data() == item:
                        # cur的前驱的后继改为cur的后继
                        current.get_prev().set_next(current.get_next())
                        # cur的后继的前驱改为cur的前驱
                        current.get_next().set_prev(current.get_prev())
                    current = current.get_next()

    # 查找指定数据是否存在
    def search(self, item):
        current = self.head
        found = False
        while current is not self.head:
            if current.get_data() == item:
                found = True
            current = current.get_next()
        if current.get_data() == item:
            found = True
        return found

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

    def __len__(self):
        return self.size()

    def size(self):
        # 循环链表和非循环链表的退出条件不一样
        count = 0
        current = self.head
        while current.get_next() is not self.head:
            count += 1
            current = current.get_next()
        return count

    def show(self):
        current = self.head
        # 循环链表和非循环链表的读取首个元素也不同
        print(current.get_data(), end=' ')
        while current.get_next() is not self.head:
            current = current.get_next()
            print(current.get_data(), end=' ')
        print()

if __name__ == '__main__':
    d_list = DoubleCycleList()
    print(d_list.is_empty())
    d_list.add(5)
    d_list.add(4)
    d_list.add(76)
    d_list.add(23)
    d_list.show()
    d_list.append(48)
    d_list.show()
    d_list.append(234)
    d_list.show()
    d_list.insert(2, 100)
    d_list.show()
    d_list.remove(5)
    d_list.show()
    print(d_list.search(48))

True

False

Process finished with exit code