泛型算法-非变易算法

• for_each()

  • #include <vector>
    #include <iostream>
    #include <algorithm>
    
    template<class A>
    inline void printElements(A& ele)
    {
            std::cout<<ele<<std::endl;
    }
    
    int main()
    {
            int elements[] = {1,2,3,100,100,5};
            int n = sizeof(elements) / sizeof(int);
            std::vector<int> v(elements, elements + n);
    
            std::for_each(v.begin(), v.end(), printElements<int>);
            return 0;
    }
    
• find find_if　

  • #include <vector>
    #include <iostream>
    #include <algorithm>
    
    int main()
    {
            int elements[] = {1,2,3,100,100,5};
            int n = sizeof(elements) / sizeof(int);
            std::vector<int> v(elements, elements + n);
    
            std::vector<int>::iterator it = std::find(v.begin(),v.end(),3);
            if(it != v.end())
            {
                    std::cout<<"Find Data "<<*it<<std::endl;
            }
    
            //找到一个数大于50      
            it = std::find_if(v.begin(),v.end(),std::bind2nd(std::greater<int>(),50));
            if(it != v.end())
            {
                    std::cout<<"Find Data "<<*it<<std::endl;
            }
    
            return 0;
    }
    ~  
    

• adjacent_find

  • #include <vector>
    #include <iostream>
    #include <algorithm>
    
    int main()
    {
            int elements[] = {1,2,3,100,100,5};
            int n = sizeof(elements) / sizeof(int);
            std::vector<int> v(elements, elements + n);
    
            std::vector<int>::iterator it;
            //找到两个数相等 (*it) = *(it++)
            it = std::adjacent_find(v.begin(), v.end());
            if(it != v.end())
            {
                    std::cout<<"Find Data "<<*it<<std::endl;
            }
    
            //找到（*it) > *(it++)
            it = std::adjacent_find(v.begin(),v.end(),std::greater<int>());
            if(it != v.end())
            {
                    std::cout<<"Find Data "<<*it<<std::endl;
            }
            return 0;
    }
    

• find_first_of

  • #include <vector>
    #include <iostream>
    #include <algorithm>
    
    //第一段范围内查找与第二段范围中任意元素匹配的元素，然后返回一个迭代器，指向第一个匹配的元素。如果找不到匹配元素，>则返回第一个范围的end迭代器。
    int main()
    {
            int elements[] = {1,2,3,100,100,5};
            int elements1[] = {100,100,5};
    
            int n = sizeof(elements) / sizeof(int);
            std::vector<int> v(elements, elements + n);
    
            int n1 = sizeof(elements1) / sizeof(int);
            std::vector<int> v1(elements1, elements1 + n1);
              
            //从v中找到v1中的值
            std::vector<int>::iterator it = std::find_first_of(v.begin(),v.end(),v1.begin(),v1.end());
            if(it != v.end())
            {    
                    std::cout<<"Find Data "<<*it<<std::endl;
            }
    
        
            return 0;
    }
    

• count count_if

  • #include <vector>
    #include <iostream>
    #include <algorithm>
    
    int main()
    {
            int elements[] = {1,2,3,100,100,5};
            int n = sizeof(elements) / sizeof(int);
            std::vector<int> v(elements, elements + n);
    
            int sum = std::count(v.begin(), v.end(), 100);
            std::cout<<"Find Equal 100 Number is:"<<sum<<std::endl;
    
            int out = std::count_if(v.begin(), v.end(), std::bind2nd(std::less<int>(),100));
            std::cout<<"Fine Less 100 Number is:"<<out<<std::endl;
            return 0;
    }
    

•  equal

  • #include <vector>
    #include <iostream>
    #include <algorithm>
    
    template<class T>
    inline bool IfEqual(T& m, T& n)
    {
            return (m == n);
    }
    int main()
    {
            int elements[] = {1,2,3,100,100,5};
            int elements1[] = {1,2,3,200};
    
            int n = sizeof(elements) / sizeof(int);
            std::vector<int> v(elements, elements + n);
    
            int n1 = sizeof(elements1) / sizeof(int);
            std::vector<int> v1(elements1, elements1 + n1);
    
            bool b = std::equal(v.begin(),v.end(),v1.begin());
            if(b)
            {
                    std::cout<<"euqal"<<std::endl;
            }
            else
            {
                    std::cout<<"not equal"<<std::endl;
            }
    
            b = std::equal(v.begin(),v.end(),v1.begin(),IfEqual<int>);
            return 0;
    }
    

• search
  • 

  • #include <vector>
    #include <iostream>
    #include <algorithm>
    template<class T>
    struct SearchDouble:public std::binary_function<T,T,bool>
    {
            bool operator()(const T& left, const T& right) const
            {
                    return (right == (left * 2));
            }
    };
    int main()
    {
            int elements[] = {1,2,3,100,100,5};
            int elements1[] = {6,200};
            int n = sizeof(elements) / sizeof(int);
            std::vector<int> v(elements, elements + n);
    
            int n1 = sizeof(elements1) / sizeof(int);
            std::vector<int> v1(elements1, elements1 + n1);
    
            std::vector<int>::iterator it;
            it = std::search(v.begin(),v.end(),v1.begin(),v1.end());
            if(it != v.end())
            {
                    std::cout<<"Find SubStr Equal v1:"<<*it<<std::endl;
            }
            else
            {
                    std::cout<<"Dont Find!"<<std::endl;
            }
    
            it = std::search(v.begin(),v.end(),v1.begin(),v1.end(),SearchDouble<int>());
            if(it != v.end())
            {
                    std::cout<<"search double ok"<<*it<<std::endl;
            }
            return 0;
    }
    

    　　

• mismatch
  • 

  • #include <vector>
    #include <iostream>
    #include <algorithm>
    
    //从第一个容器里面找到与第二个容器不一样的第一个元素
    int main()
    {
            int elements[] = {1,2,3,100,100,5};
            int elements1[] = {1,2,3,200};
    
            int n = sizeof(elements) / sizeof(int);
            std::vector<int> v(elements, elements + n);
    
            int n1 = sizeof(elements1) / sizeof(int);
            std::vector<int> v1(elements1, elements1 + n1);
    
            typedef std::vector<int>::iterator IntIterator;
            std::pair<IntIterator,IntIterator> p;
    
            p = std::mismatch(v.begin(),v.end(),v1.begin());
            if(p.first == v.end() && p.second == v1.end())
            {
                    std::cout<<"equal"<<std::endl;
            }
            else
            {
                    std::cout<<"not equal:"<<std::endl<<*p.first<<" "<<*p.second<<std::endl;
            }
    
    
            p = std::mismatch(v.begin(),v.end(),v1.begin(),std::greater_equal<int>());
            return 0;
    }