【数据结构连载一线性表】【双向链表】python

# -*- coding: UTF-8 -*-
"""
   线性表之链式存储结构 双向链表
    基本操作:
        初始化 __init__
        线性表空判断 empty
        清空线性表   clear
        获取元素    get
        是否存在数据  exist
        插入操作    insert
        删除操作    delete
        线性表的长度  length
    扩展操作
        遍历链表 show
        链表从头开始添加 add
        链表添加到最后 append
        链表删除最后元素 pop
"""


class Node(object):
    def __init__(self, data=None):
        self.data = data
        self.prior = None
        self.next = None

    def __str__(self):
        return "数据：{data}，地址：{next}".format(data=self.data, next=id(self.prior))


class DoubleLinkedList(object):
    def __init__(self):
        self._length = 0
        self._head = Node()
        self._tail = self._head

    def head(self):
        return self._head

    def tail(self):
        return self._tail

    def length(self):
        return self._length

    def empty(self):
        return self._tail == self._head

    def exist(self, value):
        """
        判断数据是否存在
        时间复杂度O(n)
        :param value:
        :return:
        """
        current = self._head.next
        while current:
            if current.data == value:
                return True
            current = current.next
        return False

    def get(self, index):
        """
        根据下标获取值
        时间复杂度O(n)
        :param index:
        :return:
        """
        current = self._head.next
        i = 0
        while current and i < self._length:
            if i == index:
                return current.data
            current = current.next
            i += 1
        return -1

    def add(self, value):
        """
        从头部插入
        时间复杂度O(1)
        :param value:
        :return:
        """
        node = Node(value)
        node.next = self._head.next
        node.prior = self._head
        if self._head.next:
            self._head.next.prior = node
        else:
            self._tail = node
        self._head.next = node
        self._length += 1

    def append(self, value):
        """
        从尾部插入
        时间复杂度为O(1)
        :param value:
        :return:
        """
        new_node = Node(value)
        new_node.prior = self._tail
        self._tail.next = new_node
        self._tail = new_node
        if not self._tail.prior:
            self._head = new_node
        self._length += 1

    def insert(self, index, value):
        """
        在任意位置插入
        :param index:
        :param value:
        :return:
        """
        if index < 0:
            raise Exception("插入位置错误, %d" % index)
        new_node = Node(value)
        pre = self._head
        cur = self._head.next
        n = 0
        while cur:
            if n == index:
                new_node.next = pre.next
                new_node.prior = pre
                pre.next.prior = new_node
                pre.next = new_node
                self._length += 1
                return
            cur = cur.next
            pre = pre.next
            n += 1
        new_node.prior = pre
        pre.next = new_node
        self._tail = new_node
        self._length += 1

    def index(self, value):
        """
        获取元素的下标
        :param value:
        :return:
        """
        current = self._head.next
        i = 0
        while i < self._length and current:
            if current.data == value:
                return i
            i += 1
            current = current.next
        return -1

    def delete(self, idx):
        """
        根据下标删除元素
        时间复杂度为O(n)
        :param idx:
        :return:
        """
        if idx >= self._length:
            raise Exception("数组越界")
        current = self._head
        i = 0
        while current and i < self._length and current.next:
            if i == idx:
                current.next = current.next.next
                if not current.next:
                    self._tail = current
                else:
                    current.next.prior = current
                self._length -= 1
                return
            current = current.next
            i += 1

    def remove(self, value):
        """
        删除指定的数据
        :param value:
        :return:
        """
        pre = self._head
        cur = pre.next
        while pre and cur:
            if cur.data == value:
                pre.next = cur.next
                if not cur.next:
                    self._tail = pre
                else:
                    cur.next.prior = pre
                self._length -= 1
                return
            pre = pre.next
            cur = cur.next
        raise Exception("元素不存在：", value)

    def pop(self):
        """
        删除最后一个元素
        :return:
        """
        current = self._head.next
        while current and current.next and current.next.next:
            current = current.next
        data = current.next.data
        current.next = None
        self._tail = current
        self._length -= 1
        return data

    def show(self):
        node = self._head.next
        while node:
            print(node.data, end=" ")
            node = node.next
        print()


if __name__ == '__main__':
    l = DoubleLinkedList()
    l.add(1)
    l.add(2)
    l.add(3)
    l.append(5)
    l.show()
    # l.show()
    print(l.pop())
    print(l.tail())
    l.show()