5 STL-常用算法

已于 2023-08-08 10:04:12 修改
阅读量140 收藏
点赞数
文章标签： c++ 算法 rpc
于 2023-08-07 11:33:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qingxiao__123456789/article/details/132142665
版权

概述:
        ●算法主要是由头文件<algorithm> I <functional>| <numeric>组成。
        ●<algorithm> 是所有STL头文件中最大的一 个，范围涉及到比较、 交换、查找、遍历操作、 复制、修改等等
        ●<numeric> 体积很小，只包括几个在序列 上面进行简单数学运算的模板函数
        ●<functional> 定义了一些模板类，用以声明函数对象。
5.1常用遍历算法
学习目标:
        ●掌握常用的遍历算法
算法简介:
        ●for_ each        //遍历容器
        ●transform         //搬运容器到另一个容器中
5.1.1 for_ each

功能描述:
●实现遍历容器
函数原型:
        ●for_ each(iterator beg, iterator end,_ func);        //遍历算法遍历容器元素
                // beg开始迭代器
                // end结束迭代器
                // _func函数或者函数对象
示例:

#include <iostream>
using namespace std;
#include <vector>
#include <algorithm>

// 常用遍历算法 for_each

// 普通函数
void print01(int val)
{
    cout << val << " ";
}
// 仿函数
class print02
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};
void test01()
{
    vector<int> v;
    for (int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }
    for_each(v.begin(), v.end(), print01);
    cout << endl;

    for_each(v.begin(), v.end(), print02());
    cout << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}

总结: for_ each在实际开发中是最常用遍历算法，需要熟练掌握

5.1.2 transform
功能描述:
●搬运容器到另一个容器中
函数原型:
        ●transform(iterator beg1， iterator end1， iterator beg2,_ _func);
                //beg1源容器开始迭代器
                //end1源容器结束迭代器
                //beg2目标容器开始迭代器
                //_func函数或者函数对象
示例:

#include <iostream>
using namespace std;
#include <vector>
#include <algorithm>

// 常用遍历算法 transform

// 仿函数
class Transform
{
public:
    int operator()(int v)
    {
        return v + 100;
    }
};
class MyPrint
{
public:
    int operator()(int v)
    {
        cout << v << " ";
    }
};
void test01()
{
    vector<int> v;
    for (int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }

    vector<int> vTarget;      // 目标容器
    vTarget.resize(v.size()); // 目标容器  需要提前开辟空间

    transform(v.begin(), v.end(), vTarget.begin(), Transform());
    for_each(vTarget.begin(), vTarget.end(), MyPrint());
    cout << endl;
};

int main()
{
    test01();
    system("pause");
    return 0;
}

5.2常用查找算法
学习目标:
●掌握常用的查找算法
算法简介:
        ●find        //查找元素
        ●find_ if        //按条件查找元素
        ●adjacent_ find         //查找相邻重复元素
        ●binary_ search         //二分查找法
        ●count        //统计元素个数
        ●count_if        //按条件统计元素个数
5.2.1 find
功能描述:
●查找指定元素，找到返回指定元素的迭代器，找不到返回结束迭代器end()
函数原型:

函数原型:
        ●find(iterator beg, iterator end, value);
                //按值查找元素,找到返回指定位置迭代器，找不到返回结束迭代器位置
                // beg开始迭代器
                // end结束迭代器
                // value查找的元素

#include <iostream>
using namespace std;
#include <vector>
#include <algorithm>
#include <string>
// 常用查找算法 find

// 查找 内置数据类型
void test01()
{
    vector<int> v;
    for (int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }

    // 查找 容器中 是否有5这个元素
    vector<int>::iterator it = find(v.begin(), v.end(), 5);
    if (it == v.end())
    {
        cout << "没有找到！" << endl;
    }
    else
    {
        cout << "找到：" << *it << endl;
    }
}
class Person
{
public:
    Person(string name, int age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }
    // 重载== 底层find知道如何对比person数据类型
    bool operator==(const Person &p)
    {
        if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    string m_Name;
    int m_Age;
};
// 查找 自定义的数据类型
void test02()
{
    vector<Person> v;
    // 创建数据
    Person p1("aaa", 10);
    Person p2("bbb", 20);
    Person p3("ccc", 30);
    Person p4("ddd", 40);
    Person p5("eee", 50);

    // 放入容器中
    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);
    v.push_back(p4);
    v.push_back(p5);

