set相关算法（includes,set_union,set_intersection,set_difference）

includes

　　S1内含S2的一个子集合，如果元素在s2出现n次，在S1出现m次，若n>m则会返回false

//版本一：用operator <比较元素 
template <class InputerIterator1,class InputerIterator2>
bool includes(InputerIterator1 first1,InputerIterator1 last1,InputerIterator2 first2,InputerIterator2 last2);

//版本二：用自定义的function object比较元素
template <class InputerIterator1,class InputerIterator2,class StrictWeakOrdering>
bool includes(InputerIterator1 first1,InputerIterator1 last1,InputerIterator2 first2,InputerIterator2 last2,StrictWeakOrdering cmp);

　　测试已排序的[first2,last2)是否为[first1,last1)的子集，每个集合中的元素不必独一无二，如果某个元素在[first1,last1)出现m次，在[first2,last2)出现n次，如果m<n，则返回false

set_union

//版本一：用operator <比较元素
template <class InputerIterator1,class InputerIterator2,class OutputIterator>
OutputIterator set_union(InputerIterator1 first1,InputerIterator1 last1,
                        InputerIterator2 first2,InputerIterator2 last2,OutputIterator rseult);
{
    while(first1!=last1 && first2!=last2)
    {
        //两个容器内的元素相比较，把较小者放入结果容器中，并向前移动迭代器
        //如果两个元素相等则写入结果中，同时移动两个迭代器
        if(*first1<*first2)
        {
            *result = *first;
            ++first1;
        }
        else if(*first2<*first1)
        {
            *result = *first;
            ++first2;
        }
        else
        {
            *result = *first1;
            ++first1;
            ++first2;
        }
        ++result;
    }
    //把剩余的元素都拷贝进结果中
    //copy返回迭代器指向目标容器的插入元素的最后一个元素的下一个元素
    return copy(first2, last2, copy(first1, last1, result));
}
//版本二：用自定义的function object比较元素
template <class InputerIterator1,class InputerIterator2,class OutputIterator,class StrictWeakOrdering>
OutputIterator set_union(InputerIterator1 first1,InputerIterator1 last1,
                        InputerIterator2 first2,InputerIterator2 last2,
                        OutputIterator result,StrictWeakOrdering cmp);

　　构造已排序的[first2,last2)和[first1,last1)的并集，每个集合中的元素不必独一无二

1. 如果某个元素在[first1,last1)出现m次，在[first2,last2)出现n次，在result中出现的次数为max(m,n)
2. 元素的相对顺序不会被改变，如果是两个集合中都有的元素，那么该元素是从第一个集合中复制来的（去除重复的元素）
3. 两个集合中的等价元素在result中，m个元素是从第一个range中复制来的，max(n-m,0)个元素从第二个range中复制来

set_intersection

//版本一：用operator <比较元素 
template <class InputerIterator1,class InputerIterator2,class OutputIterator>
OutputIterator set_intersection(InputerIterator1 first1,InputerIterator1 last1,
                        InputerIterator2 first2,InputerIterator2 last2,OutputIterator rseult);
{
    while(first1!=last1 && first2!=last2)
    {
        if(*first1<*first2)
        {
            ++first1;
        }
        else if(*first2<*first1)
        {
            ++first2;
        }
        else
        {
            *result = *first1;
            ++first1;
            ++first2;
            ++result;
        }
    }
    return result;
}
//版本二：用自定义的function object比较元素
template <class InputerIterator1,class InputerIterator2,class OutputIterator,class StrictWeakOrdering>
OutputIterator set_intersection(InputerIterator1 first1,InputerIterator1 last1,
                        InputerIterator2 first2,InputerIterator2 last2,
                        OutputIterator result,StrictWeakOrdering cmp);

　　构造两个集合的交集，如果某个元素在[first1,last1)出现n次，在[first2,last2)出现m次，在result中出现的次数为min(n,m)，所有元素赋值于[first1,last1)，其他的与set_union相同， 他是一种稳定的操作

set_difference

1. 构造两个集合的差集，result中的元素出现于第一个range但不出现于第二个range，他也是一种稳定的操作
2. 某个元素在[first1,last1)中拥有n个彼此等价的元素，在[first2,last2)中拥有m个彼此等价的元素，result中含有max(n-m)个彼此等价的元素，所有元素都复制于[first1,last1)

//版本一：用operator <比较元素 
template <class InputerIterator1,class InputerIterator2,class OutputIterator>
OutputIterator set_difference(InputerIterator1 first1,InputerIterator1 last1,
                        InputerIterator2 first2,InputerIterator2 last2,OutputIterator rseult);
{
    while(first1!=last1 && first2!=last2)
    {
        if(*first1<*first2)
        {
            *result = *first1;
            ++first;
            ++result;
        }
        else if(*first2<*first1)
        {
            ++*first2;
        }
        else
        {
            ++first1;
            ++first2;
        }
    }
    return copy(first1, last1, result);
}
//版本二：用自定义的function object比较元素
template <class InputerIterator1,class InputerIterator2,class OutputIterator,class StrictWeakOrdering>
OutputIterator set_difference(InputerIterator1 first1,InputerIterator1 last1,
                        InputerIterator2 first2,InputerIterator2 last2,
                        OutputIterator result,StrictWeakOrdering cmp);

set_symmetric_difference

1. 构造出两个集合之对称差，结果集包含出现于第一个range的元素但不出现于第二个range的元素以及出现于第二个range的元素但不出现于第一个range的元素，他也是一种稳定的操作，输入区间的元素相对顺序不会被改变
2. 某个元素在[first1,last1)中拥有n个彼此等价的元素，在[first2,last2)中拥有m个彼此等价的元素，result中含有|n-m|个彼此等价的元素，若n>m，则result元素中最后n-m个将由[first1,last1)复制来，若n<m，则result元素中最后m-n个将由[first2,last2)复制来

//版本一：用operator <比较元素
template <class InputerIterator1,class InputerIterator2,class OutputIterator>
OutputIterator set_symmetric_difference(InputerIterator1 first1,InputerIterator1 last1,
                        InputerIterator2 first2,InputerIterator2 last2,OutputIterator rseult);
{
     while(first1!=last1 && first2!=last2)
    {
        if(*first1<*first2)
        {
            *result = *first1;
            ++first1;
            ++result;
        }
        if(*first2<*first1)
        {
            *result = *first2;
            ++first2;
            ++result;
        }
        else
        {
            ++first1;
            ++first2;
        }
    }
    return copy(first1, last1, copy(first2, last2, result));
}
//版本二：用自定义的function object比较元素
template <class InputerIterator1,class InputerIterator2,class OutputIterator,class StrictWeakOrdering>
OutputIterator set_symmetric_difference(InputerIterator1 first1,InputerIterator1 last1,
                        InputerIterator2 first2,InputerIterator2 last2,
                        OutputIterator result,StrictWeakOrdering cmp);