c++學習筆記（十一、常用算法）

這一篇只要是介紹了一些STL的常用算法，查找函數、遍歷函數、排序函數、拷貝和替換函數、算術生成函數、集合算法。這些算法應該都是比較常用的，所以就過一遍，其實這篇文件我原創內容不多，都是看着黑馬程序員c++的視頻，把函數抄出來的，希望黑馬程序員那邊不要介意，有需要看詳細的，可以去看看他們的c++視頻，是免費的哈哈哈。

11.1 常用查找函數

/*
    find    算法    查找元素
    @param  beg     容器開始迭代器
    @param  end     容器結束迭代器
    @param  value   查找的元素
    @return  iterator 返回查找元素的位置（迭代器）
*/
iterator find(iterator beg, iterator end, value);

/*
    adjacent_find       算法            查找相鄰重複元素
    @param  beg         容器開始迭代器
    @param  end         容器結束迭代器
    @param  _callback   回調函數或者謂詞（返回bool類型的函數對象）
    @return iterator  返回相鄰元素的第一個位置的迭代器（迭代器）
*/
iterator adjacent_find(iterator beg, iterator end, _callback);

/*
    binary_search       算法            二分查找法
    注意：在無序序列中不可用
    @param  beg         容器開始迭代器
    @param  end         容器結束迭代器
    @param  value       查找的元素
    @return  bool       查找返回true 否則false
*/
bool binary_search(iterator beg, iterator end, value);

/*
    find_if       算法            條件查找
    @param  beg         容器開始迭代器
    @param  end         容器結束迭代器
    @param  _callback   回調函數或者謂詞（返回bool類型的函數對象）
    @return  iterator   返回第一個滿足_callback條件的迭代器
*/
iterator find_if(iterator beg, iterator end, _callback);

/*
    count       算法            統計元素出現次數
    @param  beg         容器開始迭代器
    @param  end         容器結束迭代器
    @param  value       需要統計的元素
    @return  int        返回元素個數
*/
int count(iterator beg, iterator end, value);

/*
    count_if       算法            統計元素出現次數
    @param  beg         容器開始迭代器
    @param  end         容器結束迭代器
    @param  _callback   回調函數或者謂詞（返回bool類型的函數對象）
    @return  int        返回滿足_callback的元素個數
*/
int count_if(iterator beg, iterator end, _callback);

例子就不用寫了吧

11.2 常用遍歷函數

/*
    for_each       遍歷算法            遍歷容器元素
    @param  beg         容器開始迭代器
    @param  end         容器結束迭代器
    @param  _callback   回調函數或者函數對象
    @return  函數對象

    源碼：
    template <class _InIt, class _Fn>
    _Fn for_each(_InIt _First, _InIt _Last, _Fn _Func)
*/
_Fn for_each(iterator beg, iterator end, _Fn _callback);

/*
    transform      算法            將指定容器區間元素搬運到另一個容器中
    注意：transform 不會給目標容器分配內存，所以需要我們提前分配好內存（比如vector容器，需要用resize分配內存，而不能使用reserve）
    @param  beg1         源容器開始迭代器
    @param  end1         源容器結束迭代器
    @param  beg2         目標容器開始迭代器
    @param  _callback   回調函數或者函數對象
    @return  返回目標容器的迭代器

    源碼：
    template <class _InIt, class _OutIt, class _Fn>
    _OutIt transform(const _InIt _First, const _InIt _Last, _OutIt _Dest, _Fn _Func);
*/
iterator transform(iterator beg1, iterator end1, iterator beg2, _Fn _callback);

這個有點難點，還是寫下例子：

Person* show4(Person* p) {
   return p;
}

void main(){
	vector<Person*> vpp;
	vector<Person*> vpp1;
	vpp.push_back(&p1);
	vpp.push_back(&p2);
	vpp.push_back(&p3);
	vpp.push_back(&p4);
	cout << "======================" << endl;
	for_each(vpp.begin(), vpp.end(), mem_fun(&Person::show));
	
	vpp1.resize(vpp.size());    //這是申請空間
	
	transform(vpp.begin(), vpp.end(), vpp1.begin(), show4); //拷貝
	cout << "======================" << endl;
	for_each(vpp1.begin(), vpp1.end(), mem_fun(&Person::show));
}

運行結果：

11.3 常用排序算法

/*
    merge      算法      容器元素合併，並存儲到另一個容器中
    注意：兩個容器必須是有序的，不支持隨機訪問也可以
    @param  beg1         容器 1 開始迭代器
    @param  end1         容器 1 結束迭代器
    @param  beg2         容器 2 開始迭代器
    @param  end2         容器 2 結束迭代器
    @param  dest         目標容器開始迭代器
    @return  返回目標容器的迭代器

    源碼：
    template <class _InIt1, class _InIt2, class _OutIt>
    _CONSTEXPR20 _OutIt merge(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
*/
iterator merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

/*
    sort      算法      容器元素排序
    注意：支持隨機訪問
    @param  beg         容器開始迭代器
    @param  end         容器結束迭代器
    @param  _callback   回調函數或者謂詞（返回bool類型的函數對象）
    @return  void

    源碼：
    template <class _RanIt, class _Pr>
    _CONSTEXPR20 void sort(const _RanIt _First, const _RanIt _Last, _Pr _Pred)
*/
void sort(iterator beg, iterator end, _callback);

