std::multimap

STL container: `std::multimap`

std::multimap is an associative container in the C++ Standard Template Library (STL) that stores key-value pairs in a sorted order based on the keys, allowing multiple elements with the same key. Like std::map, it is typically implemented as a balanced binary search tree (usually a red-black tree), providing logarithmic time complexity for insertion, deletion, and search operations.

Key Characteristics

Stores key-value pairs (elements)
Keys are sorted but not unique (multiple values can be associated with the same key)
Provides logarithmic time complexity (O(log n)) for insertion, deletion, and search operations
Supports bidirectional iterators
Allows for custom key comparison functions
Suitable for scenarios where multiple values need to be associated with a single key in a sorted structure

Example 1: Basic Usage

#include <iostream>
#include <map>
#include <string>

int main() {
    std::multimap<std::string, int> studentScores;

    // Inserting elements
    studentScores.insert({"Alice", 85});
    studentScores.insert({"Bob", 90});
    studentScores.insert({"Alice", 92});  // Another score for Alice
    studentScores.insert({"Charlie", 88});
    studentScores.insert({"Bob", 95});    // Another score for Bob

    // Iterating through the multimap
    for (const auto& pair : studentScores) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    // Counting entries for a specific key
    std::string name = "Alice";
    std::cout << "Number of scores for " << name << ": " 
              << studentScores.count(name) << std::endl;

    // Finding all scores for a specific student
    auto range = studentScores.equal_range(name);
    std::cout << name << "'s scores: ";
    for (auto it = range.first; it != range.second; ++it) {
        std::cout << it->second << " ";
    }
    std::cout << std::endl;

    // Size of the multimap
    std::cout << "Total number of scores: " << studentScores.size() << std::endl;

    return 0;
}

Explanation:

A multimap with string keys (student names) and integer values (scores) is created
Elements are inserted using the insert() method
Multiple entries with the same key are allowed
The multimap is iterated using a range-based for loop, showing key-value pairs
count() is used to find the number of entries for a specific key
equal_range() returns a pair of iterators representing the range of elements with a given key
size() returns the total number of elements in the multimap

Example 2: Custom Comparator for Descending Order

#include <iostream>
#include <map>
#include <string>

// Custom comparator for descending order of keys
struct DescendingOrder {
    bool operator()(const std::string& a, const std::string& b) const {
        return a > b;
    }
};

int main() {
    std::multimap<std::string, int, DescendingOrder> fruitInventory;

    fruitInventory.insert({"Apple", 100});
    fruitInventory.insert({"Banana", 150});
    fruitInventory.insert({"Cherry", 75});
    fruitInventory.insert({"Apple", 120});  // Another entry for Apple
    fruitInventory.insert({"Banana", 130}); // Another entry for Banana

    for (const auto& pair : fruitInventory) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    return 0;
}

Explanation:

A custom comparator DescendingOrder is defined for string keys
The multimap is initialized with this custom comparator
Elements are automatically sorted in descending order of keys
This example demonstrates how to use a custom sorting criteria with std::multimap

Example 3: Using `multimap` for Grouping and Analysis

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

// Structure to represent a sale
struct Sale {
    std::string product;
    double amount;
    std::string date;
};

// Function to print sales summary
void printSalesSummary(const std::multimap<std::string, Sale>& sales) {
    for (const auto& category : sales) {
        std::cout << "Category: " << category.first << std::endl;
        double total = 0.0;
        std::vector<double> amounts;
        for (auto it = sales.lower_bound(category.first); 
             it != sales.upper_bound(category.first); ++it) {
            total += it->second.amount;
            amounts.push_back(it->second.amount);
        }
        std::cout << "  Total Sales: $" << total << std::endl;
        if (!amounts.empty()) {
            std::cout << "  Average Sale: $" << total / amounts.size() << std::endl;
            std::cout << "  Highest Sale: $" << *std::max_element(amounts.begin(), amounts.end()) << std::endl;
        }
        std::cout << std::endl;
    }
}

int main() {
    std::multimap<std::string, Sale> salesData;

    // Inserting sales data
    salesData.insert({"Electronics", {"Laptop", 1200.00, "2023-01-15"}});
    salesData.insert({"Clothing", {"T-Shirt", 25.99, "2023-01-16"}});
    salesData.insert({"Electronics", {"Smartphone", 800.00, "2023-01-17"}});
    salesData.insert({"Clothing", {"Jeans", 59.99, "2023-01-18"}});
    salesData.insert({"Electronics", {"Headphones", 150.00, "2023-01-19"}});
    salesData.insert({"Clothing", {"Dress", 89.99, "2023-01-20"}});

    // Print sales summary
    printSalesSummary(salesData);

    return 0;
}

