algorithm之不变序列操作

/*
std::for_each
template <class InputIterator, class Function>
Function for_each (InputIterator first, InputIterator last, Function fn);

Apply function to range
Applies function fn to each of the elements in the range [first,last).
[对[first, last)中的所有元素调用函数fn]
The behavior of this template function is equivalent to:
[该模板函数的行为与以下操作等价：]
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);
}
*/

#include <iostream>
#include <vector>
#include <algorithm>

class myclass
{
public:
void operator() (int i)
{
std::cout<<' '<<i;
}
};

void myfunctoin (int i)
{
std::cout<<' '<<i;
}

int main()
{
std::vector<int> myvec;
std::vector<int>::iterator it;

for(int i=0; i<10; i++)
myvec.push_back(i+1);

std::cout<<"myvec contains:";
for_each(myvec.begin(), myvec.end(), myfunctoin);
std::cout<<'\n';

//or
myclass obj;
std::cout<<"myvec contains:";
for_each(myvec.begin(), myvec.end(), obj);
std::cout<<'\n';

system("pause");
return 0;
}

/*
std::find
template <class InputIterator, class T>
InputIterator find (InputIterator first, InputIterator last, const T& val);

Find value in range
Returns an iterator to the first element in the range [first,last) that compares equal to val. If no such element is found, the function returns last.
[返回[first, last)中第一个指向val的迭代器，如果没有找到则返回last]
The function uses operator== to compare the individual elements to val.
[该函数使用operator==来比较元素元素是否为val]
The behavior of this function template is equivalent to:
[该模板函数的行为与以下操作等价：]
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;
}
*/

#include <iostream>
#include <vector>
#include <algorithm>

int main()
{
// using std::find with array and pointer.
int myints[] = {10, 20, 30, 40};
int *p;

p = std::find(myints, myints+4, 30);
if(p != myints+4)
std::cout<<"Element found in myints: "<<*p<<'\n';
else
std::cout<<"Element not found in myints\n";

// using std::find with vector and iterator.
std::vector<int> myvector (myints, myints+4);
std::vector<int>::iterator it;

it = std::find(myvector.begin(), myvector.end(), 30);
if(it != myvector.end())
std::cout<<"Element found in myints: "<<*it<<'\n';
else
std::cout<<"Element not found in myints\n";

system("pause");
return 0;
}

/*
std::find_if
template<class InputIterator, class UnaryPredicate>
InputIterator find_if (InputIterator first, InputIterator last, UnaryPredicate pred);

Find element in range
Returns an iterator to the first element in the range [first,last) for which pred returns true. If no such element is found, the function returns last.
[返回[first, last)中第一个使得pred返回真的迭代器，如果没有找到，则返回last]
The behavior of this function template is equivalent to:
[该函数模板的行为等价于以下操作：]
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;
}
*/

#include <iostream>
#include <algorithm>
#include <vector>

bool IsOdd (int i)
{
return ((i%2) == 1);
}

int main()
{
std::vector<int> myvector;

myvector.push_back(10);
myvector.push_back(25);
myvector.push_back(40);
myvector.push_back(55);

std::vector<int>::iterator it = std::find_if(myvector.begin(), myvector.end(), IsOdd);

if(it != myvector.end())
std::cout<<"The first odd value in myvector is "<<*it<<'\n';
else
std::cout<<"There is no odd value in myvector."<<'\n';

system("pause");
return 0;
}

/*
//std::adjacent_find
template <class FowardIterator>
FowardIterator adjacent_find (FowardIterator first, FowardIterator last);

template <class FowardIterator, class BinaryPredicate>
FowardIterator adjacent_find (FowardIterator first, FowardIterator last, BinaryPredicate pred);

Find equal adjacent elements in range
Searches the range [first,last) for the first occurrence of two consecutive elements that match, and returns an iterator to the first of these two elements, or last if no such pair is found.
[在[fisrt, last)中寻找第一次匹配成功的两个连续元素，并返回指向其中第一个元素的迭代器，如果没有匹配成功，则返回last]
Two elements match if they compare equal using operator== (or using pred, in version (2)).
[默认使用operator==来判断两个元素是否匹配成功，或者使用pred来判断]
The behavior of this function template is equivalent to:
[该函数模板的行为等价于以下操作：]
template <class FowardIterator>
FowardIterator adjacent_find (FowardIterator first, FowardIterator last)
{
if(first != last)
{
FowardIterator next = first;
++next;
while(next != last){
if(*first == *next)    return first;
++first;    ++next;
}
return last;
}
}
*/

#include <iostream>
#include <algorithm>
#include <vector>

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

int main()
{
int myints[] = {5, 20, 5, 30, 30, 20, 10, 10, 20};
std::vector<int> myvector(myints, myints+9);
std::vector<int>::iterator it;

it  = std::adjacent_find(myvector.begin(), myvector.end());

if(it != myvector.end())
std::cout<<"The first pair of repeated elements are "<<*it<<'\n';

it = std::adjacent_find(++it, myvector.end(), myfunctoin);

if(it != myvector.end())
std::cout<<"The second pair of repeated elements are "<<*it<<'\n';

system("pause");
return 0;
}

/*
std::find_end
template <class ForwardIterator1, class ForwardIterator2>
ForwardIterator1 find_end (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2);

template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
ForwardIterator1 find_end (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);

Find last subsequence in range
Searches the range [first1,last1) for the last occurrence of the sequence defined by [first2,last2), and returns an iterator to its first element, or last1 if no occurrences are found.
[在序列[first1, last2)中搜索出最后一个与序列[first2, last2)相匹配的子序列，并返回指向搜索到的子序列的第一个元素的迭代器，如果没有搜索到则返回last1]
The elements in both ranges are compared sequentially using operator== (or pred, in version (2)): A subsequence of [first1,last1) is considered a match only when this is true for all the elements of [first2,last2).
[比较两个序列中的元素是通过operator==来进行的(或者使用pred)]
This function returns the last of such occurrences. For an algorithm that returns the first instead, see search.
[该函数按返回的是最后一个匹配的子序列，如果想要得到第一个匹配的子序列，请看search算法]
The behavior of this function template is equivalent to:
[该函数模板的行为等价于以下操作：]
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)) for version (2)
++it1;    ++it2;
if(it2 == last2)    {ret = first1;    break;}
if(it1 == last1)    return ret;
}
++first1;
}
return ret;
}
*/

#include <iostream>
#include <algorithm>
#include <vector>

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

int main()
{
int myints[] = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5};
std::vector<int> myvector(myints, myints+10);

int needle1[] = {1, 2, 3};

// using default comparison.
std::vector<int>::iterator it;
it = std::find_end(myvector.begin(), myvector.end(), needle1, needle1+3);

if(it != myvector.end())
std::cout<<"needle1 last found  at position "<<(it - myvector.begin())<<'\n';

int needle2[] = {4, 5, 1};

// using predicate comparison.
it = std::find_end(myvector.begin(), myvector.end(), needle2, needle2+3, myfunctoin);

if(it != myvector.end())
std::cout<<"needle2 last found at position "<<(it - myvector.begin())<<'\n';

system("pause");
return 0;
}

/*
std::find_first_of
template <class ForwardIterator1, class ForwardIterator2>
ForwardIterator1 find_first_of (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2);

template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
ForwardIterator1 find_first_of (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);

Find element from set in range
Returns an iterator to the first element in the range [first1,last1) that matches any of the elements in [first2,last2). If no such element is found, the function returns last1.
[返回指向[first1, last1)中第一个与[first2, last2)中任一元素相匹配的元素的迭代器，如果没有找到则返回last1]]
The elements in [first1,last1) are sequentially compared to each of the values in [first2,last2) using operator== (or pred, in version (2)), until a pair matches.
[元素的比较是通过operator==来进行的(或者通过pred)]
The behavior of this function template is equivalent to:
[该函数模板的行为等价于以下操作：]

template <class ForwardIterator1, class ForwardIterator2>
ForwardIterator1 find_first_of (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2)
{
while(first1 != last1){
for(ForwardIterator2 it2 = first2; it2 != last2; ++it2){
if(*it2 == *first1)     // or: if (pred(*it,*first)) for version (2)
return first1;
}
++first1;
}
return last1;
}
*/

