深入探索C++ STL查找算法：高效、灵活的容器操作

本文链接：https://blog.youkuaiyun.com/qq_57063846/article/details/145649453

深入探索STL查找算法：高效、灵活的容器操作

在C++标准模板库（STL）中，查找算法是处理容器数据时最常用的功能之一。这些算法不仅提供了强大的查找能力，还通过模板机制实现了高度的通用性和灵活性。本文将通过一系列代码示例，深入探讨STL中常用的查找算法：find、find_if、binary_search、count、count_if和adjacent_find，并分析它们在不同场景下的应用。

1. `find`：查找指定值

find算法用于在容器中查找第一个与指定值匹配的元素，并返回指向该元素的迭代器。如果未找到，则返回end()迭代器。find算法适用于所有容器类型，并且支持自定义比较逻辑。

示例代码（`find.cpp`）

cpp复制

#include "me.h"

class person
{
public:
    int m_a;
    int m_b;
    person(int a, int b) : m_a(a), m_b(b) {};
    bool operator==(const person& p)
    {
        return (this->m_a == p.m_a && this->m_b == p.m_b); // 重载==
    }
};

void test1()
{
    vector<int> v;
    for (int i = 0; i < 8; i++)
    {
        v.push_back(i);
    }

    vector<int>::iterator it = find(v.begin(), v.end(), 3);
    if (it != v.end())
    {
        cout << *it << endl; // 输出找到的值
    }

    person p1(1, 2);
    person p2(5, 2);
    person p3(1, 3);
    vector<person> p;
    p.push_back(p1);
    p.push_back(p2);
    p.push_back(p3);

    vector<person>::iterator pit = find(p.begin(), p.end(), p2);
    if (pit != p.end())
    {
        cout << "找到元素" << endl;
    }
}

分析

在上述代码中，find用于查找vector<int>中的值3，以及vector<person>中的person对象。为了使find能够正确比较自定义类型person，我们需要重载operator==。find算法的时间复杂度为O(n)，适用于未排序的容器。

2. `find_if`：基于条件的查找

find_if算法用于查找第一个满足特定条件的元素。与find不同，find_if需要一个谓词函数（或函数对象）作为参数，用于定义查找条件。

示例代码（`find_if.cpp`）

cpp复制

#include "me.h"

class greater5
{
public:
    bool operator()(int a) const
    {
        return a > 5; // 查找大于5的元素
    }
};

class person
{
public:
    int m_a;
    int m_b;
    person(int a, int b) : m_a(a), m_b(b) {};
};

class classfind
{
public:
    bool operator()(person p) const
    {
        return (p.m_a > 10 && p.m_b < 5); // 自定义查找条件
    }
};

void test2()
{
    vector<int> v;
    for (int i = 0; i < 8; i++)
    {
        v.push_back(i);
    }

    vector<int>::iterator it = find_if(v.begin(), v.end(), greater5());
    if (it != v.end())
    {
        cout << *it << endl; // 输出找到的值
    }

    person p1(1, 2);
    person p2(5, 2);
    person p3(16, 3);
    vector<person> p;
    p.push_back(p1);
    p.push_back(p2);
    p.push_back(p3);

    vector<person>::iterator pit = find_if(p.begin(), p.end(), classfind());
    if (pit != p.end())
    {
        cout << "找到元素" << endl;
    }
}

分析

find_if通过谓词函数定义查找条件，使得查找更加灵活。在上述代码中，greater5用于查找vector<int>中大于5的元素，而classfind用于查找vector<person>中满足特定条件的对象。find_if的时间复杂度同样为O(n)。

3. `binary_search`：二分查找

binary_search算法用于在已排序的容器中查找指定值。它基于二分查找原理，时间复杂度为O(log n)，效率远高于线性查找算法（如find）。需要注意的是，使用binary_search之前，必须确保容器已排序。

示例代码（`binary_search.cpp`）

cpp复制

#include "me.h"

void test4()
{
    vector<int> v;
    for (int i = 0; i < 8; i++)
    {
        v.push_back(i);
    }

    bool ret = binary_search(v.begin(), v.end(), 6);
    cout << ret << endl; // 输出查找结果
}

分析

