2. 程式人生 > >STL 演算法vector/set集合-交集,並集,差集,對稱差

STL 演算法vector/set集合-交集,並集,差集,對稱差

阿新 • • 發佈：2019-02-08
針對這裡提及的四個集合運算必須特別注意： 
1、第一個演算法需保證第一集合和第二集合有序，並從小到大排序，內部使用預設“<”操作符比較元素大小； 

2、第二個演算法需保證第一集合和第二集合有序，排序方式參照Compare確定，內部使用Compare比較元素大小。

1 -- set_intersection(交集)

template <class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator set_intersection(InputIterator1 first1, InputIterator1 last1,
                    InputIterator2 first2, InputIterator2 last2,
                    OutputIterator result);

template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
OutputIterator set_intersection(InputIterator1 first1, InputIterator1 last1,
                    InputIterator2 first2, InputIterator2 last2,
                    OutputIterator result, Compare comp);

該函式用於求兩個集合的交集，結果集合中包含所有同時屬於第一個集合和第二個集合的元素。例如：集合{1,2,3,7,9}和{3,4,5,7}的交集為{3,7}。 
函式返回值：結果集合的結束位置的back_insert_iterator(和普通的迭代器不樣)。
引數：

（第一個集合的開始位置，第一個集合的結束位置，第二個引數的開始位置，第二個引數的結束位置，結果集合的插入迭代器（inserter(result, result.begin())））

對於第二個演算法，Compare指定用於比較元素大小的仿函式。 

2 -- set_union(並集)

template <class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator set_union(InputIterator1 first1, InputIterator1 last1,
                    InputIterator2 first2, InputIterator2 last2,
                    OutputIterator result);

template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
OutputIterator set_union(InputIterator1 first1, InputIterator1 last1,
                    InputIterator2 first2, InputIterator2 last2,
                    OutputIterator result, Compare comp);
該函式用於求兩個集合的交集，結果集合中包含所有同時屬於第一個集合和第二個集合的元素。例如：集合{1,2,3,7,9}和{3,4,5,7}的並集為{1,2,3,4,5,7}。 

3 -- set_difference(差集)

template <class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator set_difference(InputIterator1 first1, InputIterator1 last1,
                    InputIterator2 first2, InputIterator2 last2,
                    OutputIterator result);

template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
OutputIterator set_difference(InputIterator1 first1, InputIterator1 last1,
                    InputIterator2 first2, InputIterator2 last2,
                    OutputIterator result, Compare comp);
該函式用於求兩個集合的差集，結果集合中包含所有屬於第一個集合但不屬於第二個集合的元素。例如：集合{1,2,3,7,9}和{3,4,5,7}的差集為{1,2,9}。
該函式用於求兩個集合的差集，結果集合中包含所有屬於第一個集合但不屬於第二個集合的元素。例如：集合{1,2,3,7,9}和{3,4,5,7}的差集為{1,2,9}。 

4 -- set_symeetric_difference(對稱差集)

template<class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
                    InputIterator2 first2, InputIterator2 last2,
                    OutputIterator result);

template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
OutputIterator set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
                    InputIterator2 first2,
                    InputIterator2 last2,
                    OutputIterator result, Compare comp);
數學上，兩個集合的對稱差集是隻屬於其中一個集合，而不屬於另一個集合的元素組成的集合。也就是說對稱差集是去除同時出現在兩個集合中的元素後，兩集合其他元素組成的集合。例如：集合{1,2,3,7,9}和{3,4,5,7}的對稱差為{1,2,4,5,9}。集合論中的這個運算相當於布林邏輯中的異或運算。集合A和B的對稱差通常表示為AΔB。 

應用舉例（以並集為例）：

第一類--兩個陣列求並：

// set_union example
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

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

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

  set_union (first, first+5, second, second+5, inserter(v, v.begin()));
                                               // 5 10 15 20 25 30 40 50  0  0
  for(vector<int>::iterator it=v.begin();it!=v.end();it++)
        cout<<*it<<" ";
  return 0;
}

 第二類兩個set求並： 
#include <set>
#include <iterator>
#include <iostream>
#include <algorithm>
using namespace std;


int main(void)
{
    set<int> a,b,c;   //c也可以定義成vector
    a.insert(1);
    a.insert(6);
    a.insert(6);
    b.insert(2);
    b.insert(6);
    b.insert(9);


    //最後一個引數若使用c.begin()會產生編譯錯誤assignment of read-only localtion.


    set_union(a.begin(), a.end(), b.begin(), b.end(), inserter(c, c.begin()));
    for(set<int>::iterator it=c.begin();it!=c.end();it++)
        cout<<*it<<" ";


    return 0;
}

