本文将介绍一些鲜为人知但非常有用的算法。它们是

。这些算法可以帮助高效地查找子序列或特定值的位置。本文详细解释了每个算法的用法、参数和返回值，并提供了相应的示例代码。通过学习和掌握这些隐藏宝藏算法，可以更加灵活和高效地处理各种搜索需求。

以下所有函数都不假设它们操作的元素是有序的，因此它们使用 

(或提供的自定义比较器)来执行比较。

是C++标准库中的一个算法，位于

 类中的对应方法类似（参见上一篇文章），它用于在一个范围内查找第一个与给定元素集合中的任何元素匹配的元素，并返回其迭代器。但并不局限于 

template <typename ForwardIterator1, typename ForwardIterator2>
ForwardIterator1 find_first_of(ForwardIterator1 first, ForwardIterator1 last,
                               ForwardIterator2 s_first, ForwardIterator2 s_last);

中的任何元素匹配，函数就会立即返回匹配元素的迭代器。

方法在算法中没有对应的方法。

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

int main() {
    std::vector<int> numbers {1, 2, 3, 4, 5};
    std::vector<int> targets {4, 6, 8};

    auto it = std::find_first_of(numbers.begin(), numbers.end(),
                                 targets.begin(), targets.end());

    if (it != numbers.end()) {
        std::cout << "Found matching element: " << *it << std::endl;
    } else {
        std::cout << "No matching element found." << std::endl;
    }

    return 0;
}

函数是一个简单的线性搜索算法，因此它的性能可能不适用于大型数据集。如果需要更高效的搜索算法，可以考虑使用其他的数据结构或算法。

在一个范围内搜索两个连续的相同元素，并返回这两个元素的第一个元素的迭代器。如果没有找到连续的元素，则返回该范围的结束迭代器。

template<class ForwardIt>
ForwardIt adjacent_find(ForwardIt first, ForwardIt last);

template<class ForwardIt, class BinaryPredicate>
ForwardIt adjacent_find(ForwardIt first, ForwardIt last, BinaryPredicate p);

范围内的元素，并依次检查相邻的元素对，看它们是否满足指定条件。如果找到满足条件的相邻元素对，函数就会立即返回指向这对元素的第一个元素的迭代器。

在现实开发中有着有趣的用法。

假设有一个集合，希望将连续的相同元素合并在一起。可以使用

template <typename ForwardIterator, typename OutputIterator>
OutputIterator mergeAdjacent(ForwardIterator first, ForwardIterator last, OutputIterator results)
{
    ForwardIterator beginUnique = first;
    while (beginUnique != last)
    {     
      // output all unique elements; stop when finding indentical adjacent ones
      ForwardIterator endUnique = std::adjacent_find(beginUnique, last);
      results = std::copy(beginUnique, endUnique, results);
    
      // identify the range of identical adjacent elements
      ForwardIterator beginIdentical = endUnique;
      ForwardIterator endIdentical = std::find_if(beginIdentical, last, [beginIdentical](const auto& element) {return element != *beginIdentical;});
    
      // aggregate identical flows into one
      if (beginIdentical != endIdentical)
      {
         *results = std::accumulate(beginIdentical, endIdentical, typename ForwardIterator::value_type());
         ++results;
      }
      beginUnique = endIdentical;
    }
    return results;
}

vector<int> v = { 1, 4, 5, 5, 3, 42, 7, 7, 7, 7, 3, 9 };
vector<int> results;
mergeAdjacent(v.begin(), v.end(), back_inserter(results));
// results now contains: 1 4 10 3 42 28 3 9

注意这个函数的核心部分是如何调用

被取为这样的名称，即使它可能找不到任何东西？

已经存在，并且做了一些其他的事情。一起来了解一下

头文件中。它用于在一个范围内查找第一次出现某个子序列的位置，并返回指向该子序列起始位置的迭代器。

template<class ForwardIt1, class ForwardIt2>
ForwardIt1 search(ForwardIt1 first1, ForwardIt1 last1,
                  ForwardIt2 first2, ForwardIt2 last2);

template<class ForwardIt1, class ForwardIt2, class BinaryPredicate>
ForwardIt1 search(ForwardIt1 first1, ForwardIt1 last1,
                  ForwardIt2 first2, ForwardIt2 last2,
                  BinaryPredicate p);

范围内的元素相匹配的子序列。它会从

的每个位置开始，逐个比较元素，直到找到完全匹配的子序列或搜索范围结束。

与字符串中的子字符串搜索非常相似。但它并不局限于字符和字符串，它可以在任何类型的范围内搜索子范围的第一次出现。

