Generic Algorithms

Generic algorthims are template functions that use iterators to do their thing on almost any (qualifying) container. For example: 
template < class InputIterator, class T >
InputIterator find(InputIterator first, InputIterator last,
		   const T& value) {
    while (first != last && *first != value) ++first;
    return first;
}
There is also often a predicate version which takes a function object argument as well as an iterator type: 
template < class InputIterator, class Predicate >
InputIterator find_if(InputIterator first, InputIterator last,
		      Predicate pred) {
    while (first != last && !pred(*first)) ++first;
    return first;
}
In addition, mutating operators often have a copy version that does not change the original range but does its job on a new range built from copying the range (using an output iterator). For example: 
template < class InputIterator, class OutputIterator, class T >
OutputIterator replace_copy(InputIterator first,
			    InputIterator last,
			    OutputIterator result,
			    const T& old_value,
			    const T& new_value) {
    while (first != last) {
	*result++ = *first == old_value ?
				new_value : 
				*first;	++first; }
    return result;
}

Non-mutating sequence operations

for_each()

find()

find_end()

find_first_of()

adjacent_find()

count()

mismatch()

equal()

search()

Mutating sequence operations

copy()

swap()

transform()

replace()

fill()

generate()

remove()

unique()

reverse()

rotate()

random_shuffle()

partition()

Sorting and Searching

sort()

stable_sort()

partial_sort()

nth_element()

lower_bound()

upper_bound()

equal_range()

binary_search()

merge()

Sets

includes()

set_union()

set_intersection()

set_difference()

set_symmetric_difference()

Heaps

push_heap()

pop_heap()

make_heap()

sort_heap()

Numeric algorithms

accumulate()

inner_product()

partial_sum()

adjacent_differences()

Miscellaneous

min()

max()

min_element()

max_element()

lexicographical_compare()

next_permutation()

prev_permutation()