STL Algorithms

The STL Algorithm Model

Standard algorithms separate what operation to perform from how data is stored. A container owns elements; iterators describe a range; an algorithm reads or modifies that range.

#include <algorithm>
#include <vector>

std::vector<int> values{7, 2, 9, 4};
std::sort(values.begin(), values.end());

The same find or count_if can work with vector, array, deque and many user-defined ranges when their iterators meet the requirements. Algorithms do not magically include their headers; use <algorithm> for most sequence algorithms and <numeric> for accumulation and related numeric operations.

Start with the STL architecture guide if containers and iterators are new.

Iterator Ranges, Requirements and C++20 Ranges

Classic algorithms usually accept [first,last). The first position is included; last is one past the range and must not be dereferenced.

auto first = values.begin();
auto last = values.end();
std::reverse(first, last);

This explains why std::sort works with vector but not list. Study iterator categories for the complete model.

C++20 range algorithms can accept a whole range and use projections:

#include <ranges>

struct Student { std::string name; int mark; };
std::ranges::sort(students, std::greater{}, &Student::mark);

Many ranges algorithms return structured result types rather than a single iterator. Views may be lazy and often refer to another range, so the source lifetime must outlast view use.

Searching, Counting and Predicates

auto found = std::find(values.begin(), values.end(), 9);
if (found != values.end()) {
    std::cout << "Index: " << std::distance(values.begin(), found);
}

const auto evens = std::count_if(values.begin(), values.end(),
                                 [](int n) { return n % 2 == 0; });
const bool all_positive = std::all_of(values.begin(), values.end(),
                                      [](int n) { return n > 0; });

A predicate must not invalidate the range or unpredictably modify values used by the algorithm. Capture only what is needed and prefer pure, readable lambdas.

Copy, Transform, Replace and Remove

std::vector<int> doubled(values.size());
std::transform(values.begin(), values.end(), doubled.begin(),
               [](int n) { return n * 2; });

std::replace(values.begin(), values.end(), -1, 0);
std::reverse(values.begin(), values.end());

The destination of copy/transform must have enough space, or use an insertion iterator:

std::vector<int> result;
result.reserve(values.size());
std::copy_if(values.begin(), values.end(),
             std::back_inserter(result),
             [](int n) { return n >= 0; });

Erase–remove correctly

auto new_end = std::remove_if(values.begin(), values.end(),
                              [](int n) { return n < 0; });
values.erase(new_end, values.end());

// C++20 container convenience:
std::erase_if(values, [](int n) { return n < 0; });

remove_if does not erase container elements; it moves retained values forward and returns the logical end. Using only the first line leaves a valid but unspecified tail.

Sorting, Comparators and Binary Search

std::sort(values.begin(), values.end());
const bool has_75 = std::binary_search(values.begin(), values.end(), 75);
auto first_75 = std::lower_bound(values.begin(), values.end(), 75);
auto after_75 = std::upper_bound(values.begin(), values.end(), 75);

A comparator must impose strict weak ordering. Use a < b, not a <= b. Binary-search algorithms require a range partitioned according to a compatible ordering; calling them on arbitrary unsorted data violates their precondition.

std::sort(students.begin(), students.end(),
          [](const Student& a, const Student& b) {
              if (a.mark != b.mark) return a.mark > b.mark;
              return a.name < b.name;
          });

Numeric Algorithms and Type Safety

#include <numeric>

const long long total = std::accumulate(values.begin(), values.end(), 0LL);
std::vector<int> ids(5);
std::iota(ids.begin(), ids.end(), 101); // 101 102 103 104 105

The initial value in accumulate determines the accumulation type. Using 0 accumulates as int; use 0LL for a wider integer sum or 0.0 for floating point when appropriate.

Complete Student-Score Analysis with Output

#include <algorithm>
#include <functional>
#include <iostream>
#include <numeric>
#include <vector>

int main() {
    std::vector<int> scores{64, 91, 75, 52, 88};
    const int total = std::accumulate(scores.begin(), scores.end(), 0);
    const auto passed = std::count_if(scores.begin(), scores.end(),
                                      [](int score) { return score >= 75; });

    std::sort(scores.begin(), scores.end(), std::greater<>{});

    std::cout << "Descending:";
    for (int score : scores) std::cout << ' ' << score;
    std::cout << "\nPass count: " << passed
              << "\nAverage: " << total / static_cast<double>(scores.size());
}

Total is 370, so the floating-point average is exactly 74 for this dataset. The comparator orders descending, and the pass predicate includes 75.

Common Mistakes, Practice and Review

Practice: sort Student records by two keys, find first failing mark, remove invalid scores, calculate running totals, obtain top three with partial_sort, and compare classic algorithms with C++20 ranges.

1. Correct header?
2. Valid half-open range?
3. Iterator category sufficient?
4. Ordering precondition satisfied?
5. Comparator/predicate valid?
6. Output destination large enough?
7. Returned iterator checked?
8. Numeric result type deliberate?

Authoritative References

• C++ Working Draft: Algorithms Library
• C++ Working Draft: Non-modifying Algorithms
• C++ Working Draft: Sorting and Related Operations

Iterator requirements, ordering preconditions and algorithm behavior were checked against the current working draft. Practice them with the complete vector tutorial and sorting/searching lesson.