具有 O(log n) indexOf 操作的列表

Question

我正在寻找一种可以存储元素列表的数据结构，同时还支持 sub-O(n) 查找给定元素的索引和给定索引的元素，以及在索引处插入。

元素密集（整数0..n）且唯一，但未排序。

例如，在 Rust 中，这个数据结构会这样使用：

fn main() {
    let mut list = List::new();
    list.extend(vec![5, 2, 0, 4, 1, 3]);

    assert_eq!(list.get(2), 0);
    assert_eq!(list.get(3), 4);
    assert_eq!(list.index_of(0), 2);
    assert_eq!(list.index_of(4), 3);
}

O(√n) 操作是可以接受的，O(log n) 是理想的。我在这里画一个空白；非常感谢任何帮助！

Answer 1

This library提供了一个“IndexedTreeListSet”数据结构，实现了O(log n)中所需的三个操作：

• 查找索引 -> 元素
• 查找元素 -> 索引（也称为索引）
• 在索引处插入元素

作为 Mo B.notes，它使用辅助哈希图将元素映射到树中的节点，然后向上遍历到根。由于树中的每个节点都包含其相对索引，因此可以在根部计算绝对索引。

我从幼稚的方法（使用 O(n) 插入）切换到此方法，并将插入的墙执行时间（每秒发生约 100 次）从约 100 毫秒减少到约 1 毫秒。

Answer 2

单独维护Vec<T> 和HashMap<usize, T> 是否足够？ HashMap 将有一个 lower lookup time 而不是 O(log n)，它是 O(1)~。

这样的缺点似乎是：

• 您必须将Vec<T> 和HashMap<usize, T> 都存储在内存中。
• 删除元素后，您还必须减少 HashMap<usize, T> 中每个元素的索引，这可能会增加删除成本。

use std::collections::HashMap;

struct List {
    index_to_value: Vec<i32>,
    value_to_index: HashMap<i32, usize>,
}

impl List {
    fn new<I>(index_to_value: I) -> Self
    where
        I: Into<Vec<i32>>,
    {
        let index_to_value = index_to_value.into();
        let value_to_index = index_to_value
            .iter()
            .copied()
            .enumerate()
            .map(|(index, value)| (value, index))
            .collect();

        Self {
            index_to_value,
            value_to_index,
        }
    }

    fn get(&self, n: usize) -> Option<i32> {
        self.index_to_value.get(n).copied()
    }

    fn index_of(&self, i: i32) -> Option<usize> {
        self.value_to_index.get(&i).copied()
    }
}

fn main() {
    let list = List::new(vec![5, 2, 0, 4, 1, 3]);

    assert_eq!(list.get(2), Some(0));
    assert_eq!(list.get(3), Some(4));
    assert_eq!(list.index_of(0), Some(2));
    assert_eq!(list.index_of(4), Some(3));
}