不必在线性时间内操作。在算法族中，

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

int main() {
    std::vector<int> numbers {1, 2, 3, 4, 5, 6, 7, 8, 9};
    std::vector<int> subsequence {4, 5, 6};

    auto it = std::search(numbers.begin(), numbers.end(),
                          subsequence.begin(), subsequence.end());

    if (it != numbers.end()) {
        std::cout << "Found subsequence starting at index: " << std::distance(numbers.begin(), it) << std::endl;
    } else {
        std::cout << "Subsequence not found." << std::endl;
    }

    return 0;
}

用于在一个范围内查找第一次出现连续n个相同值的子序列，并返回指向该子序列起始位置的迭代器。

template<class ForwardIt, class Size, class T>
ForwardIt search_n(ForwardIt first, ForwardIt last, Size count, const T& value);

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

int main() {
    std::vector<int> numbers {1, 2, 2, 2, 3, 4, 2, 2, 2, 5};

    auto it = std::search_n(numbers.begin(), numbers.end(), 3, 2);

    if (it != numbers.end()) {
        std::cout << "Found subsequence of three 2's starting at index: " << std::distance(numbers.begin(), it) << std::endl;
    } else {
        std::cout << "Subsequence not found." << std::endl;
    }

    return 0;
}

用于在一个范围内查找最后一次出现某个子序列的位置（而

是搜索第一次出现），并返回指向该子序列起始位置的迭代器。

template<class ForwardIt1, class ForwardIt2>
ForwardIt1 find_end(ForwardIt1 first1, ForwardIt1 last1,
                    ForwardIt2 first2, ForwardIt2 last2);

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

int main() {
    std::vector<int> numbers {1, 2, 3, 4, 2, 3, 4, 2, 3, 4};
    std::vector<int> subsequence {2, 3, 4};

    auto it = std::find_end(numbers.begin(), numbers.end(),
                            subsequence.begin(), subsequence.end());

    if (it != numbers.end()) {
        std::cout << "Found subsequence ending at index: " << std::distance(numbers.begin(), it) << std::endl;
    } else {
        std::cout << "Subsequence not found." << std::endl;
    }

    return 0;
}

不必在线性时间内操作。允许进行

有一些更聪明的算法确实在线性时间内运行，其中一些在Boost中可用。他们的工作方式超出了本文的范围，但可以在`Boost·中找到其中三种：

注意，即使它们在线性时间内运行，也不能保证在特定情况下具有更好的性能，原因有两个：

此外，对于搜索算法，STL比Boost更灵活，因为它允许搜索最后出现的情况(

)，并允许自定义比较运算符，这两个都是Boost无法做到的。

因此，一般情况下建议使用STL搜索算法，除非确定Boost的搜索算法在特定情况下性能更好。

以上就是使用STL进行搜索的内容。C++标准库中的搜索算法提供了强大而高效的功能，但很多开发者可能对它们不太熟悉。本文介绍了

用于查找第一次出现某个子序列的位置，

用于查找连续n个相同值的子序列的位置，而

用于查找最后一次出现某个子序列的位置。详细解释了每个算法的使用方法和参数，并提供了示例代码帮助读者理解和应用这些算法。通过掌握这些隐藏宝藏算法，可以提升他们的搜索算法技能，并在实际项目中更加高效地处理各种搜索任务。

本文将介绍一些鲜为人知但非常有用的算法。它们是std::search、std::search_n和std::find_end。这些算法可以帮助高效地查找子序列或特定值的位置。本文详细解释了每个算法的用法、参数和返回值，并提供了相应的示例代码。通过学习和掌握这些隐藏宝藏算法，可以更加灵活和高效地处理各种搜索需求。

探索C++标准库中的隐藏宝藏：强大而鲜为人知的搜索算法

本文将介绍一些鲜为人知但非常有用的算法std::search、std::search_n和std::find_end。这些算法可以帮助高效地查找子序列或特定值的位置。

编程语言

算法

探索C++标准库中的高效搜索算法：std::search、std::search_n和std::find_end。这些算法能快速定位子序列或特定值，支持自定义比较，适用于无序数据。文章详解了每个算法的参数、返回值及代码示例，帮助开发者提升搜索效率。掌握这些隐藏宝藏算法，可优化数据处理流程，满足多样化搜索需求。

数据结构

容器

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

探索C++标准库中的隐藏宝藏：强大而鲜为人知的搜索算法

探索C++标准库中的隐藏宝藏：强大而鲜为人知的搜索算法

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