c++11新算法：algorithm

all_of、any_of、none_of
checks if a predicate is true for all, any or none of the elements in a range.
template <class InputIt, class UnaryPredicate>
bool all_of(InputIt first, InputIt last, UnaryPredicate p);
template <class InputIt, class UnaryPredicate>
bool any_of(InputIt first, InputIt last, UnaryPredicate p);
template <class InputIt, class UnaryPredicate>
bool none_of(InputIt first, InputIt last, UnaryPredicate p);

find_if_not、copy_if、copy_n
template <class InputIt, class UnaryPredicate>
InputIt find_if_not(InputIt first, InputIt last, UnaryPredicate q);
template <class InputIt, class OutputIt, class UnaryPredicate>
OutputIt copy_if(InputIt first, InputIt last, OutputIt d_first, UnaryPredicate pred);
template <class InputIt, class Size, class OutputIt>
OutputIt copy_n(InputIt first, Size count, OutputIt result);

move、move_backward
template <class InputIt, class OutputIt>
OutputIt move(InputIt first, InputIt last, OutputIt d_first);
template <class BidirIt1, class BidirIt2>
BidirIt2 move_backward(BidirIt1 first, BidirIt1 last, BidirIt2 d_last);
可能的实现:
OutputIt move(InputIt first, InputIt last, OutputIt d_first)
{
	while (first != last) {
		*d_first++ = std::move(*first++);
	}
	return d_first;
}
template <class BidirIt1, class BidirIt2>
BidirIt2 move_backward(BidirIt1 first, BidirIt1 last, BidirIt2 d_last)
{
	while (first != last) {
		*(--d_last) = std::move(*(--last));
	}
	return d_last;
}

shuffle
template <class RandomIt, class URBG>
void shuffle(RandomIt first, RandomIt last, URBG&& g);
原来的random_shuffle在17标准中被删除。
可能的实现:
template <class RandomIt, class URBG>
void shuffle(RandomIt first, RandomIt last, URBG&& g)
{
	typedef std::uniform_int_distribution<> distr_t;
	typedef typename distr_t::param_type param_t;
	distr_t D;
	for (int i = last-first-1; i > 0; --i) {
		std::swap(first[i], first[D(g, param_t(0, i))]);
	}
}
示例:
#include <random>
#include <algorithm>
#include <iterator>
#include <iostream>
int main()
{
	std::vector<int> v = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
	std::random_device rd;
	std::mt19937 g(rd());
	std::shuffle(v.begin(), v.end(), g);
	std::copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " "));
	std::cout << std::endl;
}

is_partitioned
检测序列是不是partitioned，即前部分pred为true，后部分pred为false。空序列返回true。
template <class InputIterator, class UnaryPredicate>
bool is_partitioned(InputIterator first, InputIterator last, UnaryPredicate pred);

partition_copy
将序列分别拷贝到两个新序列中，前部分元素满足pred为true，后部分元素满足pred为false。
template <class InputIterator, class OutputIterator1, class OutputIterator2, class UnaryPredicate pred>
pair<OutputIterator1,OutputIterator2>
partition_copy(InputIterator first, InputIterator last,
	OutputIterator1 result_true, OutputIterator2 result_false, UnaryPredicate pred);

partition_point
找到序列中第一个pred为false的元素，序列中的元素被认为已经是partitioned。
template <class ForwardIterator, class UnaryPredicate>
ForwardIterator partition_point(ForwardIterator first, ForwardIterator last, UnaryPredicate pred);

is_sorted
检测序列是否有序
template <class ForwardIterator>
bool is_sorted(ForwardIterator first, ForwardIterator last);
template <class ForwardIterator, class Compare>
bool is_sorted(ForwardIterator first, ForwardIterator last, Compare comp);

is_sorted_until
查找序列中第一个不符合之前元素顺序的元素
template <class ForwardIterator>
ForwardIterator is_sorted_until(ForwardIterator first, ForwardIterator last);
template <class ForwardIterator, class Compare>
ForwardIterator is_sorted_until(ForwardIterator first, ForwardIterator last, Compare comp);

is_heap
检测序列是不是构成一个堆
template <class RandomAccessIterator>
bool is_heap(RandomAccessIterator first, RandomAccessIterator last);
template <class RandomAccessIterator, class Compare>
bool is_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);

is_heap_until
Find first element not in heap order
template <class RandomAccessIterator>
RandomAccessIterator is_heap_until(RandomAccessIterator first, RandomAccessIterator last);
template <class RandomAccessIterator, class Compare>
RandomAccessIterator is_heap_until(RandomAccessIterator first, RandomAccessIterator last, Compare comp);

is_permutation
判断两个序列是不是有相同的元素，其元素顺序可以不同
template <class ForwardIterator1, class ForwardIterator2>
bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2);
template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
	ForwardIterator2 first2, BinaryPredicate pred);

max、min
max和min增加了初始化列表版本
template <class T>
T min(initializer_list<T> il);
template <class T, class Compare>
T min(initializer_list<T> il, Compare comp);
template <class T>
T max(initializer_list<T> il);
template <class T, class Compare>
T max(initializer_list<T> il, Compare comp);

minmax
同时返回最小最大值
template <class T>
pair<const T&, const T&> minmax(const T& a, const T& b);
template <class T, class Compare>
pair<const T&, const T&> minmax(const T& a, const T& b, Compare comp);
template <class T>
pair<T,T> minmax(initializer_list<T> il);
template <class T, class Compare>
pair<T,T> minmax(initializer_list<T> il, Compare comp);

minmax_element
同时返回序列中的最小最大元素
template <class ForwardIterator>
pair<ForwardIterator, ForwardIterator>
minmax_element(ForwardIterator first, ForwardIterator last);
template <class ForwardIterator, class Compare>
pair<ForwardIterator, ForwardIterator>
minmax_element(ForwardIterator first, ForwardIterator last, Compare comp);

另外<numeric>提供了一个填充序列为递增数值的函数iota，其实现等价于：

template <class ForwardIt, class T>
void iota(ForwardIt first, ForwardIt last, T value)
{
    while(first != last) *first++ = value++;
}