C++ STL Algorithms

Overview

The STL provides a rich collection of algorithms that operate on containers through iterators.

Non-modifying Algorithms

std::find and std::find_if

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = {10, 20, 30, 40, 50};
    
    // Find specific value
    auto it = std::find(vec.begin(), vec.end(), 30);
    if (it != vec.end()) {
        std::cout << "Found 30 at position: " << std::distance(vec.begin(), it) << std::endl;
    }
    
    // Find using condition
    auto it2 = std::find_if(vec.begin(), vec.end(), [](int x) {
        return x > 25;
    });
    if (it2 != vec.end()) {
        std::cout << "First element > 25: " << *it2 << std::endl;
    }
    
    return 0;
}

std::count and std::count_if

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = {10, 20, 30, 20, 40, 20, 50};
    
    // Count specific value
    int count = std::count(vec.begin(), vec.end(), 20);
    std::cout << "Count of 20: " << count << std::endl;
    
    // Count using condition
    int even_count = std::count_if(vec.begin(), vec.end(), [](int x) {
        return x % 2 == 0;
    });
    std::cout << "Count of even numbers: " << even_count << std::endl;
    
    return 0;
}

std::for_each

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    
    // Apply function to each element
    std::for_each(vec.begin(), vec.end(), [](int x) {
        std::cout << x << " ";
    });
    std::cout << std::endl;
    
    // Modify elements using for_each
    std::for_each(vec.begin(), vec.end(), [](int& x) {
        x *= 2;
    });
    
    std::cout << "After doubling: ";
    for (int x : vec) {
        std::cout << x << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

Modifying Algorithms

std::transform

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    std::vector<int> result(vec.size());
    
    // Transform elements
    std::transform(vec.begin(), vec.end(), result.begin(), [](int x) {
        return x * x;
    });
    
    std::cout << "Original: ";
    for (int x : vec) {
        std::cout << x << " ";
    }
    std::cout << std::endl;
    
    std::cout << "Squared: ";
    for (int x : result) {
        std::cout << x << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

std::copy and std::move

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> source = {10, 20, 30, 40, 50};
    std::vector<int> destination(5);
    
    // Copy elements
    std::copy(source.begin(), source.end(), destination.begin());
    
    std::cout << "Copied: ";
    for (int x : destination) {
        std::cout << x << " ";
    }
    std::cout << std::endl;
    
    // Copy with back_inserter
    std::vector<int> dest2;
    std::copy(source.begin(), source.end(), std::back_inserter(dest2));
    
    return 0;
}

std::fill and std::replace

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec(10);
    
    // Fill with value
    std::fill(vec.begin(), vec.end(), 0);
    
    std::cout << "After fill: ";
    for (int x : vec) {
        std::cout << x << " ";
    }
    std::cout << std::endl;
    
    // Replace values
    vec[2] = 5;
    vec[5] = 5;
    vec[8] = 5;
    
    std::replace(vec.begin(), vec.end(), 5, 99);
    
    std::cout << "After replace: ";
    for (int x : vec) {
        std::cout << x << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

Sorting Algorithms

std::sort

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>

int main() {
    std::vector<int> numbers = {5, 2, 8, 1, 9, 3};
    
    // Sort in ascending order
    std::sort(numbers.begin(), numbers.end());
    
    std::cout << "Sorted ascending: ";
    for (int x : numbers) {
        std::cout << x << " ";
    }
    std::cout << std::endl;
    
    // Sort in descending order
    std::sort(numbers.begin(), numbers.end(), std::greater<int>());
    
    std::cout << "Sorted descending: ";
    for (int x : numbers) {
        std::cout << x << " ";
    }
    std::cout << std::endl;
    
    // Sort strings
    std::vector<std::string> words = {"banana", "apple", "cherry", "date"};
    std::sort(words.begin(), words.end());
    
    std::cout << "Sorted words: ";
    for (const auto& word : words) {
        std::cout << word << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

std::stable_sort

#include <iostream>
#include <vector>
#include <algorithm>

struct Person {
    std::string name;
    int age;
};

int main() {
    std::vector<Person> people = {
        {"Alice", 25},
        {"Bob", 20},
        {"Charlie", 25},
        {"David", 30}
    };
    
    // Stable sort by age (maintains order of equal elements)
    std::stable_sort(people.begin(), people.end(), [](const Person& a, const Person& b) {
        return a.age < b.age;
    });
    
    std::cout << "Sorted by age (stable):" << std::endl;
    for (const auto& person : people) {
        std::cout << person.name << ": " << person.age << std::endl;
    }
    
    return 0;
}

Numeric Algorithms

std::accumulate

#include <iostream>
#include <vector>
#include <numeric>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    
    // Sum all elements
    int sum = std::accumulate(numbers.begin(), numbers.end(), 0);
    std::cout << "Sum: " << sum << std::endl;
    
    // Product of all elements
    int product = std::accumulate(numbers.begin(), numbers.end(), 1, std::multiplies<int>());
    std::cout << "Product: " << product << std::endl;
    
    // Custom operation
    std::string result = std::accumulate(numbers.begin(), numbers.end(), std::string(),
        [](const std::string& acc, int x) {
            return acc + std::to_string(x) + "+";
        });
    std::cout << "Concatenated: " << result << std::endl;
    
    return 0;
}

std::min_element and std::max_element

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> numbers = {10, 5, 20, 15, 8, 25};
    
    auto min_it = std::min_element(numbers.begin(), numbers.end());
    auto max_it = std::max_element(numbers.begin(), numbers.end());
    
    std::cout << "Minimum: " << *min_it << std::endl;
    std::cout << "Maximum: " << *max_it << std::endl;
    
    return 0;
}