#include <iostream>     // std::cout
#include <algorithm>    // std::find_first_of
#include <vector>       // std::vector
#include <cctype>       // std::tolower

bool comp_case_insensitive (char c1, char c2) {
return (std::tolower(c1)==std::tolower(c2));
}

int main () {
int mychars[] = {'a','b','c','A','B','C'};
std::vector<char> haystack (mychars,mychars+6);
std::vector<char>::iterator it;

int needle[] = {'A','B','C'};

// using default comparison:
it = find_first_of (haystack.begin(), haystack.end(), needle, needle+3);

if (it!=haystack.end())
std::cout << "The first match is: " << *it << '\n';

// using predicate comparison:
it = find_first_of (haystack.begin(), haystack.end(),
needle, needle+3, comp_case_insensitive);

if (it!=haystack.end())
std::cout << "The first match is: " << *it << '\n';

system("pause");
return 0;
}

/*
std::equal
template <class InputItertor1, class InputIterator2>
bool equal (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);

template <class InputIterator1, class InputIterator2, class BinaryPredicate>
bool equal (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, BinaryPredicate pred);

Test whether the elements in two ranges are equal
[比较两个范围中的元素是否相等]
Compares the elements in the range [first1,last1) with those in the range beginning at first2, and returns true if all of the elements in both ranges match.
[将[first1, last1)中的元素与以first2为起点的相同范围内的元素进行比较，如果两个范围中的元素全部相等则返回真]
The elements are compared using operator== (or pred, in version (2)).
[元素间通过operator==进行比较(或者使用pred)]
The behavior of this function template is equivalent to:
[该函数模板的行为等价于以下操作：]
template <class InputIterator1, class InputIterator2>
bool equal (InputIterator1 first1, InputIterator2 last1, InputIterator2 first2)
{
while(first1 != last1){
if(!(*first1 == *first2))     // or: if (!pred(*first1,*first2)), for version 2
return false;
++first1;    ++first2;
}
return true;
}
*/

#include <iostream>
#include <algorithm>
#include <vector>

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

int main()
{
int myints[] = {20, 40, 60, 80, 100};
std::vector<int> myvector(myints, myints+5);

if(std::equal(myvector.begin(), myvector.end(), myints))
std::cout<<"The contents of both sequences are equal.\n";
else
std::cout<<"The contents of both sequences differ.\n";

myvector[3] = 81;

if(std::equal(myvector.begin(), myvector.end(), myints, mypredicate))
std::cout<<"The contents of both sequences are equal.\n";
else
std::cout<<"The contents of both sequences differ.\n";

system("pause");
return 0;
}

/*
std::mismatch
template <class InputIterator1, class InputIterator2>
pair<InputIterator1, InputIterator2> mismatch (InputIterator1 first1, InputIterator1 last1, InputIterator1 first2);

template <class InputIterator1, class InputIterator2, class BinaryPredicate>
pair<InputIterator1, InputIterator2> mismatch (InputIterator1 first1, InputIterator1 last1, InputIterator1 first2, BinaryPredicate pred);

Return first position where two ranges differ
Compares the elements in the range [first1,last1) with those in the range beginning at first2, and returns the first element of both sequences that does not match.
[比较[first1, last1)与[fist2, last2)之间的元素，并返回两者第一个不匹配的元素]
The elements are compared using operator== (or pred, in version (2)).
[元素间的比较通过operator==来进行(或者通过pred)]
The function returns a pair of iterators to the first element in each range that does not match.
[该函数的返回值类型是pair，其中的两个参数是指向两个区间中不匹配元素的迭代器]
The behavior of this function template is equivalent to:
[该函数模板的行为等价于以下操作：]

template <class InputIterator1, class InputIterator2>
pair<InputIterator1, InputIterator2> mismatch (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2 )
{
while ( (first1!=last1) && (*first1==*first2) )  // or: pred(*first1,*first2), for version 2
{ ++first1; ++first2; }
return std::make_pair(first1,first2);
}
*/