    Person pp("bbb", 20);

    vector<Person>::iterator it = find(v.begin(), v.end(), pp);
    if (it == v.end())
    {
        cout << "没有找到" << endl;
    }
    else
    {
        cout << "找到元素  姓名：" << it->m_Name << ",年龄：" << it->m_Age << endl;
    }
}

int main()
{
    // test01();
    test02();
    system("pause");
    return 0;
}

总结:利用find可以在容器中找指定的元素， 返回值是迭代器
5.2.2 find_ if
功能描述:
●按条件查找元素
函数原型:
        ●find_ if(iterator beg, iterator end,_ Pred);
                //按值查找元素,找到返回指定位置迭代器，找不到返回结束迭代器位置
                // beg开始迭代器
                // end结束迭代器
                //_pred 函数或者谓词(返回bool类型的仿函数)
示例:

#include <iostream>
using namespace std;
#include <vector>
#include <algorithm>
#include <string>
// 常用查找算法 find_if

// 查找 内置数据类型
class GreaterFive
{
public:
    bool operator()(int val)
    {
        return val > 5;
    }
};
void test01()
{
    vector<int> v;
    for (int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }
    vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive());
    // 查找 容器中 是否有大于5这个元素
    if (it == v.end())
    {
        cout << "没有找到！" << endl;
    }
    else
    {
        cout << "找到大于5的数字：" << *it << endl;
    }
}
class Person
{
public:
    Person(string name, int age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }
    // 重载== 底层find知道如何对比person数据类型
    bool operator==(const Person &p)
    {
        if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    string m_Name;
    int m_Age;
};
class Greater20
{
public:
    bool operator()(Person &p)
    {
        return p.m_Age > 20;
    }
};
// 查找 自定义的数据类型
void test02()
{
    vector<Person> v;
    // 创建数据
    Person p1("aaa", 10);
    Person p2("bbb", 20);
    Person p3("ccc", 30);
    Person p4("ddd", 40);
    Person p5("eee", 50);

    // 放入容器中
    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);
    v.push_back(p4);
    v.push_back(p5);

    // 找年龄大于20的人
    vector<Person>::iterator it = find_if(v.begin(), v.end(), Greater20());

    if (it == v.end())
    {
        cout << "没有找到" << endl;
    }
    else
    {
        cout << "找到元素  姓名：" << it->m_Name << ",年龄：" << it->m_Age << endl;
    }
}

int main()
{
    // test01();
    test02();
    system("pause");
    return 0;
}

5.2.3 adjacent_ find|
功能描述:
        ●查找相邻重复元素
函数原型:
        ●adjacent_ find(iterator beg, iterator end);
                //查找相邻重复元素,返回相邻元素的第一个位 置的迭代器
                // beg开始迭代器
                // end结束迭代器
示例:

#include <iostream>
using namespace std;
#include <vector>
#include <algorithm>
#include <string>
// 常用查找算法 adjacent_find
void test01()
{
    vector<int> v;
    v.push_back(0);
    v.push_back(2);
    v.push_back(3);
    v.push_back(0);
    v.push_back(5);
    v.push_back(2);
    v.push_back(2);
    v.push_back(6);
    v.push_back(2);

    vector<int>::iterator pos = adjacent_find(v.begin(), v.end());

    if (pos == v.end())
    {
        cout << "未找到相邻重复元素" << endl;
    }
    else
    {
        cout << "找到相邻重复元素：" << *pos << endl;
    }
}

int main()
{
    test01();
    system("pause");
    return 0;
}

