Comparison of data structures
From Wikipedia, the free encyclopedia
This is a comparison of the performance of notable data structures, as measured by the complexity of their logical operations. For a more comprehensive listing of data structures, see List of data structures.
The comparisons in this article are organized by abstract data type. As a single concrete data structure may be used to implement many abstract data types, some data structures may appear in multiple comparisons (for example, a hash map can be used to implement an associative array or a set).
A list or sequence is an abstract data type that represents a finite number of ordered values, where the same value may occur more than once. Lists generally support the following operations:
- peek: access the element at a given index.
- insert: insert a new element at a given index. When the index is zero, this is called prepending; when the index is the last index in the list it is called appending.
- delete: remove the element at a given index.
| Peek (index) |
Mutate (insert or delete) at … | Excess space, average | |||
|---|---|---|---|---|---|
| Beginning | End | Middle | |||
| Linked list | Θ(n) | Θ(1) | Θ(1), known end element; Θ(n), unknown end element |
Θ(n) | Θ(n) |
| Array | Θ(1) | N/a | N/a | N/a | 0 |
| Dynamic array | Θ(1) | Θ(n) | Θ(1) amortized | Θ(n) | Θ(n)[1] |
| Balanced tree | Θ(log n) | Θ(log n) | Θ(log n) | Θ(log n) | Θ(n) |
| Random-access list | Θ(log n)[2] | Θ(1) | N/a[2] | N/a[2] | Θ(n) |
| Hashed array tree | Θ(1) | Θ(n) | Θ(1) amortized | Θ(n) | Θ(√n) |
Maps
Maps store a collection of (key, value) pairs, such that each possible key appears at most once in the collection. They generally support three operations:[3]
- Insert: add a new (key, value) pair to the collection, mapping the key to its new value. Any existing mapping is overwritten. The arguments to this operation are the key and the value.
- Remove: remove a (key, value) pair from the collection, unmapping a given key from its value. The argument to this operation is the key.
- Lookup: find the value (if any) that is bound to a given key. The argument to this operation is the key, and the value is returned from the operation.
Unless otherwise noted, all data structures in this table require O(n) space.
| Data structure | Lookup, removal | Insertion | Ordered | ||
|---|---|---|---|---|---|
| average | worst case | average | worst case | ||
| Association list | O(n) | O(n) | O(1) | O(1) | No |
| B-tree[4] | O(log n) | O(log n) | O(log n) | O(log n) | Yes |
| Hash table | O(1) | O(n) | O(1) | O(n) | No |
| Unbalanced binary search tree | O(log n) | O(n) | O(log n) | O(n) | Yes |
Integer keys
Some map data structures offer superior performance in the case of integer keys. In the following table, let m be the number of bits in the keys.
| Data structure | Lookup, removal | Insertion | Space | ||
|---|---|---|---|---|---|
| average | worst case | average | worst case | ||
| Fusion tree | [?] | O(log m n) | [?] | [?] | O(n) |
| Van Emde Boas tree | O(log log m) | O(log log m) | O(log log m) | O(log log m) | O(m) |
| X-fast trie | O(n log m)[a] | [?] | O(log log m) | O(log log m) | O(n log m) |
| Y-fast trie | O(log log m)[a] | [?] | O(log log m)[a] | [?] | O(n) |
