//---------------------------15/03/29----------------------------
//****************************set相关算法*****************************
/*
1>set相关算法一共有4种：并集(union)，交集(intersection)，差集(difference)，
对称差集(symmetric difference)。
2>set相关算法只接受set/multiset。
3>每个算法都是根据 “<”(可以自行定义)
来确定大小 以及是否相等。
4>这四个算法都是稳定算法，执行后元素的相对顺序不会改变
*/
//set_union
//并集就是除了一样的不加
其它的通通塞到Output迭代器中去，所以比较大小，把
//小的都塞进去，碰到相等的，塞一个进去。最后可能两个迭代器中有一个还有剩余，
//就把剩余的都拷贝到
输出区间
template<class InputIterator1,
class InputIterator2,
class OutputIterator>
OutputIterator set_union(InputIterator first1, InputIterator last1,
InputIterator first2, InputIterator last2,
OutputIterator result)
{
while (first1 != last1 && first2 != last)
{
if (*first1 < *first2)
//自定义版本是这样的： if(comp(*first1, *first2))
{
*result = *first1;
++first1;
}
else
if(*first2 < *first1)//自定义版本： if(comp(*first2, *first1))
{
*result = *first2;
++first2;
}
else
{
*result = *first1;
++first1;
++first2;
}
++result;
}
return copy(first2, last2, copy(first1, last1, result));
}
//set_intersection
//交集么只要取相等的元素，遇到不相等情况的，只要把小的那自加即可。最后就算那个区间有多也可以不管了。
template<class InputIterator1,
class InputIterator2,
class OutputIterator>
OutputIterator set_intersection(InputIterator first1, InputIterator last1,
InputIterator first2, InputIterator last2,
OutputIterator result)
{
while (first1 != last1 && first2 != last2)
{
if(*first1 < *first2)
++first1;
else if(*first2 < *first1)
++first2;
else
{
*result = *first1;
++first1;
++first2;
++result;
}
}
return result;
}
//set_difference
//差集则只要考虑区间1中有的，区间2中没有的，1中小于2的元素可以输出，碰到相等的就让
//两个区间的都自加，2中小于1的并没有意义，只需让2自加即可，最后1中有剩余的输出，不用考虑2剩余的情况
template<class InputIterator1,
class InputIterator2,
class OutputIterator>
OutputIterator set_difference(InputIterator first1, InputIterator last1,
InputIterator first2, InputIterator last2,
OutputIterator result)
{
while (first1 != last1 && first2 != last2)
{
if(*first1 < *first2)
{
*result = *first;
++first1;
++result;
}
else if(*first2 < *first1)
++first2;
else
{
++first1;
++first2;
}
}
return copy(first, last1, result);
}
//set_symmetric_difference
//对称差集，只有相等的情况不输出，所以碰到相等的
两个区间都自加，剩下情况的都输出。
//最后会有一个区间有多，也要都输出
template<class InputIterator1,
class InputIterator2,
class OutputIterator>
OutputIterator set_difference(InputIterator first1, InputIterator last1,
InputIterator first2, InputIterator last2,
OutputIterator result)
{
while (first1 != last1 && first2 != last2)
{
if(*first1 < *first2)
{
*result = *first1;
++first1;
++result;
}
else if(*first2 < *first1)
{
*result = *first2
++first2;
++result;
}
else
{
++first1;
++first2;
}
}
return copy(first2, last2, copy(first1, last1, result));
}
//****************************set相关算法*****************************
//****************************其它算法*****************************
//adjacent_find
//找到第一组
满足条件(默认是 ==)的
相邻元素
template<class ForwardIterator>
ForwardIterator adjacent_find(ForwardIterator first, ForwardIterator last)
{
if (first == last)
return last;
ForwardIterator next = first;
while (++next != last)
{
if(*first == *next)
//自己定义版本 if(binary_pred(*first, *next))
return first;
first = next;
}
return last;
}
//count
//找到与传入的value相等的元素的个数
template<class InputIterator,
class T>
typename iterator_traits<InputIterator>::difference_type
count(InputIterator first, InputIterator last,
const T& value)
{
typename iterator_traits<InputIterator>::difference_type n =0;
for(; first != last; ++first)
if(*first == value)
//count_if版本 if( pred(*first))
++n;
return n;
}
//find
//找到第一个符合条件的元素
template<class InputIterator,
class T>
InputIterator find(InputIterator first, InputIterator last,
const T& value)
{
//find_if版本 while(first != last && !pred(*first))
while(first != last && *first != value)
++first;
return first;
}
//find_end
//找到区间1中最后一组
和区间2 相同的元素
//如果可以从队尾开始搜索可以快很多，所以分两种情况，可以后退的迭代器，不能后退的迭代器
template<class ForwardIterator1,
class ForwardIterator2>
inline ForwardIterator1
find_end(ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2, ForwardIterator2 last2)
{
typedef typename iterator_traits<ForwardIterator1>::iterator_category
category1;
typedef typename iterator_traits<ForwardIterator2>::iterator_category
category2;
return __find_end(first1, last1, first2, last2, category1(), category2());
}
template<class ForwardIterator1,
class ForwardIterator2>
ForwardIterator1 __find_end(ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2, ForwardIterator2 last2,
forward_iterator_tag, forward_iterator_tag)
{
if(first2 == last2)
return last1;
else
{
ForwardIterator1 result = last1;
while (1)
{
//先搜索下一组，再把下一组赋给result
就和单链表删除节点一样，要删除下一个节点，
//我们要预留上一个节点，这里是要先找到
下一个不符合的情况 我们才知道这是最后一个
ForwardIterator1 new_result = search(first1, last1, first2, last2);
if(new_result == last1)
return result;
else
{
result = new_result;
first1 = new_result;
++first;
}
}
}
}
//双向迭代器走这边
template<class BidirectionalIterator1,
class BidirectionalIterator2>
BidirectionalIterator1
__find_end(BidirectionalIterator1 first1, BidirectionalIterator1 last1,
BidirectionalIterator2 first2, BidirectionalIterator2 last2,
bidirectional_iterator_tag, bidirectional_iterator_tag)
{
typedef reverse_iterator<BidirectionalIterator1> reviter1;
typedef reverse_iterator<BidirectionalIterator2> reviter2;
//先确定end位置
reviter1 rlast1(first1);
reviter2 rlast2(first2);
//找到第一组就可以了
reviter1 rresult = search(reviter1(last1), rlast1,
reviter2(last2), rlast2);
if(rresult == rlast1)
return last1;
//没找到
else
{
//修改位置， base()成员函数可以取得真实位置，因为反向迭代器有两个位置，
//一个是真实位置，一个是他 “下一个”位置
他的”下一个“其实是正向迭代器的上一个
//1 2 3
此时反向迭代器指向3 operator*() 取到的是2 base()取到的是 3
//下面的操作是为了使result == end
BidirectionalIterator1 result = rresult.base();
//减去距离，就可以使result变成first
advance(result, -distance(first2, last2));
return result;
}
}
//find_first_of
//在区间1中找到
第一个 与区间2中
任意元素匹配 的位置
template<class InputIterator,
class ForwardIterator>
InputIterator find_first_of(InputIterator first1, InputIterator last1,
ForwardIterator first2, ForwardIterator last2)
{
for(; first1 != last1; ++first1)
for(ForwardIterator iter = first2; iter != last2; ++iter)
if(*first1 == *iter)
//自定义版本 if(comp(*first, *last))
return first;
return last1;
}
//for_each
//对每个元素调用仿函数f
template<class InputIterator,
class Function>
Function for_each(InputIterator first, InputIterator last, Function f)
{
for(; first != last; ++first)
f(*first);
return f;
}
//generate
//把仿函数的返回值填充区间。相当于: auto rel=gen(); fill(first, last, rel);
template<class ForwardIterator,
class Generator>
void generate(ForwardIterator first, ForwardIterator last, Generator gen)
{
for(; first != last; ++first)
*first = gen();
}
//填充n个 gen()
template<class OutputIterator,class Size,
class Generator>
OutputIterator generate_n(OutputIterator first, Size n, Generator gen)
{
for(; n > 0; --n, ++first)
*first = gen();
return first;
}
//includes
应用于有序的区间
//依次找，只要区间1的元素
小于等于 区间二就继续下去
一旦区间2中的元素小于区间1的
//说明这个数
在区间1中
就找不到和他相等的数了，就可以返回false了
template<class InputIterator1,
class InputIterator2>
bool includes(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2)
{
while (first1 != last1 && first2 != last2)
{
if(*first2 < *first1)
//自定义版本：if(comp(*first2, *first1))
return false;
else
if(*first1 < *first2)
//自定义版本：if(comp(*first1, *first2))
++first1;
else
++first1, ++first2;
}
return first2 == last2;
}
//max_element
template<class ForwardIterator>
ForwardIterator max_element(ForwardIterator first, ForwardIterator last)
{
if(first == last)
return first;
ForwardIterator result = first;
while(++first != last)
if(*result < *first)
//自定义版本： if(comp(*result, *first))
result = first;
return result;
}
//merge
要求有序
template<class InputIterator1,
class InputIterator2,
class OutputIterator>
OutputIterator merge(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2,
OutputIterator result)
{
while (first1 != last1 && first2 != last2)
{
if(*first2 < *first1)
//自定义版本： if(comp(*first2, *first1))
{
*result = *first2;
++first2;
}
else
{
*result = *first1;
++first1;
}
++result;
}
return copy(first2, last2, copy(first1, last1, result));
}