Set容器

一、Set

（1）定義

set/multiset會根據待定的排序準則，自動將元素排序。二者不一樣在於前者不容許元素重複，然後者容許。

set，顧名思義是「集合」的意思，用來存儲同一數據類型的數據類型。

在set中元素都是惟一的，並且默認狀況下會對元素自動進行升序排列，支持集合的交(set_intersection)，差(set_difference) ，並(set_union)，對稱差(set_symmetric_difference) 等一些集合上的操做，若是須要集合中的元素容許重複那麼可使用multiset 。

C++ STL 之因此獲得普遍的讚譽，也被不少人使用，不僅是提供了像vector, string, list等方便的容器，更重要的是STL封裝了許多複雜的數據結構算法和大量經常使用數據結構操做。

vector封裝數組，list封裝了鏈表，map和set封裝了二叉樹等，在封裝這些數據結構的時候，STL按照程序員的使用習慣，以成員函數方式提供的經常使用操做，如：插入、排序、刪除、查找等。讓用戶在STL使用過程當中，並不會感到陌生。

應該注意的是set中數元素的值不能直接被改變。

（2）底層實現

C++ STL中標準關聯容器set, multiset, map, multimap內部採用的就是一種很是高效的平衡檢索二叉樹：紅黑樹，也成爲RB樹(Red-Black Tree)。

RB樹的統計性能要好於通常平衡二叉樹，因此被STL選擇做爲了關聯容器的內部結構，插入刪除操做時僅僅須要指針操做節點便可完成，不涉及到內存移動和拷貝，因此效率比較高。

（3）模板原型

set模板原型：

template <class Key, class Compare=less<Key>, class Alloc=STL_DEFAULT_ALLOCATOR(Key) >

從原型能夠看出，能夠看出比較函數對象及內存分配器採用的是默認參數，所以若是未指定，它們將採用系統默認方式。

set的標準形式是set<Key, Compare, Alloc>：

（4）特色

1) 不能直接改變元素值，由於那樣會打亂本來正確的順序，要改變元素值必須先刪除舊元素，則插入新元素；

2) 不提供直接存取元素的任何操做函數，只能經過迭代器進行間接存取，並且從迭代器角度來看，元素值是常數；

3) 元素比較動做只能用於型別相同的容器(即元素和排序準則必須相同)。

（5）性能分析

（1）爲什麼map和set的插入刪除效率比用其餘序列容器高？

由於對於關聯容器來講，不須要作內存拷貝和內存移動。set容器內全部元素都是以節點的方式來存儲，其節點結構和鏈表差很少，指向父節點和子節點。結構圖可能以下：

　   A
　  / \
　 B C
　/ \ / \
  D E F G

插入的時候只須要稍作變換，把節點的指針指向新的節點就能夠了。刪除的時候相似，稍作變換後把指向刪除節點的指針指向其餘節點便可。這裏的一切操做就是指針換來換去，和內存移動沒有關係。

（2）爲什麼每次insert以後，之前保存的iterator不會失效？

iterator這裏就至關於指向節點的指針，內存沒有變，指向內存的指針怎麼會失效呢(固然被刪除的那個元素自己已經失效了)。

相對於vector來講，每一次刪除和插入，指針都有可能失效，調用push_back在尾部插入也是如此。由於爲了保證內部數據的連續存放，iterator指向的那塊內存在刪除和插入過程當中可能已經被其餘內存覆蓋或者內存已經被釋放了。即便時push_back的時候，容器內部空間可能不夠，須要一塊新的更大的內存，只有把之前的內存釋放，申請新的更大的內存，複製已有的數據元素到新的內存，最後把須要插入的元素放到最後，那麼之前的內存指針天然就不可用了。

特別是在和find等算法在一塊兒使用的時候，牢記這個原則：不要使用過時的iterator。

（3）當數據元素增多時，set的插入和搜索速度變化如何？

在set中查找是使用二分查找，也就是說，若是有16個元素，最多須要比較4次就能找到結果，有32個元素，最多比較5次。那麼有10000個呢？最多比較的次數爲log10000，最多爲14次，若是是20000個元素呢？最多不過15次。看見了吧，當數據量增大一倍的時候，搜索次數只不過多了1次，多了1/14的搜索時間而已。這樣就能夠安心往裏面放入元素了。

二、成員函數

（1）構造函數

//建立set對象，共5種方式，提示若是比較函數對象及內存分配器未出現，即表示採用的是系統默認方式
set<int> s1; 
//建立空的set對象，元素類型爲int

set<const char*, strLess> s2( strLess); 
//建立空的set對象，元素類型char*，比較函數對象(即排序準則)爲自定義strLess

set<int> s3(s1); 
//利用set對象s1,拷貝生成set對象s2

int iArray[] = {13, 32, 19};
set<int> s4(iArray, iArray + 3);
//用迭代區間[&first, &last)所指的元素，建立一個set對象

