275 research outputs found
Optimal resizable arrays
A \emph{resizable array} is an array that can \emph{grow} and \emph{shrink}
by the addition or removal of items from its end, or both its ends, while still
supporting constant-time \emph{access} to each item stored in the array given
its \emph{index}. Since the size of an array, i.e., the number of items in it,
varies over time, space-efficient maintenance of a resizable array requires
dynamic memory management. A standard doubling technique allows the maintenance
of an array of size~ using only space, with amortized time, or
even worst-case time, per operation. Sitarski and Brodnik et al.\
describe much better solutions that maintain a resizable array of size~
using only space, still with time per operation. Brodnik
et al.\ give a simple proof that this is best possible.
We distinguish between the space needed for \emph{storing} a resizable array,
and accessing its items, and the \emph{temporary} space that may be needed
while growing or shrinking the array. For every integer , we show that
space is sufficient for storing and accessing an array of
size~, if space can be used briefly during grow and shrink
operations. Accessing an item by index takes worst-case time while grow
and shrink operations take amortized time. Using an exact analysis of a
\emph{growth game}, we show that for any data structure from a wide class of
data structures that uses only space to store the array, the
amortized cost of grow is , even if only grow and access operations
are allowed. The time for grow and shrink operations cannot be made worst-case,
unless .Comment: To appear in SOSA 202
Fast Dynamic Arrays
We present a highly optimized implementation of tiered vectors, a data
structure for maintaining a sequence of elements supporting access in time
and insertion and deletion in time for
while using extra space. We consider several different implementation
optimizations in C++ and compare their performance to that of vector and
multiset from the standard library on sequences with up to elements. Our
fastest implementation uses much less space than multiset while providing
speedups of for access operations compared to multiset and speedups
of compared to vector for insertion and deletion operations
while being competitive with both data structures for all other operations
Efficient Representations for Large Dynamic Sequences in ML
International audienceThe use of sequence containers, including stacks, queues, and double-ended queues, is ubiquitous in programming. When the maximal number of elements is not known in advance, containers need to grow dynamically. For this purpose, most ML programs either rely on lists or vectors. These structures are inefficient, both in terms of time and space usage. We investigate the use of chunked-based data structures. Such structures save a lot of memory and may deliver better performance than classic container data structures. We observe a 2x speedup compared with vectors, and up to a 3x speedup compared with lengthy lists
- …