C++ Reference Material
The STL Algorithms Classified by Purpose
Still needs some work ...
Applying  Bounding  Comparing  Copying  Counting  Filling  Filtering  Generating  Heap Operations  Math Operations  Merging  Min/Max  Partitioning  Permuting  Randomizing/Shuffling  Removing  Replacing  Reversing  Rotating  Searching  Set Operations  Sorting  Swapping  Transforming
This page contains two tables. The first one gives an "algorithm interface key". The second gives a list of all STL algorithms grouped by purpose, and uses the algorithm interface key from the first table to keep the list as concise as possible. Each algorithm interface will (eventually) be a link to the more detailed description and any associated sample program(s) for that algorithm which appear in the (more complete) alphabetical algorithm listing.
This algorithm "interface key" shown in the first table below is an extended version of the one found in The STL <PRIMER>, and contains a few more symbols to help provide a little more information in the abbreviated forms of the algorithms shown here. Also, because the notation here is based on that source, it differs (though not confusingly so, one hopes) from the notation used on the other STL reference pages on this site.
Here are some notes on the table and its use with the algorithm "catalog" which follows:
Iterators  

Key  Meaning 
b  a bidirectional iterator 
f  a forward iterator 
i  an input iterator 
o  an output iterator 
r  a random access iterator 
(?, ?)  a pair of iterators as a return value, as in (f,f) 
Predicates and other functions  
Key  Meaning 
upred  a unary predicate (boolean function or function
object)
(generally used to test a single value from a container) 
bpred  a binary predicate (boolean function or function
object)
(generally used to compare the order of two values from a container) 
ufunc  a unary (valuereturning) function (or function object) 
bfunc  a binary (valuereturning) function (or function object) 
pfunc  a "parameterless" (valuereturning) function (or
function object)
(often used to "generate" a value of some kind) 
uproc  a unary procedure (void function or function object) 
bproc  a binary procedure (void function or function object) 
pproc  a "parameterless" procedure (void function or function object) 
Other items  
key  meaning 
n  a quantity (or size) 
v  a value 
&  a (generally const) reference to a value 
One or more algorithms may conceptually fit into more than one grouping. For example, the includes algorithm could be placed either where it is (in the Set Operations group), or in the Searching group of algorithms. However, to avoid any potential confusion caused by such duplication, each algorithm appears only once, in what we hope is its most appropriate location. Every use of the term "function" can be read as "function or function object", and every use of the phrase "end of a/the range" can be interpreted as "onepastthelast position of the range".
Applying  

ufunc for_each(i,i,ufunc)
Apply a function to every item in a range and return the function. 

Bounding  
(f,f) equal_range(f,f,&)
(f,f) equal_range(f,f,&,bpred) Find the lower bound and upper bound of a value within a range and return a pair of iterators pointing to those two values (in that order). 

f lower_bound(f,f,&)
f lower_bound(f,f,&,bpred) Find the lower bound of a value within a range and return an iterator pointing to it. 

f upper_bound(f,f,&)
f upper_bound(f,f,&,bpred) Find the upper bound of a value within a range and return an iterator pointing to it. 

Comparing  
bool equal(i1,i1,i2)
bool equal(i1,i1,i2,bpred) Check if the values in two ranges match. 

bool lexicographical_compare(i1,i1,i2,i2)
bool lexicographical_compare(i1,i1,i2,i2,bpred) Compare two ranges lexicographically, and return true if the first range is less than the second; otherwise return false. 

(i1,i2) mismatch(i1,i1,i2)
(i1,i2) mismatch(i1,i1,i2, bpred) Search two ranges for the first two items in corresponding positions that don't match, and return a pair of iterators pointing to those two items. 

Copying  
o copy(i,i,o)
Copy a range of items to a destination and return an iterator pointing to the end of the copied range. 

b2 copy_backward(b1,b1,b2)
Copy a range of items backwards to a destination and return an iterator pointing to the end of the copied range. 

Counting  
n count(i,i,&)
Count the items in a range that match a value and return that count. 

n count_if(i,i,upred)
Count the items in a range that satisfy a predicate and return that count. 

