C++ STL（3）：子序列匹配

#include <iostream>
#include <algorithm>
#include <cstring>

bool eq_nosign(int x, int y){return abs(x) == abs(y);}

void lookup(int *first, int *last, size_t nCount, int val)
{
    std::cout << "Searching for a signed sequence of " << nCount << " '" << val << "'" << (nCount != 1 ? "s: " : ": ");
    int *res = std::search_n(first, last, nCount, val);
    if(res == last)
        std::cout << "Not fount" << std::endl;
    else
        std::cout << "Index = " << res - first << std::endl;
}

void lookup_nosign(int *first, int *last, size_t nCount, int val)
{
    std::cout << "Searching for a unsigned sequence of " << nCount << " '" << val << "'" << (nCount != 1 ? "s: " : ": ");
    int *res = std::search_n(first, last, nCount, val, eq_nosign);
    if(res == last)
        std::cout << "Not fount" << std::endl;
    else
        std::cout << "Index = " << res - first << std::endl;
}

//子序列匹配
template<class Integer>
struct congruent
{
    congruent(Integer mod):N(mod){}
    bool operator()(Integer a, Integer b) const
    {
        return (a - b) % N == 0;
    }
    Integer N;
};

int main()
{
    /************************************************************************/
    //search
    /************************************************************************/
    //在范围[first1,last1)内查找某个子串，使得该子串与[first2,last2)的元素一一对应，类似strstr函数
    //search查找到第一个满足条件的子串立即返回
    //版本1：利用operator==
    //版本2：利用function object binary_pred
    /*
        template<class ForwardIterator1, class ForwardIterator2>
        ForwardIterator1 search(
            ForwardIterator1 _First1, 
            ForwardIterator1 _Last1,
            ForwardIterator2 _First2, 
            ForwardIterator2 _Last2
        );
    */
    /*
        template<class ForwardIterator1, class ForwardIterator2, class Pr>
        ForwardIterator1 search(
            ForwardIterator1 _First1, 
            ForwardIterator1 _Last1,
            ForwardIterator2 _First2, 
            ForwardIterator2 _Last2
            BinaryPredicate _Comp
        );
    */

    //测试版本1：
    const char *s1 = "hello world.";
    const char *s2 = "world";
    const char *p = std::search(s1, s1 + strlen(s1), s2, s2 + strlen(s2));

    //Found substring "world" at charactor 6 of string "hello world."
    if(p != s1 + strlen(s1))
        std::cout << "Found substring " << "\"" << s2 << "\"" << " at charactor " 
            << p - s1 << " of string " << "\"" << s1 << "\"" << std::endl;
    else
        std::cout << "Couldn't found substring" << std::endl;

    //测试版本2：查找数组中以1，2，3为末位的三子数形成的序列
    int a[] = {23, 46, 81, 2, 43, 19, 14, 98, 72, 51};
    int digits[3] = {1, 2, 3};
    int *seq = std::search(a, a + 10, digits, digits + 3, congruent<int>(10));
    if(seq != a + 10)
    {
        std::cout << "Subsequence: " ;
        copy(seq, seq + 3, std::ostream_iterator<int>(std::cout, " "));//Subsequence: 81 2 43
        std::cout << std::endl;
    }
    else
        std::cout << "Subsequence not found." << std::endl;


    /************************************************************************/
    //find_end
    /************************************************************************/
    //类似search，但是find_end查找最后一个满足条件的子串，函数原型参数跟search相似
    /*
        template<class ForwardIterator1, class ForwardIterator2>
        ForwardIterator1 find_end(
            ForwardIterator1 _First1, 
            ForwardIterator1 _Last1,
            ForwardIterator2 _First2, 
            ForwardIterator2 _Last2
        );
    */
    /*
        template<class ForwardIterator1, class ForwardIterator2, class Pr>
        ForwardIterator1 find_end(
            ForwardIterator1 _First1, 
            ForwardIterator1 _Last1,
            ForwardIterator2 _First2, 
            ForwardIterator2 _Last2,
            BinaryPredicate _Comp
        );
    */
    //测试略，同search类似



    /************************************************************************/
    //search_n
    /************************************************************************/
    //search_n在范围[first,last)内查找由count个相邻元素组成的子序列，且每个元素的值都为value
    //如果count为0，则查找函数一定成功且返回first
    //版本1：利用operator==
    //版本2：利用function object binary_pred
    /*
        template<class ForwardIterator1, class Diff2, class Type>
        ForwardIterator1 search_n(
            ForwardIterator1 _First1, 
            ForwardIterator1 _Last1,
            Size2 _Count, 
            const Type& _Val
        );
    */
    /*
        template<class ForwardIterator1, class Size2, class Type, class BinaryPredicate>
        ForwardIterator1 search_n(
            ForwardIterator1 _First1, 
            ForwardIterator1 _Last1,
            Size2 _Count, 
            const Type& _Val,
            BinaryPredicate _Comp
        );
    */

    const int N = 10;
    int A[N] = {1, 2, 1, 1, 3, -3, 1, 1, 1, 1};
    //测试版本1：
    lookup(A, A + N, 1, 4);//Searching for a signed sequence of 1 '4': Not fount
    lookup(A, A + N, 0, 4);//Searching for a signed sequence of 0 '4's: Index = 0
    lookup(A, A + N, 1, 1);//Searching for a signed sequence of 1 '1': Index = 0
    lookup(A, A + N, 2, 1);//Searching for a signed sequence of 2 '1's: Index = 2
    lookup(A, A + N, 3, 1);//Searching for a signed sequence of 3 '1's: Index = 6
    lookup(A, A + N, 4, 1);//Searching for a signed sequence of 4 '1's: Index = 6
    lookup(A, A + N, 1, 3);//Searching for a signed sequence of 1 '3': Index = 4
    lookup(A, A + N, 2, 3);//Searching for a signed sequence of 2 '3's: Not fount

    //测试版本2：
    lookup_nosign(A, A + N, 1, 3);//Searching for a unsigned sequence of 1 '3': Index = 4
    lookup_nosign(A, A + N, 2, 3);//Searching for a unsigned sequence of 2 '3's: Index = 4

    return 0;
}

====================打个广告，欢迎关注====================

QQ:	412425870
csdn博客：	http://blog.csdn.net/caychen
码云：	https://gitee.com/caychen/
github：	https://github.com/caychen
点击群号或者扫描二维码即可加入QQ群: 328243383(1群)
点击群号或者扫描二维码即可加入QQ群: 180479701(2群)