C++_3——库（algorithm）

  这一系列文章的目的是在学习了C++基础后，继续补充一些C++基础和进阶的知识点，包括C++11的相关内容。
以C++11标准为基础。

sort & reverse & rotate

	// 排序原理：快速排序
	// 比较函数comp：小于为升序排列，大于为降序排列，不输入比较函数，默认为升序排列
	void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);
	// e.g.
	bool myfunction (int i,int j) 
	{ 
		return (i<j); 
	}
	
	std::sort (myvector.begin(), myvector.end(), myfunction);
	
	
	// 排序原理：middle之前的元素，为，按顺序，升序排列最小的n个元素，或降序排列最大的n个元素；middle之后没有特定顺序
	// 比较函数comp作用同上
	void partial_sort (RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last, Compare comp);

	// 倒序排列
	void reverse (BidirectionalIterator first, BidirectionalIterator last);
	
	// 旋转容器，以middle为第一个元素，之前元素，有序移动到尾部
	ForwardIterator rotate (ForwardIterator first, ForwardIterator middle, ForwardIterator last);
	//e.g.	1 2 3 4 5 6 7 8 9 ---> 4 5 6 7 8 9 1 2 3

min & max & min_element & max_element

	// 比较大小
	// 比较函数comp：返回值为 a是否小于b
	const T& min (const T& a, const T& b, Compare comp);
	// 比较函数comp：返回值为 a是否小于b，是的，还是“是否小于“
	const T& max (const T& a, const T& b, Compare comp);
	
	// 找最大/最小值的位置，返回的是指向该值的指针
	ForwardIterator min_element (ForwardIterator first, ForwardIterator last, Compare comp);
	ForwardIterator max_element (ForwardIterator first, ForwardIterator last, Compare comp);

merge

	// 合并两个排序序列
	// result 是合并到的容器的某个位置，一般是起始位置
	OutputIterator merge (InputIterator1 first1, InputIterator1 last1,
	                      InputIterator2 first2, InputIterator2 last2,
	                      OutputIterator result, Compare comp);

copy

	// 复制first到last范围的内容 到 起始位置result
	OutputIterator copy (InputIterator first, InputIterator last, OutputIterator result);
	
	// 有选择地复制
	OutputIterator copy_if (InputIterator first, InputIterator last,
	                        OutputIterator result, UnaryPredicate pred);
	//e.g.
	std::vector<int> foo = {25,15,5,-5,-15};
	std::vector<int> bar (foo.size());
	auto it = std::copy_if (foo.begin(), foo.end(), bar.begin(), [](int i){return !(i<0);} );
	
	// 倒着来
	BidirectionalIterator2 copy_backward (BidirectionalIterator1 first,
	                                      BidirectionalIterator1 last,
	                                      BidirectionalIterator2 result);

move & swap

	// 移动到result后，原位置的元素，处于未指定但有效状态
	OutputIterator move (InputIterator first, InputIterator last, OutputIterator result);
	BidirectionalIterator2 move_backward (BidirectionalIterator1 first,
	                                      BidirectionalIterator1 last,
	                                      BidirectionalIterator2 result);
	
	// C++11之后，swap交换基于move
	void swap (T& a, T& b);
	void swap (T (&a)[N], T (&b)[N]);
	//交换一定范围的值
	ForwardIterator2 swap_ranges (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2);

replace & fill & generate & remove

	// 单值替换单值：将范围内的 old_value 替换成 new_value
	void replace (ForwardIterator first, ForwardIterator last, const T& old_value, const T& new_value);
	
	// 单值替换条件值（多值）
	void replace_if (ForwardIterator first, ForwardIterator last, UnaryPredicate pred, const T& new_value );
	
	// 范围内填充单值 val
	void fill (ForwardIterator first, ForwardIterator last, const T& val);
	OutputIterator fill_n (OutputIterator first, Size n, const T& val);	//返回最后一个填充值的下一个位置（C++11）
	
	// 范围内填充生成值
	void generate (ForwardIterator first, ForwardIterator last, Generator gen);
	//e.g.
	// function generator:
	int RandomNumber () { return (std::rand()%100); }
	std::vector<int> myvector (8);
	std::generate (myvector.begin(), myvector.end(), RandomNumber);

	// 移除范围内的值
	// 坑：这是假移除，符合移除要求的值被移动到末尾，最后返回的位置指向 尾部 所有移除元素的第一个元素位置
	ForwardIterator remove (ForwardIterator first, ForwardIterator last, const T& val);

find

	// 测试所有元素满足条件
	bool all_of (InputIterator first, InputIterator last, UnaryPredicate pred);
	// 测试有元素满足条件
	bool any_of (InputIterator first, InputIterator last, UnaryPredicate pred);
	// 测试所有元素不满足条件
	bool none_of (InputIterator first, InputIterator last, UnaryPredicate pred);
	// 对每个元素执行一次函数fn
	Function for_each (InputIterator first, InputIterator last, Function fn);
	
	// 找到元素第一次出现的位置
	InputIterator find (InputIterator first, InputIterator last, const T& val);
	// 按条件第一次出现的位置
	InputIterator find_if (InputIterator first, InputIterator last, UnaryPredicate pred);
	
	// 出现次数
	count (InputIterator first, InputIterator last, const T& val);
	count_if (InputIterator first, InputIterator last, UnaryPredicate pred);
	
	// 在1号范围内，第一次出现2号范围内元素的位置，	可自定义pred 判断是否符合匹配情况
	ForwardIterator1 search (ForwardIterator1 first1, ForwardIterator1 last1,
	                         ForwardIterator2 first2, ForwardIterator2 last2,
	                         BinaryPredicate pred);