精华内容
下载资源
问答
  • set.hpp: Added mp_set_intersection, mp_set_difference, mp_set_symmetric_difference, mp_set_union (in response to <a href="url">https://github.com/boostorg/mp11/issues/25</a>)</p><p>该提问来源于开源...
  • 主要介绍了c++ STL set_difference set_intersection set_union 操作,需要的朋友可以参考下
  • includes,set_intersection,set_union,set_difference,set_symmetric_difference都是集合论中的操作。这些算法都假定指定区间类的元素已经有序。 includes:A∈B set_intersection:A∩B set_union:A∪B...

    includes,set_intersection,set_union,set_difference,set_symmetric_difference都是集合论中的操作。这些算法都假定指定区间类的元素已经有序。

    includes:A∈B

    set_intersection:A∩B

    set_union:A∪B

    set_difference:A-B

    set_symmetric_difference:(A-B)∪(B-A)


    1,includes

    声明:

    1. #include <algorithm>  
    2. template <class inputItr1, class inputItr2>  
    3. bool includes(inputItr1 first1, inputItr1 last1, inputItr2 first2, inputItr2 last2);  
    4. template <class inputItr1, class inputItr2, class binaryPredicate>  
    5. bool includes(inputItr1 first1, inputItr1 last1, inputItr2,binaryPredicate op);  

    示例代码:

    1. #include <iostream>  
    2. #include <list>  
    3.   
    4. #include <string>  
    5. #include <numeric>  
    6. #include <iterator>  
    7. #include <vector>  
    8. #include <functional>  
    9.   
    10. #include <algorithm>  
    11.   
    12. using namespace std;  
    13.   
    14. int main() {  
    15.     char setA[5] = {'A','B','C','D','E'};  
    16.     char setB[10] = {'A','B','C','D','E','F','I','J','K','L'};  
    17.     char setC[5] = {'A','E','I','O','U'};  
    18.   
    19.     ostream_iterator<char> screen(cout, " ");  
    20.     cout << "setA:" << endl;  
    21.     copy(setA,setA+5,screen);  
    22.     cout << endl;  
    23.     cout << "setB:" << endl;  
    24.     copy(setB,setB+10,screen);  
    25.     cout << endl;  
    26.     cout << "setC:" << endl;  
    27.     copy(setC,setC+5,screen);  
    28.     cout << endl;  
    29.   
    30.     if (includes(setB,setB+10,setA,setA+5))  
    31.     {  
    32.         cout << "setA is a subset of setB" << endl;  
    33.     } else {  
    34.         cout << "setA is not a subset of setB" << endl;  
    35.     }  
    36.   
    37.     if (includes(setB,setB+10,setC,setC+5))  
    38.     {  
    39.         cout << "setC is a subset of setB" << endl;  
    40.     } else {  
    41.         cout << "setC is not a subset of setB" << endl;  
    42.     }  
    43.   
    44.     return 0;  
    45. }  

    运行结果:

    charList:
    a b c d e
    charList:
    A B C D E
    list
    2 8 5 1 7 11 3
    4 16 10 2 14 22 6
    list
    4 16 10 2 14 22 6


    2,set_intersection,set_union

    声明:

    1. #include <algorithm>  
    2. template <class inputItr1, class inputItr2,class outputItr>  
    3. outputItr set_intersection(inputItr1 first1, inputItr1 last1, inputItr2 first2,inputItr2 last2,outputItr destFirst);  
    4. template <class inputItr1, class inputItr2,class outputItr,class binaryPredicate>  
    5. outputItr set_intersection(inputItr1 first1, inputItr1 last1, inputItr2 first2,inputItr2 last2,outputItr destFirst,binaryPredicate op);  
    6.   
    7. template <class inputItr1, class inputItr2,class outputItr>  
    8. outputItr set_union(inputItr1 first1, inputItr1 last1, inputItr2 first2,inputItr2 last2,outputItr destFirst);  
    9. template <class inputItr1, class inputItr2,class outputItr,class binaryPredicate>  
    10. outputItr set_union(inputItr1 first1, inputItr1 last1, inputItr2 first2,inputItr2 last2,outputItr destFirst,binaryPredicate op);  

    示例代码:

    1. #include <iostream>  
    2. #include <list>  
    3.   
    4. #include <string>  
    5. #include <numeric>  
    6. #include <iterator>  
    7. #include <vector>  
    8. #include <functional>  
    9.   
    10. #include <algorithm>  
    11.   
    12. using namespace std;  
    13.   
    14. int main() {  
    15.     int setA[5] = {2,4,5,7,8};  
    16.     int setB[7] = {1,2,3,4,5,6,7};  
    17.     int setC[5] = {2,5,8,8,15};  
    18.     int setD[6] = {1,4,4,6,7,12};  
    19.     int AunionB[10];  
    20.     int AunionC[10];  
    21.     int BunionD[15];  
    22.     int AintersectB[10];  
    23.     int AintersectC[10];  
    24.   
    25.     int * lastElement;  
    26.     ostream_iterator<int> screen(cout," ");  
    27.     cout << "setA:" << endl;  
    28.     copy(setA,setA+5,screen);  
    29.     cout << endl;  
    30.     cout << "setB:" << endl;  
    31.     copy(setB,setB+7,screen);  
    32.     cout << endl;  
    33.     cout << "setC:" << endl;  
    34.     copy(setC,setC+5,screen);  
    35.     cout << endl;  
    36.     cout << "setD:" << endl;  
    37.     copy(setD,setD+6,screen);  
    38.     cout << endl;  
    39.   
    40.     // set_union  
    41.     lastElement = set_union(setA,setA+5,setB,setB+7,AunionB);  
    42.     cout << "AunionB:" << endl;  
    43.     copy(AunionB,lastElement,screen);  
    44.     cout << endl;  
    45.   
    46.     lastElement = set_union(setA,setA+5,setC,setC+5,AunionC);  
    47.     cout << "AunionC:" << endl;  
    48.     copy(AunionC,lastElement,screen);  
    49.     cout << endl;  
    50.   
    51.     lastElement = set_union(setB,setB+7,setD,setD+6,BunionD);  
    52.     cout << "BunionD:" << endl;  
    53.     copy(BunionD,lastElement,screen);  
    54.     cout << endl;  
    55.   
    56.     // set_intersection  
    57.     lastElement = set_intersection(setA, setA+5,setB,setB+7,AintersectB);  
    58.     cout << "AintersectB:" << endl;  
    59.     copy(AintersectB,lastElement,screen);  
    60.     cout << endl;  
    61.   
    62.     lastElement = set_intersection(setA, setA+5,setC,setC+5,AintersectC);  
    63.     cout << "AintersectC:" << endl;  
    64.     copy(AintersectC,lastElement,screen);  
    65.     cout << endl;  
    66.     return 0;  
    67. }  

    运行结果:

    charList:
    a b c d e
    charList:
    A B C D E
    list
    2 8 5 1 7 11 3
    4 16 10 2 14 22 6
    list
    4 16 10 2 14 22 6


    3 set_difference,set_symmetric_difference

    声明:
    1. #include <algorithm>  
    2. template <class inputItr1, class inputItr2,class outputItr>  
    3. outputItr set_difference(inputItr1 first1, inputItr1 last1, inputItr2 first2,inputItr2 last2,outputItr destFirst);  
    4. template <class inputItr1, class inputItr2,class outputItr,class binaryPredicate>  
    5. outputItr set_difference(inputItr1 first1, inputItr1 last1, inputItr2 first2,inputItr2 last2,outputItr destFirst,binaryPredicate op);  
    6.   
    7. template <class inputItr1, class inputItr2,class outputItr>  
    8. outputItr set_symmetric_difference(inputItr1 first1, inputItr1 last1, inputItr2 first2,inputItr2 last2,outputItr destFirst);  
    9. template <class inputItr1, class inputItr2,class outputItr,class binaryPredicate>  
    10. outputItr set_symmetric_difference(inputItr1 first1, inputItr1 last1, inputItr2 first2,inputItr2 last2,outputItr destFirst,binaryPredicate op);  

    示例代码:
    1. #include <iostream>  
    2. #include <list>  
    3.   
    4. #include <string>  
    5. #include <numeric>  
    6. #include <iterator>  
    7. #include <vector>  
    8. #include <functional>  
    9.   
    10. #include <algorithm>  
    11.   
    12. using namespace std;  
    13.   
    14. int main() {  
    15.     int setA[5] = {2,4,5,7,8};  
    16.     int setB[7] = {3,4,5,6,7,8,10};  
    17.     int setC[5] = {1,5,6,8,15};  
    18.   
    19.     int AdifferenceC[5];  
    20.     int BsymDiffC[10];  
    21.     int * lastElement;  
    22.     ostream_iterator<int> screen(cout," ");  
    23.     cout << "setA:" << endl;  
    24.     copy(setA,setA+5,screen);  
    25.     cout << endl;  
    26.     cout << "setB:" << endl;  
    27.     copy(setB,setB+7,screen);  
    28.     cout << endl;  
    29.     cout << "setC:" << endl;  
    30.     copy(setC,setC+5,screen);  
    31.     cout << endl;  
    32.   
    33.     // set_difference  
    34.     lastElement = set_difference(setA,setA+5,setC,setC+5,AdifferenceC);  
    35.     cout << "AdifferenceC:" << endl;  
    36.     copy(AdifferenceC,lastElement,screen);  
    37.     cout << endl;  
    38.   
    39.     // set_symmetric_differenc 对称差  
    40.     lastElement = set_symmetric_difference(setB,setB+7,setC,setC+5,BsymDiffC);  
    41.     cout << "BsymDiffC:" << endl;  
    42.     copy(BsymDiffC,lastElement,screen);  
    43.     cout << endl;  
    44.       
    45.     return 0;  
    46. }  
    运行结果:

    setA:
    2 4 5 7 8
    setB:
    3 4 5 6 7 8 10
    setC:
    1 5 6 8 15
    AdifferenceC:
    2 4 7
    BsymDiffC:
    1 3 4 7 10 15
    展开全文
  • set里面有set_intersection(取集合交集)、set_union(取集合并集)、set_difference(取集合差集)、set_symmetric_difference(取集合对称差集)等函数。其中,关于函数的五个参数问题做一下小结: 1、这几个...

    set里面有set_intersection(取集合交集)、set_union(取集合并集)、set_difference(取集合差集)、set_symmetric_difference(取集合对称差集)等函数。其中,关于函数的五个参数问题做一下小结:

    1、这几个函数的前四个参数一样,只有第五个参数有多重版本。

    2、EX1:set_union(A.begin(),A.end(),B.begin(),B.end(),inserter( C1 , C1.begin() ) );前四个参数依次是第一的集合的头尾,第二个集合的头尾。第五个参数的意思是将集合A、B取合集后的结果存入集合C中。

    EX2:set_union(A.begin(),A.end(),B.begin(),B.end(),ostream_iterator<int>(cout," “));这里的第五个参数的意思是将A、B取合集后的结果直接输出,(cout," ")双引号里面是输出你想用来间隔集合元素的符号或是空格。

    下面是set_union的原型:

    template<class InputIterator1, class InputIterator2, class OutputIterator>

    OutputIterator set_union(

    InputIterator1_First1 ,

    InputIterator1_Last1 ,

    InputIterator2_First2 ,

    InputIterator2_Last2 ,

    OutputIterator_Result

    );

    <span style="font-family:Comic Sans MS;font-size:18px;">/*Description
    集合的运算就是用给定的集合去指定新的集合。设A和B是集合,则它们的并差交补集分别定义如下:
    A∪B={x|x∈A∨x∈B}
    A∩B={x|x∈A∧x∈B}
    A-B={x|x∈A∧x不属于 B}
    SA ={x|x∈(A∪B)∧x 不属于A}
    SB ={x|x∈(A∪B)∧x 不属于B}
    <!--[endif]-->
    Input
    第一行输入一个正整数T,表示总共有T组测试数据。(T<=200)
    然后下面有2T行,每一行都有n+1个数字,其中第一个数字是n(0<=n<=100),表示该行后面还有n个数字输入。
    Output
    对于每组测试数据,首先输出测试数据序号,”Case #.NO”,
    接下来输出共7行,每行都是一个集合,
    前2行分别输出集合A、B,接下5行来分别输出集合A、B的并(A u B)、交(A n B)、差(A – B)、补。
    集合中的元素用“{}”扩起来,且元素之间用“, ”隔开。
    Sample Input
    1
    4 1 2 3 1
    0
    Sample Output
    Case# 1:
    A = {1, 2, 3}
    B = {}
    A u B = {1, 2, 3}
    A n B = {}
    A - B = {1, 2, 3}
    SA = {}
    SB = {1, 2, 3}
    */
    #include <iostream>
    #include <set>
    #include <algorithm>
    #include <iterator>
    using namespace std;
    int main()
    {
        set<int>A;
        set<int>B;
        set<int>C1;
        set<int>C2;
        set<int>C3;
        set<int>C4;
        set<int>C5;
        set<int>C6;
     
        set<int>::iterator pos;/// 定义迭代器,作用是输出set元素
        int count=0;
        int A_i,B_i,n,m;
        cin>>n;
        while(n--)
        {
            count++;
            cin>>A_i;
            while(A_i--)///输入集合A
            {
                cin>>m;
                A.insert(m);
            }
            cin>>B_i;///输入集合B
            while(B_i--)
            {
                cin>>m;
                B.insert(m);
            }
     
            cout<<"Case# "<<count<<":"<<endl;
     
            cout<<"A = {";
            for(pos=A.begin(); pos!=A.end(); pos++)///迭代器的作用
            {
                if(pos!=A.begin())cout<<", ";
                cout<<*pos;///迭代器的作用,迭代器是一种特殊的指针
            }
            cout<<"}"<<endl;
     
            cout<<"B = {";
            for(pos=B.begin(); pos!=B.end(); pos++)
            {
                if(pos!=B.begin())cout<<", ";
                cout<<*pos;
            }
            cout<<"}"<<endl;
     
            set_union(A.begin(),A.end(),B.begin(),B.end(),inserter( C1 , C1.begin() ) );    /*取并集运算*/
            //set_union(A.begin(),A.end(),B.begin(),B.end(),ostream_iterator<int>(cout," "));    /*取并集运算*/ //其中ostream_iterator的头文件是iterator
            cout<<"A u B = {";
            for(pos=C1.begin(); pos!=C1.end(); pos++)
            {
                if(pos!=C1.begin())cout<<", ";
                cout<<*pos;
            }
            cout<<"}"<<endl;
     
            set_intersection(A.begin(),A.end(),B.begin(),B.end(),inserter( C2 , C2.begin() ));    /*取交集运算*/
            cout<<"A n B = {";
            for(pos=C2.begin(); pos!=C2.end(); pos++)
            {
                if(pos!=C2.begin())cout<<", ";
                cout<<*pos;
            }
            cout<<"}"<<endl;
     
            set_difference( A.begin(), A.end(),B.begin(), B.end(),inserter( C3, C3.begin() ) );    /*取差集运算*/
            cout<<"A - B = {";
            for(pos=C3.begin(); pos!=C3.end(); pos++)
            {
                if(pos!=C3.begin())cout<<", ";
                cout<<*pos;
            }
            cout<<"}"<<endl;
     
            set_difference(C1.begin(),C1.end(), A.begin(), A.end(),inserter( C4, C4.begin() ) );/*取差集运算*/
            cout<<"SA = {";
            for(pos=C4.begin(); pos!=C4.end(); pos++)
            {
                if(pos!=C4.begin())cout<<", ";
                cout<<*pos;
            }
            cout<<"}"<<endl;
     
            set_difference(C1.begin(),C1.end(), B.begin(), B.end(),inserter( C5, C5.begin() ) );/*取差集运算*/
            cout<<"SB = {";
            for(pos=C5.begin(); pos!=C5.end(); pos++)
            {
                if(pos!=C5.begin())cout<<", ";
                cout<<*pos;
            }
            cout<<"}"<<endl;
     
            set_symmetric_difference(A.begin(),A.end(),B.begin(),B.end(),inserter( C6 , C6.begin() ) );///取 对称差集运算
            cout<<"A ⊕ B = {";
            for(pos=C6.begin(); pos!=C6.end(); pos++)
            {
                if(pos!=C6.begin())cout<<", ";
                cout<<*pos;
            }
            cout<<"}"<<endl;
     
            A.clear();
            B.clear();//各个集合清零,否则下次使用会出错
            C1.clear();
            C2.clear();
            C3.clear();
            C4.clear();
            C5.clear();
            C6.clear();
        }
    }
    

    https://blog.csdn.net/zangker/article/details/22984803 


    // set_union example(求并集可用)
    #include <iostream> // std::cout
    #include <algorithm> // std::set_union, std::sort
    #include <vector> // std::vector

    int main () {
      int first[] = {5,10,15,20,25};
      int second[] = {50,40,30,20,10};
      std::vector<int> v(10);                      // 0 0 0 0 0 0 0 0 0 0
      std::vector<int>::iterator it;

      std::sort (first,first+5);     // 5 10 15 20 25
      std::sort (second,second+5);   // 10 20 30 40 50

      it=std::set_union (first, first+5, second, second+5, v.begin());    
         // 5 10 15 20 25 30 40 50 0 0      //参数:求并集的两个集合(数组或者set等其他类型)的起止地址,最后一个参数是前两个集合并集的结果需要插入的地方
      v.resize(it-v.begin());                      // 5 10 15 20 25 30 40 50

      std::cout << "The union has " << (v.size()) << " elements:\n";
      for (it=v.begin(); it!=v.end(); ++it)
        std::cout << ' ' << *it;
      std::cout << '\n';

      return 0;

    }

    output

     

    The union has 8 elements:
     5 10 15 20 25 30 40 50
    

     

    以上来自http://www.cplusplus.com/reference/algorithm/set_union/?kw=set_union;

    set_union可以对任意类型起作用。

    返回值是最后一个插入的位置。

    #include<bits/stdc++.h>
    using namespace std;
    int main()
    {
        set<int>x1;
        x1.insert(1);
        x1.insert(2);
        x1.insert(3);
        set<int>x2;
        x2.insert(1);
        x2.insert(4);
        set<int>x;
       set_union(x1.begin(),x1.end(),x2.begin(),x2.end(),inserter(x,x.begin()));    
        for(set<int>::iterator it=x.begin();it!=x.end();it++)
            cout<<*it<<' ';
        cout<<endl;
    }

    输出:1 2 3 4

     

    set_intersection:(求交集可用)

    #include<bits/stdc++.h>
    using namespace std;
    int main()
    {
        set<int>x1;
        x1.insert(1);
        x1.insert(2);
        x1.insert(3);
        set<int>x2;
        x2.insert(1);
        x2.insert(4);
        set<int>x;
        set_intersection(x1.begin(),x1.end(),x2.begin(),x2.end(),inserter(x,x.begin())); 
        for(set<int>::iterator it=x.begin();it!=x.end();it++)
            cout<<*it<<' ';
        cout<<endl;
    }

    输出:1

    https://blog.csdn.net/frankax/article/details/54880890


    集合A,B。(可以使用数组、list、vector)
    头文件:#include<algorithm>
    前提:两个集合已经有序。
    merge() //归并两个序列,元素总个数不变,只是将两个有序序列归并为一个有序序列。
    set_union() //实现求集合A,B的并。
    set_difference()//实现求集合A,B的差(即A—B)
    set_symmetric_difference()//实现求集合A,B的对称差(即(A-B)并(B-A))
    set_intersection()//实现求集合A,B交集。
     
    //集合运算
    //熊八八
    //2013-3-15
     
    #include<iostream>
    #include<stdio.h>
    #include<list>
    #include<algorithm>            //set_union求并集
    using namespace std;
     
    template<class T>
    void Print(T List)
    {
           class T::iterator iter;
           for(iter=List.begin(); iter!=List.end(); iter++)
                  printf("%d ", *iter);
           printf("\n");
    }
    int main()
    {
           list<int> List_A;
           list<int> List_B;
           int temp;
           printf("Enter 5 integers into List_A:\n");
           for(int i=0; i<5; i++)
           {
                  scanf("%d", &temp);
                  List_A.push_back(temp);
           }
           //printf("Enter some integers into List_B:\n");
           for(int i=0; i<5; i++)
           {
                  scanf("%d", &temp);
                  List_B.push_back(temp);
           }
          
           List_A.sort();
           List_B.sort();
          
           list<int> List_C(10);
           //不能将操作后的结果重新放入List_A或者List_B.如果非要如此,可以设一中间变量List_C,先将结果存储至List_C,然后List_A = List_C
           //merge(List_A.begin(), List_A.end(), List_B.begin(), List_B.end(), List_C.begin()); //合并
           //set_union(List_A.begin(), List_A.end(), List_B.begin(), List_B.end(), List_C.begin());//并集
           //set_difference(List_A.begin(), List_A.end(), List_B.begin(), List_B.end(), List_C.begin());//差集
           //set_symmetric_difference(List_A.begin(), List_A.end(), List_B.begin(), List_B.end(), List_C.begin());//对称差
           set_intersection(List_A.begin(), List_A.end(), List_B.begin(), List_B.end(), List_C.begin());//交集
          
           printf("List_A contains:\n");
           Print(List_A);
           printf("List_B contains:\n");
           Print(List_B);
           printf("List_C contains:\n");
           Print(List_C);
           system("pause");
           return 0;
    }

    https://blog.csdn.net/CillyB/article/details/60993193


    如上。

    展开全文
  • STL set中有set_union(取两集合并集)、set_intersection(取两集合交集)、set_difference(取两集合差集)。 1、这几个函数的参数一样。 2、set_union(x1.begin(), x1.end(), x2.begin(), x2.end(), inserter(x, x....

    STL set中有set_union(取两集合并集)、set_intersection(取两集合交集)、set_difference(取两集合差集)。

    1、这几个函数的参数一样。
    2、set_union(x1.begin(), x1.end(), x2.begin(), x2.end(), inserter(x, x.begin())),前两个参数是集合x1的头尾,再依次是集合x2的头尾,最后一个参数就是将集合x1和集合x2取合集后存入集合x中。
    当使用set_intersection()规定两个区间必须是有序的。

    具体介绍如下:

     set_intersection

     

    两个排序范围的交点

    构造一个从result指向的位置开始的排序范围,以及两个排序范围的集合交集。 两组的交集仅由两组中存在的元素形成。函数复制的元素始终来自第一个范围,顺序相同。 使用第一个版本的元素和第二个版本的comp进行比较。两个元素,[first1,last1)[first2,last2)



    operator<一个 和 b如果(!(a<b) && !(b<a))或如果,则视为等效(!comp(a,b) && !comp(b,a))

    范围内的元素必须按照相同的标准(operator<或comp)进行排序。结果范围也根据此进行排序。(即两个集合的排列大小的顺序必须相同)

    此函数模板的行为等效于:

    template <class InputIterator1, class InputIterator2, class OutputIterator>
      OutputIterator set_intersection (InputIterator1 first1, InputIterator1 last1,
                                       InputIterator2 first2, InputIterator2 last2,
                                       OutputIterator result)
    {
      while (first1!=last1 && first2!=last2)
      {
        if (*first1<*first2) ++first1;
        else if (*first2<*first1) ++first2;
        else {
          *result = *first1;
          ++result; ++first1; ++first2;
        }
      }
      return result;
    }

    参数

    first1,last1

    将迭代器输入到第一个排序序列的初始位置和最终位置。使用的范围是[first1,last1),包含first1和last1之间的所有元素,包括first1指向的元素,但不包括last1指向的元素。

    first2,last2

    将迭代器输入到第二个排序序列的初始位置和最终位置。使用的范围是[first2,last2)

    结果

    将迭代器输出到存储结果序列的范围的初始位置。
    指向类型应支持从第一个范围分配元素的值。

    参数

    first1,last1

    将迭代器输入到第一个排序序列的初始位置和最终位置。使用的范围是[first1,last1),包含first1和last1之间的所有元素,包括first1指向的元素,但不包括last1指向的元素。

    first2,last2

    将迭代器输入到第二个排序序列的初始位置和最终位置。使用的范围是[first2,last2)

    结果

    将迭代器输出到存储结果序列的范围的初始位置。
    指向类型应支持从第一个范围分配元素的值。

    返回值

    构造范围末尾的迭代器。

    // set_intersection example
    #include <iostream>     // std::cout
    #include <algorithm>    // std::set_intersection, std::sort
    #include <vector>       // std::vector
    
    int main () {
      int first[] = {5,10,15,20,25};
      int second[] = {50,40,30,20,10};
      std::vector<int> v(10);                      // 0  0  0  0  0  0  0  0  0  0
      std::vector<int>::iterator it;
    
      std::sort (first,first+5);     //  5 10 15 20 25
      std::sort (second,second+5);   // 10 20 30 40 50
    
      it=std::set_intersection (first, first+5, second, second+5, v.begin());
                                                   // 10 20 0  0  0  0  0  0  0  0
      v.resize(it-v.begin());                      // 10 20
    
      std::cout << "The intersection has " << (v.size()) << " elements:\n";
      for (it=v.begin(); it!=v.end(); ++it)
        std::cout << ' ' << *it;
      std::cout << '\n';
    
      return 0;
    }
    输出10 20

    set_union 

     

    并集

    联合两个排序范围

    构造一个从result指向的位置开始的排序范围,以及两个排序范围的集合[first1,last1)[first2,last2)

    两组的并集由存在于任一组中的元素形成,或者由两者组成。第二个范围中具有第一个范围中的等效元素的元素不会复制到结果范围。

    使用operator<第一个版本的元素和第二个版本的comp进行比较。两个元素,一个 和 b如果(!(a<b) && !(b<a))或如果,则视为等效(!comp(a,b) && !comp(b,a))

    范围内的元素必须按照相同的标准(operator<或comp)进行排序。结果范围也根据此进行排序。

    此函数模板的行为等效于:

    template <class InputIterator1, class InputIterator2, class OutputIterator>
      OutputIterator set_union (InputIterator1 first1, InputIterator1 last1,
                                InputIterator2 first2, InputIterator2 last2,
                                OutputIterator result)
    {
      while (true)
      {
        if (first1==last1) return std::copy(first2,last2,result);
        if (first2==last2) return std::copy(first1,last1,result);
    
        if (*first1<*first2) { *result = *first1; ++first1; }
        else if (*first2<*first1) { *result = *first2; ++first2; }
        else { *result = *first1; ++first1; ++first2; }
        ++result;
      }
    }

    first1,last1

    将迭代器输入到第一个排序序列的初始位置和最终位置。使用的范围是[first1,last1),包含first1和last1之间的所有元素,包括first1指向的元素,但不包括last1指向的元素。

    first2,last2

    将迭代器输入到第二个排序序列的初始位置和最终位置。使用的范围是[first2,last2)

    结果

    将迭代器输出到存储结果序列的范围的初始位置。
    指向的类型应支持从其他范围分配元素的值。

    范围不得重叠。

     

    返回值

    构造范围末尾的迭代器。

    // set_union example
    #include <iostream>     // std::cout
    #include <algorithm>    // std::set_union, std::sort
    #include <vector>       // std::vector
    
    int main () {
      int first[] = {5,10,15,20,25};
      int second[] = {50,40,30,20,10};
      std::vector<int> v(10);                      // 0  0  0  0  0  0  0  0  0  0
      std::vector<int>::iterator it;
    
      std::sort (first,first+5);     //  5 10 15 20 25
      std::sort (second,second+5);   // 10 20 30 40 50
    
      it=std::set_union (first, first+5, second, second+5, v.begin());
                                                   // 5 10 15 20 25 30 40 50  0  0
      v.resize(it-v.begin());                      // 5 10 15 20 25 30 40 50
    
      std::cout << "The union has " << (v.size()) << " elements:\n";
      for (it=v.begin(); it!=v.end(); ++it)
        std::cout << ' ' << *it;
      std::cout << '\n';
    
      return 0;
    }
    输出5 10 15 20 25 30 40 50

    set_difference

     

    差集

    两个排序范围的差异

    构造从result指向的位置开始的排序范围,其中排序范围相对于排序范围的设置差异。 两组的差异由第一组中存在的元素形成,但不存在于第二组中。函数复制的元素始终来自第一个范围,顺序相同。 对于支持多次出现的值的容器,差异包括与第一个范围中一样多的给定值的出现,减去第二个保留顺序中的匹配元素的数量。 请注意,这是一个方向性操作 - 对于对称的等效操作,请参阅[first1,last1)[first2,last2)


    set_symmetric_difference

    使用operator<第一个版本的元素和第二个版本的comp进行比较。两个元素,一个 和 b如果(!(a<b) && !(b<a))或如果,则视为等效(!comp(a,b) && !comp(b,a))

    范围内的元素必须按照相同的标准(operator<或comp)进行排序。结果范围也根据此进行排序。

    此函数模板的行为等效于

    ​template <class InputIterator1, class InputIterator2, class OutputIterator>
      OutputIterator set_difference (InputIterator1 first1, InputIterator1 last1,
                                     InputIterator2 first2, InputIterator2 last2,
                                     OutputIterator result)
    {
      while (first1!=last1 && first2!=last2)
      {
        if (*first1<*first2) { *result = *first1; ++result; ++first1; }
        else if (*first2<*first1) ++first2;
        else { ++first1; ++first2; }
      }
      return std::copy(first1,last1,result);
    }​

    first1,last1

    将迭代器输入到第一个排序序列的初始位置和最终位置。使用的范围是[first1,last1),包含first1和last1之间的所有元素,包括first1指向的元素,但不包括last1指向的元素。

    first2,last2

    将迭代器输入到第二个排序序列的初始位置和最终位置。使用的范围是[first2,last2)

    结果

    将迭代器输出到存储结果序列的范围的初始位置。
    指向类型应支持从第一个范围分配元素的值。

    范围不得重叠。

     

    返回值

    构造范围末尾的迭代器。

    // set_difference example
    #include <iostream>     // std::cout
    #include <algorithm>    // std::set_difference, std::sort
    #include <vector>       // std::vector
    
    int main () {
      int first[] = {5,10,15,20,25};
      int second[] = {50,40,30,20,10};
      std::vector<int> v(10);                      // 0  0  0  0  0  0  0  0  0  0
      std::vector<int>::iterator it;
    
      std::sort (first,first+5);     //  5 10 15 20 25
      std::sort (second,second+5);   // 10 20 30 40 50
    
      it=std::set_difference (first, first+5, second, second+5, v.begin());
                                                   //  5 15 25  0  0  0  0  0  0  0
      v.resize(it-v.begin());                      //  5 15 25
    
      std::cout << "The difference has " << (v.size()) << " elements:\n";
      for (it=v.begin(); it!=v.end(); ++it)
        std::cout << ' ' << *it;
      std::cout << '\n';
    
      return 0;
    }

    输出:

    差异有3个要素:
     5 15 25

     

    set_symmetric_difference

     

    对称差集

    两个排序范围的对称差异

    构造一个从result指向的位置开始的排序范围,以及两个排序范围的设置对称差异。 两组的对称差异由一组中存在的元素形成,而另一组中不存在。在每个范围中的等效元素中,丢弃的那些是在调用之前以现有顺序出现的那些元素。还会为复制的元素保留现有顺序。 使用第一个版本的元素和第二个版本的comp进行比较。两个元素,[first1,last1)[first2,last2)



    operator<一个 和 b如果(!(a<b) && !(b<a))或如果,则视为等效(!comp(a,b) && !comp(b,a))

    范围内的元素必须按照相同的标准(operator<或comp)进行排序。结果范围也根据此进行排序。

    此函数模板的行为等效于:

     

    template <class InputIterator1, class InputIterator2, class OutputIterator>
      OutputIterator set_symmetric_difference (InputIterator1 first1, InputIterator1 last1,
                                               InputIterator2 first2, InputIterator2 last2,
                                               OutputIterator result)
    {
      while (true)
      {
        if (first1==last1) return std::copy(first2,last2,result);
        if (first2==last2) return std::copy(first1,last1,result);
    
        if (*first1<*first2) { *result=*first1; ++result; ++first1; }
        else if (*first2<*first1) { *result = *first2; ++result; ++first2; }
        else { ++first1; ++first2; }
      }
    }

     

     

    参数

    first1,last1

    将迭代器输入到第一个排序序列的初始位置和最终位置。使用的范围是[first1,last1),包含first1和last1之间的所有元素,包括first1指向的元素,但不包括last1指向的元素。

    first2,last2

    将迭代器输入到第二个排序序列的初始位置和最终位置。使用的范围是[first2,last2)

    结果

    将迭代器输出到存储结果序列的范围的初始位置。
    指向的类型应支持从其他范围分配元素的值

    范围不得重叠。

     

    返回值

    构造范围末尾的迭代器。

    // set_symmetric_difference example
    #include <iostream>     // std::cout
    #include <algorithm>    // std::set_symmetric_difference, std::sort
    #include <vector>       // std::vector
    
    int main () {
      int first[] = {5,10,15,20,25};
      int second[] = {50,40,30,20,10};
      std::vector<int> v(10);                      // 0  0  0  0  0  0  0  0  0  0
      std::vector<int>::iterator it;
    
      std::sort (first,first+5);     //  5 10 15 20 25
      std::sort (second,second+5);   // 10 20 30 40 50
    
      it=std::set_symmetric_difference (first, first+5, second, second+5, v.begin());
                                                   //  5 15 25 30 40 50  0  0  0  0
      v.resize(it-v.begin());                      //  5 15 25 30 40 50
    
      std::cout << "The symmetric difference has " << (v.size()) << " elements:\n";
      for (it=v.begin(); it!=v.end(); ++it)
        std::cout << ' ' << *it;
      std::cout << '\n';
    
      return 0;
    }
    编辑并运行
    

     

    输出:

    对称差异有6个要素:
     5 15 25 30 40 50
    

    merge

    合并已排序的范围

    结合的元素在排序的区间[first1,last1)[first2,last2),进入一个新的开始范围在结果与它的所有元素进行排序。

    使用operator<第一个版本的元素和第二个版本的comp进行比较。两个范围内的元素必须按照相同的标准(operator<或comp)进行排序。结果范围也根据此进行排序。

    此函数模板的行为等效于:

    template <class InputIterator1, class InputIterator2, class OutputIterator>
      OutputIterator merge (InputIterator1 first1, InputIterator1 last1,
                            InputIterator2 first2, InputIterator2 last2,
                            OutputIterator result)
    {
      while (true) {
        if (first1==last1) return std::copy(first2,last2,result);
        if (first2==last2) return std::copy(first1,last1,result);
        *result++ = (*first2<*first1)? *first2++ : *first1++;
      }
    }

    参数

    first1,last1

    将迭代器输入到第一个排序序列的初始位置和最终位置。使用的范围是[first1,last1),包含first1和last1之间的所有元素,包括first1指向的元素,但不包括last1指向的元素。

    first2,last2

    将迭代器输入到第二个排序序列的初始位置和最终位置。使用的范围是[first2,last2)

    结果

    将迭代器输出到存储结果组合范围的范围的初始位置。它的大小等于上述两个范围的总和。

    范围不得重叠。
    两个输入范围中的元素应该可以分配给result指向的范围内的元素。它们也应该具有可比性(operator<对于(1),对于(2)的comp)。

     

    返回值

    一个迭代器,指向结果序列中的past-the-end元素。

    // merge algorithm example
    #include <iostream>     // std::cout
    #include <algorithm>    // std::merge, std::sort
    #include <vector>       // std::vector
    
    int main () {
      int first[] = {5,10,15,20,25};
      int second[] = {50,40,30,20,10};
      std::vector<int> v(10);
    
      std::sort (first,first+5);
      std::sort (second,second+5);
      std::merge (first,first+5,second,second+5,v.begin());
    
      std::cout << "The resulting vector contains:";
      for (std::vector<int>::iterator it=v.begin(); it!=v.end(); ++it)
        std::cout << ' ' << *it;
      std::cout << '\n';
    
      return 0;
    }
    编辑并运行
    

     

    输出:

    得到的载体含有:5 10 10 15 20 20 25 30 40 50

     

    展开全文
  • C++集合运算函数总结 集合A,B。(可以使用数组、list、vector) 头文件:#include 前提:两个集合已经有序。 merge() //归并两个序列...set_difference()//实现求集合A,B的差(即A—B) set_symmetric_differen

    C++集合运算函数总结

    集合A,B。(可以使用数组、list、vector)
    头文件:#include<algorithm>
    前提:两个集合已经有序。
    merge() //归并两个序列,元素总个数不变,只是将两个有序序列归并为一个有序序列。
    set_union() //实现求集合A,B的并。
    set_difference()//实现求集合A,B的差(即A—B)
    set_symmetric_difference()//实现求集合A,B的对称差(即(A-B)并(B-A))
    set_intersection()//实现求集合A,B交集。
     
    //集合运算
    //熊八八
    //2013-3-15
     
    #include<iostream>
    #include<stdio.h>
    #include<list>
    #include<algorithm>            //set_union求并集
    using namespace std;
     
    template<class T>
    void Print(T List)
    {
           class T::iterator iter;
           for(iter=List.begin(); iter!=List.end(); iter++)
                  printf("%d ", *iter);
           printf("\n");
    }
    int main()
    {
           list<int> List_A;
           list<int> List_B;
           int temp;
           printf("Enter 5 integers into List_A:\n");
           for(int i=0; i<5; i++)
           {
                  scanf("%d", &temp);
                  List_A.push_back(temp);
           }
           //printf("Enter some integers into List_B:\n");
           for(int i=0; i<5; i++)
           {
                  scanf("%d", &temp);
                  List_B.push_back(temp);
           }
          
           List_A.sort();
           List_B.sort();
          
           list<int> List_C(10);
           //不能将操作后的结果重新放入List_A或者List_B.如果非要如此,可以设一中间变量List_C,先将结果存储至List_C,然后List_A = List_C
           //merge(List_A.begin(), List_A.end(), List_B.begin(), List_B.end(), List_C.begin()); //合并
           //set_union(List_A.begin(), List_A.end(), List_B.begin(), List_B.end(), List_C.begin());//并集
           //set_difference(List_A.begin(), List_A.end(), List_B.begin(), List_B.end(), List_C.begin());//差集
           //set_symmetric_difference(List_A.begin(), List_A.end(), List_B.begin(), List_B.end(), List_C.begin());//对称差
           set_intersection(List_A.begin(), List_A.end(), List_B.begin(), List_B.end(), List_C.begin());//交集
          
           printf("List_A contains:\n");
           Print(List_A);
           printf("List_B contains:\n");
           Print(List_B);
           printf("List_C contains:\n");
           Print(List_C);
           system("pause");
           return 0;
    }

     


    set容器使用时这样比较常用吧

                set_intersection(x.begin(), x.end(), y.begin(), y.end(), inserter(z, z.end()));
                ....

    展开全文
  • set_union:并集 set_intersection:交集 set_difference:求两个集合的差集,结果集合中包含所有属于第一个集合但不属于第二个集合的元素。
  • 原文 以下是STL algorithm的几...set_difference 这个是求得在第一个容器中有,第二个容器中没有的。set_intersection 求两个容器的交, set_union 求两个容器的并。 set_symmetric_difference 求两个容器的差。 最后
  • 文章目录0 常用集合算法简介【set_intersection、set_union、set_difference】1 set_intersection【将两个容器的交集存储至新容器】2 set_union【将两个容器的并集存储至新容器】3 set_difference【将两个容器的差集...
  • set_difference用法:  v3.resize(v1.size() + v2.size());  std::sort(v1.begin(), v1.end(), [](int a, int b){return a  std::sort(v2.begin(), v2.end(), [](int a, int b){return a  auto it
  • set_difference:求两个容器的差集 这3个算法均由algorithm头文件提供。 set_intersection 函数原型:set_intersection(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest) 作用:将容器1和...
  • template<classInputIterator1,classInputIterator2,classOutputIterator>OutputIterator set_difference(InputIterator1first1,InputIterator1last1,...
  • STL set中有set_union(取两集合并集)、set_intersection(取两集合交集)、set_difference(取两集合差集)。 #include "stdafx.h" #include &lt;iostream&gt; #include &lt;algorithm&gt; #...
  • >1.set_intersection() //将两个容器的交集放到目标容器中 >2.set_union() //将两个容器的并集放到目标容器中 >3.set_difference() //将两个容器的差集放到目标容器中
  • 每次都会进行查找理解,这次参考了http://blog.csdn.net/zangker/article/details/22984803的博客...STL set中有set_union(取两集合并集)、set_intersection(取两集合交集)、set_difference(取两集合差集)。...
  • C++ STL accumulate fill算术生成算法 和 set_intersection set_union set_difference集合操作算法 #include<iostream> #include<vector> #include<iterator> #include<algorithm> #include...
  • set_difference

    千次阅读 2011-10-31 16:22:49
    // set_difference.cpp -- 2011-10-05-13.56 #include "stdafx.h" #include #include #include #include using std ::vector ; using std ::greater ; template class Print { public: void op
  • //set_union #include #include #include #include #include #include using namespace std; bool fanxu(int a,int b){ return a; } int main(){ int a[]={1,2,2,4,6,7,7,9}; int b[]={2,2
  • set_difference(inputIterator1 first1, inputIterator1 last1,  inputIterator2 first2, inputIterator2 last2,  outputIterator first);   template, class inputIterator2,  class ...
  • set_difference原型: std::set_difference default (1) template OutputIterator set_difference (InputIterator1 first1, InputIterator1 last1, InputItera
  • 需要的头文件: algorithm源码://源码比较复杂,不予列出 //有兴趣的可以参考sgi stl的源码作用: 计算两个集合的并集、交集、差集、对称差集。 通过二元仿函数我们可以取代 operator<例子...#include <set> #in
  • set_unition(并集),set_intersection(交集),set_difference(差集) 3 个函数的写法 set_??(a.begin(),a.end(),b.begin(),b.end(),inserter(x,x.begin()); #include #include #include #include using namespace ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,757
精华内容 2,702
关键字:

set_difference