总结:面试题中如果出现查我相邻重复元素，记得用STL中的adjacent_find算法
5.2.4 binary_ search
功能描述:
●查找指定元素是否存在
函数原型:
        ●bool binary_ search(iterator beg, iterator end, value);
                //查找指定的元素，查到返回true否则false
                //注意:在无序序列中不可用
                // beg开始迭代器
                // end结束迭代器
                // value查找的元素
示例:

#include <iostream>
using namespace std;
#include <vector>
#include <algorithm>
#include <string>
// 常用查找算法 binary_search
void test01()
{
    vector<int> v;
    for (int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }
    // v.push_back(2); 如果是无序序列，结果未知!
    //  查找容器中是否有9元素
    //  注意:容器必须是有序的序列
    bool ret = binary_search(v.begin(), v.end(), 9);

    if (ret)
    {
        cout << "找到了元素" << endl;
    }
    else
    {
        cout << "未找到" << endl;
    }
}

int main()
{
    test01();
    system("pause");
    return 0;
}

总结:二分查找法查找效率很高，值得注意的是查找的容器中元素必须的有序序列
5.2.5 count
功能描述:
        ●统计元素个数
函数原型:
        ●count(iterator beg, iterator end, value);
                //统计元素出现次数
                // beg开始迭代器
                // end结束迭代器
                // value统计的元素
示例:

#include <iostream>
using namespace std;
#include <vector>
#include <algorithm>
#include <string>
// 常用查找算法 count

// 1、 统计内置数据类型
void test01()
{
    vector<int> v;
    v.push_back(10);
    v.push_back(20);
    v.push_back(40);
    v.push_back(30);
    v.push_back(40);
    v.push_back(30);

    int num = count(v.begin(), v.end(), 40);
    cout << "40的元素个数为：" << num << endl;
};

// 2、 统计自定义数据类型
class Person
{
public:
    Person(string name, int age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }
    bool operator==(const Person &p)
    {
        if (this->m_Age == p.m_Age)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    string m_Name;
    int m_Age;
};
void test02()
{
    vector<Person> v;
    Person p1("刘备", 35);
    Person p2("关羽", 45);
    Person p3("张飞", 56);
    Person p4("赵云", 33);

    // 将人员插入到容器中
    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);
    v.push_back(p4);

    Person p("诸葛亮", 33);

    int num = count(v.begin(), v.end(), p);
    cout << "和诸葛亮同岁数的人员个数为：" << num << endl;
}

int main()
{
    // test01();
    test02();
    system("pause");
    return 0;
}

总结:统计自定义数据类型时候， 需要配合重载operator==
5.2.6 count_ if
功能描述:
●按条件统计元素个数
函数原型:
        ●count_ if(iterator beg, iterator end,_ Pred);
                //按条件统计元素出现次数
                // beg开始迭代器
                // end结束迭代器
                //_pred谓词
示例:

#include <iostream>
using namespace std;
#include <vector>
#include <algorithm>
#include <string>
// 常用查找算法 count_if

// 1、 统计内置数据类型
class Greator20
{
public:
    bool operator()(int val)
    {
        return val > 20;
    }
};
void test01()
{
    vector<int> v;
    v.push_back(10);
    v.push_back(20);
    v.push_back(40);
    v.push_back(30);
    v.push_back(40);
    v.push_back(30);

    int num = count_if(v.begin(), v.end(), Greator20());
    cout << "大于20的元素个数为：" << num << endl;
};

// 2、 统计自定义数据类型
class Person
{
public:
    Person(string name, int age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }
    bool operator==(const Person &p)
    {
        if (this->m_Age == p.m_Age)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    string m_Name;
    int m_Age;
};
class AgeGreater20
{
public:
    bool operator()(const Person &p)
    {
        return p.m_Age > 20;
    }
};
void test02()
{
    vector<Person> v;
    Person p1("刘备", 35);
    Person p2("关羽", 45);
    Person p3("张飞", 56);
    Person p4("赵云", 33);

    // 将人员插入到容器中
    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);
    v.push_back(p4);

    // 统计 大于20的人数

    Person p("诸葛亮", 33);