#include <iostream>
#include <algorithm>
#include <vector>
#include <utility>    //std::pair

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

int main()
{
std::vector<int> myvector;
for(int i=1; i<6; i++)    myvector.push_back(i*10);

int myints[] = {10, 20, 40, 320, 1024};

std::pair<std::vector<int>::iterator, int*> mypair;

// using default comparison
mypair = std::mismatch(myvector.begin(), myvector.end(), myints);
std::cout<<"First mismatch elements: "<<*mypair.first<<" and "<<*mypair.second<<'\n';

// using predicate comparison
mypair = std::mismatch(++mypair.first, myvector.end(), ++mypair.second, mypredicate);
std::cout<<"Second mismatch elements: "<<*mypair.first<<" and "<<*mypair.second<<'\n';

system("pause");
return 0;
}

/*
template <class ForwardIterator1, class ForwardIterator2>
ForwardIterator1 search (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator1 first2, ForwardIterator1 last2);

template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
ForwardIterator1 search (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator1 first2, ForwardIterator1 last2, BinaryPredicate pred);

Search range for subsequence
Searches the range [first1,last1) for the first occurrence of the sequence defined by [first2,last2), and returns an iterator to its first element, or last1 if no occurrences are found.
[在[first1, last1)中搜索第一个与序列[first2, last2)相匹配的子序列，并返回指向搜索到的子序列的第一个元素的迭代器，如果没有搜索到则返回last1]
The elements in both ranges are compared sequentially using operator== (or pred, in version (2)): A subsequence of [first1,last1) is considered a match only when this is true for all the elements of [first2,last2).
[元素的比较是通过operator==来进行的(或者通过pred)]
This function returns the first of such occurrences. For an algorithm that returns the last instead, see find_end.
[该函数返回第一个与给定序列匹配的子序列，如果想要返回最后一个，请参看find_end.]
The behavior of this function template is equivalent to:
[该函数模板的行为等价于以下操作：]

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

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

#include <iostream>
#include <algorithm>
#include <vector>

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

int main()
{
std::vector<int> myvector;
for(int i=1; i<10; i++)    myvector.push_back(i*10);
std::vector<int>::iterator it;

// using default comparison.
int needle1[] = {40, 50, 60, 70};
it = std::search(myvector.begin(), myvector.end(), needle1, needle1+4);

if(it != myvector.end())
std::cout<<"needle1 found at position "<<it-myvector.begin()<<'\n';
else
std::cout<<"needle1 not found.\n";

// using predicate comparison.
int needle2[] = {20, 30, 50};
it = std::search(myvector.begin(), myvector.end(), needle2, needle2+3, mypredicate);

if(it != myvector.end())
std::cout<<"needle2 found at position "<<it-myvector.begin()<<'\n';
else
std::cout<<"needle2 not found.\n";

system("pause");
return 0;
}

/*
template <class ForwardIterator, class Size, class T>
ForwardIterator search_n (ForwardIterator first, ForwardIterator last, Size count, const T& val);

template <class ForwardIterator, class Size, class T, class BinaryPredicate>
ForwardIterator search_n (ForwardIterator first, ForwardIterator last, Size count, const T& val, BinaryPredicate pred);

Search range for elements
Searches the range [first,last) for a sequence of count elements, each comparing equal to val (or for which pred returns true).
[在[first, last)中搜索是否连续出现count次val]
The function returns an iterator to the first of such elements, or last if no such sequence is found.
[该函数返回指向第一个等于val的元素的迭代器，如果没有找到则返回last]
The behavior of this function template is equivalent to:
[该函数模板的行为等价于以下操作：]

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);  //注：私认为应该是std::advance(limit, std::distance(first, last)-count+1)

while (first!=limit)
{
it = first; i=0;
while (*it==val)       // or: while (pred(*it,val)) for the pred version
{ ++it; if (++i==count) return first; }
++first;
}
return last;
}
*/

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

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