const char* szArray[] = {"hello", "dog", "bird" };
set<const char*, strLess> s5(szArray, szArray + 3, strLess() );
//用迭代區間[&first, &last)所指的元素，及比較函數對象strLess，建立一個set對象

（2）插入操做

insert(key_value); 
//將key_value插入到set中 ，返回值是pair<set<int>::iterator,bool>，bool標誌着插入是否成功，而iterator表明插入的位置，若key_value已經在set中，則iterator表示的key_value在set中的位置。
inset(first,second);
//將定位器first到second之間的元素插入到set中，返回值是void.
insert(&pos, value)
//在pos位置以前插入value，返回新元素位置，但不必定能插入成功

示例：

deque<int> d {1,2,3,4,5};
cout<<"s1.insert(...) : "<<endl;
for (int i = 0; i <5 ; i++)
    s1.insert(i*10);
printSet(s1);
cout<<"s1.insert(20).second = "<<endl;;
if (s1.insert(20).second)
    cout<<"Insert OK!"<<endl;
else
    cout<<"Insert Failed!"<<endl;
cout<<"s1.insert(50).second = "<<endl;
if (s1.insert(50).second)
{cout<<"Insert OK!"<<endl; printSet(s1);}
else
    cout<<"Insert Failed!"<<endl;
cout<<"pair<set<int>::iterator::iterator, bool> p;/np = s1.insert(60);/nif (p.second):"<<endl;
pair<set<int>::iterator::iterator, bool> p;
p = s1.insert(60);
if (p.second)
{cout<<"Insert OK!"<<endl; printSet(s1);}
else
   cout<<"Insert Failed!"<<endl;

（3）刪除操做

clear();
//刪除set容器中的全部的元素

erase(iterator);
//刪除定位器iterator指向的值
erase(first,second);
//刪除定位器first和second之間的值
erase(key_value);
//刪除鍵值key_value的值

示例：

#include <iostream>
#include <set>

using namespace std;

int main()
{
    set<int> s;
    set<int>::const_iterator iter;
    set<int>::iterator first;
    set<int>::iterator second;
    for(int i = 1 ; i <= 10 ; ++i)
    {
        s.insert(i);
    }
    //第一種刪除
    s.erase(s.begin());
    //第二種刪除
    first = s.begin();
    second = s.begin();
    second++;
    second++;
    s.erase(first,second);
    //第三種刪除
    s.erase(8);
    cout<<"刪除後 set 中元素是 ：";
    for(iter = s.begin() ; iter != s.end() ; ++iter)
    {
        cout<<*iter<<" ";
    }
    cout<<endl;
    return 0;
}
運行結果：
刪除後 set 中元素是 ：4 5 6 7 9 10
小結：
set中的刪除操做是不進行任何的錯誤檢查的，好比定位器的是否合法等等，因此用的時候本身必定要注意。

（4）定位查找

s.begin()
//返回set容器的第一個元素
s.end()
//返回set容器的最後一個元素

c.rbegin()
//返回的值和end()相同
c.rend()
//返回的值和rbegin()相同
c.at(pos)返回索引爲pos的位置的元素,會執行邊界檢查,若是越界拋出out_of_range異常

lower_bound(key_value);
//返回第一個大於等於key_value的定位器
upper_bound(key_value);
//返回最後一個大於等於key_value的定位器

find()；
//返回給定值值得定位器，若是沒找到則返回end()

equal_range();
//返回一對定位器，分別表示第一個大於或等於給定關鍵值的元素和第一個大於給定關鍵值的元素，
//這個返回值是一個pair類型，若是這一對定位器中哪一個返回失敗，就會等於end()的值

count(value);
//返回set對象內元素值爲value的元素個數

示例：

#include <iostream>
#include <set>

using namespace std;

int main()
{
    set<int> s;
    s.insert(1);
    s.insert(2);
    s.insert(3);
    s.insert(1);
    cout<<"set 中的第一個元素是 ："<<*s.begin()<<endl;
    cout<<"set 中的最後一個元素是:"<<*s.end()<<endl;
    s.clear();
    if(s.empty())
    {
        cout<<"set 爲空 ！！！"<<endl;
    }
    cout<<"set 的 size 值爲 ："<<s.size()<<endl;
    cout<<"set 的 maxsize的值爲 ："<<s.max_size()<<endl;
    return 0;
}

#include <iostream>
#include <set>

using namespace std;

int main()
{
    set<int> s;
    s.insert(1);
    s.insert(3);
    s.insert(4);
    cout<<*s.lower_bound(2)<<endl;
    cout<<*s.lower_bound(3)<<endl;
    cout<<*s.upper_bound(3)<<endl;
    return 0;
}
運行結果：
3
3
4

#include <iostream>
#include <set>

using namespace std;

int main()
{
    int a[] = {1,2,3};
    set<int> s(a,a+3);
    set<int>::iterator iter;
    if((iter = s.find(2)) != s.end())
    {
        cout<<*iter<<endl;
    }
    return 0;
}

#include <iostream>
#include <set>

