Std partition point in c++

partition point() acquires the partition point: Returns an iterator to the first partitioned element in the range [first, last] for which pred(predicate) is false, indicating the partition point of that element.

As if partition had been called with the identical inputs, the range's elements must already be partitioned.

The function compares non-consecutive elements of the sorted range, which is especially effective for random-access iterators, to reduce the amount of comparisons made.

Returning the first element in the supplied range for which pred is false requires the usage of the C++ algorithm partition point() function. The elements are arranged so that those that satisfy the criterion are placed before those that do not.

Syntax

ForwardIterator partition_point(ForwardIterator first, 
                                  ForwardIterator last,
                                  UnaryPredicate pred); 

First and last parameters are forward iterators that go to the beginning and end of the partitioned sequence, respectively. The range that has been tested is [first, last], which includes all of the elements between first and last but excludes the element pointed to by last.

A unary function that takes a range element as argument and returns a value that can be converted to a bool. The result shows if the element before the partition point (if true, it goes before; if false goes at or after it). Its parameter may not be modified by the function. This could be a function object or a function pointer.

Return Value: An iterator to the last element in the partitioned range [first, last] if pred is false for any element, or to the last element if pred is false for any element.

This function template's definition is equivalent to:

template 
  ForwardIterator partition_point (ForwardIterator first, ForwardIterator last,
                                   UnaryPredicate pred)

{
  auto n = distance(first, last);
  while (n>0)
  {
    ForwardIterator it = first;
    auto step = n/2;
    std::advance (it, step);
    if (pred(*it)) { first=++it; n-=step+1; }
    else n=step;
  }
  return first;
}

Example

// C++ program to get odd elements
// and even elements
#include <iostream> // std::cout

#include <algorithm> // std::partition, std::partition_point
#include <vector> // std::vector

bool IsOdd(int i) { return (i % 2) == 1; }

int main()
{
	std::vector<int> data{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	std::vector<int> odd, even;

	// partition data on the basis of odd elements
	// using pred IsOdd()
	std::stable_partition(data.begin(), data.end(), IsOdd);

	// gets the partition point based on odd elements
	auto it = std::partition_point(data.begin(), data.end(),
													IsOdd);

	// assign elements to odd from beginning till partition
	// point.
	odd.assign(data.begin(), it);
	even.assign(it, data.end());

	// print contents of odd:
	std::cout << "odd:";
	for (int& x : odd)
		std::cout << ' ' << x;
	std::cout << '\n';

	// print contents of even:
	std::cout << "even:";
	for (int& x : even)
		std::cout << ' ' << x;
	std::cout << '\n';

	return 0;
}

Output:

odd:  1 3 5 7 9
even: 2 4 6 8 10

Example

// C++ program to get negative elements
// and positive elements using partition_point
#include <iostream> // std::cout

#include <algorithm> // std::partition, std::partition_point
#include <vector> // std::vector

bool IsNegative(int i) { return (i < 0); }

int main()
{
	std::vector<int> data{ 1, -1, 3, -4, 5, 2, -2, 4,
											-5, -3 };
	std::vector<int> negative, positive;

	// partition data on the basis of odd elements using
	// pred IsNegative()
	std::stable_partition(data.begin(), data.end(),
									IsNegative);

	// gets the partition point based on odd elements
	auto it = std::partition_point(data.begin(), data.end(),
												IsNegative);

	// assign elements to odd from beginning till
	// partition point.
	negative.assign(data.begin(), it);
	positive.assign(it, data.end());

	// print contents of odd:
	std::cout << "Negative: ";
	for (int& x : negative)
		std::cout << ' ' << x;
	std::cout << '\n';

	// print contents of even:
	std::cout << "Positive: ";
	for (int& x : positive)
		std::cout << ' ' << x;
	std::cout << '\n';

	return 0;
}

Output:

Negative:  -1 -4 -2 -5 -3
Positive:  1 3 5 2 4

About log2(N)+2 element comparisons are performed (where N is this distance). The iterator advancements provide an additional linear complexity in N on non-random access iterators, on average.

Example

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

bool IsOdd(int i) { return (i % 2) == 1; }
int main(){
   std::vector<int> data{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
   std::vector<int> odd, even;
   std::stable_partition(data.begin(), data.end(), IsOdd);
   auto it = std::partition_point(data.begin(), data.end(),
   IsOdd);
   odd.assign(data.begin(), it);
   even.assign(it, data.end());
   std::cout << "odd:";
   for (int& x : odd)
      std::cout << ' ' << x;
   std::cout << '\n';
   std::cout << "even:";
   for (int& x : even)
      std::cout << ' ' << x;
   std::cout << '\n';
   return 0;
}

Output: