O(1) 在非连续内存中查找？

Question

是否有任何已知的数据结构提供 O(1) 随机访问，而不使用大小为 O(N) 或更大的连续内存块？这是受到this answer 的启发，出于好奇而不是任何特定的实际用例而提出要求，尽管它可能在堆严重碎片化的情况下有用。

Answer 1

是的，这里有一个 C++ 示例：

template<class T>
struct Deque {
  struct Block {
    enum {
      B = 4*1024 / sizeof(T), // use any strategy you want
                              // this gives you ~4KiB blocks
      length = B
    };
    T data[length];
  };
  std::vector<Block*> blocks;

  T& operator[](int n) {
    return blocks[n / Block::length]->data[n % Block::length]; // O(1)
  }

  // many things left out for clarity and brevity
};

与 std::deque 的主要区别在于它具有 O(n) push_front 而不是 O(1)，实际上实现 std::deque 以具有 all 存在一些问题的：

1. O(1) push_front
2. O(1) push_back
3. O(1) 运算[]

---

也许我误解了“不使用大小为 O(N) 或更大的连续内存块”，这似乎很尴尬。你能澄清你想要什么吗？我将其解释为“没有单个分配包含一个代表序列中的每个项目的项目”，例如有助于避免大量分配。 （即使我确实为向量分配了一个大小为 N/B 的单一分配。）

如果我的回答不符合您的定义，那么除非您人为地限制容器的最大尺寸，否则什么都不会。 （例如，我可以将您限制为 LONG_MAX 个项目，将上述块存储在树中，然后调用该 O(1) 查找。）

Answer 2

您可以使用trie，其中键的长度是有界的。由于在长度为m 的键的树中查找是O(m)，如果我们绑定键的长度，那么我们绑定m，现在查找是O(1)。

所以想一想其中键是字母表上的字符串 { 0, 1 } 的 trie（即，我们将键视为整数的二进制表示）。如果我们将键的长度限制为 32 个字母，则我们可以将其视为由 32 位整数索引的结构，并且可以在O(1) 时间随机访问。

这是 C# 中的一个实现：

class TrieArray<T> {
    TrieArrayNode<T> _root;

    public TrieArray(int length) {
        this.Length = length;
        _root = new TrieArrayNode<T>();
        for (int i = 0; i < length; i++) {
            Insert(i);
        }
    }

    TrieArrayNode<T> Insert(int n) {
        return Insert(IntToBinaryString(n));
    }

    TrieArrayNode<T> Insert(string s) {
        TrieArrayNode<T> node = _root;
        foreach (char c in s.ToCharArray()) {
            node = Insert(c, node);
        }
        return _root;
    }

    TrieArrayNode<T> Insert(char c, TrieArrayNode<T> node) {
        if (node.Contains(c)) {
            return node.GetChild(c);
        }
        else {
            TrieArrayNode<T> child = new TrieArray<T>.TrieArrayNode<T>();
            node.Nodes[GetIndex(c)] = child;
            return child;
        }

    }

    internal static int GetIndex(char c) {
        return (int)(c - '0');
    }

    static string IntToBinaryString(int n) {
        return Convert.ToString(n, 2);
    }

    public int Length { get; set; }

    TrieArrayNode<T> Find(int n) {
        return Find(IntToBinaryString(n));
    }

    TrieArrayNode<T> Find(string s) {
        TrieArrayNode<T> node = _root;
        foreach (char c in s.ToCharArray()) {
            node = Find(c, node);
        }
        return node;
    }

    TrieArrayNode<T> Find(char c, TrieArrayNode<T> node) {
        if (node.Contains(c)) {
            return node.GetChild(c);
        }
        else {
            throw new InvalidOperationException();
        }
    }

    public T this[int index] {
        get {
            CheckIndex(index);
            return Find(index).Value;
        }
        set {
            CheckIndex(index);
            Find(index).Value = value;
        }
    }

    void CheckIndex(int index) {
        if (index < 0 || index >= this.Length) {
            throw new ArgumentOutOfRangeException("index");
        }
    }

    class TrieArrayNode<TNested> {
        public TrieArrayNode<TNested>[] Nodes { get; set; }
        public T Value { get; set; }
        public TrieArrayNode() {
            Nodes = new TrieArrayNode<TNested>[2];
        }

        public bool Contains(char c) {
            return Nodes[TrieArray<TNested>.GetIndex(c)] != null;

        }

        public TrieArrayNode<TNested> GetChild(char c) {
            return Nodes[TrieArray<TNested>.GetIndex(c)];
        }
    }
}

这里是示例用法：

class Program {
    static void Main(string[] args) {
        int length = 10;
        TrieArray<int> array = new TrieArray<int>(length);
        for (int i = 0; i < length; i++) {
            array[i] = i * i;
        }
        for (int i = 0; i < length; i++) {
            Console.WriteLine(array[i]);
        }
    }
}

Answer 3

好吧，既然我已经花时间思考它，可以认为所有哈希表要么是大小 >N 的连续块，要么具有与 N 成比例的存储桶列表，而 Roger 的Blocks 的顶级数组是 O(N)，系数小于 1，我在 cmets 中针对他的问题提出了解决方案，如下：

int magnitude( size_t x ) { // many platforms have an insn for this
    for ( int m = 0; x >>= 1; ++ m ) ; // return 0 for input 0 or 1
    return m;
}

template< class T >
struct half_power_deque {
    vector< vector< T > > blocks; // max log(N) blocks of increasing size
    int half_first_block_mag; // blocks one, two have same size >= 2

    T &operator[]( size_t index ) {
        int index_magnitude = magnitude( index );
        size_t block_index = max( 0, index_magnitude - half_first_block_mag );
        vector< T > &block = blocks[ block_index ];
        size_t elem_index = index;
        if ( block_index != 0 ) elem_index &= ( 1<< index_magnitude ) - 1;
        return block[ elem_index ];
    }
};

template< class T >
struct power_deque {
    half_power_deque forward, backward;
    ptrdiff_t begin_offset; // == - backward.size() or indexes into forward
    T &operator[]( size_t index ) {
        ptrdiff_t real_offset = index + begin_offset;
        if ( real_offset < 0 ) return backward[ - real_offset - 1 ];
        return forward[ real_offset ];
    }
};

half_power_deque 实现擦除除最后一个块之外的所有块，适当地改变 half_first_block_mag。这允许 O(max over time N) 内存使用，在两端分摊 O(1) 插入，永远不会使引用无效，以及 O(1) 查找。

Answer 4

地图/字典怎么样？最后我检查了一下，这是 O(1) 性能。