Dynamic array

From Wikipedia, the free encyclopedia

It has been suggested that Vector (STL) be merged into this article or section. (Discuss)

In computer science, a dynamic array, growable array, resizable array, dynamic table, or array list is an array data structure that can be resized and allows elements to be added or removed. It is supplied with standard libraries in many modern mainstream programming languages.

A dynamic array is not the same thing as a dynamically-allocated array, which is a fixed-size array whose size is fixed when the array is allocated; for more discussion of this type of array, see array.

1 Bounded-size dynamic arrays and capacity
2 Geometric expansion and amortized cost
3 Performance
4 Variants
5 Language support
6 References
7 External links

[edit] Bounded-size dynamic arrays and capacity

The simplest dynamic array is constructed by allocating a fixed-size array and then dividing it into two parts: the first stores the elements of the dynamic array and the second is reserved, or unused. We can then add or remove elements at the end of the dynamic array in constant time by using the reserved space, until this space is completely consumed. The number of elements used by the dynamic array contents is its logical size or size, while the size of the underlying array is called the dynamic array's capacity, which is the maximum possible logical size.

In applications where the logical size is bounded, this data structure suffices. Resizing the underlying array is an expensive operation, typically involving copying the entire contents of the array.

[edit] Geometric expansion and amortized cost

To avoid incurring the cost of resizing many times, dynamic arrays resize by a large amount, such as doubling in size, and use the reserved space for future expansion. The operation of adding an element to the end might work as follows:

function insertEnd(dynarray a, element e)
    if (a.size = a.capacity)
        // resize a to twice its current capacity:
        a.capacity ← a.capacity * 2  
        // (copy the contents to the new memory location here)
    a[a.size] ← e
    a.size ← a.size + 1

As n elements are inserted, the capacities form a geometric progression. Expanding the array by any constant proportion ensures that inserting n elements takes O(n) time overall, meaning that each insertion takes amortized constant time. The value of this proportion a leads to a time-space tradeoff: the average time per insertion operation is about a/(a−1), while the number of wasted cells is bounded above by (a−1)n. The choice of a is application-dependent, but a=2 is commonly-used.

Many dynamic arrays also deallocate some of the underlying storage if its size drops below a certain threshold, such as 30% of the capacity.

Dynamic arrays are a common example when teaching amortized analysis.

[edit] Performance

	Linked list	Array	Dynamic array
Indexing	Θ(n)	Θ(1)	Θ(1)
Insertion/deletion at end	Θ(1)	N/A	Θ(1)
Insertion/deletion in middle	Θ(1)	N/A	Θ(n)
Wasted space (average)	Θ(n)	0	Θ(n)

The dynamic array has performance similar to an array, with the addition of new operations to add and remove elements from the end:

Getting or setting the value at a particular index (constant time)
Iterating over the elements in order (linear time, good cache performance)
Inserting or deleting an element in the middle of the array (linear time)
Inserting or deleting an element at the end of the array (constant amortized time)

Dynamic arrays benefit from many of the advantages of arrays, including good locality of reference and data cache utilization, compactness (low memory use), and random access. They usually have only a small fixed additional overhead for storing information about the size and capacity. This makes dynamic arrays an attractive tool for building cache-friendly data structures.

Compared to linked lists, dynamic arrays have faster indexing (constant time versus linear time) and typically faster iteration due to improved locality of reference; however, dynamic arrays require linear time to insert or delete at an arbitrary location, since all following elements must be moved, while linked lists can do this in constant time. This disadvantage is mitigated by the gap buffer and tiered vector variants discussed under Variants below. Also, in a highly-fragmented memory region, it may be expensive or impossible to find contiguous space for a large dynamic array, whereas linked lists do not require the whole data structure to be stored contiguously.

[edit] Variants

Gap buffers are similar to dynamic arrays but allow efficient insertion and deletion operations clustered near the same arbitrary location. Some deque implementations are based on dynamic arrays; see Deque#Dynamic_array_implementation.

Goodrich ^[1] presented a dynamic array algorithm called Tiered Vectors that provided O(n^1/2) performance for order preserving insertions or deletions from the middle of the array.

Hashed Array Tree (HAT) is a dynamic array algorithm invented by Sitarski in 1996. ^[2] Hashed Array Tree wastes order n^1/2 amount of storage space, where n is the number of elements in the array. The algorithm has O(1) amortized performance when appending a series of objects to the end of a Hashed Array Tree.

In a 1999 paper^[3], Brodnik et al. describe a tiered dynamic array data structure, which wastes only n^1/2 space for n elements at any point in time, and they prove a lower bound showing that any dynamic array must waste this much space if the operations are to remain amortized constant time. Additionally, they present a variant where growing and shrinking the buffer has not only amortized but worst-case constant time.

Bagwell (2002) ^[4] presented the VList algorithm, which can be adapted to implement a dynamic array.

[edit] Language support

C++'s std::vector is an implementation of dynamic arrays, as are the ArrayList ^[5] classes supplied with the Java API and the .NET Framework. The generic List<> class supplied with version 2.0 of the .NET Framework is also implemented with dynamic arrays. Delphi and D implement dynamic arrays at the language's core. Many scripting languages such as Perl offer dynamic arrays as a built-in primitive data type.