链表

单链表：

"""
线性结构：内存是连续的，可通过下标访问
链式结构：
    内存不连续，不能通过下标访问
    追加的方式会很方便，直接放到后面就可以了
    遍历操作，find 方法会比较麻烦
单链表：
    root(入口) --> head --> ... --> tail(尾节点)
    Node： value 和 next
    属性：
        root
        长度
    方法：
        init
        append
        appendleft
        iter_node
        remove
        find
        popleft
        clear
"""


class Node(object):
    def __init__(self, value=None, n_next=None):
        self.value = value
        self.n_next = n_next


class LinkList(object):
    """
    初始化的时候只有一个根节点，为 root
    插入一个节点，就需要构造一个新的节点
    """
    def __init__(self, max_size=None):
        self.max_size = max_size
        self.root = Node()
        self.length = 0
        self.tail_node = None

    def __len__(self):
        return self.length

    def append(self, value):
        if self.max_size is not None and len(self) > self.max_size:
            raise Exception('full stack')
        node = Node(value)
        if self.tail_node is None:
            self.root.n_next = node
        else:
            self.tail_node.n_next = node

        self.tail_node = node
        self.length += 1

    def append_left(self, value):
        if self.max_size is not None and len(self) > self.length:
            raise Exception('full')

        head_node = Node(value)
        head_node.n_next = self.root.n_next
        self.root.n_next = head_node

        self.length += 1

    def iter_node(self):
        cur_node = self.root.n_next
        while cur_node is not self.tail_node:
            yield cur_node
            cur_node = cur_node.n_next
        yield cur_node

    def __iter__(self):
        for node in self.iter_node():
            yield node.value

    def remove(self, value):  # O(n)
        prev_node = self.root
        cur_node = self.root.n_next

        for cur_node in self.iter_node():
            if cur_node.value == value:
                prev_node.n_next = cur_node.n_next
                if cur_node is self.tail_node:
                    self.tail_node = prev_node
                del cur_node
                self.length -= 1
                return 1
            else:
                prev_node = cur_node
        return -1

    def find(self, value):  # O(n)
        index = 0
        for node in self.iter_node():
            if node.value == value:
                return index
            index += 1
        return -1

    def pop_left(self):  # O(1) 以后可以实现双端队列
        if self.root.n_next is None:
            raise Exception('pop from empty list')
        cur_node = self.root.n_next
        self.root.n_next = cur_node.n_next
        value = cur_node.value
        del cur_node
        self.length -= 1

        return value

    def clear(self):
        for node in self.iter_node():
            del node
        self.root.n_next = None
        self.length = 0

循环双链表

"""
双链表
"""


class Node(object):
    def __init__(self, value=None, prev=None, next=None):
        self.prev = prev
        self.next = next
        self.value = value


class CirculDoubleLinkList(object):

    def __init__(self, max_size=None):
        self.max_size = max_size  # None 表示无限长度
        node = Node()
        node.next, node.prev = node, node  # 根节点自己实现闭环
        self.root = node
        self.length = 0  # root节点不计算在链表的长度中

    def __len__(self):
        return self.length

    def head_node(self):
        return self.root.next

    def tail_node(self):
        return self.root.prev

    def append(self, value):
        if self.max_size is not None and len(self) > self.max_size:
            raise Exception('full')

        node = Node()
        tailnode = self.tail_node()

        tailnode.next = node
        node.prev = tailnode
        node.next = self.root
        self.root.prev = node
        node.value = value

        self.length += 1

    def append_left(self, value):
        if self.max_size is not None and len(self) > self.max_size:
            raise Exception('full')
        node = Node(value=value)

        if self.root.next is self.root:  # 链表为空
            self.root.next = node
            self.root.prev = node
            node.next = self.root
            node.prev = self.root
        else:
            headnode = self.root.next
            self.root.next = node
            node.next = headnode
            headnode.prev = node
            node.prev = self.root

        self.length += 1

    def remove(self, node):  # 入参 node 而不是 value
        if node is self.root:
            return
        else:
            node.prev.next = node.next
            node.next.prev = node.prev
        self.length -= 1
        return node

    def iter_node(self):
        if self.root.next is self.root:
            return

        cur_node = self.root.next
        while cur_node is not self.root:
            yield cur_node
            cur_node = cur_node.next
        # yield cur_node

    def __iter__(self):
        for node in self.iter_node():
            yield node.value

    def iter_node_reverse(self):
        if self.root.next is self.root:
            return

        cur_node = self.root.prev
        while cur_node.prev is not self.root:
            yield cur_node
            cur_node = cur_node.prev
        yield cur_node

    def insert(self, value, new_value):
        for node in self.iter_node():
            if node.value == value:
                new_node = Node(value=new_value)
                new_node.next = node
                new_node.prev = node.prev
                node.prev.next = new_node

                node.prev = new_node
                break