Python实现双向链表的封装

什么是双向链表

和单向链表不同的是，双向链表每个节点有两个链接:一个指向前一个节点,当此节点为第一个节点时,指向空值;而另一个指向下一个节点,当此节点为最后一个节点时,指向空值。

双向链表的操作和代码实现

前面先实现节点的封装和链表的封装以及链表是否为空、链表长度、遍历链表的代码：

class Node(object):
    """链表节点的实现"""

    def __init__(self, element):
        """创建一个节点"""
        self.element = element
        self.prev = None
        self.next = None

class DoubleSingleLinkList(object):
    """双向链表的实现"""

    def __init__(self):
        self._head = None # 第一个节点？

    def is_empty(self):
        """链表是否为空"""
        return self._head == None

    def __len__(self):
        """链表长度"""
        if not self._head:
            return 0
        length = 1
        cur = self._head
        while cur.next != None:
            length += 1
            cur = cur.next
        return length

    def travel(self):
        """遍历链表"""
        if self.is_empty():
            print("空链表")
        else:
            cur = self._head
            while cur.next != None:
                print(cur.element, end=',')
                cur = cur.next
            # 输出最后一个节点的元素
            print(cur.element, end=',')

头部添加节点

    def add(self, item):
        """头部添加元素"""
        # 实例化节点
        node = Node(item)
        # 1.将新节点的next指向原先的头结点
        node.next = self._head
        # 非空链表
        if not self.is_empty():
            # 2.需要将下一个链表节点的prev指向前一个节点
            self._head.prev = node
        # 3. 头节点指向node
        self._head = node

指定位置添加元素

    def insert(self, index, item):
        """指定位置添加元素"""
        if index <= 0:
            self.add(item)
        elif index >= self.__len__():
            self.append(item)
        else:
            count = 0 # 当前位置
            cur = self._head
            # 找到插入节点的前一个节点
            while count < index - 1:
                count += 1
                cur = cur.next

            node = Node(item)
            node.next = cur.next
            cur.next.prev = node
            cur.next = node
            node.prev = cur

删除节点

    def remove(self, item):
        """删除节点"""
        if self.is_empty():
            return
        else:
            cur = self._head
            while cur != None:
                if cur.element == item:
                    # 1.如果是头节点
                    if cur.prev == None:
                        # 如果只有一个节点
                #         if cur.next ==None:
                #             self._head = None
                        self._head = cur.next
                        self._head.prev = None
                        # cur.next.prev = None
                    else:
                        # 2.如果是中间节点
                        if cur.next:
                            # 将删除位置的上一个节点的next指向删除位置的下一个节点,
                            # 将删除位置的下一个节点的prev指向删除位置的上一个节点
                            cur.next.prev = cur.prev
                            cur.prev.next = cur.next
                        else:
                            # 3.如果是尾节点
                            cur.prev.next = None
                    break

                else:
                    cur = cur.next

查询节点

    def search(self, item):
        """查询节点"""
        cur = self._head
        while cur.next != None:
            if cur.element == item:
                return True
            else:
                cur = cur.next
        # 判断最后一个节点的element
        if cur.element == item:
            return True
        return False

测试代码

if __name__ == '__main__':
    DLinkList = DoubleSingleLinkList()
    # print(DLinkList.is_empty())
    # print(DLinkList.__len__())
    DLinkList.add(1)
    DLinkList.add(3)
    DLinkList.add(2)
    # DLinkList.append('hello')
    DLinkList.insert(1, 0)
    DLinkList.remove(3)
    # print(DLinkList.__len__())
    print(DLinkList.travel())
    print(DLinkList.search(1))