Filling  
fill(f,f,&)
Set every item in a range to a particular value. 

fill_n(o,n,&)
Set n items to a particular value. 

Filtering  
f unique(f,f)
f unique(f,f,bpred) Collapse each group of consecutive duplicate values in a range of values to a single value, and return an iterator pointing to the end of the modified range. . 

o unique_copy(i,i,o)
o unique_copy(i,i,o,bpred) Copy a range of values, performing the same action as unique above, and return an iterator pointing to the end of the new range. . 

Generating  
generate(f,f,pfunc)
Fill a range with generated values. 

generate_n(o,n,pfunc)
Generate a specified number of values. 

Heap Operations  
make_heap(r,r)
make_heap(r,r,bpred) Make a range of values into a heap. 

pop_heap(r,r)
pop_heap(r,r,bpred) Delete the first value from a heap. 

push_heap(r,r)
push_heap(r,r,bpred) Insert the last value of a range into a heap. 

sort_heap(r,r)
sort_heap(r,r,bpred) Sort a heap. 

Math Operations (from <numeric>)  
v accumulate(i,i,v)
v accumulate(i,i,v,bfunc) Sum an initial value and the values in a range, and return the sum. 

o adjacent_difference(i,i,o)
o adjacent_difference(i,i,o,bfunc) Calculate the difference between adjacent pairs of values, write the differences to an output range, and return an iterator pointing to the end of that output range. 

v inner_product(i1,11,i2,vInitial)
v inner_product(i1,i1,i2,v,bfunc1,bfunc2) Calculate the inner product of two ranges and return that value plus vInitial. 

o partial_sum(i,i,o)
o partial_sum(i,i,o, bfunc) Fill a range with running totals and return an iterator pointing to ... . 

Merging  
inplace_merge(b,b,b)
inplace_merge(b,b,b,bpred) Merge two sorted ranges, in place, into a single sorted range. 

o merge(i1,i1,i2,i2,o)
o merge(i1,i1,i2,i2,o,bpred) Merge two sorted ranges into a single sorted range. 

Min/Max  
& min(&,&)
& min(&,&,bpred) Find the minimum of two values and return a reference to that value. 

& max(&,&)
& max(&,&,bpred) Find the maximum of two values and return a reference to that value. 

f min_element(f,f)
f min_element(f,f,bpred) Find the minimum value in a range and return an iterator pointing to that value. 

f max_element(f,f)
f max_element(f,f,bpred) Find the maximum value in a range and return an iterator pointing to that value. 

Partitioning  
nth_element(r,r,r)
nth_element(r,r,r,bpred) Partition a range of values so that the value pointed to by the middle r in the parameter list is in its correct sorted position, and no element to its left is greater than any element to its right. 

b partition(b,b,upred)
Partition a range of values using a predicate, and return an iterator pointing to the first value for which upred returns false. 

b stable_partition(b,b,upred)
Partition a range using a predicate without altering the relative order of the values, and return an iterator pointing to the first value for which upred returns false. 

Permuting  
bool next_permutation(b,b)
bool next_permutation(b,b,bpred) Change a range of values to the next lexicographic permutation of those values, and return true, or return false if no next permuation exists. 

bool prev_permutation(b,b)
bool prev_permutation(b,b,bpred) Change a range of values to the previous lexicographic permutation of those values, and return true, or return false if no previous permuation exists. 

Randomizing/Shuffling  
random_shuffle(r,r)
random_shuffle(r,r,ranGen) Randomize a range of values, and use the random generator function ranGen, if supplied, rather than an internal random generator. 

Removing  
remove(f,f,&)
Remove from a range of values all values that match a give value. 

remove_if(f,f,upred)
Remove values that satisfy a predicate from a range of values. 

remove_copy(i,i,o,&)
Copy a range of values, removing all values that match a given value. 

remove_copy_if(i,i,o,upred)
Copy a range of values, removing all values that satisfy a predicate. 

Replacing  
replace(f,f,&,&)
Replace, within a range of values, one specified value with another value. 

replace_if(f,f,upred,&)
Replace, within a range of values, each value that satisfies a predicate with a specified value. 

