双链表+hashmap 实现有序字典OrderedDict

双链表+hashmap 实现有序字典OrderedDict

1. python的OrderedDict是来自collections的类，是一个有序的字典

2. 原理：使用一个双链表来动态维护一个字典的key的顺序

3. 链表的优点：添加和删除节点是O(1),但是双链表的缺点是检索数据是O(n)，如何提高检索的速度呢？在OrderedDict中增加一个hashmap来记录key的前驱和后继节点，这样要添加和删除元素的时间复杂度都是O(1)了，也就是说用空间来换时间

4. 既然要维护一个key的序列，使用list可以吗？可以，将key依次存储在数组中。但是数组的缺点是添加和删除元素是O(k)，当添加和删除元素时，需要对该元素后的所有元素进行大量移动。而且字典中数据是动态变化的，这样十分不方便，因此选择链表就是最好的选择，链表可以维护一个动态序列。

5. 那么使用单链表可以吗？可以，但是单链表只有后继索引，如果要得到其前驱索引，还需要额外一个变量来存储其前驱索引，而且单链表对一些复杂的操作，比如：反转时需要额外一个变量来保存其前驱节点，操作比较复杂。而且单链表进行append这样的尾部插入时，需要先遍历到链表的尾部节点，然后再进行插入操作，也是比较复杂的。因此，使用双链表可以十分简单的实现头插入和尾部插入、反转等复杂的操作。

6. 循环双向链表的优点：
   循环双向链表是有哨兵节点的双链表，哨兵节点，也被称为哑值，信号值，标志值 。就是为了简化边界条件的处理而存在。回看链表的删除过程，需要额外判断删除的是否是头节点，或者最后一个元素的next指针是否为空。而用哨兵节点就大可不必这样麻烦了。并且哨兵节点永远不会被删除（这简化了算法）。
   哨兵节点的优点：1）增加操作的速度 2）降低算法的复杂性和代码的大小 3）增加数据结构的鲁棒性

OrderedDict的源码：

class OrderedDict(dict):
    '记住插入顺序的字典'
    # 一个继承自dict的键值对字典
    # 继承的字典提供 __getitem__, __len__, __contains__, get 方法
    # 所有方法的时间复杂度O() 均与正常的字典一样.

    # 内部的 self.__map 字典将key与双向链表的指针关联在一起
    # 循环双向链表是以一个哨兵元素作为开始和结束节点的，即表头的prev指向表尾，表尾的next指向表头
    # 哨兵元素永远不会被删除 (这简化了算法).

    def __init__(*args, **kwds):

        '''初始化一个有序字典。 方法的签名与常规字典一样'''
        '''Initialize an ordered dictionary.  The signature is the same as regular dictionaries, 但是并不建议使用关键字参数进行初始化，因为他们的插入顺序是任意的，没有保证的

        '''
        if not args:
            raise TypeError("descriptor '__init__' of 'OrderedDict' object "
                            "needs an argument")
        self = args[0]
        args = args[1:]
        if len(args) > 1:
            raise TypeError('expected at most 1 arguments, got %d' % len(args))
        try:
            self.__root
        except AttributeError:
            self.__root = root = []                     # sentinel node 哨兵节点
            root[:] = [root, root, None] # 初始化哨兵节点
            self.__map = {} # 初始化 存储key和链表的字典
        self.__update(*args, **kwds)

    def __delitem__(self, key, dict_delitem=dict.__delitem__):
        'od.__delitem__(y) <==> del od[y]'
        # 删除已有的元素，使用 self.__map 来获取key对应的链表
        # 我们通过更新该节点的前继节点和后续节点中的链接来删除
        dict_delitem(self, key)
        link_prev, link_next, _ = self.__map.pop(key)
        link_prev[1] = link_next                        # update link_prev[NEXT]
        link_next[0] = link_prev                        # update link_next[PREV]

    def __iter__(self):
        'od.__iter__() <==> iter(od)'
        # 按顺序遍历链表
        root = self.__root
        curr = root[1]                                  # start at the first node
        while curr is not root:
            yield curr[2]                               # yield the curr[KEY]
            curr = curr[1]                              # move to next node

    def __reversed__(self):
        'od.__reversed__() <==> reversed(od)'
        # 反向遍历链表
        root = self.__root
        curr = root[0]                                  # start at the last node
        while curr is not root:
            yield curr[2]                               # yield the curr[KEY]
            curr = curr[0]                              # move to previous node
		def __setitem__(self, key, value, dict_setitem=dict.__setitem__):
    	# 添加新元素的时候会在链表的末尾创建新链表， 并使用新的 键值对 更新被继承的字典
    	if key not in self:
        	root = self.__root
        	# 这个root 就是所谓的哨兵节点
        	last = root[0]  # root 节点的前驱节点
        	last[1] = root[0] = self.__map[key] = [last, root, key] 
        	# 将root节点作为尾节点，创建新节点，并更新root节点的前驱节点的后继节点和root节点的前驱节点的指向， 形象一点就是在root 节点前不断的对新节点进行前插（基本链表算法）
    	return dict_setitem(self, key, value)           

    def clear(self):
        'od.clear() -> None.  删除所有的链表中的元素'
        root = self.__root
        root[:] = [root, root, None] #哨兵节点永远不会被删除
        self.__map.clear()
        dict.clear(self)