链表

Author: PegasusWang

3_链表/double_link_list.py

@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+
+
+class Node(object):
+
+    def __init__(self, value=None, prev=None, next=None):
+        self.value, self.prev, self.next = value, prev, next
+
+
+class CircularDoubleLinkedList(object):
+    """循环双端链表 ADT
+    多了个循环其实就是把 root 的 prev 指向 tail 节点，串起来
+    """
+
+    def __init__(self, maxsize=None):
+        self.maxsize = maxsize
+        node = Node()
+        node.next, node.prev = node, node
+        self.root = node
+        self.length = 0
+
+    def __len__(self):
+        return self.length
+
+    def headnode(self):
+        return self.root.next
+
+    def tailnode(self):
+        return self.root.prev
+
+    def append(self, value):    # O(1), 你发现一般不用 for 循环的就是 O(1)，有限个步骤
+        if self.maxsize is not None and len(self) > self.maxsize:
+            raise Exception('LinkedList is Full')
+        node = Node(value=value)
+        tailnode = self.tailnode() or self.root
+
+        tailnode.next = node
+        node.prev = tailnode
+        node.next = self.root
+        self.root.prev = node
+        self.length += 1
+
+    def appendleft(self, value):
+        if self.maxsize is not None and len(self) > self.maxsize:
+            raise Exception('LinkedList is Full')
+        node = Node(value=value)
+        if self.root.next is self.root:   # empty
+            node.next = self.root
+            node.prev = self.root
+            self.root.next = node
+            self.root.prev = node
+        else:
+            node.prev = self.root
+            headnode = self.root.next
+            node.next = headnode
+            headnode.prev = node
+            self.root.next = node
+        self.length += 1
+
+    def remove(self, node):      # O(1)，传入node 而不是 value 我们就能实现 O(1) 删除
+        """remove
+        :param node  # 在 lru_cache 里实际上根据key 保存了整个node:
+        """
+        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
+        curnode = self.root.next
+        while curnode.next is not self.root:
+            yield curnode
+            curnode = curnode.next
+        yield curnode
+
+    def __iter__(self):
+        for node in self.iter_node():
+            yield node.value
+
+    def iter_node_reverse(self):
+        """相比单链表独有的反序遍历"""
+        if self.root.prev is self.root:
+            return
+        curnode = self.root.prev
+        while curnode.prev is not self.root:
+            yield curnode
+            curnode = curnode.prev
+        yield curnode
+
+
+def test_double_link_list():
+    dll = CircularDoubleLinkedList()
+    assert len(dll) == 0
+
+    dll.append(0)
+    dll.append(1)
+    dll.append(2)
+
+    assert list(dll) == [0, 1, 2]
+
+    assert [node.value for node in dll.iter_node()] == [0, 1, 2]
+    assert [node.value for node in dll.iter_node_reverse()] == [2, 1, 0]
+
+    headnode = dll.headnode()
+    assert headnode.value == 0
+    dll.remove(headnode)
+    assert len(dll) == 2
+    assert [node.value for node in dll.iter_node()] == [1, 2]
+
+    dll.appendleft(0)
+    assert [node.value for node in dll.iter_node()] == [0, 1, 2]
+
+
+if __name__ == '__main__':
+    test_double_link_list()

3_链表/linked_list.md