replace_copy(i,i,o,&,&)
Copy a range of values, replacing one specified value with another specified value. 

replace_copy_if(i,i,o,upred,&)
Copy a range of values, replacing each value that satisfies a predicate with a specified value. 

Reversing  
reverse(b,b)
Reverse the order of all values in a range of values. 

reverse_copy(b,b,o)
Write to an output destination a reversed copy of a range of values. 

Rotating  
rotate(f,f,f)
Rotate a range of values by n positions. 

rotate_copy(f,f,f,o)
Copy a range of values to an output destination, rotating it by n position. 

Searching  
f adjacent_find(f,f)
f adjacent_find(f,f, bpred) Search for the first pair of equal adjacent values in a range of values, and return an iterator pointing to the first value of the pair. 

bool binary_search(f,f,&)
Search for a value in a sorted range of values and return true if found, false if not found. 

i find(i,i,&)
Search for a value in a range of values, and return an iterator pointing to the value or to the end of the range if the value was not found. 

f1 find_end(f1,f1,f2,f2)
f1 find_end(f1,f1,f2,f2,bpred) Search for the last occurrence of a second range of values in a first range of values and return an iterator pointing to the first value of that last match within the first range, or pointing to the end of the first range if the second range of values does not occur within the first range of values. 

f1 find_first_of(f1,f1,f2,f2)
f1 find_first_of(f1,f1,f2,f2,bpred) Search for any of the values from a second range in a first range and return an iterator pointing to the first such value found, or to the end of the first range if no such value was found. 

i find_if(i,i,upred)
Search for a value that satisfies a predicate and return an iterator pointing to the first such value, or to the end of the range if there is no such value. 

f1 search(f1,f1,f2,f2)
f1 search(f1,f1,f2,f2) Search for the first occurrence of a second range of values within a first range of values and return an iterator pointing to the first value of that first match within the first range, or pointing to the end of the first range if the second range of values does not occur within the first range of values. 

f search_n(f,f,n,&)
f search_n(f,f,n,&,bpred) Search in a range of values for a contiguous sequence of n values each equal to &, and return an iterator pointing to the first of those values, or to the end of the range if the search is unsuccessful. 

Set Operations  
bool includes(i1,i1,i2,i2)
bool includes(i1,i1,i2,i2,bpred) Search for all values from the second range in the first range and return true if found, otherwise return false. 

o set_difference(i1,i1,i2,i2,o)
o set_difference(i1,i1,i2,i2,o,bpred) Create an output range of values that are in the first range but not in the second range and return an iterator pointing to the end of that output range. 

o set_intersection(i1,i1,i2,i2,o)
o set_intersection(i1,i1,i2,i2,o,bpred) Create an output range of values that are in the first range and also in the second range and return an iterator pointing to the end of that output range. 

o set_symmetric_difference(i1,i1,i2,i2,o)
o set_symmetric_difference(i1,i1,i2,i2,o,bpred) Create an output range of values that are not common to both ranges and return an iterator pointing to the end of that output range. 

o set_union(i1,i1,i2,i2,o)
o set_union(i1,i1,i2,i2,o,bpred) Create an output range of values that are either in the first range or in the second range and return an iterator pointing to the end of that output range. 

Sorting  
partial_sort(r,r,r)
partial_sort(r,r,r,bpred) Sort all values till first part of range is in sorted order. 

r partial_sort_copy(i,i,r,r)
r partial_sort_copy(i,i,r,r,bpred) Partially sort a range of values (as above) and copy as many values as will fit into an output range. 

sort(r,r)
sort(r,r,bpred) Sort a range of values. 

stable_sort(r,r)
stable_sort(r,r,bpred) Sort a range of values, maintaining the same relative order of duplicate values. 

Swapping  
iter_swap(f,f)
Swap the values pointed to by the two iterators. 

swap(&,&)
Swap the two values. 

f2 swap_ranges(f1,f1,f2)
Swap the corresponding values in two ranges of values and return an iterator pointing to the end of the second range. 

Transforming  
o transform(i,i,o,ufunc)
o transform(i,i,o,bfunc) Transform one range of values into another. 