【数据结构连载一线性表】【单向循环链表】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.next = None

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


class CycleLinkedList(object):
    def __init__(self):
        self._length = 0
        self._rear = Node()
        self._rear.next = self._rear

    def head(self):
        return self._rear.next

    def tail(self):
        return self._rear

    def length(self):
        return self._length

    def empty(self):
        return self._rear.next == self._rear

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

    def get(self, index):
        """
        根据下标获取值
        时间复杂度O(n)
        :param index:
        :return:
        """
        current = self._rear.next
        tail = self._rear
        i = 0
        while tail != current:
            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._rear.next
        self._rear.next = node
        self._length += 1

    def append(self, value):
        """
        从尾部插入
        时间复杂度为O(1)
        :param value:
        :return:
        """
        new_node = Node(value)
        cur = self._rear.next
        tail = self._rear
        while tail != cur.next:
            cur = cur.next
        new_node.next = cur.next
        cur.next = new_node
        self._length += 1

    def insert(self, index, value):
        """
        在任意位置插入
        :param index:
        :param value:
        :return:
        """
        new_node = Node(value)
        current = self._rear
        tail = self._rear
        i = 0
        while current.next != tail:
            if i == index:
                new_node.next = current.next
                current.next = new_node
                self._length += 1
                return
            current = current.next
            i += 1
        new_node.next = current.next
        current.next = new_node
        self._length += 1

    def index(self, value):
        """
        获取元素的下标
        :param value:
        :return:
        """
        tail = self._rear
        current = self._rear.next
        i = 0
        while tail != 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("数组越界")

        tail = self._rear
        current = self._rear
        i = 0
        while current.next != tail:
            if i == idx:
                current.next = current.next.next
                self._length -= 1
                return
            current = current.next
            i += 1

    def remove(self, value):
        """
        删除指定的数据
        :param value:
        :return:
        """
        tail = self._rear
        cur = self._rear
        while tail != cur.next:
            if cur.next.data == value:
                cur.next = cur.next.next
                self._length -= 1
                return
            cur = cur.next
        raise Exception("元素不存在：", value)

    def pop(self):
        """
        删除最后一个元素
        :return:
        """
        current = self._rear
        tail = self._rear
        while current.next.next != tail:
            current = current.next
        data = current.next.data
        current.next = tail
        self._length -= 1
        return data

    def show(self):
        tail = self._rear
        cur = self._rear.next
        while tail != cur:
            print(cur.data, end=" ")
            cur = cur.next
        print()


if __name__ == '__main__':
    l = CycleLinkedList()
    l.add(1)
    l.add(2)
    l.add(3)
    l.add(5)
    print(l.exist(5))
    print(l.get(3))
    l.append(6)
    l.append(8)
    l.insert(7, 100)
    l.show()
    print(l.length())
    print(l.index(1100))
    l.delete(0)
    l.remove(100)
    print(l.pop())
    l.show()