    int num = count_if(v.begin(), v.end(), AgeGreater20());
    cout << "大于20的人数的人员个数为：" << num << endl;
}

int main()
{
    // test01();
    test02();
    system("pause");
    return 0;
}

5.3常用排序算法
学习目标:
●掌握常用的排序算法
算法简介: .
        ●sort        //对容器内元素进行排序
        ●random_shuffle  //洗牌 指定范围内的元素随机调整次序
        ●merge        //容器元素合并,并存储到另-容器中
        ●reverse        //反转指定范围的元素
5.3.1 sort
功能描述: .
        ●对容器内元素进行排序
函数原型:
        sort(iterator beg, iterator end,_ Pred);
                //按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
        //beg 开始迭代器

        // end 结束迭代器
        //_ Pred谓词

案例：

#include <iostream>
using namespace std;
#include <algorithm>
#include <vector>
#include <functional>

// 常用排序算法 sort
void MyPrint(int val)
{
    cout << val << " ";
}
void test01()
{
    vector<int> v;
    v.push_back(10);
    v.push_back(40);
    v.push_back(30);
    v.push_back(40);
    v.push_back(50);
    v.push_back(60);

    // 利用sort进行升序
    sort(v.begin(), v.end());
    for_each(v.begin(), v.end(), MyPrint);
    cout << endl;

    // 改为 降序
    sort(v.begin(), v.end(), greater<int>());
    for_each(v.begin(), v.end(), MyPrint);
    cout << endl;
};

int main()
{
    test01();
    system("pause");
    return 0;
}

总结: sort属于开发中最常用的算法之一，需熟练掌握
5.3.2 random_shuffle
功能描述:
●洗牌指定范围内的元素随机调整次序
函数原型:
●random_ shuffle(iterator bleg, iterator end);
        //指定范围内的元素随机调整次序
        // beg开始迭代器
        // end结束迭代器
示例:

#include <iostream>
using namespace std;
#include <algorithm>
#include <vector>
#include <functional>
#include <ctime>

// 常用排序算法 random_shuffle
void MyPrint(int val)
{
    cout << val << " ";
}
void test01()
{
    srand((unsigned int)time(NULL));
    vector<int> v;
    for (int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }
    // 利用洗牌 算法 打算顺序
    random_shuffle(v.begin(), v.end());

    for_each(v.begin(), v.end(), MyPrint);
    cout << endl;
};

int main()
{
    test01();
    system("pause");
    return 0;
}

总结: random_shufle洗牌算法比较实用，使用时记得加随机数种子

5.3.3 merge
功能描述:
●两个容器元素合并,并存储到另-容器中
函数原型:
●merge(iterator beg1， iterator end1, iterator beg2， iterator end2， iterator dest);
        //容器元素合并，并存储到另-容器中
        //注意:两个容器必须是有序的
        // beg1容器 1开始迭代器
        //end1容器1结束迭代在缓冲 - O0KB/s
        // beg2容器2开始迭代器
        // end2容器2结束迭代器
        // dest目标容器开始迭代器
示例:

#include <iostream>
using namespace std;
#include <algorithm>
#include <vector>

// 常用排序算法 merge
void MyPrint(int val)
{
    cout << val << " ";
}
void test01()
{
    vector<int> v1;
    vector<int> v2;
    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i);
        v2.push_back(i + 1);
    }

    // 目标容器
    vector<int> vTarge;
    vTarge.resize(v1.size() + v2.size());
    merge(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarge.begin());

    for_each(vTarge.begin(), vTarge.end(), MyPrint);
    cout << endl;
};

int main()
{
    test01();
    system("pause");
    return 0;
}

总结: merge合并的两个容器必须的有序序列
5.3.4 reverse
功能描述:
●将容器内元素进行反转
函数原型:
●reverse(iterator beg, iterator end) ;
        //反转指定范围的元素
        // beg开始迭代器
        // end结束迭代器
示例:

#include <iostream>
using namespace std;
#include <algorithm>
#include <vector>

