How do I partition and stable_partition sequences in C++?

Partition and Stable Partition in C++

In C++, the std::partition and std::stable_partition algorithms are used to rearrange the elements of a sequence based on a predicate. The key difference between them is that while std::partition does not maintain the original order of equal elements, std::stable_partition does.

Using std::partition

std::partition rearranges the elements in such a way that all the elements for which the predicate returns true appear before the elements for which it returns false. However, it may not preserve the relative order of the equal elements.

Using std::stable_partition

std::stable_partition performs a similar task, but maintains the relative order of the equal elements. This is particularly useful when the order of elements matters.

Example

#include <iostream> #include <vector> #include <algorithm> bool isEven(int x) { return x % 2 == 0; } int main() { std::vector numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; // Using std::partition std::partition(numbers.begin(), numbers.end(), isEven); std::cout << "Partitioned (not stable): "; for (int num : numbers) { std::cout << num << " "; } std::cout << std::endl; // Reset vector numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; // Using std::stable_partition std::stable_partition(numbers.begin(), numbers.end(), isEven); std::cout << "Stable Partitioned: "; for (int num : numbers) { std::cout << num << " "; } std::cout << std::endl; return 0; }

C++ partition stable_partition algorithms vectors sorting programming

Related Questions

How do I avoid rehashing overhead with std::set in multithreaded code?

How do I find elements with custom comparators with std::set for embedded targets?

How do I erase elements while iterating with std::set for embedded targets?

How do I provide stable iteration order with std::unordered_map for large datasets?

How do I reserve capacity ahead of time with std::unordered_map for large datasets?

How do I erase elements while iterating with std::unordered_map in multithreaded code?

How do I provide stable iteration order with std::map for embedded targets?

How do I provide stable iteration order with std::map in multithreaded code?

How do I avoid rehashing overhead with std::map in performance-sensitive code?

How do I merge two containers efficiently with std::map for embedded targets?