Краткая структура данных

В информатике , А сжатая структура данных является структурой данных , которая использует количество пространства, которое «близко» к информации теоретико- нижняя граница, но ( в отличии от других сжатых представлений) по- прежнему дает возможность эффективной работы запроса. Эта концепция была первоначально введена Якобсоном ^[1] для кодирования битовых векторов , (немаркированных) деревьев и плоских графов . В отличие от обычных алгоритмов сжатия данных без потерь , сжатые структуры данных сохраняют возможность использовать их на месте, не распаковывая их предварительно. Связанное с этим понятие - это сжатая структура данных., в котором размер структуры данных зависит от конкретных представляемых данных.

Предположим, что это оптимальное с теоретической точки зрения количество битов, необходимое для хранения некоторых данных. Представление этих данных называется:${\displaystyle Z}$

• неявно, если занимаетнемного места,${\displaystyle Z+O(1)}$
• кратко, если занимает немного места, и${\displaystyle Z+o(Z)}$
• компактный, если занимает немного места.${\displaystyle O(Z)}$

Например, структура данных, в которой используются биты памяти, компактна, биты - лаконичны, биты также лаконичны, а биты неявны.${\displaystyle 2Z}$${\displaystyle Z+{\sqrt {Z}}}$${\displaystyle Z+\lg Z}$${\displaystyle Z+3}$

Таким образом, неявные структуры обычно сводятся к хранению информации с использованием некоторой перестановки входных данных; самый известный пример - куча .

Краткие словари [ править ]

Краткие индексируемые словари, называемые также ранга / выберите словари, образуют основу ряда методов малообъемных представления, в том числе бинарных деревьев , -ичных деревьев и мультимножествами , ^[2] , а также деревьев суффиксов и массивов . ^[3] Основная проблема состоит в том, чтобы сохранить подмножество юниверса , обычно представленное как битовый массив, где iff . Индексируемый словарь поддерживает обычные методы словарей (запросы и вставки / удаления в динамическом случае), а также следующие операции :${\displaystyle k}$${\displaystyle S}$${\displaystyle U=[0\dots n)=\{0,1,\dots ,n-1\}}$${\displaystyle B[0\dots n)}$${\displaystyle B[i]=1}$${\displaystyle i\in S.}$

• ${\displaystyle \mathbf {rank} _{q}(x)=|\{k\in [0\dots x]:B[k]=q\}|}$
• ${\displaystyle \mathbf {select} _{q}(x)=\min\{k\in [0\dots n):\mathbf {rank} _{q}(k)=x\}}$

для .${\displaystyle q\in \{0,1\}}$

Другими словами, возвращает количество элементов, равных до позиции, а возвращает позицию -го вхождения .${\displaystyle \mathbf {rank} _{q}(x)}$${\displaystyle q}$${\displaystyle x}$${\displaystyle \mathbf {select} _{q}(x)}$${\displaystyle x}$${\displaystyle q}$

There is a simple representation^[4] which uses ${\displaystyle n+o(n)}$ bits of storage space (the original bit array and an ${\displaystyle o(n)}$ auxiliary structure) and supports rank and select in constant time. It uses an idea similar to that for range-minimum queries; there are a constant number of recursions before stopping at a subproblem of a limited size. The bit array ${\displaystyle B}$ is partitioned into large blocks of size ${\displaystyle l=\lg ^{2}n}$ bits and small blocks of size ${\displaystyle s=\lg n/2}$ bits. For each large block, the rank of its first bit is stored in a separate table ${\displaystyle R_{l}[0\dots n/l)}$; each such entry takes ${\displaystyle \lg n}$ bits for a total of ${\displaystyle (n/l)\lg n=n/\lg n}$ bits of storage. Within a large block, another directory ${\displaystyle R_{s}[0\dots l/s)}$ stores the rank of each of the ${\displaystyle l/s=2\lg n}$ small blocks it contains. The difference here is that it only needs ${\displaystyle \lg l=\lg \lg ^{2}n=2\lg \lg n}$ bits for each entry, since only the differences from the rank of the first bit in the containing large block need to be stored. Thus, this table takes a total of ${\displaystyle (n/s)\lg l=4n\lg \lg n/\lg n}$ bits. A lookup table ${\displaystyle R_{p}}$ can then be used that stores the answer to every possible rank query on a bit string of length ${\displaystyle s}$ for ${\displaystyle i\in [0,s)}$; this requires ${\displaystyle 2^{s}s\lg s=O({\sqrt {n}}\lg n\lg \lg n)}$ bits of storage space. Thus, since each of these auxiliary tables take ${\displaystyle o(n)}$ space, this data structure supports rank queries in ${\displaystyle O(1)}$ time and ${\displaystyle n+o(n)}$ bits of space.

