浅谈Python的列表和链表

　　本文从实现原理的角度比较了python的列表和链表的性能差异, 并且通过LRU算法,实现一个最大堆等实例来阐明如何正确地使用它们.

一. 从归并排序说起

　　归并排序是分治法的一个经典实现案例, 我特别喜欢. 在维基百科里面, 使用python实现的归并排序实例如下:

def mergeSort(nums):
    if len(nums) < 2:
        return nums
    mid = len(nums) // 2
    left = mergeSort(nums[:mid])
    right = mergeSort(nums[mid:])
    result = []
    while left and right:
        if left[0] <= right[0]:
            result.append(left.pop(0))
        else:
            result.append(right.pop(0))
    if left:
        result += left
    if right:
        result += right
    return result

　　但是, 这个案例存在性能问题. 现在, 我们重写一个归并排序函数, 然后测试二者的性能:

def myMergeSort(nums: [int]) -> [int]:
    # 我们重写的归并排序算法
    if len(nums) < 2:
        return nums
    mid = len(nums) // 2
    left = myMergeSort(nums[:mid])
    right = myMergeSort(nums[mid:])
    m, n = 0, 0
    for i in range(len(nums)):
        if n >= len(right) or (m < len(left) and left[m] < right[n]):
            nums[i] = left[m]
            m += 1
        else:
            nums[i] = right[n]
            n += 1
    return nums


def test(func: Callable[[List[int]], List[int]]) -> None:
    li = list(range(int(1e5)))
    ans = li[:]
    random.shuffle(li)
    start = time.time()
    assert func(li) == ans
    print('func: {}, time cost: {:.2f}s'.format(func.__name__, time.time() - start))


if __name__ == '__main__':
    test(mergeSort)
    test(myMergeSort)

二者的执行用时如下:

　　可以看到, 我们写的归并函数明显性能更好, 这主要是由于, 我们在合并left和right两个列表时, 使用的是移动指针而非pop(0)操作, 后者的时间复杂度是O(n), 这直接把一个时间复杂度O(n log n)的算法优化到O(n³ log n).

二. 列表和链表的实现原理

1. 列表的储存原理

　　列表是在CPython的C层面实现的, 其本质上是一个数组, 数组的值为列表对应位置元素的指针. 对于一个数组来说, 它占有连续的内存空间:

　　

因此, 假如我们现在有一个python列表, 其值为['h', 'e', 'l', 'l', 'o'], 那么在内存空间中, 它大概是长这个样子的:

　　这样做的好处是便于寻址, 由于内存地址连续, 我们可以在常数级别的时间内获取到位置为i的元素. 但是, 假如我们要添加或者删除元素, 情况就不一样了. 比如对于刚才的数组, 我们执行pop(0)操作:

对于列表而言, 向i位置添加或删除一个元素, 在i之后的所有元素都要挪动位置. 这也就解答了上一章提出的问题: 为什么列表pop(0)的时间复杂度为O(n).

2. 列表的扩容机制

　　上一节讲到, python列表的底层实现是一个数组, 数组的值指向对应位置元素的指针. 但是, 数组的长度是固定的, 添加或删除元素很不方便. 为了应对这个问题, python使用扩容机制对列表进行了优化. 下面的代码展示了python的扩容机制:

from sys import getsizeof

li = []
for _ in range(10):
    li.append(None)
    print(f'length: {len(li)}, size: {getsizeof(li)}')

运行结果如下:

可以看到, 列表占用的内存并不是线性增长的. 以['h', 'e', 'l', 'l', 'o']这个数组为例, 它在底层长这样:

　　对于一个列表, CPython为其分配长度为4,8,16,25,35...的数组. 比如上面的这个列表长度为5, 那么其底层数组的长度为8. 这样做的好处是, 在调用append操作时, 如果数组还有闲置空间, 我们就不需要重新创建数组, 等列表长度超过8之后, 我们再创建一个长度为16的数组也不迟. 因此, 虽然数组扩容的时间复杂度为O(n), 但是python避免了频繁的扩容. 把开销分摊到每一次的append上, 时间复杂度就是O(1).

　　pop(-1)的机制同理, python不会频繁地缩减空间, 因此时间复杂度也是O(1).

3. 链表的实现原理

　　通过如下代码, 我们就能定义一个链表:

class LinkNode:
    def __init__(self, val: int = 0) -> None:
        self.val = val
        self.next = None

    def __repr__(self) -> str:
        # 别这么用,链表过长会超过递归层数
        return f'{self.val}->{repr(self.next)}'

    @staticmethod
    def make(arr: [int]) -> Optional['LinkNode']:
        root = LinkNode()
        node = root
        for num in arr:
            node.next = LinkNode(num)
            node = node.next
        return root.next


link = LinkNode.make([1, 2, 3, 4, 5])
print(link)

运行结果如下:

 

如果没有特殊需求, 建议使用collections库中自带的deque链表, deque的文档

　　链表的最大特点是内存不连续, 每个节点储存着下一个节点的指针. 在内存中它大概长这样:

相对于列表来说, 链表不能迅速定位元素, 如果你想要找到一个节点, 你就首先得找到这个节点的上一个节点, 要找到上一个节点, 你就得找到上一个节点的上一个节点. 循环往复, 直到头节点为止.

　　但是, 链表的这种数据结构也带来了插入和删除元素上的优势, 比如我们已经得到了A节点, 现在要在A节点之后插入B:

在上面的例子中, 我们只需要让A节点重新指向B, 然后让B指向C, 这样就完成了插入. 由于每个节点都只和它之前的一个节点有关联, 因此插入和删除节点的时间复杂度都是O(1).

4. 二者的性能对比和总结

