数据结构-五 链式存储-双链

定义

在单链表基础上加一个指向前面结点的指针，如下图

”“”Python定义一个双链表“”“

class Node(object):
    def __init__(self, value):
        self.value = value
        self.__prior = None     # 前驱
        self.__next = None      # 后继

操作

1. 插入

 

2.删除

python代码实现

"""python对双链表的操作"""
class DoubleLinkedList(object):
    def __init__(self):
        self.__head = None

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

    def __len__(self):
        count = 0
        cur = self.__head
        while cur:
            count += 1
            cur = cur.next
        return count

    def traverse(self):
        cur = self.__head
        while cur:
            print(cur.value)
            cur = cur.next

    def add(self, value):
        node = Node(value)
        if self.is_empty():
            self.__head = node
        else:
            # 待插入节点的后继区指向原头节点
            node.next = self.__head
            # 原头节点的前驱区指向待插入节点
            self.__head.prev = node
            self.__head = node

    def append(self, value):
        node = Node(value)
        cur = self.__head
        if self.is_empty():
            self.__head = Node
            return
        while cur.next:
            cur = cur.next
        cur.next = node
        node.prev = cur

    def insert(self, pos, value):
        if pos <= 0:
            self.add(value)
        elif pos > len(self) - 1:
            self.append(value)
        else:
            node = Node(value)
            count = 0
            cur = self.__head
            # 定位到pos-1位置
            while count < pos - 1:
                count += 1
                cur = cur.next
            # 此时的游标指向pos的前一个位置
            # 这里的实现方法不唯一
            node.next = cur.next
            cur.next.prev = node
            node.prev = cur
            cur.next = node

    def search(self, value):
        cur = self.__head
        while cur:
            if cur.value == value:
                return True
            else:
                cur = cur.next
        return False

    def remove(self, value):
        if self.is_empty():
            return
        cur = self.__head
        while cur:
            if cur.value == value:
                # 只存在头结点时
                if cur == self.__head:
                    self.__head = cur.next
                    if cur.next:
                        cur.next.prev = None
                else:
                    cur.prev.next = cur.next
                    # 处理待删除节点是最后一个情况
                    if cur.next:
                        cur.next.prev = cur.prev
                return
            else:
                cur = cur.next

循环链表

循环单链表

循环单链表和单链表的区别在于，单链表表中最后一个节点的指针是Null，循环单链表改为指向头结点，从而整个链表形成一个环。

1. 判空条件：头结点的后继指针是否等于头指针
2. 从任何一个结点出发都能访问带链表的每个元素
3. 对单链表的操作是在表头和表尾进行的，此时对循环单链表不设头指针而设尾指针，从而使得操作效率更高。

循环双链表

类比循环单链表，循环双链表区别双链表就是首位结点构成环。

1. 在循环双链表中，尾结点的后继指针指向表头结点，头结点的前驱指针指向表尾结点
2. 当循环双链表为空时，其头结点的前驱和后继都等于自身

 

静态链表

静态链表是借助数组来描述线性表的链式存储结构，结点也有数据域data和指针域next，与前面链表中的指针不同的是，这里的指针指的是结点的相对地址，也称为游标。

当next指针域为-1时，表示链表结束。