Python 数据结构之链表：单向链表，双向链表，循环链表实现。

1. 链表

我们在 Python 序列：列表 (list)，元组（tuple），字符串（str）深入分析（包括扩容和摊销）。 和 Python：栈和队列的 python 列表实现 中可以看出列表是存在一定问题的：

1. 由于动态数组，底层的数组长度可能会超过实际存储元素的个数，造成空间上的浪费。
2. 我们 append 的平均时间复杂度是 O(1)，但是这是摊销的结果，某一次的时间复杂度最坏为 O(n)。
3. 队列的一般实现，每次出队的时间复杂度是 O(n)

于是就有了另外一种结构，就是链表。链表和列表可以对其中的元素保持一定的顺序，但是实现方式不同：

1. 数组采用一种集中式，一个大的内存区域进行元素的存放。
2. 链表是一种分布式的方法，每个元素是一个节点。每个节点有当前节点自身元素的值（引用方式，也就是存放的是指向真正对象的地址），还有一个下一对象的引用（指向下一对象）。这样链表的元素实际存放在不同的区域，靠着指向来保证遍历和顺序。

2. 链表的实现（单链表）

class Node:
    def __init__(self, val):
        self.val = val
        self.next = None


class SingleLinkedList:
    def __init__(self, node=None):
        self.head = node
        if node:
            self.size = 1
        else:
            self.size = 0

    def is_empty(self):
        return self.size == 0

    def length(self):
        return self.size

    def add_first(self, val):
        node = Node(val)
        node.next = self.head
        self.head = node
        self.size += 1

    def append(self, val):
        node = Node(val)
        current = self.head
        if current is None:
            self.head = node
        else:
            while current.next:
                current = current.next
            current.next = node
        self.size += 1

    def insert_by_position(self, pos, val):
        if pos > self.size or pos < 0:
            print('Out of linked list index!')
        elif pos == 0:
            self.add_first(val)
        else:
            node = Node(val)
            count = 0
            pre = self.head
            while count < (pos-1):
                pre = pre.next
                count = count + 1

            node.next = pre.next
            pre.next = node
            self.size += 1

    def remove_by_value(self, val):
        current = self.head
        pre = None
        while current:
            if current.val == val:
                if pre:
                    pre.next = current.next
                else:
                    self.head = current.next
                self.size -= 1
                return
            pre = current
            current =