// 常用排序算法 reverse
void MyPrint(int val)
{
    cout << val << " ";
}
void test01()
{
    vector<int> v;
    v.push_back(10);
    v.push_back(30);
    v.push_back(50);
    v.push_back(40);
    v.push_back(10);

    cout << "反转前：" << endl;
    for_each(v.begin(), v.end(), MyPrint);
    cout << endl;

    cout << "反转后：" << endl;
    reverse(v.begin(), v.end());
    for_each(v.begin(), v.end(), MyPrint);
    cout << endl;
};

int main()
{
    test01();
    system("pause");
    return 0;
}

总结: reverse反转区间内元素，面试题可能涉及到
5.4常用拷贝和替换算法
学习目标:
        ●掌握常用的拷贝和替换算法
算法简介:
        ●copy        //容器内指定范围的元素拷贝到另一容器中
        ●replace        //将容器内指定范围的旧元素修改为新元素
        ●replace_ if        //容器内指定范围满足条件的元素替换为新元素
        ●swap        //互换两个容器的元素
5.4.1 copy
功能描述:
        ●容器内指定范围的元素拷贝到另一容器中
函数原型:
          ●copy(iterator beg, iterator end, iterator dest);
                //按值查找元素,找到返回指定位置迭代器，找不到返回结束迭代器位置
                // beg开始迭代器
                // end结束迭代器
                // dest目标起始迭代器
示例:

#include <iostream>
using namespace std;
#include <algorithm>
#include <vector>

// 常用拷贝和替换算法 copy
void MyPrint(int val)
{
    cout << val << " ";
}
void test01()
{
    vector<int> v1;
    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i);
    }

    vector<int> v2;
    v2.resize(v1.size());
    copy(v1.begin(), v1.end(), v2.begin());

    for_each(v2.begin(), v2.end(), MyPrint);
    cout << endl;
};

int main()
{
    test01();
    system("pause");
    return 0;
}

总结:利用copy算法在拷贝时，目标容器记得提前开辟空间

5.4.2 replace
功能描述:
        ●将容器内指定范围的旧元素修改为新元素
函数原型:
        ●replace(iterator beg, iterator end, oldvalue, newvalue);
                //将区间内旧元素替换成新元素
                // beg开始迭代器
                // end结束迭代器
                // oldvalue旧元素
                // newvalue新元素
示例:

#include <iostream>
using namespace std;
#include <algorithm>
#include <vector>

// 常用拷贝和替换算法 replace
class MyPrint
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};
void test01()
{
    vector<int> v;
    v.push_back(10);
    v.push_back(30);
    v.push_back(20);
    v.push_back(50);
    v.push_back(60);
    v.push_back(70);
    v.push_back(70);
    v.push_back(10);
    v.push_back(10);

    cout << "替换前：" << endl;
    for_each(v.begin(), v.end(), MyPrint());
    cout << endl;

    // 将20 替换  2000
    replace(v.begin(), v.end(), 20, 2000);
    cout << "替换后：" << endl;
    for_each(v.begin(), v.end(), MyPrint());
    cout << endl;
};

int main()
{
    test01();
    system("pause");
    return 0;
}

总结: replace会替换区间内满足条件的元素
5.4.3 replace_if
功能描述:
        ●将区间内满足条件的元素，替换成指定元素
函数原型:
        ●replace_ if(iterator beg, iterator end,_ pred, newvalue);
                //按条件替换元素，满足条件的替换成指定元素
                // beg开始迭代器
                // end结束迭代器
                // _pred谓词
                // newvalue替换的新元素
示例:

#include <iostream>
using namespace std;
#include <algorithm>
#include <vector>

// 常用拷贝和替换算法 replace_if
class MyPrint
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};
class Greater30
{
public:
    bool operator()(int val)
    {
        return val > 30;
    }
};
void test01()
{
    vector<int> v;
    v.push_back(10);
    v.push_back(30);
    v.push_back(20);
    v.push_back(50);
    v.push_back(60);
    v.push_back(70);
    v.push_back(70);
    v.push_back(10);
    v.push_back(10);

    cout << "替换前：" << endl;
    for_each(v.begin(), v.end(), MyPrint());
    cout << endl;

    // 将大于等于30 替换  3000
    replace_if(v.begin(), v.end(), Greater30(), 3000);
    cout << "替换后：" << endl;
    for_each(v.begin(), v.end(), MyPrint());
    cout << endl;
};