using namespace std;

int main()
{
    set<int> s;
    set<int>::iterator iter;
    for(int i = 1 ; i <= 5; ++i)
    {
        s.insert(i);
    }
    for(iter = s.begin() ; iter != s.end() ; ++iter)
    {
        cout<<*iter<<" ";
    }
    cout<<endl;
    pair<set<int>::const_iterator,set<int>::const_iterator> pr;
    pr = s.equal_range(3);
    cout<<"第一個大於等於 3 的數是 ："<<*pr.first<<endl;
    cout<<"第一個大於 3的數是 ： "<<*pr.second<<endl;
    return 0;
}

（5）數據大小

max_size();
//返回set容器可能包含的元素最大個數
size();
//返回當前set容器中的元素個數

count(); 
//用來查找set中某個某個鍵值出現的次數;
//這個函數在set並非很實用，由於一個鍵值在set只可能出現0或1次，這樣就變成了判斷某一鍵值是否在set出現過了。

示例：

#include <iostream>
#include <set>

using namespace std;

int main()
{
    set<int> s;
    s.insert(1);
    s.insert(2);
    s.insert(3);
    s.insert(1);
    cout<<"set 的 size 值爲 ："<<s.size()<<endl;
    cout<<"set 的 maxsize的值爲 ："<<s.max_size()<<endl;
    s.clear();
    if(s.empty())
    {
        cout<<"set 爲空 ！！！"<<endl;
    }
    cout<<"set 的 size 值爲 ："<<s.size()<<endl;
    cout<<"set 的 maxsize的值爲 ："<<s.max_size()<<endl;
    return 0;
}
結果：
set的size值爲：3
set的maxsize的值爲：1073741823
set的size值爲：0
set的maxsize的值爲：1073741823

小結：
插入3以後雖然插入了一個1，可是咱們發現set中最後一個值仍然是3哈，這就是set 。
還要注意begin() 和 end()函數是不檢查set是否爲空的，使用前最好使用empty()檢驗一下set是否爲空.

#include <iostream>
#include <set>

using namespace std;

int main()
{
    set<int> s;
    s.insert(1);
    s.insert(2);
    s.insert(3);
    s.insert(1);
    cout<<"set 中 1 出現的次數是 ："<<s.count(1)<<endl;
    cout<<"set 中 4 出現的次數是 ："<<s.count(4)<<endl;
    return 0;
}

（6）交換操做

s1.swap(s2)
//交換容器s1,s2;
swap(s1,s2)
//同上。

示例：

set<int> s1,s2;
s1.insert(100);
s2.insert(200);
cout<<"s1.swap(s2) :"<<endl;
s1.swap(s2);

（7）並交差

set_intersection();
//交
set_difference();
//差 
set_union();
//並
set_symmetric_difference();
//對稱差

示例：

#include<set>
#include<iterator>
#include<iostream>
using namespace std;
int main()
{
set<int>eg1;
//遍歷set，能夠發現元素是有序的
set<int>::iterator set_iter=eg1.begin();
cout<<"Set named eg1:"<<endl;
for(;set_iter!=eg1.end();set_iter++) cout<<*set_iter<<" ";
cout<<endl;

set<int>eg2;
for(int i=6;i<15;i++)
eg2.insert(i);
cout<<"Set named eg2:"<<endl;
for(set_iter=eg2.begin();set_iter!=eg2.end();set_iter++)
   cout<<*set_iter<<" ";
cout<<endl;

//得到兩個set的並
set<int>eg3;
cout<<"Union:";
set_union(eg1.begin(),eg1.end(),eg2.begin(),eg2.end(),insert_iterator<set<int> >(eg3,eg3.begin()));//注意第五個參數的形式
copy(eg3.begin(),eg3.end(),ostream_iterator<int>(cout," "));
cout<<endl;

//得到兩個set的交，注意進行集合操做以前接收結果的set要調用clear()函數清空一下
eg3.clear();
set_intersection(eg1.begin(),eg1.end(),eg2.begin(),eg2.end(),insert_iterator<set<int> >(eg3,eg3.begin()));
cout<<"Intersection:";
copy(eg3.begin(),eg3.end(),ostream_iterator<int>(cout," "));
cout<<endl;

//得到兩個set的差
eg3.clear();
set_difference(eg1.begin(),eg1.end(),eg2.begin(),eg2.end(),insert_iterator<set<int> >(eg3,eg3.begin()));
cout<<"Difference:";
copy(eg3.begin(),eg3.end(),ostream_iterator<int>(cout," "));
cout<<endl;

//得到兩個set的對稱差，也就是假設兩個集合分別爲A和B那麼對稱差爲AUB-A∩B
eg3.clear();
set_symmetric_difference(eg1.begin(),eg1.end(),eg2.begin(),eg2.end(),insert_iterator<set<int> >(eg3,eg3.begin()));
copy(eg3.begin(),eg3.end(),ostream_iterator<int>(cout," "));
cout<<endl;return 0;
}