算法函数练习

find：

#include <iostream>
#include <list>
#include <algorithm>

using namespace std;

int main()
{
	int a[10]={0,1,2,3,4,5,6,7,8,9};
	size_t a_size = sizeof(a)/sizeof(int);
	list<int> li(a, a+a_size);
	list<int>::iterator itor1, itor2;

	for(itor1 = li.begin(); itor1 != li.end(); ++itor1)//打印：0 1 2 3 4 5 6 7 8 9
		cout << *itor1 << "	";
	cout << endl;

	itor1 = find(li.begin(), li.end(), 5);
	itor2 = find(li.begin(), li.end(), 9);
	li.erase(itor1, itor2);//删除的区间为：[itor1, itor2)-----左闭右开

	for(itor1 = li.begin(); itor1 != li.end(); ++itor1)//打印：0 1 2 3 4 9
		cout << *itor1 << "	";
	cout << endl;
	return 0;
}

　　count

#include <iostream>
#include <vector>
#include <algorithm>  //count 在此定义

using namespace std;

int main()
{
    vector<int> vec;
    for(vector<int>::size_type cnt1 = 0; cnt1 != 10; ++cnt1)
    {
        for(vector<int>::size_type cnt2 = 0; cnt2 != cnt1; ++cnt2)
        {
            vec.push_back(cnt2);
        }
    }
    int val;
    while(cin >> val)
    {
        cout << val << " 在vector中出现了 " << count(vec.begin(), vec.end(), val) << " 次。" << endl;
    }
    return 0;
}

find_first_of

/**
  * find_first_of查找算法：这个算法带有两对迭代器参数来标记两段元素范围，在第一段范围内
  * 查找与第二段范围中 任意 元素匹配的元素，然后返回一个迭代器，指向第一个匹配的元素，
  * 如果找不到匹配元素，则返回第一个范围的end迭代器。
  */

/**
  *示例：假设list1 和 list2 是两个存放名字的 list 对象，可使用find_first_of 统计
  *有多少个名字同时出现在这两个列表当中
  *list1 和  list2类型不必精确匹配；list1可以是list对象，list2可以是vector对象、deque对象，只要
  *可以进行 == 操作符进行比较即可。如果list1 是 list<string> 对象，则 list2 可以是vector<char *>对象，
  *因为string标准库为string标准库为string对象与char*对象定义了相等(==)操作符。
  */
#include <iostream>
#include <algorithm>
#include <list>

using namespace std;

int main()
{
    list<string> list1;
    list<string> list2;
    
    list1.push_back("Jack");
    list1.push_back("Ben");
    list1.push_back("Bob");
    list1.push_back("Marry");
    
    list2.push_back("Jack");
    list2.push_back("Lucy");
    list2.push_back("Andy");
    list2.push_back("Bob");
    
    size_t cnt = 0;
    list<string>::iterator it = list1.begin();
    while((it = find_first_of(it, list1.end(), list2.begin(), list2.end())) != list1.end())
    {
        ++cnt;
        ++it;
    }
    cout << "list1 和 list2 中公有的名字一共有 " << cnt << " 个." << endl;
    system("pause");
    return 0;
}

 erase

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

using namespace std;

int main()
{
    int a[10]={0,1,2,3,4,5,6,7,8,9};
    size_t a_size = sizeof(a)/sizeof(int);

    list<int> li(a, a+a_size);
    cout << "初始list中元素为：" << endl;
    for(list<int>::iterator itor = li.begin(); itor != li.end(); ++itor)
    {
        cout << *itor << "	";
    }
    cout << endl;

    vector<int> ve(a, a+a_size);
    cout << "初始vector中的元素为" << endl;
    for(vector<int>::iterator itor = ve.begin(); itor != ve.end(); ++itor)
    {
        cout << *itor << "	";
    }
    cout << endl;

    for(list<int>::iterator itor = li.begin(); itor != li.end(); ++itor)
    {
        if((*itor) & 1)
        {
            //li.erase(itor);注意这样写是错误的，不能达到预期效果，引文每次erase之后的迭代器会失效，所以要重新赋值
            itor = li.erase(itor);  //erase返回指向删除迭代器itor所指元素之后的下一个元素的迭代器，
                                    //如果itor已经指向超出末端的下一位置的迭代器，则返回的迭代器也指向容器超出末端的下一位置
        }
    }
    for(vector<int>::iterator itor = ve.begin(); itor != ve.end(); ++itor)
    {
        if(!((*itor) & 1))
        {
            itor = ve.erase(itor);
        }
    }


    cout << "删除奇数后list中元素为：" << endl;
    for(list<int>::iterator itor = li.begin(); itor != li.end(); ++itor)
    {
        cout << *itor << "	";
    }
    cout << endl;
    cout << "删除偶数后vector中元素为：" << endl;
    for(vector<int>::iterator itor = ve.begin(); itor != ve.end(); ++itor)
    {
        cout << *itor << "	";
    }
    cout << endl;
    system("pause");
    return 0;
}

/*
#include <iostream>
#include <list>
#include <vector>
using namespace std;

int main(int argc, char* argv[])
{
    int ia[] = { 0, 1, 1, 2, 3, 5, 8, 13, 21, 55, 89 };
    vector<int> iVec( ia, ia+11 );
    list<int> iLst( ia, ia+11 );

    cout << "  Before erase, the elements of iVec are:" << endl;
    for ( vector<int>::iterator it = iVec.begin(); it != iVec.end(); ++it )
        cout << *it << " ";
    cout << "
  Before erase, the elements of iLst are:" << endl;
    for ( list<int>::iterator it = iLst.begin(); it != iLst.end(); ++it )
        cout << *it << " ";

    // 2 erase
    for ( vector<int>::iterator iter = iVec.begin(); iter != iVec.end(); ++iter )
    {
        if ( *iter % 2 == 0 )
        {
            iter = iVec.erase( iter );
        }
    }
    for ( list<int>::iterator Lit = iLst.begin(); Lit != iLst.end(); ++Lit )
    {
        if ( *Lit % 2 == 1 )
        {
            Lit = iLst.erase( Lit );
            --Lit;
        }
    }


    // show
    cout << "
  After erase, the elements of iVec are:" << endl;
    for ( vector<int>::iterator it = iVec.begin(); it != iVec.end(); ++it )
        cout << *it << " ";
    cout << "
  After erase, the elements of iLst are:" << endl;
    for ( list<int>::iterator it = iLst.begin(); it != iLst.end(); ++it )
        cout << *it << " ";
    cout << endl;

    system("pause");
    return 0;
}
*/

 accumulate

/**
  *   accumulate 算法在numeric头文件中定义，accumulate有带有三个形参，头两个形参指定要累加的元素范围，第三个形参
  *   则是累加的初值。accumulate 将它的一个内部变量设置为指定的初值，然后在此初值上累加输入范围内所有元素的值。
  *   accumulate 算法返回累加的结果，其返回类型就是第三个实参的类型
  *   accumulate 对要累加的元素类型一无所知，必须根据第三个参数来确定，所以第三个实参不能少
  */

/*
示例一：用accumulate统计vector<int>容器对象中的元素之和
#include <iostream>
#include <vector>
#include <numeric>  //accumulate 在此定义

using namespace std;

int main()
{
    vector<int> vec;
    for(vector<int>::size_type cnt = 0; cnt != 101; ++cnt)
        vec.push_back(cnt);
    cout << "0到100的和为：" << accumulate(vec.begin(), vec.end(), 0) << endl;
    system("pause");
    return 0;
}
*/
//示例二：用 accumulate 把string类型的vector容器中的元素连接起来：
#include <iostream>
#include <vector>
#include <numeric>

using namespace std;

int main()
{
    vector<string> vec;
    string str;
    while(cin >> str)
        vec.push_back(str);
    cout << "连接后的字符串为" << accumulate(vec.begin(), vec.end(), string("")) << endl;
    /**
      *注意程序显示的创建了一个string对象，用作该函数调用的第三个实参。传递一个字符串字面值将会导致编译时错误。
      *因为此时累加和的类型将是 const char*类型，而string的加法操作符所使用的操作数则分别是string和const char*类型，
      *加法的结果将产生一个string对象，而不是const char*指针
    */
    system("pause");
    return 0;
}

 写容器元素的算法

#include <iostream>
#include <algorithm>
#include <iterator>
#include <list>
#include <vector>

using namespace std;

int main()
{
    list<int> li;
    list<int>::iterator itor;
    for(list<int>::size_type cnt = 0; cnt != 10; ++cnt)
        li.push_back(cnt);
    for(itor = li.begin(); itor != li.end(); ++itor)
        cout << *itor << "  ";
    cout << endl;
    
    // back_inserter是插入迭代器，是可以给基础容器添加元素的迭代器
    fill_n(back_inserter(li), 10, 0);  //在原来li序列的后边插入10个0
    
    for(itor = li.begin(); itor != li.end(); ++itor)
        cout << *itor << "  ";
    cout << endl;
    
    fill(li.begin(), li.end(), 0);     //把li列表中的值全赋值成 0
    for(itor = li.begin(); itor != li.end(); ++itor)
        cout << *itor << "  ";
    cout << endl;
    
    vector<int> ivec;
    // copy elements from li into ivec
    copy(li.begin(), li.end(), back_inserter(ivec));
    //该做法效率比较差，相当于vector<int> ivec(li.begin(), li.end());
    
    //replace any elements with value of 0 by 42
    replace(li.begin(), li.end(), 0, 42);//把li中所有0变成42
    
    //create empty vector to hold the replacement
    vector<int> vec;//li中的元素不变，把li中的元素复制到vec中，并且把所有为0的元素改成42
    replace_copy(li.begin(), li.end(), back_inserter(vec), 0, 42);
    
    for(itor = li.begin(); itor != li.end(); ++itor)
        cout << *itor << "  ";
    cout << endl;
    
    for(vector<int>::iterator itor1 = ivec.begin(); itor1 != ivec.end(); ++itor1)
        cout << *itor1 << "  ";
    cout << endl;
    for(vector<int>::iterator itor1 = vec.begin(); itor1 != vec.end(); ++itor1)
        cout << *itor1 << "  ";
    cout << endl;
    
    
    system("pause");
    return 0;
}

 对容器元素重新排序的算法

/**
  * 功能：对一个存储了string类型单词的vector容器，计算该容器中有多少个由六位或以上字母组成的单词
  *每个单词只统计一次，不考虑他出现的次数，要求以长度从小到大输出，长度相同的按照字典序从小到大输出
  * 步骤：1、字典排序；  2、去掉所有重复的单词；  3、按照单词长度排序  4、统计长度等于后超过6个字符的单词个数
  */
#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

bool isShorter(const string &s1, const string &s2)  //从小到大排序
{
    return s1.size() < s2.size();
}

bool GT6(const string s)
{
    return s.size() >= 6;
}

string make_plural(size_t ctr, const string &word, const string &ending)
{
    return (ctr == 1) ? word : word + ending;
}
int main()
{
    vector<string> words;
    
    string next_word;
    while(cin >> next_word)
    {
        words.push_back(next_word);
    }
    //sort(words.begin(), words.end());  //字典序排列
    vector<string>::iterator unique_end = unique(words.begin(), words.end());//
    //unique算法，删除  相邻   的   重复  元素（并非真的删除，words的大小没有变化）然后重新排列输入范围内的元素
    //并且返回一个迭代器，表示无重复的值范围的结束；unique函数只是将无重复的元素复制到序列的前端，
    //返回的迭代器指向超出无重复元素范围的下一个位置.
    
    words.erase(unique_end, words.end());
    stable_sort(words.begin(), words.end(), isShorter);//长度按照从大到小的稳定排序，所以长度相同的仍然按照的是字典序排列
    vector<string>::size_type cnt = count_if(words.begin(), words.end(), GT6);

    cout << cnt << " " << make_plural(cnt, "word", "s") << " 6 characters or longer" << endl;
    for (vector<string>::iterator it = words.begin();  it != words.end(); ++it)
        cout << *it << "  ";
    cout << endl;

    system("pause");
    return 0;
}

 unique_copy

//unique_copy用于指定复制不重复的元素到目标序列
#include <iostream>
#include <algorithm>
#include <vector>
#include <list>

using namespace std;

int main()
{

    int ia[] = { 1, 2, 3, 4, 100, 100, 5 };
    list<int> iLst( ia, ia+7 );
    // testing out iLst
    cout << "
	The contents of iLst:
	";
    for ( list<int>::iterator it = iLst.begin(); it != iLst.end(); ++it )
        cout << *it << "  ";
    cout << endl;

    vector<int> iVec;
    // copy iLst's member to iVec;
    cout << "
  Using unique_copy, copy iLst's member to iVec: " << endl;
    unique_copy( iLst.begin(), iLst.end(), back_inserter( iVec) );

    cout << "
	The contents of iVec:
	";
    for ( vector<int>::iterator it = iVec.begin(); it != iVec.end(); ++it )
        cout << *it << "  ";
    cout << endl;
    system("pause");
    return 0;
}