int main()
{
    test01();
    system("pause");
    return 0;
}

总结: replace_if按条件查找，可以利用仿函数灵活筛选满足的条件
5.4.4 swap
功能描述:
●互换两个容器的元素
函数原型:
        ●swap(container C1, container C2);
                //互换两个容器的元素
                // C1容器1
                // c2容器2
示例: .

#include <iostream>
using namespace std;
#include <algorithm>
#include <vector>

// 常用拷贝和替换算法 swap
class MyPrint
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};
class Greater30
{
public:
    bool operator()(int val)
    {
        return val > 30;
    }
};
void test01()
{
    vector<int> v1;
    vector<int> v2;

    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i);
        v2.push_back(i + 100);
    }

    cout << "交换前：" << endl;
    for_each(v1.begin(), v1.end(), MyPrint());
    cout << endl;
    for_each(v2.begin(), v2.end(), MyPrint());
    cout << endl;

    cout << "-------------" << endl;
    // 交换后
    cout << "替换后：" << endl;
    swap(v1, v2);
    for_each(v1.begin(), v1.end(), MyPrint());
    cout << endl;
    for_each(v2.begin(), v2.end(), MyPrint());
    cout << endl;
};

int main()
{
    test01();
    system("pause");
    return 0;
}

总结: swap交换容器时，注意交换的容器要同种类型
5.5常用算术生成算法
学习目标:
        ●掌握常用的算术生成算法
注意:
        ●算术生成算法属于小型算法,使用时包含的头文件为#include <numeric>
算法简介:
        ●accumulate        //计算容器元素累计总和
        ●fill        //向容器中添加元素
5.5.1 accumulate
功能描述:
●计算区间内容器元素累计总和

函数原型:
        ●accumulate(iterator beg, iterator end, value);
                //计算容器元素累计总和
                // beg开始迭代器
                // end结束迭代器
                // value起始值
示例:

#include <iostream>
using namespace std;
#include <vector>
#include <numeric>
// 常用算术生成算法 accumulate

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

    // 参数3  起始累加值
    int total = accumulate(v.begin(), v.end(), 0);

    cout << "total=" << total << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}

总结: accumulate使用时头文件注意是numeric,这个算法很实用
5.5.2 fill 
功能描述:
        ●向容器中填充指定的元素
函数原型:
        ●fill(iterator beg, iterator end, value);
                //向容器中填充元素
                // beg开始迭代器
                // end结束迭代器
                // value填充的值
示例:

#include <iostream>
using namespace std;
#include <vector>
#include <numeric>
#include <algorithm>
// 常用算术生成算法 fill

void myPrint(int val)
{
    cout << val << " ";
}
void test01()
{
    vector<int> v;
    v.resize(10);

    // 后期重新填充
    fill(v.begin(), v.end(), 100);

    for_each(v.begin(), v.end(), myPrint);
}

int main()
{
    test01();
    system("pause");
    return 0;
}

总结:利用fill可以将容器区间内元素填充为指定的值.
5.6常用集合算法
学习目标:
        ●掌握常用的集合算法
算法简介:
        ●set_ intersection        //求两个容器的交集
        ●set_union        //求两个容器的并集
        ●set_ difference        //求两个容器的差集
5.6.1 set intersection
功能描述:
        ●求两个容器的交集
函数原型:
        ●set_ intersection(iterator beg1, iterator end1, iterator beg2, iterator end2，iterator dest);
                //求两个集合的交集
                //注意:两个集合必须是有序序列
                // beg1容器1开始迭代器
                // end1容器1结束迭代器
                // beg2容器2开始迭代器
                // end2容器2结束迭代器
                // dest目标容器开始迭代器
示例:

