View source

==Tradeoffs==

Hashtables use a lot of memory but can be very fast searches, in linear time.

In general you should use the data structure that best fits what you want to do, rather then trying to find the most efficient way. 

  [TODO:]
  Use asymptotic behaviour to decide, most importantly seeing how the
  structure will be ''used'': an infrequent operation does not need to be
  fast if it means everything else will be much faster


  [TODO:]
  Can use a table like this one to compare the asymptotic behaviour of every
  structure for every operation on it.

Sequences (aka lists):
{| border="1"
|
| Dynamic Array
| Array Deque
| Singly Linked List
| Double Linked List
|-
| Push (Front)
| O(n)
| O(1)
| O(1)
| O(1)
|-
| Pop (Front)
| O(n)
| O(1)
| O(1)
| O(1)
|-
| Push (Back)
| O(1)
| O(1)
| O(n), maybe O(1)*
| O(1)
|-
| Pop (Back)
| O(1)
| O(1)
| O(n)
| O(1)
|-
| Insert before (given iterator)
| O(n)
| O(n)
| O(n)
| O(1)
|-
| Delete (given iterator)
| O(n)
| O(n)
| O(n)
| O(1)
|-
| Insert after (given iterator)
| O(n)
| O(n)
| O(1)
| O(1)
|-
| Delete after (given iterator)
| O(n)
| O(n)
| O(1)
| O(1)
|-
| Get nth element (random access)
| O(1)
| O(1)
| O(n)
| O(n)
|-
| Good for implementing stacks
| yes (back is top)
| yes
| yes (front is top)
| yes
|-
| Good for implementing queues
| no
| yes
| maybe*
| yes
|-
| C++ STL
| <code>std::vector</code>
| <code>std::deque</code>
| -
| <code>std::list</code>
|-
| Java Collections
| <code>java.util.ArrayList</code>
| <code>java.util.ArrayDeque</code>
| -
| <code>java.util.LinkedList</code>
|-
|}
 * singly-linked lists can push to the back in O(1) with the modification that you keep a pointer to the last node

Associative containers (sets, associative arrays):
{| border="1"
|
| Sorted Array
| Sorted Linked List
| Self-balancing Binary Search Tree
| Hash Table
|-
| Find key
| O(log n)
| O(n)
| O(log n)
| O(1) average O(n) worst
|-
| Insert element
| O(n)
| O(n)
| O(log n)
| O(1) average O(n) worst
|-
| Erase key
| O(n)
| O(n)
| O(log n)
| O(1) average O(n) worst
|-
| Erase element (given iterator)
| O(n)
| O(1)
| O(1)
| O(1)
|-
| Can traverse in sorted order?
| yes
| yes
| yes
| no
|-
| Needs
| comparison function
| comparison function
| comparison function
| hash function
|-
| C++ STL
| -
| -
| <code>std::set</code><br>
<code>std::map</code><br>
<code>std::multiset</code><br>
<code>std::multimap</code>
| <code>__gnu_cxx::hash_set</code><br>
<code>__gnu_cxx::hash_map</code><br>
<code>__gnu_cxx::hash_multiset</code><br>
<code>__gnu_cxx::hash_multimap</code>
|-
| Java Collections
| -
| -
| <code>java.util.TreeSet</code><br>
<code>java.util.TreeMap</code>
| <code>java.util.HashSet</code><br>
<code>java.util.HashMap</code>
|-
|}


  [TODO:]
  Can also add a table that specifies the best structure for some specific need
  e.g. For queues, double linked. For stacks, single linked. For sets, hash tables. etc...

  [TODO:]
  Could also contain table with space complexity information (there is a significative cost
  in using hashtables or lists implemented via arrays, for example).