To answer a query for ${\displaystyle \mathbf {rank} _{1}(x)}$ in constant time, a constant time algorithm computes:

• ${\displaystyle \mathbf {rank} _{1}(x)=R_{l}[\lfloor x/l\rfloor ]+R_{s}[\lfloor x/s\rfloor ]+R_{p}[x\lfloor x/s\rfloor ,x{\text{ mod }}s]}$

In practice, the lookup table ${\displaystyle R_{p}}$ can be replaced by bitwise operations and smaller tables that can be used to find the number of bits set in the small blocks. This is often beneficial, since succinct data structures find their uses in large data sets, in which case cache misses become much more frequent and the chances of the lookup table being evicted from closer CPU caches becomes higher.^[5] Select queries can be easily supported by doing a binary search on the same auxiliary structure used for rank; however, this takes ${\displaystyle O(\lg n)}$ time in the worst case. A more complicated structure using ${\displaystyle 3n/\lg \lg n+O({\sqrt {n}}\lg n\lg \lg n)=o(n)}$ bits of additional storage can be used to support select in constant time.^[6] In practice, many of these solutions have hidden constants in the ${\displaystyle O(\cdot )}$ notation which dominate before any asymptotic advantage becomes apparent; implementations using broadword operations and word-aligned blocks often perform better in practice.^[7]

Entropy-compressed dictionaries[edit]

The ${\displaystyle n+o(n)}$ space approach can be improved by noting that there are ${\displaystyle \textstyle {\binom {n}{m}}}$ distinct ${\displaystyle m}$-subsets of ${\displaystyle [n)}$ (or binary strings of length ${\displaystyle n}$ with exactly ${\displaystyle m}$ 1’s), and thus ${\displaystyle \textstyle {\mathcal {B}}(m,n)=\lceil \lg {\binom {n}{m}}\rceil }$ is an information theoretic lower bound on the number of bits needed to store ${\displaystyle B}$. There is a succinct (static) dictionary which attains this bound, namely using ${\displaystyle {\mathcal {B}}(m,n)+o({\mathcal {B}}(m,n))}$ space.^[8] This structure can be extended to support rank and select queries and takes ${\displaystyle {\mathcal {B}}(m,n)+O(m+n\lg \lg n/\lg n)}$ space.^[2] Correct rank queries in this structure are however limited to elements contained in the set, analogous to how minimal perfect hashing functions work. This bound can be reduced to a space/time tradeoff by reducing the storage space of the dictionary to ${\displaystyle {\mathcal {B}}(m,n)+O(nt^{t}/\lg ^{t}n+n^{3/4})}$ with queries taking ${\displaystyle O(t)}$ time.^[9]

Examples[edit]

A null-terminated string (C string) takes Z + 1 space, and is thus implicit. A string with an arbitrary length (Pascal string) takes Z + log(Z) space, and is thus succinct. If there is a maximum length – which is the case in practice, since 2³² = 4 GiB of data is a very long string, and 2⁶⁴ = 16 EiB of data is larger than any string in practice – then a string with a length is also implicit, taking Z + k space, where k is the number of data to represent the maximum length (e.g., 64 bits).

When a sequence of variable-length items (such as strings) needs to be encoded, there are various possibilities. A direct approach is to store a length and an item in each record – these can then be placed one after another. This allows efficient next, but not finding the kth item. An alternative is to place the items in order with a delimiter (e.g., null-terminated string). This uses a delimiter instead of a length, and is substantially slower, since the entire sequence must be scanned for delimiters. Both of these are space-efficient. An alternative approach is out-of-band separation: the items can simply be placed one after another, with no delimiters. Item bounds can then be stored as a sequence of length, or better, offsets into this sequence. Alternatively, a separate binary string consisting of 1s in the positions where an item begins, and 0s everywhere else is encoded along with it. Given this string, the ${\displaystyle select}$ function can quickly determine where each item begins, given its index.^[10] This is compact but not succinct, as it takes 2Z space, which is O(Z).

Another example is the representation of a binary tree: an arbitrary binary tree on ${\displaystyle n}$ nodes can be represented in ${\displaystyle 2n+o(n)}$ bits while supporting a variety of operations on any node, which includes finding its parent, its left and right child, and returning the size of its subtree, each in constant time. The number of different binary trees on ${\displaystyle n}$ nodes is ${\displaystyle {\tbinom {2n}{n}}}$${\displaystyle /(n+1)}$. For large ${\displaystyle n}$, this is about ${\displaystyle 4^{n}}$; thus we need at least about ${\displaystyle \log _{2}(4^{n})=2n}$ bits to encode it. A succinct binary tree therefore would occupy only ${\displaystyle 2}$ bits per node.

See also[edit]

• Minimal perfect hash function

References[edit]