advanced stl
DESCRIPTION
Advanced STL. Overview of Containers, Iterators, Algorithms. Using Functionality in STL. Learning & Development Team. http://academy.telerik.com. Telerik Software Academy. Table of Contents (1). Containers Concepts Priority queue (multi)Sets, (multi)Maps Iterators Concepts - PowerPoint PPT PresentationTRANSCRIPT
Advanced STLOverview of Containers, Iterators,
Algorithms. Using Functionality in STL
Learning & Development Teamhttp://academy.telerik.com
Telerik Software Academy
Table of Contents (1)1. Containers
1.Concepts2.Priority queue3.(multi)Sets, (multi)Maps
2. Iterators1.Concepts2.STL container iterators3.Insertion iterators and iterators on
streams2
Table of Contents (2)3. Algorithms
3. Heap creation4. Sorting, Operations on sorted
containers5. Searching6. Combinatorial
4. Functors3. Concepts4. Creating and using Generators,
Unary and Binary Functors
ContainersSTL Container Architecture, Advanced
Containers
Containers STL Containers represent collections of objects Going through objects is called
iterating Several base concepts & refinements for all STL containers: Container Forward Container, Reversible
Container Random Access Container
Concepts – definitions, not implementations
Refinements – extensions/specific definitions
Containers Containers also fall into one of two groups: Sequences Associative containers
Actual data structures are models of the above i.e. implementations of the
Concepts e.g. a vector is a model of a
Sequence
Containers – Pseudo-Diagram
Container
Forward, Reversible, Random Access
SequenceFront/Back Insertion
Associative ContainerSimple, Pair, Sorted,
Uniquevecto
rlist
dequebit_vectorset
map
multiset
multimap
stackqueuepriority_que
ue
Adaptor
Containers STL Containers are templates
A template is filled compile-time with type data
i.e. a STL container is defined once compiled into different classes depending on its passed template
parameters E.g. the container class vector is
defined in the header <vector> once, but we can: use a vector<int>, to store integers use another vector<string> to store
strings, etc.
Containers Container concept
Stores elements, element lifetime ends when container lifetime ends
No guarantees on element order Forward Container concept (refinement of Container) Elements have some order Order won't change as a side effect
of going through (iterating) the elements
Guarantees "forward direction" of iteration
Containers Reversible Container concept (refinement of Forward Container) Guarantees two (opposite)
directions of iteration – "forward" and "backward"
Random Access Container (refinement of Reversible Container) Guarantees (amortized) constant
time access to any contained element
i.e. can access an element, without iterating other elements to reach it
Sequences Sequences are refinements of Forward Containers Have a definite ordering of
elements Have variable size – elements can
be added indefinitely, at specific positions
Sequence models: vector list deque
Associative Containers Associative Containers are Containers Similar to Sequences, but cannot
add elements at specific positions Each element has a key and a value Elements are accessed by their key Elements can be added indefinitely,
but the container decides their "position"
Several types (to be discussed later)
Container Adaptors Adaptors limit access to containers
Fundamental for FIFO and LIFO data structures
Adaptor models: queue stack priority_queue
Advanced Container Modelspriority_queue, map, set, multimap,
multiset, Usage and Examples
Note: for basic container models, see Basic ADTs in STL
Priority Queue The priority_queue is a queue
Enables insertion of elements Enables access/removal of "top"
element "First" element is referred to as
"top" element Guarantees the top element is the
largest Biggest for numbers (by default) Last lexicographically for strings (by
default) Or according to a comparer Or overloaded operators for other
types
Priority Queue Priority Queue (#include <queue>)
priority_queue<T, Sequence = vector<T>, Compare = less<T> >
T has to be able to be compared by Compare
Fast at accessing the top element (1)
Fast at inserting elements (log n) Good at removing top element (log
n) Uses a container for storing
elements (default: vector)
16
Priority Queue Declaring and initializing a priority queue:
Retrieving top element: Removing top element:
#include<queue> //required header…priority_queue<int> numsBySize;numsBySize.push(1);numsBySize.push(3);numsBySize.push(2);
priority_queue<string> stringsByLex;stringsByLex.push("a");stringsByLex.push("c");stringsByLex.push("b");
numsBySize.top() //returns 3, does not remove it
stringsByLex.pop() //removes "c"
Priority Queue UsageLive Demo
Problems Solved with Priority Queues
Finding shortest path in weighted graphs (Dijkstra's algorithm uses priority queues)
Getting largest N items from several sorted lists
Compression in Huffman coding Heapsort (STL priority queue uses a heap)
Simple problem: Given a sequence of numbers, each
time a numbers is 0, print the largest number so-far
Simple Problem Solved with a Priority Queue
Live Demo
Associative Container Models
Several categories Simple, Sorted, Unique
Simple Associative Containers Elements are their own keys
Pair Associative Container Values are in the form (key,
element) Sorted Associative Containers
Elements ordered, most operations are log n
Unique Associative Containers No duplicate keys are allowed
Set Categories: Sorted, Simple, Unique Elements are their own keys
E.g. if you want to check if an element is contained, you query with the (copy) of the element
Guarantees no duplicate elements Extracting elements one by one:
Yields the elements in ascending order
Set Set (#include <set>)
set<Key,Compare = less<Key>, Alloc = new>
Key has to be comparable by Compare Fast checking if an element is
contained (log n) Fast inserting elements (log n) Fast deleting (erasing) elements
(log n) Deleting elements does not
invalidate iterators to other elements
23
Set Declaring and initializing a set:
Set elements can be accessed through iterator (and consequently iterated in ascending order)
Set elements can be removed By iterator By value
#include<set> //required header…set<int> uniqueNums;uniqueNums.insert(3);uniqueNums.insert(7);uniqueNums.insert(2);uniqueNums.insert(7);
uniqueNumbers.begin(); //iterator to first element (2)
uniqueNums.erase(uniqueNums.begin());uniqueNums.erase(2);
Set UsageLive Demo
Problems Solved with Sets Any problems including mathematical set operations Unions, intersections, etc.
Set Cover Problem Simple problem:
You are given a sequence of numbers. Print all numbers in the sequence, without printing the same number more than once
Simple Problem Solved with a Set
Live Demo
Multiset Same as a set, without the Unique category i.e. there can be repeating elements All other operations & properties
are the same Multiset (#include <set>)
multiset (same template parameters as set)
Declaring and initializing a multiset
#include<set> //required header…multiset<int> nums;nums.insert(2);nums.insert(2); //nums contains: 2, 2
Multiset UsageLive Demo
Map Categories: Sorted, Unique, Pair Each element has a key
Accessing elements is done through the key
Guarantees no duplicate elements Element keys are iterated in increasing order
Often pictured as an array, the indices of which can be any type – number, string or even some class
Map Map (#include <map>)
map <Key, Data, Compare = less<Key>Alloc = new>
Key must be comparable by Compare Fast at accessing elements by key
(log n) Fast at deleting elements by key
(log n) Fast at inserting elements by key
(log n) Values are of the type std::pair<Key, Data> Iterators will point to std::pair
objects
Map Declaring and initializing a map:
Accessing element by key:
Removing element by key:
#include<map> //required header…map<char*, int> peopleAges;
peopleAges["Joro"] = 22;peopleAges.insert(pair<char*, int>("Petya", 20));
peopleAges.erase("Joro");
peopleAges["Petya"];peopleAges["Petya"]++;
Map UsageLive Demo
Problems Solved with Maps Maps have similar efficiency as hash-tables, but keep elements ordered
Many compression algorithms use maps/hash-tables
Several cryptographic attacks use maps/hash-tables
Simple Problem: You are given a sentence of words.
Count how many times each word occurs in the text.
Simple Problem Solved with a Map
Live Demo
Multimap Same as a map, without the Unique category i.e. there can be repeating elements No [] operator, as there can be
multiple values, corresponding to the same key
All other operations & properties are the same
Most element access is done through iterators
Multimap Multimap (#include <map>)
multimap (same template parameters as map)
Declaring and initializing a multimap
#include<map> //required header…multimap<string, string> personNicks;personNicks.insert(pair<string, string>("George", "Joro"));personNicks.insert(pair<string, string>("George", "Gosho"));personNicks.insert(pair<string, string>("George", "Joro"));personNicks.insert(pair<string, string>("George", "Gopi"));
Multimap UsageLive Demo
IteratorsThe Way of STL Element Access
Iterators Iterators are a pattern in STL Enable access to container elements For almost any container's elements
Most container iterators have similar mechanics to pointers Can be incremented, to point to
next element Can be dereferenced, to get
element value Can use -> operator to access
element members Can be const
Iterators Each container defines its own iterator type A class inside the container's class
Syntax to access iterator type
Example for an iterator of a vector<int>:
container_type<template_parameters...>::iterator
vector<int> numbers;numbers.push_back(1);numbers.push_back(2);
vector<int>::iterator numsIter = numbers.begin();cout<<*numsIter<<endl;numsIter++;cout<<*numsIter<<endl;
Iterators: Simple ExampleLive Demo
Iterators and ContainersSyntax, Usage, Examples
Iterators Several types of iterator Concepts
with differing purposes and functionality
Output Iterator Supports storing values
i.e. writing values to the pointed element
i.e. mutable Supports incrementing Other operations are not
necessarily supported i.e. no guarantee on dereferencing,
comparing…
Iterators Input Iterator
Supports dereferencing Supports incrementing Does not necessarily support
storing values i.e. writing values to the pointed
element i.e. not necessarily mutable
Opposite of Output iterator, in some sense
Iterators Forward Iterator
Refinement of Input & Output iterators
Reflects the idea of a linear sequence of values Allows multipass algorithms
Implementations can be mutable/immutable
Can only increment, i.e. can't "go back", only "forward"
Iterators Bidirectional Iterator
Refinement of Forward Iterator Can be both incremented and
decremented i.e. allows "going back"
Iterators Random Access Iterator
Refinement of Bidirectional Iterator Constant-time moving in arbitrarily-
sized steps i.e. can increment/decrement with
any value, not just 1 step like other iterators
e.g. increment a random access iterator 5 steps:
Note: using vector iterator, as it is a Random Access Iterator
vector<int>::iterator iter = someVector.begin();iter+=5;
Iterators and Containers
Most container operations require iterators or return iterators erase(), find(), insert() to name a
few Some containers require iterators
To access elements in a meaningful way
list, set, multiset, multimap Iterating over maps/sets
Gives the elements in order Note: Container iterators are at least Forward
Iterators and Containers
Iterating a container i.e. go through container elements
with iterator Instantiate an iterator of the container's type
Set it to the beginning (usually .begin())
Start a loop, incrementing the iterator Stop if the iterator equals .end() of
container end() – iterator pointing "after the
last element" At each step, the iterator will point
to an element (unless you've reached end())
Iterators and Containers
Iterating a set<string> Result: strings in lexicographical
order set<string> orderedStrings;
orderedStrings.insert(...);...
for(set<string>::iterator iter = orderedStrings.begin(); stringsIter != orderedStrings.end(); stringsIter++){ cout<<(*stringsIter)<<endl;}
Iterating Over ContainersLive Demo
Iterators and Containers
Don't overuse iterators Especially for Random Access
Containers vector and deque support the [] operator For both, [] does fast pointer
arithmetic Faster to traverse by index, than by
iterator
Iterators and Containers
Iterators are the standard link between data structures and algorithms in STL Some algorithms will return results
by iterator You will have to iterate the results
The power of iterators: Separate containers from
algorithms Any algorithm can work on any
container But they don't need to know about
each other As long as both understand iterators
Iterators and Containers
Simple problem: You are given a sentence and a word contained in that sentence. Show the positions at which the
word is (first word is position 0, second position 1, etc.)
Using Iterators to Take Advantage of
Container OperationsLive Demo
Insertion & Stream Iteratorsostream/istream iterators, front/back
insertion
Insertion & Stream Iterators
STL has built-in iterators for input/output Input & Output iterator
implementations #include<iterator>
Stream iterators Provide formatted read/write access
to streams ostream_iterator, istream_iterator
Insertion iterators (Output iterators) Attach to Sequences and insert
when written to insertion_iterator, front_insertion_iterator, back_insertion_iterator,
Insertion & Stream Iterators
ostream_iterator<T, …> T is the data type to write to the
stream Other template parameters:
info here Initializing with a stream and
output separator:
Writing values
ostream_iterator<int> coutIterator(cout, ", ");
*coutIterator = 5; //equivalent to cout<<5<<", "; //stream advances to next position
ostream_iterator Basic Usage
Live Demo
Insertion & Stream Iterators
istream_iterator<T, …> Initializing with a stream:
Initializing without a stream creates an "End of Stream" iterator
type
Reading (and printing) values to end of stream
stringstream ss; ss.str("5 2 3");istream_iterator<int> ssIterator(ss);
istream_iterator<int> intEOS;
while(ssIterator != intEOS){ cout<<(*ssIterator)<<" "; //getting current value ssIterator++; //advance to next value}
istream_iterator Basic Usage
Live Demo
Insertion & Stream Iterators
insert_iterator<Container> Container must support insert() Initialize by container instance and
iterator in it
Inserting values is just writing to the element, pointed by the iterator
list<string> words;words.insert("one");words.insert("three");list<string>::iterator wordsMiddle = words.begin();wordsMiddle++;insert_iterator< list<string> >
wordInserter (words, wordsMiddle);
*wordInserter = "hello";
Insertion & Stream Iterators
front_insert_iterator & back_insert_iterator Modifications of insert_iterator Insert only at front/back of a
container Require container to support push_front or push_back, respectively
Initialized by container:list<string> words;front_insert_iterator< list<string> > frontInserter(words);back_insert_iterator< list<string> > backInserter(words);
Insertion Iterators:Basic Usage
Live Demo
Pointers and Iterators Pointers can be implicitly converted to Random Access Iterators Since Random Access iterators use
the same mechanics to move between elements
E.g. algorithms using Random Access Iterators can be executed on arrays You just pass pointers to the
array/elements in the array
Common STL AlgorithmsSorting, Searching, Mutating, Heaps, Combinatorics, etc.
Common STL Algorithms
The STL has a wide range of built-in algorithms, in several categories Non-mutating (searching, counting,
etc.) Mutating (removing, rotating,
swapping, etc.) Sorting Heap operations (make heap, push
heap, etc.) Combinatorial (next/previous
permutation) Set, comparison, numeric, min/max
operations
Common STL Algorithms
Some common principles used by algorithms Algorithms on ranges take them as
iterators In the form [first, last), i.e. last is
non-inclusive Inserting a new element at an
iterator Pushes any existing element at that
iterator forward (i.e. to the next iterator position)
Searching, Counting, Matching
find(first, last, value) Returns 1st iterator, pointing to
same value If no such iterator exists – returns last
count(first, last, value) Returns the number of elements,
equal to value equal(first1, last1, first2)
Checks if the range [first1, last) is element-by-element equal to the range [ first2, first2 + (last1 – first1) )
Searching, Counting, Matching
Live Demo
Mutating Algorithms copy(first, last, result)
Copies the Input Iterator range [first, last)
Into the Output Iterator result fill(first, last, value)
Sets all elements in the range to value
swap_ranges(first, last, first2) Exchanges the range [first1, last)
with the range [first2, first2 + (last1 – first1)) and returns the element after the second range
Mutating AlgorithmsLive Demo
Sorting Algorithms sort(first, last)
Sorts the Random Access Iterator range in ascending order
stable_sort(first, last) Same as sort, but keeps relative
ordering of equal elementsas Potentially a bit slower than sort in
its worst case
Sorting AlgorithmsLive Demo
Heap Operations Note: STL Heaps are what priority_queue uses.
The first/top element is largest, it has 2 child elements which are smaller, they are first/top elements of their own heaps, etc. All STL Heap operations use Random Access Iterators
make_heap(first, last) Makes the range into a heap
push_heap(first, last) Assumes [first, last – 1) is a heap The element at last – 1 is placed in
the heap pop_heap(first, last)
Assumes [first, last) is a heap, removes top
Heap Operations, a.k.a.
How to Make a Priority QueueLive Demo
Combinatorial Algorithms
next_permutation(first, last) Transforms the Bidirectional
Iterator range into the lexicographically next permutation of the elements. If the last permutation has already been reached, transforms into the first permutation (i.e. sorts ascending)
prev_permutation(first, last) Same as next_permutation, but
transforms into the previous permutation
Permutation AlgorithmsLive Demo
FunctorsInjecting Custom Logic Into Containers
and Algorithms
Functors A Function Object (Functor) is anything, which can be called as a function A function is a functor A function pointer is a functor A class/struct, which overloads the () operator
Several Concepts for Functors in STL Generator Unary Function, Predicate Binary Function, Binary Predicate
Functors Generator – called with no arguments
Unary Function – receives a single argument
Binary Function – receives two arguments
Predicate – Unary Function, which returns bool
Binary Predicate – Binary Function, which returns bool
Functor Defining a Binary Predicate for a "greater than" relation As a function:
As a class with operator ()
bool greaterThan(int a, int b){ return a > b;}
struct GreaterThan{ bool operator ()(int a, int b) { return a > b; }}
Functor Advantages to picking the class/struct definition Can keep object state
e.g. count number of comparisons, calculate sum and average of arguments, etc.
Container template parameters need to be types struct/class create types, while
simply taking a function name will give an error
Functors Most containers and algorithms take Functors: Algorithms take Functor objects Containers take Functor types
(template args) Containers and Algorithms
Have default behavior, described by functors
Custom behavior is added through new functors E.g. different ordering rules for a
set/map Or different ordering rules for the
sort algorithm
Functors Example: Using a Functor to order a set's elements in descending orderstruct greaterThan{ bool operator ()(int a, int b) { return a > b; }};int main(){ set<int, greaterThan> nums; nums.insert(...); ... for(set<int>::iterator iter = nums.begin(); iter != nums.end(); iter++) cout<<*iter<<endl; //elements in descending order
Functors: Change Container Ordering
Live Demo
Functors Example: Using a Functor to compare
ranges of doubles by arbitrary epsilon, instead of absolutely:struct EqualEpsilon { double epsilon; EqualEpsilon(double eps) { this->epsilon = eps; } bool operator ()(double a, double b) { return abs(a - b) < this->epsilon; }};int main() { list<double> range1; list<double> range2; //fill values equal(range1.begin(), range1.end(), range2.begin(), EqualEpsilon(0.1)); //will compare by epsilon 0.1}
Functors: Arbitrary Epsilon for Equal
AlgorithmLive Demo
Functors The STL already has a lot of the common required functions defined, e.g.: greater<T> less<T> equal_to<T> and not_equal_to<T> plus<T>, minus<T>, etc. A lot of others – use them for simple
customizations, like changing ordering
Custom Functors can also be used to use sets/maps with your own classes
Examples of Functor Customizations in
the STLLive Demo
форум програмиране, форум уеб дизайнкурсове и уроци по програмиране, уеб дизайн – безплатно
програмиране за деца – безплатни курсове и уроцибезплатен SEO курс - оптимизация за търсачки
уроци по уеб дизайн, HTML, CSS, JavaScript, Photoshop
уроци по програмиране и уеб дизайн за ученициASP.NET MVC курс – HTML, SQL, C#, .NET, ASP.NET MVC
безплатен курс "Разработка на софтуер в cloud среда"
BG Coder - онлайн състезателна система - online judge
курсове и уроци по програмиране, книги – безплатно от Наков
безплатен курс "Качествен програмен код"
алго академия – състезателно програмиране, състезанияASP.NET курс - уеб програмиране, бази данни, C#, .NET, ASP.NET
курсове и уроци по програмиране – Телерик академия
курс мобилни приложения с iPhone, Android, WP7, PhoneGapfree C# book, безплатна книга C#, книга Java, книга C# Дончо Минков - сайт за програмиране
Николай Костов - блог за програмиранеC# курс, програмиране, безплатно
?? ? ?
??? ?
?
? ?
??
?
?
? ?
Questions?
?
Advanced STL
http://algoacademy.telerik.com