STL学习笔记（16）常用STL算法

算法主要是由头文件

#include 

组成。 其中常用的功能涉及到比较，交换，查找,遍历，复制，修改，反转，排序，合并等。

常用遍历算法

for_each

/*  
  遍历算法 遍历容器元素 
  @param beg 开始迭代器 
  @param end 结束迭代器 
  @param _callback 函数回调或者函数对象 
  @return 函数对象 
*/
for_each(iterator beg, iterator end, _callback);
''

代码案例

/*template inline 
void for_each(_InIt _First, _InIt _Last, _Fn1 _Func) 
{ 
    for (; _First != _Last; ++_First) _Func(*_First); 
}
*/

//普通函数
void print01(int val)
{
    cout << val << " ";
}

//函数对象
struct print001
{
    void operator()(int val)
    {
        cout << val << " ";
    }
};

//for_each 算法基本用法
void test01()
{
    vector<int> v;
    for (int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }

    //遍历算法
    for_each(v.begin(), v.end(), print01);
    cout << endl;
    for_each(v.begin(), v.end(), print001());
    cout << endl;
}
struct print02
{
    print02() { mCount = 0; }
    void operator()(int val)
    {
        cout << val << " ";
        mCount++;
    }
    int mCount;
};

//for_each 返回值
void test02()
{
    vector<int> v;
    for (int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }
    print02 p = for_each(v.begin(), v.end(), print02());
    cout << endl;
    cout << p.mCount << endl;
}
struct print03 : public binary_function<int, int, void>
{
    void operator()(int val, int bindParam) const { cout << val + bindParam << " "; }
};

//for_each 绑定参数输出
void test03()
{
    vector<int> v;
    for (int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }
    for_each(v.begin(), v.end(), bind2nd(print03(), 100));
}

transform 算法

transform 算法 将指定容器区间元素搬运到另一容器中 注意 : transform 不会给目标容器分配内存，所以需要我们提前分配好内存

/*
  @param beg1 源容器开始迭代器 
  @param end1 源容器结束迭代器 
  @param beg2 目标容器开始迭代器 
  @param _cakkback 回调函数或者函数对象 
  @return 返回目标容器迭代器 
*/
transform(iterator beg1, iterator end1, iterator beg2, _callbakc);

其模板函数为

//transform 将一个容器中的值搬运到另一个容器中
template <class _InIt, class _OutIt, class _Fn1>
inline _OutIt _Transform(_InIt _First, _InIt _Last, _OutIt _Dest, _Fn1 _Func)
{
    for (; _First != _Last; ++_First, ++_Dest)
        *_Dest = _Func(*_First);
    return (_Dest);
}

template <class _InIt1, class _InIt2, class _OutIt, class _Fn2>
inline _OutIt _Transform(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _OutIt _Dest, _Fn2 _Func)
{
    for (; _First1 != _Last1; ++_First1, ++_First2, ++_Dest)
        *_Dest = _Func(*_First1, *_First2);
    return (_Dest);
}

例子

struct transformTest01
{
    int operator()(int val) { return val + 100; }
};
struct print01
{
    void operator()(int val) { cout << val << " "; }
};
void test01()
{
    vector<int> vSource;
    for (int i = 0; i < 10; i++)
    {
        vSource.push_back(i + 1);
    }
    //目标容器
    vector<int> vTarget;
    //给 vTarget 开辟空间
    vTarget.resize(vSource.size());
    //将 vSource 中的元素搬运到
    vTarget vector<int>::iterator it = transform(vSource.begin(), vSource.end(), vTarget.begin(), transformTest01());
    //打印
    for_each(vTarget.begin(), vTarget.end(), print01());
    cout << endl;
}

//将容器 1 和容器 2 中的元素相加放入到第三个容器中
struct transformTest02
{
    int operator()(int v1, int v2) { return v1 + v2; }
};
void test02()
{
    vector<int> vSource1;
    vector<int> vSource2;
    for (int i = 0; i < 10; i++)
    {
        vSource1.push_back(i + 1);
    }
    //目标容器
    vector<int> vTarget;
    //给 vTarget 开辟空间
    vTarget.resize(vSource1.size());
    transform(vSource1.begin(), vSource1.end(), vSource2.begin(), vTarget.begin(), tran sformTest02());
    //打印
    for_each(vTarget.begin(), vTarget.end(), print01());
    cout << endl;
}

常用查找算法

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

