C++STL經常使用數據結構

參考連接： C++ STL-Multiset.emplace()函數

目錄 

1、vector 

1.構造函數： 

2.插入函數： 

3.刪除函數： 

4.查找函數 

5.大小函數 

6.其餘函數 

2、stack 

3、array 

1.聲明一個array 

2.迭代器函數 

3.數組大小函數 

4.元素訪問函數 

5.其餘函數 

4、list 

1.構造函數 

2.迭代器 

3.容量函數 

4.元素訪問函數 

5.操做函數 

5、map 

1.構造函數 

2.迭代器 

3.容量函數 

4.元素訪問函數 

5.插入函數 

6.刪除函數 

7.操做函數 

6、queue 

1.構造函數 

2.其餘函數 

7、priority_queue 

1.構造函數 

2.其餘函數 

8、set 

1.構造函數 

2.迭代器 

3.容量函數 

4.插入函數 

5.刪除函數 

6.其餘函數 

9、multiset 

1、vector 

vector是一個能存聽任意類型，包括自定義的對象的動態數組，定義一個vector不須要指定大小，它會根據裏面的元素自動擴展大小。vector裏面的元素線性排列，查找複雜度爲O（1），可是在中間插入數據複雜度爲O（n）。 

1.構造函數： 

vector<int> myVector;//建立一個空的vector，最經常使用的構造方法；

vector<int> myVector(n);//建立一個初始大小爲n的vector，其中n能夠是變量常量或者肯定的數字

vector<int> myVector(n,m);//建立一個初始大小爲n的vector，而且全部值初始化爲m，m和n能夠是變量或者數字

vector<int> testVector(myVector);//建立一個vector而且將另外一個vector的值複製到這個新的vector裏

vector<int> testVector(myVector.begin(), myVector.end());//傳入兩個vector的迭代器，而後將迭代器之間的值複製到新的vector裏

 

2.插入函數： 

void push_back(int);//向vector的尾部插入一個元素

iterator insert(iterator it,const T& x);//向迭代器指向的位置以前插入一個元素x，返回x的位置

iterator insert(iterator it,int n,const T& x);//向迭代器指向的位置以前插入n個相同的元素x，返回插入的n個元素的第一個元素的位置

iterator insert(iterator it,const_iterator first,const_iterator last);//向迭代器指向的位置以前插入另外一個vector的迭代器區間的值，返回插入的全部元素的第一個元素的位置

 

3.刪除函數： 

iterator erase(iterator it);//刪除vector中迭代器指向的位置的元素，刪除後此位置後面全部元素前移一位，返回位置爲刪除的元素的位置

iterator erase(iterator first,iterator last);//刪除兩個迭代器之間的元素（不包括last位置的元素），返回first位置迭代器

void pop_back();//刪除最後一個元素

void clear();//清空vector全部元素 

4.查找函數 

reference at(int pos);//返回pos位置元素的引用

reference front();//返回首元素的引用

reference back();//返回尾元素的引用

iterator begin();//返回向量頭指針，指向第一個元素

iterator end();//返回向量尾指針，指向向量最後一個元素的下一個位置

reverse_iterator rbegin();//反向迭代器，指向最後一個元素

reverse_iterator rend();//反向迭代器，指向第一個元素以前的位置 

5.大小函數 

int size() const;//返回vector裏元素的個數

int capacity() const;//返回當前vector的容量，實測size爲1是容量爲1，size爲2時容量爲2，size爲3，4是容量爲4，size爲5~8時容量爲8……因此capacity函數爲vector能容下全部元素的最小的2的指數容量。

int max_size() const;//返回vector容許的最大元素個數，即size的最大值，若是插入的元素個數超過這個值應該會報錯，本想實測一下可是內存不夠

 

6.其餘函數 

bool empty() const;//判斷vector裏面是否有元素，有則返回false，沒有則返回true

void swap(vector&, vector&);//交換兩個值

void assign(int n,const T& x);//清空vector而且設置n個元素，值爲x

void assign(const_iterator first,const_iterator last);//清空vector而且吧迭代器區間裏的元素複製到vector裏 

2、stack 

bool empty() const;//若是棧空返回true，不然返回false