在上述代码中，binary_search用于查找vector<int>中的值6。由于容器是有序的，binary_search能够高效地完成查找任务。如果容器未排序，binary_search可能会返回错误结果。

4. `count`和`count_if`：统计元素

count和count_if算法用于统计容器中满足特定条件的元素数量。count用于统计与指定值完全匹配的元素个数，而count_if则通过谓词函数定义统计条件。

示例代码（`count.cpp`和`count_if.cpp`）

cpp复制

// count.cpp
#include "me.h"

class person
{
public:
    int m_a;
    int m_b;
    person(int a, int b) : m_a(a), m_b(b) {};
    bool operator==(const person& p)
    {
        return (this->m_b == p.m_b); // 重载==
    }
};

void test5()
{
    vector<int> v;
    for (int i = 0; i < 8; i++)
    {
        v.push_back(i);
    }
    v.push_back(7);

    size_t num = count(v.begin(), v.end(), 7); // 统计7出现的次数
    cout << num << endl;

    person p1(1, 2);
    person p2(5, 2);
    person p3(1, 2);
    vector<person> p;
    p.push_back(p1);
    p.push_back(p2);
    p.push_back(p3);

    num = count(p.begin(), p.end(), p1); // 统计与p1的m_b相等的元素个数
    cout << num << endl;
}

// count_if.cpp
#include "me.h"

class greater5
{
public:
    bool operator()(int a) const
    {
        return a > 5; // 查找大于5的元素
    }
};

class classcount
{
public:
    bool operator()(person p) const
    {
        return (p.m_a > 2 && p.m_b < 6); // 自定义统计条件
    }
};

void test6()
{
    vector<int> v;
    for (int i = 0; i < 8; i++)
    {
        v.push_back(i);
    }
    v.push_back(7);

    size_t num = count_if(v.begin(), v.end(), greater5()); // 统计大于5的元素个数
    cout << num << endl;

    person p1(1, 2);
    person p2(5, 2);
    person p3(1, 2);
    vector<person> p;
    p.push_back(p1);
    p.push_back(p2);
    p.push_back(p3);

    num = count_if(p.begin(), p.end(), classcount()); // 自定义统计
    cout << num << endl;
}

分析

count和count_if算法的时间复杂度均为O(n)。count适用于统计与指定值完全匹配的元素，而count_if通过谓词函数提供了更灵活的统计方式。在上述代码中，count用于统计vector<int>中值7的出现次数，以及vector<person>中与p1的m_b相等的元素个数。count_if则用于统计vector<int>中大于5的元素个数，以及vector<person>中满足特定条件的对象个数。

5. `adjacent_find`：查找相邻重复元素

adjacent_find算法用于查找容器中第一个相邻的重复元素，并返回指向该元素的迭代器。如果未找到，则返回end()迭代器。该算法适用于查找重复数据，例如在去重操作中。

示例代码（`adjacent_find.cpp`）

cpp复制

#include "me.h"

void test3()
{
    vector<int> v;
    for (int i = 0; i < 8; i++)
    {
        v.push_back(i);
    }
    v.push_back(7);

    vector<int>::iterator it = adjacent_find(v.begin(), v.end());
    if (it != v.end())
    {
        cout << *it << endl; // 输出找到的重复元素
    }
}

分析

在上述代码中，adjacent_find用于查找vector<int>中的第一个相邻重复元素。由于容器中只有最后一个元素7是重复的，因此adjacent_find返回指向7的迭代器。

总结

STL查找算法为C++开发者提供了强大的工具，用于高效地处理容器数据。通过find、find_if、binary_search、count、count_if和adjacent_find等算法，我们可以轻松实现查找、统计和重复检测等操作。这些算法不仅通用性强，还通过模板机制支持自定义类型和条件，极大地提高了代码的灵活性和可扩展性。

在实际开发中，合理选择查找算法能够显著提升程序的性能和可维护性。例如，对于已排序的数据，优先使用binary_search；对于复杂的查找条件，使用find_if或count_if；而对于重复数据检测，adjacent_find则是理想的选择。

希望本文的介绍和示例代码能够帮助你更好地理解和应用STL查找算法。在你的下一个项目中，不妨尝试使用这些强大的工具，让代码更加简洁、高效！