STL算法(非变动型算法)

最新推荐文章于 2022-03-08 16:22:50 发布

小白起步

最新推荐文章于 2022-03-08 16:22:50 发布

阅读量287

点赞数

分类专栏： STL 文章标签：算法 stl

本文链接：https://blog.csdn.net/cw312644167/article/details/70185211

版权

STL 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

STL的算法大部分都包含在算法头文件algorithm中.
这篇主要是关于里面的非变动型算法,即不对容器的内容进行修改的算法.
在算法中要求传递进来的区间为一个前闭后开区间,否则最后一位会遍历不到,并且无法根据返回的last判断是否为想要的结果

三个测试算法:

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

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

    template<class InputIterator, class UnaryPredicate>
    bool none_of(InputIterator first, InputIterator last, UnaryPredicate pred)
    {
        while (first != last)
        {
            if (pred(*first))
                return false;
            ++first;
        }
        return true;
    }
//这三个算法主要是对容器进行遍历,判断容器里面的值是否符合某种条件,传递进来一个区间,以及一个一元的函数指针(接收一个参数).

一个遍历算法

template<class InputIterator, class Function>
Function for_each(InputIterator first, InputIterator last, Function fn)
{
    while (first != last)
    {
        fn(*first);
        ++first;
    }
        return fn;  
}

//该函数对传递进来的区间进行遍历.并对里面的值进行某项操作.根据传递进来的函数指针决定是否会对容器里面的值进行改动

五个查找算法

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)的区间中找value,若存在,返回找到的位置.value的类型并不一定要和*first的类型相同,但要实现自己的operator==;

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;
    }

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

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

        ForwardIterator1 ret = last1;

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

//在第一个区间中查找与第二个区间元素完全一致的位置,并返回第一个区间中最后一次与第二个区间的元素完全相同的首元素的位置

//如区间一: 1,2,3,4,1,2,3,4; 区间二: 1 2 3
//返回的是区间一中后一个1所在的位置

template<class InputIterator, class ForwardIterator>
    InputIterator find_first_of(InputIterator first1, InputIterator last1,
        ForwardIterator first2, ForwardIterator last2)
    {
        while (first1 != last1)
        {
            for (ForwardIterator it = first2; it != last2; ++it)
            {
                if (*it == *first1)  // or: if (pred(*it,*first))
                    return first1;
            }
            ++first1;
        }
        return last1;
    }
//在第一个区间中查找首次与第二个区间元素相同的位置

template <class ForwardIterator>
    ForwardIterator adjacent_find(ForwardIterator first, ForwardIterator last)
    {
        if (first != last)
        {
            ForwardIterator next = first; 
            ++next;
            while (next != last)
            {
                if (*first == *next) // or: if (pred(*first,*next))
                    return first;
                ++first; ++next;
            }
        }
        return last;
    }
//该方法查找相邻元素相等时的第一个元素的位置

上面的三个函数都有一个重载的函数.这个重载的函数需要传递一个接收两个参数的函数指针,可以自定义比较的方式.

两个计数算法.

template <class InputIterator, class T>
  typename iterator_traits<InputIterator>::difference_type
    count (InputIterator first, InputIterator last, const T& val)
{
  typename iterator_traits<InputIterator>::difference_type ret = 0;
  while (first!=last)
  {
    if (*first == val)
         ++ret;
      ++first;
  }
  return ret;
}

template <class InputIterator, class UnaryPredicate>
  typename iterator_traits<InputIterator>::difference_type
    count_if (InputIterator first, InputIterator last, UnaryPredicate pred)
{
  typename iterator_traits<InputIterator>::difference_type ret = 0;
  while (first!=last)
  {
    if (pred(*first)) 
        ++ret;
    ++first;
  }
  return ret;
}

template <class InputIterator1, class InputIterator2>
  pair<InputIterator1, InputIterator2>
    mismatch (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2 )
{
  while ( (first1!=last1) && (*first1==*first2) )  // or: pred(*first1,*first2)
  {
       ++first1; ++first2; 
  }
  return std::make_pair(first1,first2);
}
//该方法会找出两个区间中第一个不匹配的两个元素进行结对
//如第一个区间:10,20,30,40,50; 第二个区间:10,20,40,60,80;
//进行结对的元素即为30,40;

template <class InputIterator1, class InputIterator2>
  bool equal ( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2 )
{
  while (first1!=last1) 
  {
    if (!(*first1 == *first2))   // or: if (!pred(*first1,*first2))
      return false;
    ++first1; ++first2;
  }
  return true;
//判断第一个区间里面的元素是否完全和第二个区间相等,要求第二个区间不能小于第一个区间

template<class ForwardIterator1, class ForwardIterator2>
  ForwardIterator1 search ( ForwardIterator1 first1, ForwardIterator1 last1,
                            ForwardIterator2 first2, ForwardIterator2 last2)
{
  if (first2==last2) 
      return first1; 

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

//在第一个区间中查找是否与第二个区间元素完全相同,如果有,返回相同元素的首个位置
//如,第一个区间10,20,30,40,50; 第二个区间30,40,50;
//返回的是第一个区间30所在的位置

template<class ForwardIterator, class Size, class T>
  ForwardIterator search_n (ForwardIterator first, ForwardIterator last,
                            Size count, const T& val)
{
  ForwardIterator it, limit;
  Size i;

  limit=first; 
  std::advance(limit,std::distance(first,last)-count);

  while (first!=limit)
  {
    it = first; i=0;
    while (*it==val)       // or: while (pred(*it,val)) 
     { 
          ++it; 
          if (++i==count) 
              return first; 
     }
    ++first;
  }
  return last;
}
//在区间中查找有没有count个value;找到则返回第一个val所在的位置.