std::multiset

STL container: std::multiset

std::multiset is a container in the C++ Standard Template Library (STL) that stores elements in a sorted order, allowing multiple elements with the same value. Like std::set, 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 elements in sorted order (by default, ascending)
• Allows duplicate elements
• Provides logarithmic time complexity (O(log n)) for insertion, deletion, and search operations
• Elements are const when accessed through iterators (to maintain order)
• Supports bidirectional iterators
• Allows for custom comparison functions
• Suitable for scenarios where ordered data with duplicates is required

Example 1: Basic Usage

#include <iostream>
#include <set>
#include <string>

int main() {
    std::multiset<int> numbers = {5, 2, 8, 2, 1, 9, 3, 7, 3};

    // Inserting elements
    numbers.insert(4);
    numbers.insert(2);  // Duplicate allowed

    // Printing the multiset
    std::cout << "Numbers in the multiset:" << std::endl;
    for (const auto& num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    // Counting occurrences
    std::cout << "Count of 2: " << numbers.count(2) << std::endl;

    // Finding elements
    auto range = numbers.equal_range(3);
    std::cout << "Elements equal to 3: ";
    for (auto it = range.first; it != range.second; ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    // Removing an element
    numbers.erase(numbers.find(3));  // Removes only one instance of 3

    // Size of the multiset
    std::cout << "Number of elements: " << numbers.size() << std::endl;

    return 0;
}

Explanation:

• A multiset of integers is created and initialized
• Elements are automatically sorted in ascending order
• Duplicate elements are allowed (e.g., multiple 2s and 3s)
• insert() is used to add new elements, including duplicates
• count() returns the number of occurrences of an element
• equal_range() finds a range of elements equal to a given value
• erase() with an iterator removes a single instance of an element
• size() returns the total number of elements, including duplicates

Example 2: Custom Comparator for Descending Order

#include <iostream>
#include <set>
#include <string>

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

    // This is used for printing
    friend std::ostream& operator<<(std::ostream& os, const Person& p) {
        return os << p.name << " (" << p.age << ")";
    }
};

// Custom comparator for descending order of age
struct PersonComparator {
    bool operator()(const Person& a, const Person& b) const {
        if (a.age != b.age) {
            return a.age > b.age;  // Descending order of age
        }
        return a.name < b.name;  // Ascending order of name if ages are equal
    }
};

int main() {
    std::multiset<Person, PersonComparator> people;

    people.insert({"Alice", 30});
    people.insert({"Bob", 25});
    people.insert({"Charlie", 35});
    people.insert({"David", 30});
    people.insert({"Eve", 25});

    for (const auto& person : people) {
        std::cout << person << std::endl;
    }

    return 0;
}

Explanation:

• A custom Person struct is defined
• A custom comparator PersonComparator is created for descending age order
• The multiset is initialized with Person objects and the custom comparator
• Elements are automatically sorted based on the custom comparator
• This example shows how to use a custom sorting criteria with std::multiset
• Note that people of the same age are sorted by name in ascending order

Example 3: Frequency Count and Element Removal

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

int main() {
    std::multiset<std::string> words = {
        "apple", "banana", "cherry", "date", "apple", "fig",
        "grape", "apple", "banana", "elderberry"
    };

    // Count frequency of each word
    std::map<std::string, int> frequency;
    for (const auto& word : words) {
        frequency[word]++;
    }

    // Print frequency
    std::cout << "Word frequencies:" << std::endl;
    for (const auto& pair : frequency) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    // Remove all instances of a specific word
    std::string word_to_remove = "apple";
    auto removed = words.erase(word_to_remove);
    std::cout << "\nRemoved " << removed << " instance(s) of '" << word_to_remove << "'" << std::endl;

    // Print remaining words
    std::cout << "\nRemaining words:" << std::endl;
    for (const auto& word : words) {
        std::cout << word << " ";
    }
    std::cout << std::endl;

    return 0;
}

Explanation:

• A multiset of strings is created with duplicate words
• A map is used to count the frequency of each word
• The erase() function is used to remove all instances of a specific word
• This example demonstrates how to count occurrences and remove all instances of an element

4. Range Operations and Lower/Upper Bounds

#include <iostream>
#include <set>
#include <algorithm>

void printRange(const std::multiset<int>& ms, int lower, int upper) {
    auto start = ms.lower_bound(lower);
    auto end = ms.upper_bound(upper);

    std::cout << "Elements in range [" << lower << ", " << upper << "]: ";
    std::for_each(start, end, [](int n) { std::cout << n << " "; });
    std::cout << std::endl;
}

int main() {
    std::multiset<int> numbers = {1, 2, 3, 3, 4, 5, 5, 5, 6, 7, 8, 9, 9, 10};

    std::cout << "All numbers: ";
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    // Demonstrate lower_bound and upper_bound
    printRange(numbers, 3, 7);

    // Count elements in a range
    int rangeStart = 4, rangeEnd = 8;
    auto startIt = numbers.lower_bound(rangeStart);
    auto endIt = numbers.upper_bound(rangeEnd);
    int count = std::distance(startIt, endIt);
    std::cout << "Number of elements between " << rangeStart 
              << " and " << rangeEnd << ": " << count << std::endl;

    // Remove a range of elements
    numbers.erase(numbers.lower_bound(5), numbers.upper_bound(8));

    std::cout << "After removing range [5, 8]: ";
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

Explanation:

• This example demonstrates various range operations on a multiset
• lower_bound() returns an iterator to the first element not less than a given value
• upper_bound() returns an iterator to the first element greater than a given value
• The printRange function shows elements within a specific range
• std::distance is used to count elements within a range
• erase() with a range of iterators removes all elements within that range

Additional Considerations

1. Performance: While multiset provides good performance for most operations, consider using std::vector or std::deque for small datasets or when frequent insertions/deletions are not required.

2. Memory Usage: multiset typically uses more memory than a simple array due to its tree structure.

3. Iteration Order: Elements are always traversed in the sorted order defined by the comparison function.

4. No Direct Element Modification: Elements in a multiset cannot be modified directly through iterators to maintain the correct ordering.

Summary

std::multiset is a powerful container in C++ for storing sorted elements while allowing duplicates. Key points to remember:

• It maintains elements in a sorted order and allows duplicates
• Provides logarithmic time complexity for insertion, deletion, and search operations
• Useful for scenarios requiring sorted data with possible repetitions
• Supports custom comparators for defining the order of elements
• Offers efficient range-based operations using lower_bound and upper_bound
• Allows for easy frequency counting and removal of all instances of an element

std::multiset is particularly useful in situations where you need to maintain a sorted collection of elements, including duplicates. It's commonly used in scenarios such as: - Implementing algorithms that require sorted data with repetitions - Frequency analysis of elements - Maintaining ordered lists where duplicates are meaningful - Scenarios where both sorting and the ability to store multiple identical elements are crucial

Understanding when to use std::multiset over other containers like std::set or std::vector is key to writing efficient and clear C++ code in various application domains.

Related

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