C++抽象编程——STL实战（2）——查找与修改

工欲善其事必先利其器，那么我们现在说说我们强大的< algorithm >库，一个强大的算法库，提供了我们极为方便的处理方式。虽然我们现在只是学会怎么使用，过完这个内容我们就说怎么实现这些功能，我在说这些算法的时候，我也会放上函数模板的，但是不会去分析。我们重点看看怎么使用。

这里的所有方法都要导入头文件 < algorithm >

find()

目的： 在一定范围内找寻某个值

函数模板：

template<class InputIterator, class T>
  InputIterator find (InputIterator first, InputIterator last, const T& val)
{
  while (first!=last) {
    if (*first==val) return first;
    ++first;
  }
  return last;
}

函数参数：
first, last：将序列中的初始和最终位置输入到迭代器。 搜索的范围是[first，last]，其中包含第一个和最后一个之间的所有元素，包括由first指向的元素，而不是last指向的元素。（因为last指向最后一个元素的下一位）
value：要在范围内搜索的值。

返回值
返回等于val的范围中的第一个元素的迭代器。如果没有元素匹配，函数返回最后一个迭代器。

示例：

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
    vector<int> vec;
    vector<int>::iterator it;
    int n;
    for (int i = 0; i < 6; i++) {
        vec.push_back(i * 10);
    }
    while(true){
    cout << "输入要查找的元素 ：" ;
    cin >> n;
    it = find(vec.begin(), vec.end(),n);//里面有迭代器在运行 
    if(it != vec.end()) {
        cout << "vector中有你要找的元素" << *it <<endl;
    }else{
        cout << "vector中没有你要找的元素" << endl; 
    }
    }
    return 0;
}

运行结果：

算法复杂度：线性得遍历查找每一个元素。

find_if（）

目的： 在一定范围内找寻某个值。
函数模板：

template<class InputIterator, class UnaryPredicate>
  InputIterator find_if (InputIterator first, InputIterator last, UnaryPredicate pred)
{
  while (first!=last) {
    if (pred(*first)) return first;
    ++first;
  }
  return last;
}

函数参数
first, last：将序列中的初始和最终位置输入到迭代器。 搜索的范围是[first，last]，其中包含第一个和最后一个之间的所有元素，包括由first指向的元素，而不是last指向的元素。（因为last指向最后一个元素的下一位）
pred:函数接受范围内的元素作为参数，并返回一个可转换为bool的值。 返回的值指示该元素是否在该函数的上下文中被认为是匹配项。该功能不得修改其参数。这可以是函数指针或函数对象。(通俗的说，就是这个参数是个bool值，我们需要查找符合这个条件的值，它可以是个函数，指针，或者指针对象)

返回值
返回pred中true的范围中的第一个元素的迭代器。如果所有元素的pred为false，该函数返回最后last迭代器。

示例

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
bool isGreatThan100(int n);
int main(){
    vector<int> vec;
    vector<int>::iterator it;
    for(int i = 0; i < 10; i++){
        int a;
        cin >>a;
        vec.push_back(a);
    }
    it = find_if(vec.begin(),vec.end(),isGreatThan100);
    if(it != vec.end()){
    cout << "第一个大于100的数是" << *it << endl; 
    }else{
        cout << "vector中不存在这样的数" << endl; 
    }
    return 0;
}
bool isGreatThan100(int n){
    return (n > 100);
}

结果如下：

for_each

目的:在范围内应用函数

函数模板：

template<class InputIterator, class Function>
  Function for_each(InputIterator first, InputIterator last, Function fn)
{
  while (first!=last) {
    fn (*first);
    ++first;
  }
  return fn;      // or, since C++11: return move(fn);
}

返回值：
将函数对象应用于范围中的所有元素后的函数副本（返回的是函数）

参数
first, last：将序列中的初始和最终位置输入到迭代器。 搜索的范围是[first，last]，其中包含第一个和最后一个之间的所有元素，包括由first指向的元素，而不是last指向的元素。（因为last指向最后一个元素的下一位）
fn：用户定义的应用于范围中每个元素的函数对象

示例

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int doubleN(int n);//w我们自己定义的函数，运用在每一个的元素上 
int main(){
    vector<int> vec;
    vector<int>::iterator it;
    for(int i = 0; i < 10; i++){
        int a;
        cin >>a;
        vec.push_back(a);
    }
    for_each(vec.begin(),vec.end(),doubleN);
    return 0;
}
int doubleN(int n){
    cout << (2*n) << " " ;
    return 0;
}

运行结果如下：

search

目的：搜索子序列的范围

函数模板：

template<class ForwardIterator1, class ForwardIterator2>
  ForwardIterator1 search ( ForwardIterator1 first1, ForwardIterator1 last1,
                            ForwardIterator2 first2, ForwardIterator2 last2)
{
  if (first2==last2) return first1;  // specified in C++11

  while (first1!=last1)
  {
    ForwardIterator1 it1 = first1;
    ForwardIterator2 it2 = first2;
    while (*it1==*it2) {    // or: while (pred(*it1,*it2)) for version 2
        ++it1; ++it2;
        if (it2==last2) return first1;
        if (it1==last1) return last1;
    }
    ++first1;
  }
  return last1;
}

函数参数：
first1, last1 ：将序列中的初始和最终位置输入到迭代器。 搜索的范围是[first，last]，其中包含第一个和最后一个之间的所有元素，包括由first指向的元素，而不是last指向的元素。（因为last指向最后一个元素的下一位）。
first2, last2：将迭代器转发到要搜索的序列的初始和最终位置。 使用的范围是[first2，last2）。对于（1），两个范围中的元素应使用operator ==（第一个范围的元素作为左侧操作数，第二个作为右侧操作数的元素）类型。

返回值：
在[first1，last1]中第一次出现[first2，last2]的第一个元素的迭代器。如果没有找到序列，函数返回last1。（不是last2）。

示例：

#include <iostream>
#include <iostream>     // std::cout
#include <algorithm>    // std::search
#include <vector>       // std::vector

bool mypredicate (int i, int j) {
  return (i == j);
}

int main () {
  std::vector<int> vec1;
  std::vector<int> vec2;
  /* 设置一些值        vec: 10 20 30 40 50 60 70 80 90 */
  for (int i = 1; i < 10; i++) vec1.push_back(i*10);

  /* 设置一个上面的子集 */
  for(int n = 4; n < 8;n++) vec2.push_back(n*10);
  std::vector<int>::iterator it;
  it = std::search (vec1.begin(), vec1.end(), vec2.begin(), vec2.end());
  if (it != vec1.end())
    std::cout << "vec2 found at position " << (it-vec1.begin()) << '\n';
  else
    std::cout << "vec2 not found\n";

  /* 我们预测的可能有的子序列 */ 
  std::vector<int> vec3;
  vec3.push_back(20); 
  vec3.push_back(30);
  vec3.push_back(50);
  it = std::search (vec1.begin(), vec1.end(), vec3.begin(), vec3.end(), 
  mypredicate);
  if (it != vec1.end())
    std::cout << "vec3 found at position " << (it - vec1.begin()) << '\n';
  else
    std::cout << "vec3 not found\n";

  return 0;
}

结果如下：