泛型算法-非变易算法

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