#include <iostream>
using namespace std;
#include <vector>
#include <algorithm>
// 常用集合算法 set_intersection
void MyPrint(int val)
{
    cout << val << " ";
};
void test01()
{
    vector<int> v1;
    vector<int> v2;
    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i);     // 0~9
        v2.push_back(i + 5); // 5~14
    }

    vector<int> vTarget;
    // 目标容器需要提前开辟空间
    // 最特殊的情况  大容器包含小容器 开辟空间取 小容器的size即可
    vTarget.resize(min(v1.size(), v2.size()));

    // 获取交集
    vector<int>::iterator itEnd = set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());

    for_each(vTarget.begin(), itEnd, MyPrint);
    cout << endl;
}
int main()
{
    test01();
    system("pause");
    return 0;
}

总结:
●求交集的两个集合必须的有序序列
●目标容器开辟空间需要从两个容器中取小值
●set. _intersection返回值既是交集中最后一 个元素的位置
5.6.2 set_union
功能描述:
        ●求两个集合的并集
函数原型:
        ●set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
                //求两个集合的并集
                //注意:两个集合必须是有序序列
                // beg1容器1开始迭代器
                // end1容器1结束迭代器
                // beg2容器2开始迭代器
                // end2容器2结束迭代器
                // dest目标容器开始迭代器
示例:

#include <iostream>
using namespace std;
#include <vector>
#include <algorithm>
// 常用集合算法 set_union
void MyPrint(int val)
{
    cout << val << " ";
};
void test01()
{
    vector<int> v1;
    vector<int> v2;
    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i);     // 0~9
        v2.push_back(i + 5); // 5~14
    }

    vector<int> vTarget;
    // 目标容器需要提前开辟空间
    // 最特殊情况两个容器没有交集，并集就是两个容器size相加
    vTarget.resize(v1.size() + v2.size());

    // 获取并集
    vector<int>::iterator itEnd = set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());

    for_each(vTarget.begin(), itEnd, MyPrint);
    cout << endl;
}
int main()
{
    test01();
    system("pause");
    return 0;
}

总结:
        ●求并集的两个集合必须的有序序列
        ●目标容器开辟空间需 要两个容器相加
        ●set_union返回值既是并集中最后一个元素的位置

5.6.3 set_ difference
功能描述: .
        ●求两个集合的差集
函数原型: .
        ●set_difference(iterator beg1， iterator end1, iterator beg2, iterator end2， iterator dest);
                //求两个集合的差集
                //注意:两个集合必须是有序序列
                // beg1容器1开始迭代器
                // end1容器1结束迭代器
                // beg2容器2开始迭代器
                // end2容器2结束迭代器
                // dest目标容器开始迭代器
示例:

#include <iostream>
using namespace std;
#include <vector>
#include <algorithm>
// 常用集合算法 set_difference
void MyPrint(int val)
{
    cout << val << " ";
};
void test01()
{
    vector<int> v1;
    vector<int> v2;
    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i);     // 0~9
        v2.push_back(i + 5); // 5~14
    }

    vector<int> vTarget;
    // 目标容器需要提前开辟空间
    // 最特殊情况两 个容器没有交集取两个容器中大的size作为目标容器开辟空间
    vTarget.resize(max(v1.size(), v2.size()));

    // 获取差集
    cout << "v1和v2的差集：" << endl;
    vector<int>::iterator itEnd = set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());

    for_each(vTarget.begin(), itEnd, MyPrint);
    cout << endl;

    cout << "v2和v1的差集：" << endl;
    itEnd = set_difference(v2.begin(), v2.end(), v1.begin(), v1.end(), vTarget.begin());

    for_each(vTarget.begin(), itEnd, MyPrint);
    cout << endl;
}
int main()
{
    test01();
    system("pause");
    return 0;
}

总结:
●求差集的两个集合必须的有序序列
●目标容器开辟空间需要从两个容器取较大值
●set_difference返回值既是差集中最后一个元素的位置
 