@@ -0,0 +1,78 @@
+# 链式结构
+
+上一节讲到了支持随机访问的线性结构，这次我们开始讲链式结构。最常见的就是单链表和双链表。
+之前在专栏文章[那些年，我们一起跪过的算法题[视频]](https://zhuanlan.zhihu.com/p/35175401)里实现过一个 lru_cache，
+使用到的就是循环双端链表，如果感觉这篇文章有点难理解，我们这里将会循序渐进地来实现。
+后边讲到哈希表的冲突解决方式的时候，我们会再次使用链接表。
+
+上一节我们分析了 list 的各种操作是如何实现的，如果你还有印象的话，list
+在头部进行插入是个相当耗时的操作（需要把后边的元素一个一个挪个位置）。假如你需要频繁在数组两头增删，list 就不太合适。
+今天我们介绍的链式结构将摆脱这个缺陷，当然了链式结构本身也有缺陷，比如你不能像数组一样随机根据下标访问。
+所以嘛，学习和了解数据结构的原理和实现你才能准确地选择到底什么时候该用什么数据结构，而不是瞎选导致代码性能很差。
+
+
+# 单链表
+和线性结构不同，链式结构内存不连续的，而是一个个串起来的，这个时候就需要每个链接表的节点保存一个指向下一个节点的指针。
+看到指针你也不用怕，这里我们用的 python，你只需要一个简单赋值操作就能实现，不用担心 c 语言里复杂的指针。
+
+先来定义一个链接表的节点，刚才说到有一个指针保存下一个节点的位置，我们叫它 next， 当然还需要一个 value 属性保存值
+
+```py
+class Node(object):
+    def __init__(self, value, next=None):
+        self.value = value
+        self.next = next
+```
+然后就是我们的单链表 LinkedList ADT:
+
+```py
+class LinkedList(object):
+    """ 链接表 ADT
+    [root] -> [node0] -> [node1] -> [node2]
+    """
+```
+实现我们会在视频中用画图来模拟并且手动代码实现。
+
+来看下时间复杂度：
+
+操作                      | 平均时间复杂度 |
+--------------------------|----------------|
+linked_list.append(value) | O(1)           |
+linked_list.appendleft(value) | O(1)           |
+linked_list.find(value)   | O(n)           |
+linked_list.remove(value) | O(n)           |
+
+
+# 双链表
+上边我们亲自实现了一个单链表，但是能看到很明显的问题，单链表虽然 append 是 O(1)，但是它的 find 和 remove 都是 O(n)的，
+因为删除你也需要先查找，而单链表查找只有一个方式就是从头找到尾，中间找到才退出。
+这里我之前提到过如果要实现一个 lru
+缓存（访问时间最久的踢出），我们需要在一个链表里能高效的删除元素，并把它追加到访问表的最后一个位置，这个时候单链表就满足不了了，
+因为缓存在dict 里查找的时间是 O(1)，你更新访问顺序就 O(n)了，缓存就没了优势。
+
+这里就要使用到双链表了，相比单链表来说，每个节点既保存了指向下一个节点的指针，同时还保存了上一个节点的指针。
+
+```py
+class Node(object):
+
+    def __init__(self, value=None, prev=None, next=None):
+        self.value, self.prev, self.next = value, prev, next
+```
+
+对， 就多了 prev，有啥优势嘛？
+
+- 看似我们反过来遍历双链表了。反过来从哪里开始呢？我们只要让 root 的 prev 指向 tail 节点，不就串起来了吗？
+- 直接删除节点，当然如果给的是一个值，我们还是需要查找这个值在哪个节点？ - 但是如果给了一个节点，我们把它拿掉，直接让它的前后节点互相指过去不就行了？哇欧，删除就是 O(1) 了，两步操作就行啦
+- 是不是可以很方便地
+
+好，废话不多说，我们在视频里介绍怎么实现一个双链表 ADT。
+
+
+# 小问题：
+- 这里单链表我没有实现 insert 方法，你能自己尝试实现吗？  insert(value, new_value)，我想在某个值之前插入一个值。你同样需要先查找，所以这个步骤也不够高效。
+- 你能尝试自己实现个 lru cache 吗？
+- python 内置库的哪些数据结构使用到了本章讲的链式结构？
+
+# 相关阅读
+
+[那些年，我们一起跪过的算法题- Lru cache[视频]](https://zhuanlan.zhihu.com/p/35175401)

3_链表/linked_list.py

@@ -0,0 +1,140 @@
+# -*- coding: utf-8 -*-
+
+
+class Node(object):
+    def __init__(self, value=None, next=None):   # 这里我们 root 节点默认都是 None，所以都给了默认值
+        self.value = value
+        self.next = next
+
+    def __str__(self):
+        """方便你打出来调试，复杂的代码可能需要断点调试"""
+        return '<Node: value: {}, next={}>'.format(self.value, self.next)
+
+    __repr__ = __str__
+
+
+class LinkedList(object):
+    """ 链接表 ADT
+    [root] -> [node0] -> [node1] -> [node2]
+    """
+
+    def __init__(self, maxsize=None):
+        """
+        :param maxsize: int or None, 如果是 None，无限扩充
+        """
+        self.maxsize = maxsize
+        self.root = Node()     # 默认 root 节点指向 None
+        self.tailnode = None
+        self.length = 0
+
+    def __len__(self):
+        return self.length
+
+    def append(self, value):    # O(1)
+        if self.maxsize is not None and len(self) > self.maxsize:
+            raise Exception('LinkedList is Full')
+        node = Node(value)    # 构造节点
+        tailnode = self.tailnode
+        if tailnode is None:    # 还没有 append 过，length = 0， 追加到 root 后
+            self.root.next = node
+        else:     # 否则追加到最后一个节点的后边，并更新最后一个节点是 append 的节点
+            tailnode.next = node
+        self.tailnode = node
+        self.length += 1
+
+    def appendleft(self, value):
+        headnode = self.root.next
+        node = Node(value)
+        self.root.next = node
+        node.next = headnode
+        self.length += 1
+
+    def __iter__(self):
+        for node in self.iter_node():
+            yield node.value
+
+    def iter_node(self):
+        """遍历 从 head 节点到 tail 节点"""
+        curnode = self.root.next
+        while curnode is not self.tailnode:    # 从第一个节点开始遍历
+            yield curnode
+            curnode = curnode.next    # 移动到下一个节点
+        yield curnode
+
+    def remove(self, value):    # O(n)
+        """ 删除包含值的一个节点，将其前一个节点的 next 指向被查询节点的下一个即可
+
+        :param value:
+        """
+        prevnode = self.root    #
+        curnode = self.root.next
+        while curnode.next is not None:
+            if curnode.value == value:
+                prevnode.next = curnode.next
+                del curnode
+                self.length -= 1
+                return
+
+    def find(self, value):    # O(n)
+        """ 查找一个节点，返回序号，从 0 开始
+
+        :param value:
+        """
+        index = 0
+        for node in self.iter_node():   # 我们定义了 __iter__，这里就可以用 for 遍历它了
+            if node.value == value:
+                return index
+            index += 1
+        return -1    # 没找到
+
+    def popleft(self):    # O(1)
+        """ 删除第一个链表节点
+        """
+        if self.root.next is None:
+            raise Exception('pop from empty LinkedList')
+        headnode = self.root.next
+        self.root.next = headnode.next
+        self.length -= 1
+        value = headnode.value
+        del headnode
+        return value
+
+    def clear(self):
+        for node in self.iter_node():
+            del node
+        self.root.next = None
+        self.length = 0
+
+
+def test_linked_list():
+    ll = LinkedList()
+
+    ll.append(0)
+    ll.append(1)
+    ll.append(2)
+
+    assert len(ll) == 3
+    assert ll.find(2) == 2
+    assert ll.find(3) == -1
+
+    ll.remove(0)
+    assert len(ll) == 2
+    assert ll.find(0) == -1
+
+    assert list(ll) == [1, 2]
+
+    ll.appendleft(0)
+    assert list(ll) == [0, 1, 2]
+    assert len(ll) == 3
+
+    headvalue = ll.popleft()
+    assert headvalue == 0
+    assert len(ll) == 2
+    assert list(ll) == [1, 2]
+
+    ll.clear()
+    assert len(ll) == 0
+
+
+if __name__ == '__main__':
+    test_linked_list()