第三類--兩個vector之間求並： 
#include <vector>
#include <iterator>
#include <iostream>
#include <algorithm>
using namespace std;

int main()
{
    vector<int> a,b,c;
    for(int e=0;e<10;e++)
    {
       a.push_back(e);
       b.push_back(e+5);
    }
    //最後一個引數若使用c.begin(),執行時會出錯“Segmentation fault (core dumped)”.
    set_union(a.begin(),a.end(),b.begin(),b.end(),inserter(c, c.begin()));
    for(vector<int>::iterator it=c.begin();it!=c.end();it++)
        cout<<*it<<" ";
    return 0;
}

注意事項：函式引數的最後一個引數是插入迭代器，是因為這個函式內部有對結果集合的插入過程，必須用到插入函式，若不需要插入就用普通迭代器即可，就提前就把結果集合的記憶體空間擴大。

比如：

#include <vector>
#include <iterator>
#include <iostream>
#include <algorithm>
using namespace std;

int main()
{
    vector<int> a,b,c(20);  //初始化c中有20個0
    for(int e=0;e<10;e++)
    {
       a.push_back(e);
       b.push_back(e+5);
    }
    //最後一個引數若使用c.begin(),執行時會出錯“Segmentation fault (core dumped)”.
    set_union(a.begin(),a.end(),b.begin(),b.end(),c.begin());
    for(vector<int>::iterator it=c.begin();it!=c.end();it++)
        cout<<*it<<" ";
    return 0;
}


若改為c（3）會出現3個元素，最後RE。


此時函式的最後一個引數是普通迭代器，函式的返回值也不再是插入迭代器，也變成了普通迭代器（指向結果集合的最後一個插入元素（非0的））

比如：

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

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

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

  it=set_union (first, first+5, second, second+5,v.begin());// 5 10 15 20 25 30 40 50  0  0
//如果v.begin()改成inserter(v, v.begin())，函式返回值是插入迭代器，就會出現編譯錯誤，錯誤資訊：
/*E:\Users\amdi\Desktop\zuoye.cpp|165|error: no match for 'operator=' (operand types are 'std::vector<int>::iterator {  aka __gnu_cxx::__normal_iterator<int*, std::vector<int> >}' and 'std::insert_iterator<std::vector<int> >')| */
  cout << "union has " << int(it - v.begin()) << " elements.\n";
  return 0;
}

所以求結果集合的元素個數除了用result.size()以外，也可以用以上程式的方法，不過建議還是用插入迭代器，用result.size（）畢竟用普通迭代器的問題範圍小，而且不方便（我們可能不想去預知結果集合的大小）。

相關推薦

STL 演算法vector/set集合-交集,並集,差集,對稱差

針對這裡提及的四個集合運算必須特別注意： 1、第一個演算法需保證第一集合和第二集合有序，並從小到大排序，內部使用預設“<”操作符比較元素大小； 2、第二個演算法需保證第一集合和第二集合有序，排序方式參照Compare確定，內部使用Compare比較元素大小。 1 --

1063 Set Similarity （25 分）求集合交集並集比值

題目 Given two sets of integers, the similarity of the sets is defined to be N

C++ vector去重 交集 並集

原文： yongh701 https://blog.csdn.net/yongh701/article/details/51406458 C++雖然對vector封裝了大量的函式，比如判斷元素是否在vector中find、去重的unique，還有在algorithm類中對兩

list集合交集 並集 補集

前戲： 公司有個流程是這樣的，有四條流程，一條流程四個節點。在每個流程第四個節點操作完後，複製當前節點的“疑點”資料至下一流程的節點。本來這是個很簡單的功能，但是當上一條流程的節點資料更改後要同步到下一流程的首節點。原來的做法是刪除下一節點的所以資料，重新插入上一節點的全部

STL vector/set集合運算