/*
    random_shuffle      算法      對指定範圍內的元素隨機調整次序
    注意：支持隨機訪問
    @param  beg         容器開始迭代器
    @param  end         容器結束迭代器
    @return  void

    源碼：
    template <class _RanIt, class _RngFn>
    void random_shuffle(_RanIt _First, _RanIt _Last, _RngFn&& _RngFunc)

    template <class _RanIt>
    void random_shuffle(_RanIt _First, _RanIt _Last)
*/
void random_shuffle(iterator beg, iterator end);

/*
    reverse      算法      反轉指定範圍內的元素
    注意：支持隨機訪問
    @param  beg         容器開始迭代器
    @param  end         容器結束迭代器
    @return  void

    源碼：
*/
void reverse(iterator beg, iterator end);

排序算法比較簡單，就不寫例子了。

11.4 常用拷貝和替換算法

/*
    copy      算法      將容器內指定範圍的元素拷貝到另一個容器中
    @param  beg         容器開始迭代器
    @param  end         容器結束迭代器
    @param  dest        目標容器迭代器
    @return  iterator   目標容器迭代器

    源碼：
*/
iterator copy(iterator beg, iterator end, iterator dest);

/*
    replace      算法      將容器內指定範圍的舊元素修改成爲新元素
    @param  beg         容器開始迭代器
    @param  end         容器結束迭代器
    @param  oldvalue    舊元素
    @param  mewvalue    新元素
    @return  void

    源碼：
    template <class _FwdIt, class _Ty>
    _CONSTEXPR20 void replace(const _FwdIt _First, const _FwdIt _Last, const _Ty& _Oldval, const _Ty& _Newval)

    不知道爲什麼要傳舊參數，先找到舊參數，然後替換成新參數
*/
void replace(iterator beg, iterator end, oldvalue, mewvalue);

/*
    replace_if      算法      將容器內指定範圍滿足_callback條件的元素修改成爲新元素
    @param  beg         容器開始迭代器
    @param  end         容器結束迭代器
    @param  _callback   回調函數或者謂詞（返回bool類型的函數對象）
    @param  mewvalue    新元素
    @return  void

    源碼：
    template <class _FwdIt, class _Pr, class _Ty>
    _CONSTEXPR20 void replace_if(const _FwdIt _First, const _FwdIt _Last, _Pr _Pred, const _Ty& _Val)

    _callback  一個回調函數，可以寫成大於5的條件
*/
void replace_if(iterator beg, iterator end, _callback, mewvalue);

/*
    swap      算法      互換兩個容器的元素
    @param  c1         容器1
    @param  c2         容器2
    @return  void

    源碼：
    
*/
void swap(container c1, container c2);

例子也不寫了，回調函數還需要看一下別人的。

11.5 常用算術生成算法

#include <numeric>  //包含頭文件
/*
    accumulate      算法      計算容器元素累計總和
    @param  beg         容器開始迭代器
    @param  end         容器結束迭代器
    @param  value       算了和之後，如果還要加一個值，就是這個value，如果求合填0
    @return  int       返回和

    源碼：
    
*/
int accumulate(iterator beg, iterator end, value);

/*
    fill      算法      向容器中添加元素
    @param  beg         容器開始迭代器
    @param  end         容器結束迭代器
    @param  value       填充元素
    @return  void

    源碼：
    
    就是往迭代器中，填充value的值，填充範圍是beg-end,就得要申請空間
*/
void fill(iterator beg, iterator end, value);

11.6 常用集合算法

也不是很常用，就是兩個集合的交集、並集和差集。

/*
    set_intersection      算法      求兩個set集合的交集
    注意：兩個集合必須是有序序列
    @param  beg1         容器 1 開始迭代器
    @param  end1         容器 1 結束迭代器
    @param  beg2         容器 2 開始迭代器
    @param  end2         容器 2 結束迭代器
    @param  dest         目標容器開始迭代器
    @return  iterator    目標容器的最後一個元素的迭代器地址

    源碼：
    template <class _InIt1, class _InIt2, class _OutIt, class _Pr>
    _CONSTEXPR20 _OutIt set_intersection(
    _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)

    template <class _InIt1, class _InIt2, class _OutIt>
    _CONSTEXPR20 _OutIt set_intersection(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
    
*/
iterator set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

/*
    set_union      算法      求兩個set集合的並集
    注意：兩個集合必須是有序序列
    @param  beg1         容器 1 開始迭代器
    @param  end1         容器 1 結束迭代器
    @param  beg2         容器 2 開始迭代器
    @param  end2         容器 2 結束迭代器
    @param  dest         目標容器開始迭代器
    @return  iterator    目標容器的最後一個元素的迭代器地址

    源碼：
    template <class _InIt1, class _InIt2, class _OutIt, class _Pr>
    _CONSTEXPR20 _OutIt set_union(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
    
*/
iterator set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

/*
    set_difference      算法      求兩個set集合的差集
    注意：兩個集合必須是有序序列
    @param  beg1         容器 1 開始迭代器
    @param  end1         容器 1 結束迭代器
    @param  beg2         容器 2 開始迭代器
    @param  end2         容器 2 結束迭代器
    @param  dest         目標容器開始迭代器
    @return  iterator    目標容器的最後一個元素的迭代器地址

    源碼：
    template <class _InIt1, class _InIt2, class _OutIt, class _Pr>
    _CONSTEXPR20 _OutIt set_difference(
    _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred) 

    template <class _InIt1, class _InIt2, class _OutIt>
    _CONSTEXPR20 _OutIt set_difference(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
    
    beg1 差 beg2 是隻有beg1的元素（沒有beg2的，也沒有beg1和beg2相同的元素）
*/
iterator set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);