Explanation:

This example uses multimap to group sales data by category
The Sale struct represents individual sales
Sales are inserted into the multimap with the category as the key
The printSalesSummary function demonstrates how to analyze grouped data:
It uses lower_bound and upper_bound to iterate over sales in each category
Calculates total sales, average sale, and highest sale for each category
This showcases how multimap can be used for data grouping and analysis

Example 4: Removing Elements from a `multimap`

#include <iostream>
#include <map>
#include <string>

void printMultimap(const std::multimap<std::string, int>& mm) {
    for (const auto& pair : mm) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }
    std::cout << "Size: " << mm.size() << std::endl << std::endl;
}

int main() {
    std::multimap<std::string, int> wordCount;

    // Inserting elements
    wordCount.insert({"apple", 1});
    wordCount.insert({"banana", 2});
    wordCount.insert({"apple", 3});
    wordCount.insert({"cherry", 4});
    wordCount.insert({"banana", 5});

    std::cout << "Initial multimap:" << std::endl;
    printMultimap(wordCount);

    // Removing a single element by key
    std::string keyToRemove = "cherry";
    wordCount.erase(keyToRemove);
    std::cout << "After removing '" << keyToRemove << "':" << std::endl;
    printMultimap(wordCount);

    // Removing all elements with a specific key
    keyToRemove = "banana";
    auto removed = wordCount.erase(keyToRemove);
    std::cout << "After removing all '" << keyToRemove << "' (removed " << removed << " elements):" << std::endl;
    printMultimap(wordCount);

    // Removing a single element by iterator
    auto it = wordCount.find("apple");
    if (it != wordCount.end()) {
        wordCount.erase(it);
        std::cout << "After removing one 'apple' entry:" << std::endl;
        printMultimap(wordCount);
    }

    return 0;
}

Explanation:

This example demonstrates various ways to remove elements from a multimap
erase(key) removes all elements with the specified key
erase(iterator) removes the element at the specified position
The erase function returns the number of elements removed
The example shows how to remove a single element, all elements with a specific key, and an element by iterator

Additional Considerations

Performance: While multimap provides good performance for most operations, consider using std::unordered_multimap for faster lookup times if sorting is not required.
Memory Usage: Like map, multimap typically uses more memory than simpler data structures due to its tree structure.
No Direct Access: Unlike map, multimap does not provide the [] operator for direct access, as keys are not unique.
Iteration Order: Elements are always traversed in the sorted order defined by the comparison function.
Value Modification: Values can be modified through iterators, but keys cannot be modified directly to maintain the correct ordering.

Summary

std::multimap is a powerful container in C++ for storing multiple key-value pairs with the same key in a sorted order. Key points to remember:

It maintains key-value pairs sorted by keys, allowing multiple entries per key
Provides logarithmic time complexity for insertion, deletion, and search operations
Useful for scenarios requiring sorted storage of elements with non-unique keys
Supports custom comparators for key ordering
Ideal for grouping and analyzing data based on categories or keys
Offers methods like equal_range, lower_bound, and upper_bound for efficient range operations

std::multimap is particularly useful in situations where you need to: - Store multiple values associated with a single key in a sorted structure - Implement one-to-many relationships - Group and analyze data by categories - Maintain a sorted collection of elements with potential duplicates

Understanding when to use std::multimap versus other containers like std::map, std::unordered_multimap, or std::vector is crucial for writing efficient and clear C++ code in various application domains. Its ability to handle multiple values per key while maintaining a sorted order makes it a versatile choice for many complex data management scenarios.

What are the main use cases for std::multimap
How does std::multimap differ from std::map
Can you provide an example of using std::multimap with custom data types
What are the advantages of using std::multimap over std::map
How does std::multimap handle duplicate keys

Previous Page | Course Schedule | Course Content

std::multimap

STL container: std::multimap

Key Characteristics

Example 1: Basic Usage

Explanation:

Example 2: Custom Comparator for Descending Order

Explanation:

Example 3: Using multimap for Grouping and Analysis

Explanation:

Example 4: Removing Elements from a multimap

Explanation:

Additional Considerations

Summary

Related

STL container: `std::multimap`

Example 3: Using `multimap` for Grouping and Analysis

Example 4: Removing Elements from a `multimap`