|
|
| Line 96: |
Line 96: |
| | </div> | | </div> |
| | [https://youtu.be/LsjFAx-dG5I Tutorial 24.2]: The unordered associative containers | | [https://youtu.be/LsjFAx-dG5I Tutorial 24.2]: The unordered associative containers |
| − | * Main difference between ordered/unordered | + | * Main difference between ordered/unordered [https://youtu.be/LsjFAx-dG5I?t=0m14s 0:14] |
| | ** Implication: if you iterative over an unordered container, keys will appear in (seemingly) random order | | ** Implication: if you iterative over an unordered container, keys will appear in (seemingly) random order |
| | * [WORK-IN-PROGRESS] | | * [WORK-IN-PROGRESS] |
Revision as of 18:53, 2 February 2020
Associative containers are super useful, both as a convenient fast way to create dictionary or mapping for real-world problems like managing game resources, and as a data structure to help solve more abstract algorithmic computer science problems. And hash tables are fast as balls.
Topics Covered
Part 1: ordered associative containers
-
std::map container interface
- Binary tree data structure
-
std::map key requirements (comparison)
-
std::map gotchas (std::remove_if and const keys)
-
std::set
-
std::multimap and std::multiset
Part 2: unordered associative containers
- Hash table performance vs. binary tree performance
- Hash table data structure
-
std::unordered_map key requirements
- Hash combining
-
std::unordered_map bucket interface and hashing policy
- When to choose
std::map over std::unordered_map
Video Timestamp Index
Tutorial 24.1: The ordered associative containers
[Expand]
- The
std::map<KeyType,ValueType> class 0:46
- Maps consist of keys to lookup (associated) values
-
map.insert( {key,value} ) to insert (key,value) pairs
-
map[key] returns a reference to the ValueType for a KeyType
- A Binary Tree data structure is used to manage the order of map elements 2:46
-
std::map performs lookup in O(log(n)), it uses a Binary tree data structure
- Key properties of a Binary Tree (BT):
- - Nodes can have at most 2 children (hence: binary)
- - Each left child is smaller and each right child is larger than its parent
- - Insertion is done by navigating the tree along a route Left for smaller, Right for larger such that the order property always holds
- The big advantage of the BT properties is that retrieval is very fast
- The beauty of
std::map is that we don't have to implement any of this; it's all there in the STL 7:00
- The STL implementation is further optimized, e.g. it uses a red-black tree for BT rebalancing
- A look at the
std::map cppreference.com documentation: insert, lookup & find 7:35
-
map.insert() takes a pair type std::pair<KeyType,ValueType>, the Map's elements
- C++ can deduce the pair Type, so
map.insert({keyX,valueXYZ}); with curly braces will do the job
- An even better way to insert is through
map.emplace() operation; it will construct the pair in-place.
- For lookup, you can use square braces,
map[x] will return a reference to the corresponding value
- Note: a lookup with a new key value will create that element in the map with the default constructed ValueType value
-
insert or emplace with a key that already exists will NOT override the existing value: std::map::emplace returns a std::pair<iterator,bool> where the bool inidicates whether an insertion took place
-
map.find("xyz") returns an iterator to the element if it exitst, and an iterator to map.end() if it doesn't exist (useful to check if a key already exists)
-
std::map comes with iterators and because it is a sorted map, when you iterate over its elements with for (auto& el : map), it will be in order (of the keys)
- Requirements on KeyType 14:30
- The KeyType has to be comparable. The third template parameter is a functor for KeyType Comparison that defaults to
std::less<KeyType>
- So by default keys have to implement the "less than" comparison operator or provide your own comparison functor when defining the map
-
std::map cppreference.com documentation continued: erase 15:28
-
std::map::erase offers three basic ways to erase elements:
- - With an iterator; returns an iterator following the last removed element
- - With an iterator range, idem
- - By key through
map.erase(const KeyType& key); this operation returns the number of elements erased (in size_type)
- Two important things to know when working with associative containers 16:04
-
std::remove_if does not work with associative containers (will come with C++20).
- - You have to iterate over the elements with
for( auto i = map.begin(); i != map.end();)
- - And apply
i = map.erase(i); in the body of your if logic, and ++i in the else block.
- Keys are
const. You're not allowed to modify the keys 18:38
- - Makes sense: the keys define the structure of the binary tree.
- - If you modify the key you invalidate this structure (it would require a deletion and insertion to do it properly)
- The
std::set<KeyType> class 20:00
- With a set, you only have keys, and a unique entry for each unique key
- Use case: ensure that there are no duplicates in a set
- The
std::multimap and std::multiset classes 21:28
- Map has unique keys, with multimap you can insert multiple elements with the same key
- This enables operations like
std::multimap::equal_range that returns a pair of iterators (begin and end) of the range where these elements have that same key
-
std::multimap::count will return the number of elements with specific key
- Practical example of a multimap use case 22:30
- Implementation example of a custom Comparison functor for the
Vei2 class (2D coordinate vector).
- - Chili's choice for ordering (used in the body of the functor):
- -
return (lhs.x == rhs.x) ? lhs.y < rhs.y : lhs.x < rhs.x;
- Example of how to find and print multiple elements in a multimap using
equal_range()
- Lookup in multimaps 25:21
- Note: the multimap class does not have an index operator
[]
- When you do a lookup on a multimap, you should use
equal_range()
- The problem with
find() on a multimap, is that if there are several elements with key in the ccontainer, any of them may be returned
Tutorial 24.2: The unordered associative containers
- Main difference between ordered/unordered 0:14
- Implication: if you iterative over an unordered container, keys will appear in (seemingly) random order
- [WORK-IN-PROGRESS]
Homework Assignment
The homework for this video is to enable use of a custom datatype in unordered_map hashing over multiple (4) members of that datatype. The solution video is here.
Supplementary Link
See also