VernonJsn
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c++模板stl常用算法
09-01
### C++模板STL常用算法 #### 前言 C++是一种强大的编程语言，它支持多种编程范式，包括面向对象编程、泛型编程等。其中，泛型编程是通过模板来实现的，模板允许程序员编写能处理多种类型数据的代码。标准模板库...
浅析STL中的常用算法
09-05
在这个话题中，我们将深入探讨STL中的常用算法，这些算法通常用于处理和操作容器中的数据。 首先，我们讨论非变异算法，即那些不会改变原有数据结构的算法。这类算法主要涉及对序列数据的操作，如查找、统计和匹配...
C++ STL-常用算法
qq_60406853的博客
06-16 203
C++ 常用算法
STL--常用遍历算法
hjl011006的博客
07-19 297
STL中关于遍历的算法，包含头文件algorithm。for_each，transform等函数的使用和介绍。
c++---STL常用算法
m0_50046535的博客
04-25 3347
概述： 算法主要是由头文件<algorithm><functional><numeric>组成 <algorithm>是所有stl头文件中最大的一个，涉及比较，交换，查找，遍历，复制，修改等操作 <numeric>体积很小，只包括几个在序列上进行简单数学运算的模板函数 <functional>定义了一些类模板，用以声明函数对象 一、常用遍历算法 for_each 遍历容器 transform 搬运容...
【C++提高编程】5.STL - 常用算法
糊涂懿的博客
03-10 855
目录：1. 模板的概念1. 函数模板1. 类模板 1. 模板的概念 1. 函数模板 1. 类模板 只读
【43C++STL-常用算法----1、常用遍历算法】
qq_45986997的博客
09-07 214
这些常用的遍历算法需要你掌握
【47C++STL-常用算法----5、常用算术生成算法】
qq_45986997的博客
09-08 409
C++中常用的算术产成算法，你必须掌握，因为它好用
C++ STL-常用算法 常用遍历算法 for_each transform
UUUUU22的博客
03-15 337
C++ STL-常用算法 常用遍历算法 for_each transform
STL-常用算法(二.拷贝 替换 算术 集合)
好好学习，天天向上
05-24 581
STL-常用算法(二.拷贝 替换 算术 集合)
爱上c++的第十五天：STL-常用算法
喜欢吃豆的博客
03-16 998
想比人家打代码更快？只用手速可不够，来了解一下STL的算法吧！！！
STL常用算法
qq_24472227的博客
06-06 1162
1、常用遍历算法 2、常用查找算法 3、常用排序算法 4、常用拷贝和替换算法 5、常用算术生成算法 6、常用集合算法
STL常用算法大全
12-02
STL 常用算法大全 STL（Standard Template Library）提供了丰富的算法库，涵盖了查找、排序、数值计算等多方面的算法。这些算法可以帮助开发者快速、高效地处理数据。 查找算法（13 个） 1. `adjacent_find`：在...
stl常用算法(Algorithms)介绍(stl排序算法、非变序型队列)
09-04
在这个话题中，我们将深入探讨STL中的一些常用算法，特别是排序算法和非变序型队列算法。 首先，让我们来看一下排序算法。在STL中，最常用的排序算法是`std::sort`，它位于`<algorithm>`头文件中。`std::sort`可以...
C语言 | Leetcode C语言题解之第337题打家劫舍III
最新发布
m0_59237910的博客
08-15 151
C语言 | Leetcode C语言题解之第337题打家劫舍III
C++笔记5•内存管理•
qq_64446190的博客
08-12 1093
内存管理
C++ | Leetcode C++题解之第337题打家劫舍III
Ddddddd_158的博客
08-15 205
C++ | Leetcode C++题解之第337题打家劫舍III
ubuntu22.04 安装 ros1
qq_35547879的博客
08-14 251
原先只知道ros1 noetic 只支持到ubuntu20.04。现在系统必须升级到ubuntu22.04。
C++函数模板与类模板详解：STL常用算法实现
- 逻辑抽象：类模板使程序员能够将算法从数据类型的具体实现中抽离出来，专注于逻辑结构，提高代码的可重用性和模块化。 - 举例： ```cpp template class ArraySorter { public: void sortArray(T* array, ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值