size_type size() const;//返回棧的元素個數

value_type& top();//返回棧頂元素

void push (const value_type& val);//將一個值val壓棧

template <class... Args> void emplace (Args&&... args);//調用stack元素的類型的構造函數用參數構造出一個元素，而後壓棧，與push不一樣的是它避免了對象的拷貝，效率更高

void pop();//將棧頂元素出棧

 

  

3、array 

1.聲明一個array 

array<int,5> arr;//聲明一個大小爲5的數組，若是是局部變量則不會初始化，值是隨機的，若是是全局變量會初始化爲0

array<int,4> arr = {1,2,3,4};//聲明一個大小爲4並初始化的數組，若是初始值數量小於數組大小，則後面的數組值初始化爲0

 

2.迭代器函數 

iterator begin();//返回數組首元素的迭代器

iterator end();//返回數組最後一個元素的下一個位置的迭代器

 

3.數組大小函數 

size_type size();//返回數組大小

size_type max_size();//返回array能支持的最大容量，可是實際max_size的值和size同樣

bool empty();//只有當數組size爲0是返回true，感受沒什麼意義 

4.元素訪問函數 

reference at ( size_type n );//返回數組下標爲n的元素的引用

reference front();//返回數組第一個元素的引用

reference back();//返回最後一個元素的引用

value_type* data();//返回一個指向數組首元素的指針 

5.其餘函數 

void fill (const value_type& val);//將數組裏的元素所有填充爲val

void swap(&array arr);//例如arr1.swap(arr2)，則將arr1和arr2兩個數組裏的全部元素交換，兩個array元素數量必須同樣，不然會編譯出錯 

4、list 

1.構造函數 

list<int> first;//建立一個空的list

list<int> first = {1,2,3,4};//能夠這樣初始化

list<int> second (4,100);//建立一個有四個節點的list，初始化爲100

list<int> third (second.begin(),second.end());//使用迭代器初始化list

list<int> fourth (third);//拷貝一個list

 

2.迭代器 

iterator begin();//返回第一個元素的迭代器

iterator end();//返回最後一個元素的下一個位置的迭代器

 

3.容量函數 

bool empty() const;//若是list爲空返回true，不然返回false

size_type size() const;//返回list當前的元素個數

size_type max_size() const;//返回list能支持的最大容量 

4.元素訪問函數 

reference front();//返回list第一個元素的引用

reference back();//返回list最後一個元素的引用 

5.操做函數 

void assign (size_type n, const value_type& val);//清空list並設置n個值爲val的元素

void assign (InputIterator first, InputIterator last);//清空list並將迭代器區間的值拷貝到list裏

/********************list的插入函數*********************************************/

void emplace_front (Args&&... args);//調用list類型的構造函數使用參數列表構造一個list類型對象並插入到list的頭部

void emplace_back (Args&&... args);//與上一個相似，區別在於插入到list的尾部

iterator emplace (const_iterator position, Args&&... args);//和上面兩個相似，區別在於插入到迭代器position位置的前面，並返回插入元素的迭代器

void push_front (const value_type& val);//將val插入到list的頭部

void push_back (const value_type& val);//將val插入到list的尾部

iterator insert (iterator position, const value_type& val);//插入元素到position位置以前並返回插入元素的位置的迭代器

/*****************************************************************************/

/**********************list的刪除函數*******************************************/

void pop_front();//刪除頭部元素

void pop_back();//刪除尾部元素

iterator erase (iterator position);//刪除position位置的元素並返回刪除元素的下一個元素的迭代器

iterator erase (iterator first, iterator last);//刪除迭代器區間的元素並返回迭代器區間的下一個位置

void remove (const value_type& val);//刪除list裏面值爲val的節點

void remove_if (Predicate pred);//條件式刪除，將list裏全部元素依次傳入函數pred裏，若是返回true，則刪除這個節點

void unique();//刪除list裏相鄰節點重複的元素，即若是兩個節點相鄰且值相等則會刪除其中一個

void unique (BinaryPredicate binary_pred);//帶參數的unique，即只要兩個相鄰節點傳入binary_pred後返回true則會刪除其中一個

void clear();//清空list

