Important  This document may not represent best practices for current development, links to downloads and other resources may no longer be valid. Current recommended version can be found here. 
Algorithms
Algorithms are a fundamental part of the Standard Template Library. Algorithms do not work with containers themselves but rather with iterators. Therefore, the same algorithm can be used by most if not all of the STL containers. This section discusses the conventions and terminology of the STL algorithms.
The descriptions of the algorithm template functions employ several shorthand phrases:

The phrase "in the range [A, B)" means the sequence of zero or more discrete values beginning with A up to but not including B. A range is valid only if B is reachable from A; you can store A in an object N (N = A), increment the object zero or more times (++N), and have the object compare equal to B after a finite number of increments (N == B).

The phrase "each N in the range [A, B)" means that N begins with the value A and is incremented zero or more times until it equals the value B. The case N == B is not in the range.

The phrase "the lowest value of N in the range [A, B) such that X" means that the condition X is determined for each N in the range [A, B) until the condition X is met.

The phrase "the highest value of N in the range [A, B) such that X means that X is determined for each N in the range [A, B). The function stores in K a copy of N each time the condition X is met. If any such store occurs, the function replaces the final value of N, which equals B, with the value of K. For a bidirectional or randomaccess iterator, however, it can also mean that N begins with the highest value in the range and is decremented over the range until the condition X is met.

Expressions such as X  Y, where X and Y can be iterators other than randomaccess iterators, are intended in the mathematical sense. The function does not necessarily evaluate operator if it must determine such a value. The same is also true for expressions such as X + N and X  N, where N is an integer type.
Several algorithms make use of a predicate that performs a pairwise comparison, such as with operator==, to yield a bool result. The predicate function operator==, or any replacement for it, must not alter either of its operands. It must yield the same bool result every time it is evaluated, and it must yield the same result if a copy of either operand is substituted for the operand.
Several algorithms make use of a predicate that must impose a strict weak ordering on pairs of elements from a sequence. For the predicate pr(X, Y):

Strict means that pr(X, X) is false.

Weak means that X and Y have an equivalent ordering if !pr(X, Y) && !pr(Y, X) (X == Y does not need to be defined).

Ordering means that pr(X, Y) && pr(Y, Z) implies pr(X, Z).
Some of these algorithms implicitly use the predicate X < Y. Other predicates that typically satisfy the strict weak ordering requirement are X > Y, less(X, Y), and greater(X, Y). Note, however, that predicates such as X <= Y and X >= Y do not satisfy this requirement.
A sequence of elements designated by iterators in the range [First, Last) is a sequence ordered by operator< if, for each N in the range [0, Last  First) and for each M in the range (N, Last  First) the predicate !(*(First + M) < *(First + N)) is true. (Note that the elements are sorted in ascending order.) The predicate function operator<, or any replacement for it, must not alter either of its operands. It must yield the same bool result every time it is evaluated, and it must yield the same result if a copy of either operand is substituted for the operand. Moreover, it must impose a strict weak ordering on the operands it compares.
A sequence of elements designated by iterators in the range [First, Last) is a heap ordered by operator< if, for each N in the range [1, Last  First) the predicate !(*First < *(First + N)) is true. (The first element is the largest.) Its internal structure is otherwise known only to the template functions make_heap, pop_heap, and push_heap. As with an ordered sequence, the predicate function operator<, or any replacement for it, must not alter either of its operands, and it must impose a strict weak ordering on the operands it compares. It must yield the same bool result every time it is evaluated, and it must yield the same result if a copy of either operand is substituted for the operand.
The STL algorithms are located in the <algorithm> and <numeric> header files.