/* 
  find_if 算法 条件查找 
  @param beg 容器开始迭代器 
  @param end 容器结束迭代器 
  @param callback 回调函数或者谓词(返回 bool 类型的函数对象) 
  @return bool 查找返回 true 否则 false 
*/ 
find_if(iterator beg, iterator end, _callback); 

/* 
  adjacent_find 算法 查找相邻重复元素 
  @param beg 容器开始迭代器 
  @param end 容器结束迭代器 
  @param _callback 回调函数或者谓词(返回 bool 类型的函数对象) 
  @return 返回相邻元素的第一个位置的迭代器 
*/
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); 

/* 
  count 算法 统计元素出现次数 
  @param beg 容器开始迭代器 
  @param end 容器结束迭代器 
  @param value 回调函数或者谓词(返回 bool 类型的函数对象) 
  @return int 返回元素个数 
*/
count(iterator beg, iterator end, value); 
/*
  count_if 算法 统计元素出现次数 
  @param beg 容器开始迭代器 
  @param end 容器结束迭代器 
  @param callback 回调函数或者谓词(返回 bool 类型的函数对象) 
  @return int 返回元素个数 
*/
count_if(iterator beg, iterator end, _callback);

常用排序算法

/* 
  merge 算法 容器元素合并，并存储到另一容器中 
  注意:两个容器必须是有序的 
  @param beg1 容器 1 开始迭代器 
  @param end1 容器 1 结束迭代器 
  @param beg2 容器 2 开始迭代器 
  @param end2 容器 2 结束迭代器 
  @param dest 目标容器开始迭代器 
*/ 
merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest) 

/* 
  sort 算法 容器元素排序 
  @param beg 容器 1 开始迭代器 
  @param end 容器 1 结束迭代器 
  @param _callback 回调函数或者谓词(返回 bool 类型的函数对象) 
*/
sort(iterator beg, iterator end, _callback) 

/* 
  random_shuffle 算法 对指定范围内的元素随机调整次序 
  @param beg 容器开始迭代器 
  @param end 容器结束迭代器 
*/ 
random_shuffle(iterator beg, iterator end) 

/* 
  reverse 算法 反转指定范围的元素 
  @param beg 容器开始迭代器 
  @param end 容器结束迭代器 
*/ 
reverse(iterator beg, iterator end)

常用拷贝和替换算法

/* 
  copy 算法 将容器内指定范围的元素拷贝到另一容器中 
  @param beg 容器开始迭代器 
  @param end 容器结束迭代器 
  @param dest 目标起始迭代器 
*/
copy(iterator beg, iterator end, iterator dest) 

/* 
  replace 算法 将容器内指定范围的旧元素修改为新元素 
  @param beg 容器开始迭代器 
  @param end 容器结束迭代器 
  @param oldvalue 旧元素 
  @param oldvalue 新元素 
*/
replace(iterator beg, iterator end, oldvalue, newvalue) 

/* 
  replace_if 算法 将容器内指定范围满足条件的元素替换为新元素 
  @param beg 容器开始迭代器 
  @param end 容器结束迭代器 
  @param callback 函数回调或者谓词(返回 Bool 类型的函数对象) 
  @param oldvalue 新元素 
*/
replace_if(iterator beg, iterator end, _callback, newvalue) 

/* 
  swap 算法 互换两个容器的元素 
  @param c1 容器 1 
  @param c2 容器 2 
*/
swap(container c1, container c2)

常用算数生成算法

/* 
  accumulate 算法 计算容器元素累计总和 
  @param beg 容器开始迭代器 
  @param end 容器结束迭代器 
  @param value 累加值 
*/
accumulate(iterator beg, iterator end, value) 

/* 
  fill 算法 向容器中添加元素 
  @param beg 容器开始迭代器 
  @param end 容器结束迭代器 
  @param value t 填充元素 
*/
fill(iterator beg, iterator end, value)

常用集合算法

/* 
  set_intersection 算法 求两个 set 集合的交集 
  注意:两个集合必须是有序序列 
  @param beg1 容器 1 开始迭代器 
  @param end1 容器 1 结束迭代器 
  @param beg2 容器 2 开始迭代器 
  @param end2 容器 2 结束迭代器 
  @param dest 目标容器开始迭代器 
  @return 目标容器的最后一个元素的迭代器地址 
*/
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 目标容器的最后一个元素的迭代器地址 
*/
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 目标容器的最后一个元素的迭代器地址 
*/
set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator de st)