經常用的集合運算有四種： 求交集  set_intersection(a.begin(),a.end(),b.begin(),b.end(),inserter(c,c.begin()) 求並集  set_union(a.begin(),a.end(),b.begin(),

C++ STL 有關於SET集合部分 的自定義資料型別的排序 以及 pair的使用

#include<iostream> using namespace std; #include"set" //set集合容器的標頭檔案 #include<functional> //用於識別set從大到小中greater的識別 /*知識點集合*/

資料探勘--協同過濾演算法，基於集合交集相似性計算的mapreduce演算法設計

第一個過程程的mapreduce函式： import java.io.File; import java.io.IOException; import java.util.ArrayList; import java.util.Iterator; import j

Python set運算 集合差集，並集，交集，list去重復

bsp 一行 color nbsp 方便 移除 line pytho 差集 在沒有發現方便的set運算之前，都是用遍歷list查找兩個集合的差別。 比如, 找list1和list2的差集 for i in list1: if not i in list2:

Java之兩個Set集合的交集、差集和並集

一、求交集 注：場景是讀取兩個檔案，把檔案內容放到Set中，求兩個檔案之間的共同元素。在這裡只寫對Set的操作。 public static void main(String[] args) throws Exception { String path1 = "pat

JS資料結構與演算法 —— 集合，並集，交集，補集

概念：集合是由一組無序且唯一（每個元素只出現一次）的項組成的一組資料。其與數學裡的集合是同一個概念。在ES6裡已經引入了集合的資料結構概念——Set類。 分類：常見的有空集，並集，交集，差集。 應用場景：1）資料去重；2）用於儲存一些獨一無二的資料。 js實現一個集合 集合的特性

STL集合的並集、交集、差集、對稱差集

STL一共提供了四種set相關的演算法，分別是並集(union)，交集(intersection)，差集(difference)，和對稱差集(symmetric difference)。 STL的這四個演算法所接受的set必須是有序區間，元素可以重複出現。即他們只能接受se

C# 取兩個集合的交集並集差集

兩個 color pre str exce class 並集 blog span 交集：Intersect 並集：Union 差集：Except var A= new List() { 1, 2, 3, 4, 5, 6 }; var B= new List() { 3

已知兩個連結串列A和B分別表示兩個集合，其元素遞增排列。請設計演算法求出兩個集合A和B的差集（即僅由在A中出現而不在B中出現的元素所構成的集合），並以同樣的形式儲存，同時返回該集合的元素個數。

語言：C++ #include <iostream> using namespace std; typedef struct LNode { int data; LNode *next; }LNode,*LinkList; //建立連結串列 int CreateList(Li

Java中使用Set進行並集，差集，交集查詢

利用Java中使用Set進行並集，差集，交集查詢 首先命名一個類名為DealSet存放查詢並集，差集，交集的方法 DealSet.java package SetLearning; import java.util.HashSet; import java.util.Set; p

[Python]集合的交集，並集，差集

前提：測試中需要給某些應用設定黑名單，所以從.txt檔案中求兩者的差集，就可以篩選出需要測試的應用 思路：將.txt檔案中的資料讀到列表中，求列表的集合，再輸出到指定目錄 集合的思路： a = [1,2,3,4,5,6] b = [5,6,7] c = [] ①交集 c = [i for i i

離散數學-集合的交併差集運算--STL-set類

程式碼其實很簡單，我們只需要知道set類的使用方法就可以了，比如迭代器的定義（ set<T>::iterator it=a.begin() ），和簡單的insert函式插入，以及find函式找到時返回對應的迭代器，找不到時返回該set的end。 #include <iostre

集合去重，取交集並集差值

最好的方式是用set集合做並集，CollectionUtils封裝，union底部用hashmap取值存入hashSet中，去重 // 兩個集合合併成並去重 public void mergeSet(Set a,Set b){ // org.apache.commons.collections.

python-進階教程-對兩個集合/字典求交集、差集、並集

1.集合 a = set([1,2,3,4,5,100,1000]) b = set([1,2,3,4,5,128.1024]) #交集 print(a & b) #{1, 2, 3, 4, 5} #差集 print(a - b) #{1000, 100} #並集

Java 用面向物件的方法求集合的交集，差集，並集

注意事項： 在自定義類中的成員屬性是兩個集合 在求集合的交集，差集，並集時，會修改成員屬性的這兩個集合的物件。即，若是求交集，使用的是list1.retainAll(list2)方法，此時，集合1中只剩下與集合2 相同的資料，當再求差集時，就會差生錯誤 消除

scala中集合的交集、並集、差集

原文網址：http://hongjiang.info/scala-union-diff-intersect/ scala中有一些api設計的很人性化，集合的這幾個操作是個代表： 交集： scala> Set(1,2,3) & Set(2,4) //