/**************************************************************************/

void swap (list& x);//list的元素交換函數

void resize (size_type n);//若是list大小大於n，則截斷list只保留前n個元素，若是大小小於n，則將list尾部連續插入0知道size等於n

void resize (size_type n, const value_type& val);//與上一個相似，區別在於若是list的size小於n，則填充val而不是0

/****************************list剪切*************************************/

void splice (iterator position, list& x);//將list x的全部元素剪切並插入到調用函數的list的position位置以前

void splice (iterator position, list& x, iterator i);//將list x的迭代器i指向的元素剪切並插入到調用函數的list的position位置以前

void splice (iterator position, list& x, iterator first, iterator last);//將list x的迭代器first和last之間的元素剪切並插入到調用函數的list的position位置以前

/***************************************************************************/

/***********************************list排序函數***************************/

void merge (list& x);//將兩個list進行歸併排序，結果保存在調用函數的list中，而且結束以後list x會爲空

void merge (list& x, Compare comp);//按條件comp進行歸併排序，與上一個相似

void sort();//list的排序

void sort (Compare comp);//按條件排序

void reverse();//將list全部元素順序顛倒 

5、map 

1.構造函數 

std::map<char,int> first;//構造一個空的map

std::map<char,int> second (first.begin(),first.end());//構造一個map並初始化爲另外一個map的一個區間的元素

std::map<char,int> third (second);//構造一個map並初始化爲另外一個map的全部元素

std::map<char,int,classcomp> fourth; //構造一個map並根據classcomp函數進行排序（並非很清楚，這是個人猜測）

 

2.迭代器 

iterator begin();//返回第一個元素的迭代器

iterator end();//返回最後一個元素的下一個位置的迭代器 

3.容量函數 

bool empty() const;//若是map爲空返回true，不然返回false

size_type size() const;//返回map當前的元素個數

size_type max_size() const;//返回map能支持的最大容量 

4.元素訪問函數 

mapped_type& at (const key_type& k);//返回鍵爲k的值 

5.插入函數 

pair<iterator,bool> insert (const value_type& val);//插入一對鍵值對，返回一個pair對象，一般val值爲構造的一個pair對象。若是插入成功，則返回值pair.second爲true且pair.first指向插入元素的迭代器。若是元素已存在會插入失敗，pair.first指向已存在元素的迭代器

iterator insert (iterator position, const value_type& val);//在指定位置插入元素

void insert (InputIterator first, InputIterator last);//依次插入迭代器區間的值，不包括last指向的值

pair<iterator,bool> emplace (Args&&... args);//返回值與insert相同，插入效率比insert高，代碼也更簡單

iterator emplace_hint (const_iterator position, Args&&... args);//在指定位置插入元素，若是元素已經存在則返回元素的迭代器，不然返回插入以後元素的迭代器

map[key] = value;//map支持數組下標式賦值和插入 

6.刪除函數 

void erase (iterator position);//刪除迭代器指向的元素

size_type erase (const key_type& k);//刪除鍵爲k的元素，若是存在鍵爲k的元素，則返回1，若是不存在則返回0

void erase (iterator first, iterator last);//刪除迭代器區間的元素

void clear();//清空map 

7.操做函數 

void swap (map& x);//交換兩個map的元素

iterator find (const key_type& k);//查找鍵爲k的元素，返回元素的迭代器

size_type count (const key_type& k) const;//在map中查找鍵爲k的元素，返回找到的元素的個數，由於map不能有兩個元素鍵相同，因此只能返回0或1

iterator lower_bound (const key_type& k);//返回map裏第一個鍵大於或等於k的元素迭代器

iterator upper_bound (const key_type& k);//返回map裏第一個大於k的元素迭代器

equal_range (const key_type& k)；//返回lower_bound (const key_type& k)和upper_bound (const key_type& k)組成的一個pair對象 

6、queue 

1.構造函數 

queue (const container_type& ctnr = container_type());//構造一個queue須要兩個參數，第一個是元素類型，第二個是queue的容器類型，其中第二個參數能夠省略，則默認容器類型爲dqueue

queue<int> first;//最經常使用的構造方式

