STL Algorithms in C++ — How, Why, and When to Use Them

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

struct Employee {
    std::string name;
    std::string department;
    int yearsAtCompany;
};

int main() {
    std::vector<Employee> employees = {
        {"Alice",   "Engineering", 5},
        {"Bob",     "Marketing",   3},
        {"Carol",   "Engineering", 8},
        {"Dave",    "Marketing",   3},
        {"Eve",     "Engineering", 2}
    };

    // std::stable_sort preserves Alice/Carol/Eve order within Engineering,
    // and Bob/Dave order within Marketing — critical for multi-key sorting.
    std::stable_sort(employees.begin(), employees.end(),
        [](const Employee& a, const Employee& b) {
            return a.department < b.department; // sort by department alphabetically
        });

    std::cout << "=== Sorted by Department (stable) ===\n";
    for (const auto& emp : employees) {
        std::cout << emp.department << " | " << emp.name
                  << " (" << emp.yearsAtCompany << " yrs)\n";
    }

    // Now find the top-2 most experienced employees without sorting the whole vector
    std::vector<Employee> tenureList = employees; // copy so we don't disturb the sorted list

    // partial_sort rearranges so that tenureList[0] and tenureList[1]
    // hold the two employees with the most years — rest is unspecified order
    std::partial_sort(tenureList.begin(), tenureList.begin() + 2, tenureList.end(),
        [](const Employee& a, const Employee& b) {
            return a.yearsAtCompany > b.yearsAtCompany; // descending by tenure
        });

    std::cout << "\n=== Top 2 Most Experienced ===\n";
    std::cout << tenureList[0].name << " (" << tenureList[0].yearsAtCompany << " yrs)\n";
    std::cout << tenureList[1].name << " (" << tenureList[1].yearsAtCompany << " yrs)\n";

    return 0;
}

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

struct Product {
    std::string name;
    double priceUSD;
    bool inStock;
};

int main() {
    std::vector<Product> inventory = {
        {"Laptop",     999.99, true},
        {"Mouse",       29.99, true},
        {"Keyboard",    79.99, false},
        {"Monitor",    399.99, true},
        {"Webcam",      89.99, false},
        {"Headset",    149.99, true}
    };

    // find_if: locate the FIRST out-of-stock item — returns an iterator
    auto firstOutOfStock = std::find_if(inventory.begin(), inventory.end(),
        [](const Product& p) {
            return !p.inStock; // predicate: true when item is out of stock
        });

    // Always validate before dereferencing — end() means 'not found'
    if (firstOutOfStock != inventory.end()) {
        std::cout << "First out-of-stock item: " << firstOutOfStock->name << "\n";
    }

    // any_of: does even one product cost over $500? (great for validation checks)
    bool hasPremiumItem = std::any_of(inventory.begin(), inventory.end(),
        [](const Product& p) { return p.priceUSD > 500.0; });
    std::cout << "Has premium item (>$500): " << (hasPremiumItem ? "Yes" : "No") << "\n";

    // count_if: how many items are available to ship right now?
    int availableCount = std::count_if(inventory.begin(), inventory.end(),
        [](const Product& p) { return p.inStock; });
    std::cout << "Items currently in stock: " << availableCount << "\n";

    // binary_search on a SORTED range — only gives you exists/not-exists
    std::vector<double> sortedPrices = {29.99, 79.99, 89.99, 149.99, 399.99, 999.99};
    bool priceExists = std::binary_search(sortedPrices.begin(), sortedPrices.end(), 149.99);
    std::cout << "Price $149.99 exists: " << (priceExists ? "Yes" : "No") << "\n";

    // lower_bound gives you the ITERATOR (position) — use this when you need location
    auto pricePosition = std::lower_bound(sortedPrices.begin(), sortedPrices.end(), 149.99);
    if (pricePosition != sortedPrices.end()) {
        std::cout << "Found $149.99 at index: "
                  << std::distance(sortedPrices.begin(), pricePosition) << "\n";
    }

    return 0;
}

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

struct OrderItem {
    std::string productName;
    int quantity;
    double unitPriceUSD;
};