　　总的来说, 列表和链表的最大区别是前者的内存空间连续, 后者不连续. 因此列表寻址很快, 插入和删除数据慢, 而链表相反, 对于python自带的deque双向链表来说, 头尾部的插入和删除很快, 索引很慢. 二者常用操作的时间复杂度如下:

三. 一些应用实例

1. LRU算法

　　LRU即Least Recently Used, 翻译成中文就是最近最少使用. 简单点说, 假如我们有一摞书:

现在要看某一本的话, 就会把它抽出来, 看完后, 再放回这摞书的最顶端. 这样, 近期看得最少的书很难获得放在最顶端的机会, 它就会一直在最底端. 等书的数量增多, 书架放不下之后, 最底端的肯定是最不常看的, 我们就可以把它扔掉, 这就是LRU算法.

　　现在我们用python来实现这样一个数据结构: 它提供get和set两个接口, 当调用set时, 如果容量达到上限, 它会基于LRU算法删除不常用的数据:

class LRUCache:

    def __init__(self, capacity: int) -> None:
        ...

    def get(self, key: int) -> int:
        ...

    def set(self, key: int, value: int) -> None:
        ...

　　首先, 基于上面对LRU算法的分析, 我们可以用一个链表来存放数据, 当一个节点被外部访问时, 我们就把它移动到链表头部, 当容量达到上限时, 我们就把链表尾部的节点移除. 由于链表的特性, 上述这些操作的时间复杂度都是O(1).

　　LRU淘汰算法解决了, 下一个问题就是如何定位到节点. 理论上, 定位到链表节点需要的时间复杂度为O(n), 这显然是无法接受的. 一个常用的优化方式就是用一个哈希表储存所有的节点地址, 这样我们就可以在O(1)的时间内定位到任意节点.

　　基于以上的分析, 我们使用一个双向链表和一个哈希表来实现LRU算法, 其get和set操作的时间复杂度都是O(1):

class LinkNode:

    def __init__(self, key: int = 0, value: int = 0) -> None:
        self.key = key
        self.value = value
        # 为了更方便,这里使用双向链表,两个指针分别指向前置节点和后置节点
        self.prev = None
        self.next = None

    def connect(self, node: 'LinkNode') -> None:
        self.next = node
        node.prev = self


class LRUCache:

    def __init__(self, capacity: int) -> None:
        self.capacity = capacity
        self.size = 0
        # 所有的节点都储存在头部和尾部之间
        self.head = LinkNode()
        self.tail = LinkNode()
        self.head.connect(self.tail)
        # 用一个字典来快速定位节点
        self.nodes = {}

    def get(self, key: int) -> int:
        if key not in self.nodes.keys():
            return -1
        node = self.nodes[key]
        self.add_to_head(node)
        return node.value

    def set(self, key: int, value: int) -> None:
        if key in self.nodes.keys():
            self.nodes[key].value = value
        else:
            self.nodes[key] = LinkNode(key, value)
            self.size += 1
            if self.size > self.capacity:
                last = self.tail.prev
                del self.nodes[last.key]
                last.prev.connect(self.tail)
        self.add_to_head(self.nodes[key])

    def add_to_head(self, node: LinkNode) -> None:
        if node.prev and node.next:
            node.prev.connect(node.next)
        node.connect(self.head.next)
        self.head.connect(node)

　　此外, python的有序字典OrderedDict内部就是用一个双向链表来保持有序的, 因此我们也可以直接用它来实现LRU算法:

class LRU(OrderedDict):
    'Limit size, evicting the least recently looked-up key when full'

    def __init__(self, maxsize=128, /, *args, **kwds):
        self.maxsize = maxsize
        super().__init__(*args, **kwds)

    def __getitem__(self, key):
        value = super().__getitem__(key)
        self.move_to_end(key)
        return value

    def __setitem__(self, key, value):
        if key in self:
            self.move_to_end(key)
        super().__setitem__(key, value)
        if len(self) > self.maxsize:
            oldest = next(iter(self))
            del self[oldest]

2. 实现一个最大堆

　　这个内容有点多, 我单独写了一篇文章-> 用Python实现最大堆.

3. 列表当成字典用

　　python字典的本质是一个哈希表, 其具体实现原理可以看这篇文章. 考虑到哈希冲突, 字典取值可能需要额外时间. 而相对的, 列表寻址很快, 而且每个索引值(不考虑负值)都指向列表中独一无二的位置. 现在我们分别测试二者的性能:

import random
import time
import sys

n = 10000

# 长度为n的字典, key值在[0, n - 1]之间, value为a-z的某个字母
dict = {k: chr(random.randrange(97, 123)) for k in range(n)}

# 用列表来存放dic的所有信息
list = [None] * 10000
for k, v in dict.items():
    list[k] = v


def test(data):
    print(type(data))
    print(f'size:{sys.getsizeof(data)}')
    start = time.time()
    for _ in range(100):
        for key in range(n):
            value = data[key]
    print('time cost: {:.5f}s'.format(time.time() - start))


test(dict)
test(list)

程序运行结果如下:

可以看到, 不管是内存占用还是取值需要时间, 列表都完胜字典.

　　基于以上, 在key值都是自然数的前提下, 列表是可以代替字典的, 其取值速度和内存占用都优于字典. 但是, 如果数据经常发生添加和删除等变动, 这时候列表就不占性能优势了. 因此, 是否用列表代替字典, 还得根据实际场景来定.

4. 小结

　　1. 链表的寻址很慢, 为了弥补这一劣势, 我们可以根据实际情况使用哈希表映射到链表节点, 降低寻址的时间复杂度;

　　2. 列表的索引机制给了它无限的可能, 它可以当二叉树用, 可以当字典用. 然而, 这些用法都有明显的局限性, 实际项目中还是得具体问题具体分析.