Definition in file stl_algo.h.#include <bits/stl_heap.h>
#include <bits/stl_tempbuf.h>
#include <debug/debug.h>
Include dependency graph for stl_algo.h:
Go to the source code of this file.
|
Find two adjacent values in a sequence using a predicate.
|
|
Find two adjacent values in a sequence that are equal.
Referenced by std::unique(). |
|
Count the number of copies of a value in a sequence.
|
|
Count the elements of a sequence for which a predicate is true.
|
|
Find the first occurrence of a value in a sequence.
Referenced by basic_string::find(), basic_string::find_first_not_of(), basic_string::find_first_of(), basic_string::find_last_not_of(), basic_string::find_last_of(), std::remove(), std::search(), and std::search_n(). |
|
Find last matching subsequence in a sequence using a predicate.
[first1,last1) for a sub-sequence that compares equal value-by-value with the sequence given by [first2,last2) using comp as a predicate and returns an iterator to the first element of the sub-sequence, or last1 if the sub-sequence is not found. The sub-sequence will be the last such subsequence contained in [first,last1).
Because the sub-sequence must lie completely within the range |
|
Find last matching subsequence in a sequence.
[first1,last1) for a sub-sequence that compares equal value-by-value with the sequence given by [first2,last2) and returns an iterator to the first element of the sub-sequence, or last1 if the sub-sequence is not found. The sub-sequence will be the last such subsequence contained in [first,last1).
Because the sub-sequence must lie completely within the range |
|
Find element from a set in a sequence using a predicate.
[first1,last1) for an element that is equal to some element in the range [first2,last2). If found, returns an iterator in the range [first1,last1), otherwise returns last1 . Definition at line 4905 of file stl_algo.h. |
|
Find element from a set in a sequence.
[first1,last1) for an element that is equal to some element in the range [first2,last2). If found, returns an iterator in the range [first1,last1), otherwise returns last1 . Definition at line 4868 of file stl_algo.h. |
|
Find the first element in a sequence for which a predicate is true.
Referenced by std::remove_if(). |
|
Apply a function to every element of a sequence.
f to each element in the range [first,last). f must not modify the order of the sequence. If f has a return value it is ignored. Definition at line 152 of file stl_algo.h. |
|
Assign the result of a function object to each value in a sequence.
*i = gen() for each i in the range [first,last). Definition at line 972 of file stl_algo.h. |
|
Assign the result of a function object to each value in a sequence.
*i = gen() for each i in the range [first,first+n). Definition at line 998 of file stl_algo.h. |
|
Merges two sorted ranges in place.
If enough additional memory is available, this takes (last-first)-1 comparisons. Otherwise an NlogN algorithm is used, where N is distance(first,last). The comparison function should have the same effects on ordering as the function used for the initial sort. Definition at line 3494 of file stl_algo.h. References std::distance(). |
|
Merges two sorted ranges in place.
If enough additional memory is available, this takes (last-first)-1 comparisons. Otherwise an NlogN algorithm is used, where N is distance(first,last). Definition at line 3440 of file stl_algo.h. References std::distance(). |
|
Return the maximum element in a range using comparison functor.
|
|
Return the maximum element in a range.
|
|
Merges two sorted ranges.
The comparison function should have the same effects on ordering as the function used for the initial sort. Definition at line 3021 of file stl_algo.h. References std::copy(). |
|
Merges two sorted ranges.
References std::copy(). |
|
Return the minimum element in a range using comparison functor.
|
|
Return the minimum element in a range.
|
|
Permute range into the next "dictionary" ordering using comparison functor.
References std::iter_swap(), and std::reverse(). |
|
Permute range into the next "dictionary" ordering.
References std::iter_swap(), and std::reverse(). |
|
Sort a sequence just enough to find a particular position using a predicate for comparison.
[first,last) so that *nth is the same element that would have been in that position had the whole sequence been sorted. The elements either side of *nth are not completely sorted, but for any iterator in the range [first,nth) and any iterator in the range [nth,last) it holds that comp(*j,*i) is false. Definition at line 3736 of file stl_algo.h. |
|
Sort a sequence just enough to find a particular position.
[first,last) so that *nth is the same element that would have been in that position had the whole sequence been sorted. whole sequence been sorted. The elements either side of *nth are not completely sorted, but for any iterator in the range [first,nth) and any iterator in the range [nth,last) it holds that *j<*i is false. Definition at line 3685 of file stl_algo.h. |
|
Sort the smallest elements of a sequence using a predicate for comparison.
(middle-first) elements in the range [first,last) and moves them to the range [first,middle). The order of the remaining elements in the range [middle,last) is undefined. After the sort if i and are iterators in the range [first,middle) such that precedes and is an iterator in the range [middle,last) then *comp (j,*i) and comp(*k,*i) are both false. Definition at line 2302 of file stl_algo.h.
References std::make_heap(), and std::sort_heap(). |
|
Sort the smallest elements of a sequence.
(middle-first) elements in the range [first,last) and moves them to the range [first,middle). The order of the remaining elements in the range [middle,last) is undefined. After the sort if i and are iterators in the range [first,middle) such that precedes and is an iterator in the range [middle,last) then *j<*i and *k<*i are both false. Definition at line 2261 of file stl_algo.h.
References std::make_heap(), and std::sort_heap(). |
|
Copy the smallest elements of a sequence using a predicate for comparison.
[first,last) to the range beginning at result_first , where the number of elements to be copied, N , is the smaller of (last-first) and (result_last-result_first). After the sort if i and are iterators in the range [result_first,result_first+N) such that precedes then comp(*j,*i) is false. The value returned is result_first+N . Definition at line 2408 of file stl_algo.h.
References std::make_heap(), and std::sort_heap(). |
|
Copy the smallest elements of a sequence.
[first,last) to the range beginning at result_first , where the number of elements to be copied, N , is the smaller of (last-first) and (result_last-result_first). After the sort if i and are iterators in the range [result_first,result_first+N) such that precedes then *j<*i is false. The value returned is result_first+N . Definition at line 2344 of file stl_algo.h.
References std::make_heap(), and std::sort_heap(). |
|
Move elements for which a predicate is true to the beginning of a sequence.
pred must not modify its operand. partition() does not preserve the relative ordering of elements in each group, use stable_partition() if this is needed. Definition at line 1860 of file stl_algo.h. |
|
Permute range into the previous "dictionary" ordering using comparison functor.
References std::iter_swap(), and std::reverse(). |
|
Permute range into the previous "dictionary" ordering.
References std::iter_swap(), and std::reverse(). |
|
Shuffle the elements of a sequence using a random number generator.
[first,last) using rand to provide a random distribution. Calling rand(N) for a positive integer N should return a randomly chosen integer from the range [0,N). Definition at line 1766 of file stl_algo.h.
References std::iter_swap(). |
|
Randomly shuffle the elements of a sequence.
[first,last) using a random distribution, so that every possible ordering of the sequence is equally likely. Definition at line 1739 of file stl_algo.h.
References std::iter_swap(). |
|
Remove elements from a sequence.
value are removed from the range [first,last).remove() is stable, so the relative order of elements that are not removed is unchanged.
Elements between the end of the resulting sequence and References std::find(), and std::remove_copy(). |
|
Copy a sequence, removing elements of a given value.
[first,last) not equal to value to the range beginning at result . remove_copy() is stable, so the relative order of elements that are copied is unchanged. Definition at line 1025 of file stl_algo.h.
Referenced by std::remove(). |
|
Copy a sequence, removing elements for which a predicate is true.
[first,last) for which pred returns true to the range beginning at result .remove_copy_if() is stable, so the relative order of elements that are copied is unchanged. Definition at line 1062 of file stl_algo.h. Referenced by std::remove_if(). |
|
Remove elements from a sequence using a predicate.
pred returns true are removed from the range [first,last).remove_if() is stable, so the relative order of elements that are not removed is unchanged.
Elements between the end of the resulting sequence and References std::find_if(), and std::remove_copy_if(). |
|
Replace each occurrence of one value in a sequence with another value.
i in the range [first,last) if *i == old_value then the assignment *i = new_value is performed. Definition at line 844 of file stl_algo.h. |
|
Copy a sequence, replacing each element of one value with another value.
[first,last) to the output range [result,result+(last-first)) replacing elements equal to old_value with new_value . Definition at line 908 of file stl_algo.h. |
|
Copy a sequence, replacing each value for which a predicate returns true with another value.
[first,last) to the range [result,result+(last-first)) replacing elements for which pred returns true with new_value . Definition at line 942 of file stl_algo.h. |
|
Replace each value in a sequence for which a predicate returns true with another value.
i in the range [first,last) if pred(*i) is true then the assignment *i = new_value is performed. Definition at line 875 of file stl_algo.h. |
|
Reverse a sequence.
[first,last), so that the first element becomes the last etc. For every i such that 0<=i<= (last-first)/2), reverse() swaps * (first+i) and * (last-(i+1)) Definition at line 1455 of file stl_algo.h.
Referenced by std::next_permutation(), and std::prev_permutation(). |
|
Copy a sequence, reversing its elements.
[first,last) to the range [result,result+(last-first)) such that the order of the elements is reversed. For every i such that 0<=i<= (last-first), reverse_copy() performs the assignment * (result+(last-first)-i) = *(first+i). The ranges [first,last) and [result,result+(last-first)) must not overlap. Definition at line 1481 of file stl_algo.h. |
|
Rotate the elements of a sequence.
[first,last) by (middle-first) positions so that the element at middle is moved to first , the element at middle+1 is moved to +1 and so on for each element in the range [first,last).
This effectively swaps the ranges
Performs |
|
Copy a sequence, rotating its elements.
[first,last) to the range beginning at
* (result+(n+(last-middle))(last-first))=*(first+n) for each n in the range [0,last-first). Definition at line 1714 of file stl_algo.h.
References std::copy(). |
|
Search a sequence for a matching sub-sequence using a predicate.
[first1,last1) for a sub-sequence that compares equal value-by-value with the sequence given by [first2,last2), using predicate to determine equality, and returns an iterator to the first element of the sub-sequence, or last1 if no such iterator exists.
|
|
Search a sequence for a matching sub-sequence.
[first1,last1) for a sub-sequence that compares equal value-by-value with the sequence given by [first2,last2) and returns an iterator to the first element of the sub-sequence, or last1 if the sub-sequence is not found.
Because the sub-sequence must lie completely within the range References std::find(). Referenced by basic_string::find(). |
|
Search a sequence for a number of consecutive values using a predicate.
[first,last) for count consecutive elements for which the predicate returns true. Definition at line 678 of file stl_algo.h. |
|
Search a sequence for a number of consecutive values.
[first,last) for count consecutive elements equal to val . Definition at line 625 of file stl_algo.h.
References std::find(). |
|
Sort the elements of a sequence using a predicate for comparison.
[first,last) in ascending order, such that comp (*(i+1),*i) is false for every iterator i in the range [first,last-1).
The relative ordering of equivalent elements is not preserved, use |
|
Sort the elements of a sequence.
[first,last) in ascending order, such that * (i+1)<*i is false for each iterator i in the range [first,last-1).
The relative ordering of equivalent elements is not preserved, use |
|
Move elements for which a predicate is true to the beginning of a sequence, preserving relative ordering.
partition() with the additional guarantee that the relative ordering of elements in each group is preserved, so any two elements x and y in the range [first,last) such that pred(x)==pred (y) will have the same relative ordering after calling stable_partition() . Definition at line 1971 of file stl_algo.h. |
|
Sort the elements of a sequence using a predicate for comparison, preserving the relative order of equivalent elements.
[first,last) in ascending order, such that comp (*(i+1),*i) is false for each iterator i in the range [first,last-1).
The relative ordering of equivalent elements is preserved, so any two elements |
|
Sort the elements of a sequence, preserving the relative order of equivalent elements.
[first,last) in ascending order, such that * (i+1)<*i is false for each iterator i in the range [first,last-1).
The relative ordering of equivalent elements is preserved, so any two elements |
|
Swap the elements of two sequences.
[first1,last1) with the corresponding element in the range [first2,(last1-first1)). The ranges must not overlap. Definition at line 739 of file stl_algo.h.
References std::iter_swap(). |
|
Perform an operation on corresponding elements of two sequences.
* (result+N)=binary_op(*(first1+N),*(first2+N)) for each N in the range [0,last1-first1).
|
|
Perform an operation on a sequence.
* (result+N)=unary_op(*(first+N)) for each N in the range [0,last-first).
|
|
Remove consecutive values from a sequence using a predicate.
binary_pred returns true. unique() is stable, so the relative order of elements that are not removed is unchanged. Elements between the end of the resulting sequence and last are still present, but their value is unspecified. Definition at line 1382 of file stl_algo.h.
References std::adjacent_find(). |
|
Remove consecutive duplicate values from a sequence.
last are still present, but their value is unspecified. Definition at line 1343 of file stl_algo.h.
References std::adjacent_find(). |
|
Copy a sequence, removing consecutive values using a predicate.
[first,last) to the range beginning at result , except that only the first element is copied from groups of consecutive elements for which binary_pred returns true. unique_copy() is stable, so the relative order of elements that are copied is unchanged. Definition at line 1310 of file stl_algo.h. |
|
Copy a sequence, removing consecutive duplicate values.
[first,last) to the range beginning at result , except that only the first element is copied from groups of consecutive elements that compare equal. unique_copy() is stable, so the relative order of elements that are copied is unchanged. Definition at line 1274 of file stl_algo.h. |