int main() {
    std::vector<OrderItem> cartItems = {
        {"Laptop",    1, 999.99},
        {"Mouse",     2,  29.99},
        {"USB Hub",   1,  49.99}
    };

    // transform: compute line totals and store them in a new vector
    // We write to a separate vector — cartItems stays untouched
    std::vector<double> lineTotals(cartItems.size());
    std::transform(cartItems.begin(), cartItems.end(),
                   lineTotals.begin(), // destination iterator
        [](const OrderItem& item) {
            return item.quantity * item.unitPriceUSD; // compute line total
        });

    std::cout << "=== Line Totals ===\n";
    for (size_t i = 0; i < cartItems.size(); ++i) {
        std::cout << cartItems[i].productName << ": $" << lineTotals[i] << "\n";
    }

    // accumulate: sum all line totals into a single cart total
    // Third argument is the STARTING VALUE — must match the type you want to accumulate into
    double cartTotal = std::accumulate(lineTotals.begin(), lineTotals.end(), 0.0);
    std::cout << "\nCart Total: $" << cartTotal << "\n";

    // accumulate with a custom operation: build a comma-separated summary string
    // This shows accumulate is far more than just addition
    std::string orderSummary = std::accumulate(
        cartItems.begin(), cartItems.end(),
        std::string(""),  // starting value: empty string
        [](const std::string& running, const OrderItem& item) {
            std::ostringstream oss;
            oss << running;
            if (!running.empty()) oss << ", "; // add separator between items
            oss << item.quantity << "x " << item.productName;
            return oss.str();
        });
    std::cout << "Order: " << orderSummary << "\n";

    // for_each: apply a 10% loyalty discount IN-PLACE for a returning customer
    // Note: for_each passes by value by default — use [&] or explicit ref param
    std::for_each(cartItems.begin(), cartItems.end(),
        [](OrderItem& item) {
            item.unitPriceUSD *= 0.90; // reduce each unit price by 10%
        });

    std::cout << "\n=== After 10% Loyalty Discount ===\n";
    std::for_each(cartItems.begin(), cartItems.end(),
        [](const OrderItem& item) {
            std::cout << item.productName << ": $" << item.unitPriceUSD << "\n";
        });

    return 0;
}

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

struct Task {
    std::string title;
    int priorityLevel; // 1 = low, 2 = medium, 3 = high
    bool isCompleted;
};

void printTasks(const std::string& label, const std::vector<Task>& tasks) {
    std::cout << "\n=== " << label << " ===\n";
    for (const auto& t : tasks) {
        std::cout << "[" << t.priorityLevel << "] "
                  << t.title
                  << (t.isCompleted ? " (done)" : "") << "\n";
    }
}

int main() {
    std::vector<Task> taskList = {
        {"Write unit tests",       2, false},
        {"Fix login bug",          3, false},
        {"Update README",          1, true},
        {"Deploy to staging",      3, false},
        {"Refactor auth module",   2, true},
        {"Review pull requests",   2, false}
    };

    printTasks("Original Task List", taskList);

    // ERASE-REMOVE IDIOM: remove all completed tasks from the list
    // Step 1 — remove_if shuffles incompleted tasks to the front,
    //           returns iterator 'newEnd' pointing to start of junk
    auto newEnd = std::remove_if(taskList.begin(), taskList.end(),
        [](const Task& t) { return t.isCompleted; });

    // Step 2 — erase from newEnd to the actual end to shrink the vector
    taskList.erase(newEnd, taskList.end());
    // These two lines are usually written as one: taskList.erase(remove_if(...), taskList.end());

    printTasks("After Removing Completed Tasks", taskList);

    // PARTITION: split remaining tasks so high-priority ones come first
    // partition returns an iterator to the first element that DIDN'T satisfy the predicate
    auto partitionPoint = std::stable_partition(taskList.begin(), taskList.end(),
        [](const Task& t) { return t.priorityLevel == 3; }); // high priority first

    std::cout << "\n=== Partitioned: High Priority First ===\n";
    std::cout << "High priority tasks (before partition point):\n";
    for (auto it = taskList.begin(); it != partitionPoint; ++it) {
        std::cout << "  [" << it->priorityLevel << "] " << it->title << "\n";
    }
    std::cout << "Other tasks (after partition point):\n";
    for (auto it = partitionPoint; it != taskList.end(); ++it) {
        std::cout << "  [" << it->priorityLevel << "] " << it->title << "\n";
    }

    // COPY_IF: extract only medium-priority tasks into a separate sprint plan
    std::vector<Task> sprintTasks;
    std::copy_if(taskList.begin(), taskList.end(),
                 std::back_inserter(sprintTasks), // grows sprintTasks as needed
        [](const Task& t) { return t.priorityLevel == 2; });

    printTasks("Sprint Tasks (medium priority only)", sprintTasks);

    return 0;
}