queue<int> second (container);//能夠用另外一個容器來初始化queue，若是queue沒有指定容器類型

那麼這裏的container必須是一個dequeue類型的容器

queue<int,std::list<int> > third; //指定queue容器類型

queue<int,std::list<int> > fourth (mylist);//指定類型並初始化，在指定queue的容器類型後，若是要用另外一個容器來初始化queue，那麼必須是queue的容器類型的容器 

2.其餘函數 

bool empty() const;//若是隊列爲空返回true，不然返回false

size_type size() const;//返回隊列的元素個數

value_type& front();//返回隊首元素

value_type& back();//返回隊尾元素

void push (const value_type& val);//向隊列插入一個元素，插入在隊尾

void emplace (Args&&... args);//構造並向隊列插入一個元素，插入在隊尾

void pop();//將隊列頭部一個元素出隊

 

7、priority_queue 

1.構造函數 

priority_queue<int> first;//構造一個普通的優先隊列，默認隊列首部值最大

priority_queue<int> second (myints,myints+4);//使用一個數組初始化優先隊列

priority_queue<int, std::vector<int>, std::greater<int> > third (myints,myints+4);

//這裏指定優先級方式爲greater，則最小的元素會在隊首

priority_queue<int, std::vector<int>, mycomparison> //自定義優先級函數mycomparison 

2.其餘函數 

優先隊列沒有取隊尾元素的函數，取隊首元素的函數爲 

value_type& top() const; 

其餘函數與queue同樣 

  

8、set 

1.構造函數 

set<int> first;//構造一個空的集合

set<int> second (myints,myints+5);//定義一個集合並使用數組初始化

set<int> third (second);//構造一個集合並把另外一個集合的元素複製過來

set<int> fourth (second.begin(), second.end());//定義一個集合並使用迭代器區間初始化

set<int,classcomp> fifth;//定義一個集合並自定義集合裏元素的排序方式 

2.迭代器 

iterator begin();//返回集合首元素的迭代器

iterator end();//返回集合最後一個元素的下一個位置的迭代器

 

3.容量函數 

bool empty() const;//若是集合爲空返回true，不然返回false

size_type size() const;//返回集合元素的個數

size_type max_size() const;//返回集合能支持的最大容量 

4.插入函數 

pair<iterator,bool> insert (const value_type& val);//插入一個元素，若是元素已經存在，那麼返回這個元素的迭代器，不然返回插入成功後這個元素的迭代器

iterator insert (iterator position, const value_type& val);//在指定位置插入元素，這個函數的意義在於，若是在指定位置插入元素以後集合已經有序了，那麼就不用再排序，因此有時候會比上一個效率更高

void insert (InputIterator first, InputIterator last);//插入兩個迭代器之間的一組數據

pair<iterator,bool> emplace (Args&&... args);//比insert更高效的插入方法

iterator emplace_hint (const_iterator position, Args&&... args);//在指定位置插入元素 

5.刪除函數 

void erase (iterator position);//刪除迭代器指向的位置的元素

size_type erase (const value_type& val);//刪除值爲val的元素，返回刪除的數目，因爲set元素不容許重複，因此若是刪除成功返回1，刪除失敗返回0

void erase (iterator first, iterator last);//刪除迭代器區間的元素

void clear();//清空集合 

6.其餘函數 

iterator find (const value_type& val) const;//查找值爲val的元素，返回迭代器，若是查找失敗返回set.end()迭代器

size_type count (const value_type& val) const;//查找值爲val的元素的個數，由於set不容許元素重複，因此只能返回0或1

iterator lower_bound (const value_type& val) const;//返回元素值大於等於val的第一個元素的位置

iterator upper_bound (const value_type& val) const;//返回元素值大於val的第一個元素的位置

pair<iterator,iterator> equal_range (const value_type& val) const;//返回以val爲參數的lower_bound和upper_bound組成的pair 

9、multiset 

multset和set的區別是它容許元素的值相同，這個區別致使如下函數的不一樣： 

count函數能返回大於1的值 

insert函數插入已經存在的元素能成功 

按值刪除一個元素會把值相同的全部元素刪除 

查找一個值會返回找到的第一個元素的位置 

其餘函數應該都相同