从内存位置的哈希查找中删除列表中的项目？

Question

我有一些对象，每个对象都有一个唯一的 ID，这些对象被插入到各种列表中。这些对象需要经常从其对应列表的中间删除，通常是O(n)，所以我想将它们的位置保存在dict 中，并在每次我想检索对象的位置在O(1) 中删除它。

class Node(object):
    def __init__(self, lst_id, unique_id):
        self.lst_id = lst_id
        self.unique_id = unique_id

n1 = Node('a', 1)
n2 = Node('a', 2)
n3 = Node('b', 3)
node_lsts = {}
for node in [n1,n2,n3]:
    if node.lst_id in node_lsts:
        node_lsts[node.lst_id].append(node)
    else:
        node_lsts[node.lst_id] = [node]

nodes_hash = {n1.unique_id: n1, n2.unique_id: n2, n3.unique_id: n3}

ID_TO_REMOVE = 1

在上面的例子中，如果我简单地调用del nodes_hash[ID_TO_REMOVE]，node_lsts 中的相应对象即使从字典中删除，它仍然存在 - 我应该如何将它从 O(1) 中的相应列表中删除？

在 C++ 中，我可以将指向邻居列表的指针保留为节点成员变量（链表），并通过其内存地址查找节点，获取指向其邻居的指针，取消该节点与其邻居的链接（从而将其从 ' list') 最后释放节点。我正在尝试复制这种行为。

Answer 1

您可以使用嵌套在字典中的字典，而不是使用嵌套在字典中的列表：

node[node.lst_id] = {node1.unique_id: node1, node2.unique_id: node2, ... }

假设ID_TO_REMOVE 是unique_id，您可以使用以下命令将其删除：

node_to_remove = nodes_hash[ID_TO_REMOVE]
del node_lsts[node_to_remove.lst_id][node_to_remove.unique_id]

完整代码：

class Node(object):
    def __init__(self, lst_id, unique_id):
        self.lst_id = lst_id
        self.unique_id = unique_id

    def __repr__(self):
        return "[lst_id: {}, unique_id: {}]".format(self.lst_id, self.unique_id)

n1 = Node('a', 1)
n2 = Node('a', 2)
n3 = Node('b', 3)
node_lsts = {}
for node in [n1,n2,n3]:
    if not node.lst_id in node_lsts:
        node_lsts[node.lst_id] = {}
    node_lsts[node.lst_id][node.unique_id] = node

nodes_hash = {n1.unique_id: n1, n2.unique_id: n2, n3.unique_id: n3}

ID_TO_REMOVE = 1

print("node_lsts", node_lsts)
node_to_remove = nodes_hash[ID_TO_REMOVE]
print("node_to_remove", node_to_remove)
del node_lsts[node_to_remove.lst_id][node_to_remove.unique_id]
print("node_lsts", node_lsts)

输出

node_lsts {'a': {1: [lst_id: a, unique_id: 1], 2: [lst_id: a, unique_id: 2]}, 'b': {3: [lst_id: b, unique_id: 3]}}
node_to_remove [lst_id: a, unique_id: 1]
node_lsts {'a': {2: [lst_id: a, unique_id: 2]}, 'b': {3: [lst_id: b, unique_id: 3]}}

由于我们现在使用字典，所以一切都在 O(1) 内完成，我们避免了尝试从列表中删除元素时出现的性能问题。

Answer 2

您可以在 Python 中轻松创建双向链表：

class DoublyLinkedListNode(object):
    def __init__(self, unique_id, lst_id, left=None, right=None):
        self.unique_id, self.lst_id = unique_id, lst_id

        self.left = left
        self.right = right

    def remove(self):
        if self.left is not None:
            self.left.right = self.right

        if self.right is not None:
            self.right.left = self.left

        self.left = None
        self.right = None

    def append(self, node):
        node.left = self
        node.right = self.right

        if self.right is not None:
            self.right.left = node
            node.right = self.right

        self.right = node

    def prepend(self, node):
        node.left = self.left
        node.right = self

        if self.left is not None:
            self.left.right = node

        self.left = node

    def iter_left(self):
        current = self

        while current.left is not None:
            yield current.left
            current = current.left

    def iter_right(self):
        current = self

        while current.right is not None:
            yield current.right
            current = current.right

作为一个链表，这对于任何给定的节点都有 O(1) 的插入和删除。如果您可以通过字典或其他更适合的数据结构保留对每个节点的引用，这将允许您平均情况 O(1) 访问和快速顺序迭代。

class ListContainer(object):
    def __init__(self):
        self.lists = {}
        self.node_mapping = {}

    def append(self, node):
        if node.lst_id in self.lists:
            self.lists[node.lst_id].append(node)
        else:
            self.lists[node.lst_id] = node

        self.node_mapping[node.unique_id] = node

    def remove(self, node):
        ...

请注意，如果您的列表中只有几百个元素，那么这一切都是徒劳的。对于这么少的元素，纯 Python 数据结构可能不会比 Python 实现的列表数据结构快。 Big-O 表示法会忽略常数项，如果您没有处理足够多的元素（例如 Coppersmith-Winograd algorithm），它可能会非常大。