Question

我正在寻找一种保留其元素顺序的数据结构（可能会随着客户端移动元素而改变数据结构的生命周期）。

它应该允许快速搜索，在给定元素之前/之后插入，删除给定元素，查找第一个和最后一个元素，以及从给定元素开始的双向迭代。

什么是好的实施？

这是我的第一次尝试：

从collections.abc.Iterable和collections.abc.MutableSet派生的类，其中包含链接列表和字典。字典的键是元素，值是链表中的节点。字典将处理给定元素的节点的搜索。找到元素后，链接列表将处理插入前/后，删除和迭代。通过添加或删除相关的键/值对来更新字典。显然，使用这种方法，元素必须是可清晰且唯一的（否则，我们需要另一层间接，其中每个元素由自动分配的数字标识符表示，并且只有那些标识符存储为键）。

在我看来，在渐近复杂性方面明显优于list或collections.deque，但我可能错了。 [编辑：错误，正如@roliu指出的那样。与list或deque不同，我无法通过O(1)中的数字索引找到元素。截至目前，它是O(N)，但我确信如果有必要，可以通过某种方式使其O(log N)。]

Answer 1

在Python中使用双向链表有点不常见。但是，您自己提出的双向链表和字典的解决方案具有正确的复杂性：您要求的所有操作都是O（1）。

我认为标准库中没有更直接的实现。树在理论上可能很好，但也有缺点，如O（log n）或（精确地）它们普遍缺少标准库。

Answer 2

Raymond Hettinger's OrderedSet recipe的略微修改版似乎满足了我的所有要求。我只添加了对基于位置的访问和读/写的支持。

# changes vs. original recipe at http://code.activestate.com/recipes/576696/:
# added a position parameter to add
# changed how pop works, and added popleft
# added find, get_start, get_end, next_pos, prev_pos, __getitem__, __setitem__

class OrderedSetPlus(collections.MutableSet, collections.Iterable):
    '''
    >>> oset = OrderedSetPlus([3, 3, 3, 2, 1, 8, 8])
    >>> oset.add(13)
    >>> p = oset.find(2)
    >>> oset.add(15, p)
    >>> oset
    OrderedSetPlus([3, 15, 2, 1, 8, 13])
    >>> p = oset.next_pos(p)
    >>> oset[p]
    1
    >>> oset.add(7, p)
    >>> oset
    OrderedSetPlus([3, 15, 2, 7, 1, 8, 13])
    >>> oset[p] = 20
    >>> oset
    OrderedSetPlus([3, 15, 2, 7, 20, 8, 13])
    '''

    class DuplicateElement(Exception):
        pass

    def __init__(self, iterable=None):
        self.end = end = [] 
        end += [None, end, end]         # sentinel node for doubly linked list
        self.map = {}                   # key --> [key, prev, next]
        if iterable is not None:
            self |= iterable

    def __len__(self):
        return len(self.map)

    def __contains__(self, key):
        return key in self.map

    def find(self, key):
        return self.map.get(key, None)

    # inserts element before the specified position
    # if pos is None, inserts at the end
    # position can only be obtained by calling instance methods
    def add(self, key, pos = None):
        if pos is None:
            pos = self.end
        if key not in self.map:
            curr = pos[PREV]
            curr[NEXT] = pos[PREV] = self.map[key] = [key, curr, pos]

    def discard(self, key):
        if key in self.map:        
            key, prev, next = self.map.pop(key)
            prev[NEXT] = next
            next[PREV] = prev

    def __iter__(self):
        end = self.end
        curr = end[NEXT]
        while curr is not end:
            yield curr[KEY]
            curr = curr[NEXT]

    def get_end(self):
        return self.end[PREV]

    def get_start(self):
        return self.end[NEXT]

    def next_pos(self, pos):
        pos = pos[NEXT]
        return None if pos is self.end else pos

    def prev_pos(self, pos):
        pos = pos[PREV]
        return None if pos is self.end else pos

    def __getitem__(self, pos):
        return pos[KEY]

    def __setitem__(self, pos, key):
        if key in self.map:
            raise DuplicateElement
        pos[KEY] = key

    def __reversed__(self):
        end = self.end
        curr = end[PREV]
        while curr is not end:
            yield curr[KEY]
            curr = curr[PREV]

    def popleft(self):
        return self.pop(pos = self.get_start())


    def pop(self, pos=None):
        if not self:
            raise IndexError()
        if pos is None:
            pos = self.get_end()
        key = self[pos]
        #key = next(reversed(self)) if last else next(iter(self))
        self.discard(key)
        return key

    def __repr__(self):
        return '{}({})'.format(self.__class__.__name__, list(self))

    def __eq__(self, other):
        if isinstance(other, OrderedSet):
            return len(self) == len(other) and list(self) == list(other)
        return set(self) == set(other)

Answer 3

我知道这不是你问题的直接答案（因为这不是一个python实现的解决方案），但如果你的数据结构相当大，我会考虑Redis D b。您可以使用redis-pi与Python对话。

如何实现保留订单并快速插入/删除的数据结构？

3 个答案: