STL学习笔记--非变易算法

非变易算法

　　C++ STL 的非变易算法（Non-mutating algorithm）是一组不破坏操作数据的模板函数，用来对序列数据进行逐个处理、元素查找、子序列搜索、统计和匹配。作为算法函数参数的迭代器，一般为 Input Iterator 输入迭代器，具有 "++" 迭代和 "*" 访问操作。通过迭代器的元素遍历，可对迭代器区间所界定的元素进行操作。因此，非变易算法具有极为广泛的适用性，基本上可应用于各种容器。

目录：

逐个容器元素 for_each

查找容器元素 find

条件查找容器元素 find_if

邻近查找容器元素 adjacent_find

范围查找容器元素 find_first_of

统计等于某值的容器元素个数 count

条件统计容器元素个数 count_if

元素不匹配查找 mismatch

元素相等判断 equal

子序列搜索 search

重复元素子序列搜索 search_n

最后一个子序列搜索 find_end
 

/*    下面的示例程序将 list 链表容器的元素，调用 for_each 算法函数，通过 print 函数对象，将各个链表的元素乘以3后打印，并输出元素个数
*/
-------------------------------------------------------- 应用 for_each 算法遍历 list 容器
#include <algorithm>    // 这个头文件很重要的哦
#include <list>
#include <iostream>
using namespace std;

struct print
{
    int count; // 打印的元素计数
    print(){count=0;}
    void operator() (int x)
    {
        cout << 3*x << endl;
        count++;
    }
};

int main()
{
    // 双向链表初始化
    list<int> lInt;
    lInt.push_back(29);
    lInt.push_back(32);
    lInt.push_back(16);
    lInt.push_back(22);
    lInt.push_back(28);
    lInt.push_back(27);

    // 打印链表的元素
    print  p = for_each(lInt.begin(), lInt.end(), print());
    // 打印的元素个数
    cout <<"元素个数为："<<p.count << endl;

    return 0;
}

 

 

/*    下面示例程序利用 find 算法函数查找 list 链表中第一个值为 14 的元素
*/
-------------------------------------------------------- 应用 find 算法查找 list 容器的元素
#include <algorithm>
#include <list>
#include <iostream>
using namespace std;
int main()
{
    // 双向链表初始化
    list<int>  lInt;
    lInt.push_back(100);
    lInt.push_back(10);
    lInt.push_back(14);
    lInt.push_back(13);
    lInt.push_back(14);
    lInt.push_back(40);

    // 查找元素 14
    list<int>::iterator  iLocation = find(lInt.begin(), lInt.end(), 14);
    if (iLocation != lInt.end())
        cout << "找到元素14 " << endl;

    // 打印第一个14元素前面的那个元素。即打印元素 10
    cout << "前一个元素为：" << *(--iLocation) << endl;

    return 0;
}

 

 

/*    下面示例程序使用 find_if 算法在 vector 向量容器上查找首个可被5整除的元素，程序输出为“找到第一个能被5整除的元素15，元素的索引位置为2”
*/
-------------------------------------------------------- 应用 find_if 算法条件查找 vector 容器的元素
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;

// 谓词判断函数 divby5
bool divby5(int x)
{
    return x%5 ? 0 : 1;
}

int main()
{
    vector<int>  vInt(20);  // 可以参考之前对 vector 的介绍
    for (unsigned int i=0; i<vInt.size(); i++)
        vInt[i] = (i+1)*(i+3);

    vector<int>::iterator iLocation;
    iLocation = find_if(vInt.begin(), vInt.end(), divby5);

    if (iLocation != vInt.end())
        cout << "找到第一个能被5整除的元素:"
             << *iLocation << endl  // 打印15
             << "元素的索引位置为:"
             << iLocation-vInt.begin() << endl; // 打印2

    return 0;
}

 

 

/*    调用 adjacent_find 算法函数找出邻近相等的元素11(链表中，有2个11是临近的)，再利用是否为奇偶相同，做谓词判断，找出首先同为奇数的 9和11.
*/
-------------------------------------------------------- 应用 adjacent_find 算法临近查找容器的元素
#include <algorithm>
#include <list>
#include <iostream>
using namespace std;

bool parity_equal (int x, int y)
{
    return (x-y)%2 == 0 ? 1 :0;
}

int main()
{
    // 初始化链表
    list<int>  lInt;
    lInt.push_back(3);
    lInt.push_back(6);
    lInt.push_back(9);
    lInt.push_back(11);
    lInt.push_back(11);
    lInt.push_back(18);
    lInt.push_back(20);
    lInt.push_back(20);
    // 查找邻接相等的元素
    list<int>::iterator  iResult = adjacent_find(lInt.begin(), lInt.end());
    if (iResult != lInt.end())
    {
        cout << "发现链表有两个邻接的元素相等" << endl;
        cout << *iResult << endl;    // 打印第1 个11
        ++iResult;
        cout << *iResult << endl;    // 打印第2 个11
    }

    // 查找奇偶性相同的邻接元素
    iResult = adjacent_find(lInt.begin(), lInt.end(), parity_equal);
    if (iResult != lInt.end())
    {
        cout << "发现有两个邻接元素的奇偶性相同" << endl;
        cout << *iResult << endl;   // 打印 9
        ++iResult;
        cout << *iResult << endl;   // 打印 11
    }

    return 0;
}

 

 

/*    下面示例程序在字符串 "abcdef7ghijklmn" 中查找首个出现在字符串 "zyx3pr7ys" 的字符，结果当然是字符 7
*/
-------------------------------------------------------- 应用 find_first_of 算法范围查找容器元素
#include <algorithm>
#include <iostream>
using namespace std;
int main()
{
    // 定义2个字符串
    char* str1 = "abcdef7ghijklmn";
    char* str2 = "zyx3pr7ys";
    // 范围查找 str1 于 str2 中
    char* result = find_first_of(str1,  str1 + strlen(str1),
                                 str2,  str2 + strlen(str2));
    cout << "字符串 str1 的第一个出现在 str2 的字符为："
         << *result << endl;   // 打印 7

    return 0;
}

 

 

/*    下面的示例程序链入100个20的余数到双向链表 list 中，然后统计其中等于 9 的元素个数。
*/

-------------------------------------------------------- 应用 count 算法统计等于某值的容器元素个数
#include <algorithm>
#include <list>
#include <iostream>
using namespace std;
int main()
{
    // 链表初始化
    list<int>  lInt;
    for (int i=0; i<100; i++)
        lInt.push_back(i%20);
    // 统计链表中等于 value 值的元素个数
    int num = 0;
    int value = 9;
    num = count(lInt.begin(), lInt.end(), value);
    cout << "链表中元素等于 value 的元素个数为："
         << num << endl;  // 打印5

    return 0;
}

 

 

/*    下面示例程序，将学生记录放入使用红黑树的 map 容器，然后利用一元谓词判断 setRange20_30 ，统计年龄在20至30岁之间的学生人数
*/

-------------------------------------------------------- 应用 count_if 算法统计满足条件的记录数
#pragma warning(disable:4786)
#include <algorithm>
#include <map>
#include <iostream>
using namespace std;

// 学生记录结构体
struct StudentRecord
{
    struct StudentInfo
    {
        char* name;
        int year;
        char* addr;
    };
    int id;  // 学号
    StudentInfo sf;  // 学生信息
    StudentRecord(int id_, char* name_, int year_, char* addr_)
    {
        id = id_;
        sf.name = name_;
        sf.year = year_;
        sf.addr = addr_;
    }
};

bool setRange20_30(pair<int, StudentRecord::StudentInfo>  s)
{
    // 20 < x < 30
    if (s.second.year > 20 && s.second.year < 30)
        return 1;

    return 0;
}

int main()
{
    // 学生数据
    StudentRecord  st1 = StudentRecord(1, "李强", 21, "北京");
    StudentRecord  st2 = StudentRecord(2, "李文", 29, "山东");
    StudentRecord  st3 = StudentRecord(3, "张三", 12, "江苏");
    StudentRecord  st4 = StudentRecord(4, "李四", 23, "武汉");
    StudentRecord  st5 = StudentRecord(5, "王五", 32, "上海");

    // 映照容器
    map<int, StudentRecord::StudentInfo>  m;
    // 插入 5条学生记录
    pair<int, StudentRecord::StudentInfo>  pairSt1(st1.id, st1.sf);
    m.insert(pairSt1);
    pair<int, StudentRecord::StudentInfo>  pairSt2(st2.id, st2.sf);
    m.insert(pairSt2);
    pair<int, StudentRecord::StudentInfo>  pairSt3(st3.id, st3.sf);
    m.insert(pairSt3);
    pair<int, StudentRecord::StudentInfo>  pairSt4(st4.id, st4.sf);
    m.insert(pairSt4);
    pair<int, StudentRecord::StudentInfo>  pairSt5(st5.id, st5.sf);
    m.insert(pairSt5);

    // 条件统计
    int num = 0;
    num = count_if(m.begin(), m.end(), setRange20_30);
    cout << "年龄介于20至30之间的学生人数为："
         << num << endl;  // 打印 3

    return 0;
}

 

 

/*    下面示例程序，分别使用了 mismatch 算法函数的两种形式。
*/

-------------------------------------------------------- 应用 msimatch 算法比较两个序列的元素
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;

bool strEqual(const char* s1, const char* s2)
{
    return strcmp(s1, s2) == 0 ? 1: 0;
}

int main()
{
    vector<int>  v1, v2;
    v1.push_back(2);
    v1.push_back(0);
    v1.push_back(0);
    v1.push_back(6);

    v2.push_back(2);
    v2.push_back(0);
    v2.push_back(0);
    v2.push_back(7);

    // v1 和 v2 不匹配检查
    pair<vector<int>::iterator, vector<int>::iterator>  result = mismatch(v1.begin(), v1.end(), v2.begin());

    if (result.first == v1.end() && result.second == v1.end())
        cout << "v1 和 v2 完全相同" << endl;
    else
        cout << "v1 和 v2 不相同，不匹配的数是：\n"
             << *result.first << endl
             << *result.second << endl << endl;


    // 初始化字符串 s1、s2
    char* s1[]={"apple", "pear", "watermelon", "banana", "grape"};
    char* s2[]={"apple", "pears", "watermelons", "banana", "grape"};
    // s1 和 s2 不匹配检查
    pair<char**, char**>  result2 = mismatch(s1, s1+5, s2, strEqual);
    if (result2.first == s1+5  &&  result2.second == s2+5)
        cout << "s1和s2完全相同" << endl;
    else
        cout << "s1 与 s2不相同，不匹配的字符串为：\n"
             << s1[result2.first - s1] << endl
             << s2[result2.second - s2] << endl << endl;

    return 0;
}

 

 

/*    下面示例程序，利用二元谓词判断 absEqual ，判断出两个 vector 向量容器的元素均绝对值相等。
*/

-------------------------------------------------------- 应用 equal 算法判断容器元素是否绝对值相等
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;

bool absEqual(int a, int b)
{
    return (a==abs(b) || abs(a)==b) ? 1 : 0;
}

int main()
{
    vector<int> v1(5);
    vector<int> v2(5);
    for (unsigned int i=0; i<v1.size(); i++)
    {
        v1[i] = i;
        v2[i] = -1 * i;
    }

    // v1、v2 相等检查
    if (equal(v1.begin(), v1.end(), v2.begin(), absEqual))
        cout << "v1 和 v2 元素的绝对值完全相等" << endl;
    else
        cout << "v1 和 v2 元素的绝对值不完全相等" << endl;

    return 0;
}

 

 

/*    下面示例程序，搜索 vector 向量 V1={5, 6, 7, 8, 9}是否包含子序列向量容器 v2={7, 8}.
*/

-------------------------------------------------------- 应用 search 方法搜索子序列
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
int main()
{
    // 初始化向量 v1
    vector<int> v1;
    v1.push_back(5);
    v1.push_back(6);
    v1.push_back(7);
    v1.push_back(8);
    v1.push_back(9);
    // 初始化向量 v2
    vector<int> v2;
    v2.push_back(7);
    v2.push_back(8);
    // 检查 v2 是否构成 v1 的子序列
    vector<int>::iterator  iterLocation;
    iterLocation = search(v1.begin(), v1.end(), v2.begin(), v2.end());
    // 打印从 v1[2]开始匹配
    if (iterLocation != v1.end())
        cout << "v2 的元素包含在 v1 中，起始元素为："
             << "v1[" << iterLocation - v1.begin() << "] \n";
    else
        cout << "v2的元素不包含在v1中." << endl;

    return 0;
}

 

 

/*    下面示例程序，搜索出向量 v={1, 8, 8, 8, 6, 6, 8}中有3个连续元素8、没有4个连续的元素8，以及有2个连续元素6
*/

-------------------------------------------------------- 应用 search_n 算法搜索重复元素值
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
int main()
{
    // 初始化向量 v
    vector<int> v;
    v.push_back(1);
    v.push_back(8);
    v.push_back(8);
    v.push_back(8);
    v.push_back(6);
    v.push_back(6);
    v.push_back(8);

    // 查找子序列 {8, 8, 8}
    vector<int>::iterator  iLocation;
    iLocation = search_n(v.begin(), v.end(), 3, 8);
    if (iLocation != v.end())
        cout << "在v中找到3个连续的元素8" << endl;
    else
        cout << "v中没有3个连续的元素8" << endl;

    // 查找子序列 {8, 8, 8, 8}
    iLocation = search_n(v.begin(), v.end(), 4, 8);
    if (iLocation != v.end())
        cout << "在v中找到4个连续的元素8" << endl;
    else
        cout << "v中没有4个连续的元素8" << endl;

    // 查找子序列{6, 6}
    iLocation = search_n(v.begin(), v.end(), 2, 6);
    if (iLocation != v.end())
        cout << "在v中找到2个连续的元素6" << endl;
    else
        cout << "v中没有2个连续的元素6" << endl;

    return 0;
}

 

 

/*    下面示例程序，搜索向量 v1={-5, 1, 2, -6, -8, 1, 2, -11}中最后一个与V2={1, 2}匹配的子序列，打印输出为 "v1中找到最后一个匹配v2的子序列，位置在 v1[5]"
*/
-------------------------------------------------------- 应用 find_end 算法搜索最后一个匹配子序列
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
int main()
{
    // 初始化向量 v1
    vector<int> v1;
    v1.push_back(-5);
    v1.push_back(1);
    v1.push_back(2);
    v1.push_back(-6);
    v1.push_back(-8);
    v1.push_back(1);
    v1.push_back(2);
    v1.push_back(-11);

    // 初始化向量 v2
    vector<int> v2;
    v2.push_back(1);
    v2.push_back(2);

    // v1中查找最后一个子序列 v2
    vector<int>::iterator  iLocation;
    iLocation = find_end(v1.begin(), v1.end(), v2.begin(), v2.end());

    // 打印子序列在 v1 的起始位置 v[5]
    if (iLocation != v1.end())
        cout << "v1中找到最后一个匹配 v2 的子序列，位置在"
             << "v1[" << iLocation - v1.begin() << "] \n"; 


    return 0;
}

 

 

------------ 非变易算法小结
    C++ STL 算法库中的非变易算法，是一些原则上不会变更操作数据的算法，包括可逐元素循环提交处理的 for_each 算法、用于元素查找的 find/find_if/adjacent_find/find_first_of 算法、用于统计元素个数的 count/count_if 算法、两序列匹配比较 mismatch/equal 算法和子序列搜索 search/search_n/find_end 算法。