int main () {
int myints[]={10,20,30,30,20,10,10,20};
std::vector<int> myvector (myints,myints+8);

std::vector<int>::iterator it;

// using default comparison:
it = std::search_n (myvector.begin(), myvector.end(), 2, 30);

if (it!=myvector.end())
std::cout << "two 30s found at position " << (it-myvector.begin()) << '\n';
else
std::cout << "match not found\n";

// using predicate comparison:
it = std::search_n (myvector.begin(), myvector.end(), 2, 10, mypredicate);

if (it!=myvector.end())
std::cout << "two 10s found at position " << int(it-myvector.begin()) << '\n';
else
std::cout << "match not found\n";

system("pause");
return 0;
}

/*
std::count
template <class InputIterator, class T>
typename iterator_traits<InputIterator>::difference_type count (InputIterator first, InputIterator last, const T& val);

Count appearances of value in range
Returns the number of elements in the range [first,last) that compare equal to val.
[返回[first, last)中与val相等的元素的个数]
The function uses operator== to compare the individual elements to val.
[该函数使用operator==来判断元素是否等于val]
The behavior of this function template is equivalent to:
[该函数模板的行为等价于以下操作：]
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;
}
*/

#include <iostream>
#include <algorithm>
#include <vector>

int main()
{
int myints[] = {10, 20, 30, 30, 20, 10, 10, 20};
int mycount = std::count(myints, myints+8, 10);
std::cout<<"10 appears "<<mycount<<" times.\n";

std::vector<int> myvector(myints, myints+8);
mycount = std::count(myvector.begin(), myvector.end(), 20);
std::cout<<"20 appears "<<mycount<<" times.\n";

system("pause");
return 0;
}

/*
template <class InputIterator, class UnaryPredicate>
typename iterator_traits<InputIterator>::difference_type count_if (InputIterator first, InputIterator last, UnaryPredicate pred);

Return number of elements in range satisfying condition
[返回区间中满足条件的元素个数]
Returns the number of elements in the range [first,last) for which pred is true.
[返回[first, last)中使得pred返回真的元素个数]
The behavior of this function template is equivalent to:
[该函数模板的行为等价于以下操作：]

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

#include <iostream>
#include <algorithm>
#include <map>
#include <string>
#include <utility>

class stuRecord
{
public:
class stuInfo
{
public:
void setName(std::string m_name) {name = m_name;}
void setAge(int m_age) {age = m_age;}
void setAddr(std::string m_addr) {addr = m_addr;}

std::string getName() const {return name;}
int getAge() const {return age;}
std::string getAddr() const {return addr;}

private:
std::string name;
int age;
std::string addr;
};

private:
int id;
stuInfo m_stuInfo;

public:
stuRecord(int m_id, std::string m_name, int m_age, std::string m_addr)
{
id = m_id;
m_stuInfo.setName(m_name);
m_stuInfo.setAge(m_age);
m_stuInfo.setAddr(m_addr);
}

int getId() const {return id;}
stuInfo getStuInfo() const {return m_stuInfo;}
};

typedef stuRecord::stuInfo stuRI;

bool setRange(std::pair<int, stuRI> stu)
{
return ((stu.second.getAge() > 20) && (stu.second.getAge() < 30));
}

int main()
{
stuRecord stu1(1, "张三", 21, "上海");
stuRecord stu2 = stuRecord(2, "李四", 29, "上海");
stuRecord stu3 = stuRecord(3, "王五", 12, "深圳");
stuRecord stu4 = stuRecord(4, "赵六", 25, "长沙");
stuRecord stu5 = stuRecord(5, "孙七", 30, "广东");

std::map<int, stuRI> mymap;
mymap.insert(std::make_pair(stu1.getId(), stu1.getStuInfo()));
mymap.insert(std::make_pair(stu2.getId(), stu2.getStuInfo()));
mymap.insert(std::make_pair(stu3.getId(), stu3.getStuInfo()));
mymap.insert(std::make_pair(stu4.getId(), stu4.getStuInfo()));
mymap.insert(std::make_pair(stu5.getId(), stu5.getStuInfo()));

int mycount = std::count_if(mymap.begin(), mymap.end(), setRange);
std::cout<<"The number of students whose age between 20 and 30 is "<<mycount<<'\n';

system("pause");
return 0;
}