值得记忆的STL常用算法，分分钟摆脱容器调用的困境，以vector为例，其余容器写法类似

STL常用算法

概述：

  1. 算法主要是由头文件<algorithm> <functional> <numeric>组成

  2. <algorithm>是所有STL头文件中最大的一个，范围涉及到比较、交换、查找、遍历操作、复制、修改等等

  3. <nuneric>体积很小，只包括几个在序列上面进行简单数学运算的模板函数

  4. <functional>定义了一些模板类，用以声明函数对象

1.常用遍历算法

算法简介：

for_each遍历容器

transform搬运容器到另一个容器

1.for_each

功能描述：

实现遍历容器

函数原型：

for_each(iterator beg, iterator end, _func);

遍历算法 遍历容器中所有元素

beg开始迭代器

end结束迭代器

_func函数或者函数对象

示例

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
​
//常用遍历算法 for_each
​
//普通函数
void print01(int val)
{
    cout << val << " ";
}
​
//仿函数
class print02
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};
​
void test()
{
    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()
{
    test();
    return 0;
}

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

2.transform

功能描述：

搬运容器到另一个容器中

函数原型：

tansform(iterator beg1, iterator end1, iterator beg2, _func);

beg1源容器开始迭代器

end1源容器结束迭代器

beg2目标容器开始迭代器

_func函数或者函数对象

示例：

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
​
//常用遍历算法 transform
​
class Transform
{
public:
    int operator()(int v)
    {
        return v;
    }
};
​
class print
{
public:
    int operator()(int val)
    {
        cout << val << " ";
    }
};
​
void test()
{
    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(v.begin(), v.end(), print());
}
​
int main()
{
    test();
    return 0;
}

2.常用查找算法

算法简介：

find查找元素

find_if按条件查找

adjacent_find查找相邻重复元素

binary_search二分查找

count统计元素个数

count_if按条件统计元素个数

1.find

功能描述：

查找指定元素，找到返回指定元素的迭代器，找不到返回结束迭代器end()

函数原型：

find(iterator beg, iterator end, value);

按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置

beg开始迭代器

end结束迭代器

value查找的元素

代码

#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
using namespace std;
​
//常用的查找算法 
//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("zhangsan",18);
    Person p2("lisi",19);
    Person p3("wangwu",20);
    Person p4("zaholiu",21);
    Person p5("tangqi",22);
    //放入容器
    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);
    v.push_back(p4);
    v.push_back(p5);
    
    Person p("wangwu",20);
    
    vector<Person>::iterator it = find(v.begin(), v.end(), p);
    if(it == v.end())
    {
        cout << "没有找到！" << endl;
    }
    else
    {
        cout << "找到了：" << "姓名为：" << it->m_Name << " 年龄为：" << it->m_Age << endl; 
    }
}
​
int main()
{
    test01();
    test02();
    return 0;
}

2.find_if

功能描述：

按条件查找元素

函数原型：

find_if(iterator beg, iterator end, _Pred);

按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置

beg开始迭代器

end结束迭代器

_Pred函数或者谓词（返回bool类型的仿函数）

示例：

#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
​
//常用查找算法 find_if
​
//1.查找内置数据类型
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());
    if(it == v.end())
    {
        cout << "没有找到" << endl;
    }
    else
    {
        cout << "找到大于5的数字：" << *it << endl;
    }
}
​
//2.查找自定义数据类型
class Person
{
public:
    Person(string name, int age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }
    
    string m_Name;
    int m_Age;
};
​
class GreaterT
{
public:
    bool operator()(Person &p)
    {
        return p.m_Age > 20;
    }
};
​
void test02()
{
    vector<Person>v;
    
    Person p1("zhangsan",19);
    Person p2("lisi",20);
    Person p3("wangwu",21);
    Person p4("zhaoliu",22);
    
    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);
    v.push_back(p4);
    
    //找年龄大于20岁的
    vector<Person>::iterator it = find_if(v.begin(), v.end(), GreaterT());
    
    if(it == v.end())
    {
        cout << "没有找到" << endl;
    }
    else
    {
        cout << "找到了姓名：" << it->m_Name << " 年龄：" << it->m_Age << endl;
    }
}
​
int main()
{
    test01();
    test02();
    return 0;
}

3.adjacent_find

功能描述：

查找相邻重复元素

函数原型：

adjacent_find(iterator beg,iterator end);

查找相邻里复元素返回相邻元素的第一个位置的迭代器

beg开始迭代器

end结束迭代器

示例：

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
​
//常用查找算法 adjacent_find
void test()
{
    vector<int>v;
    v.push_back(0);
    v.push_back(2);
    v.push_back(0);
    v.push_back(3);
    v.push_back(1);
    v.push_back(4);
    v.push_back(3);
    v.push_back(3);
    
    vector<int>::iterator pos = adjacent_find(v.begin(), v.end());
    if(pos == v.end())
    {
        cout << "未找到相邻重复元素" << endl;
    }
    else
    {
        cout << "找到相邻重复元素：" << *pos << endl;
    }
}
int main()
{
    test();
    return 0;
}

4.binary_search

功能描述：

查找指定元素是否存在

函数原型：

bool binary_search(iterator beg,iterator end,value);

查找指定的元素，查到返回true否则false

注意：在无序序列中不可用

beg开始迭代器

end结束迭代器

value查找的元素

示例：

#include<iostream>
#include<vector>
#include<algorithm>
​
//常用查找算法 binary_search
void test()
{
    vector<int>v;
    for(int i = 0;i < 10; i++)
    {
        v.push_back(i);
    }
    
    //查找容器中是否有9 元素
    bool ret = binary_search(v.begin(), v.end(), 9);
    if(ret)
    {
        cout << "找到了元素" << endl;
    }
    else
    {
        cout << "没有找到" << endl;
    }
}
​
int main()
{
    test();
    return 0;
}

总结：二分查找法查找效率很高，值得注意的是查找的容器中元素必须得是有序序列

5.count

功能描述：

统计元素个数

函数原型：

count(iterator beg,iterator end,value);

统计元素出现次数

beg开始迭代器

end结束迭代器

value统计的元素

示例：

#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;
​
//常用查找算法 count
​
//1.统计内置数据类型
void test1()
{
    vector<int>v;
    
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(3);
    v.push_back(3);
    v.push_back(4);
    
    int num = count(v.begin(), v.end(), 3);
    cout << "3的元素个数：" << 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 test2()
{
    vector<Person>v;
    
    Person p1("aaa",18);
    Person p2("bbb",19);
    Person p3("ccc",20);
    Person p4("ddd",18);
    Person p5("eee",18);
    Person p6("fff",18);
    
    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);
    v.push_back(p4);
    v.push_back(p5);
    v.push_back(p6);
    
    Person p7("ggg",18);
    int num = count(v.begin(), v.end(), p7);
    cout << "和p7年龄一样的有" << num << "个" << endl;
}
​
int main()
{
    test1();
    test2();
    return 0;
}

6.count_if

功能描述：

按条件统计元素个数

函数原型：

count_if(iterator beg, iterator end, _Pred);

按条件统计元素出现次数

beg开始迭代器

end结束迭代器

_Pred谓词

示例：

#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
​
//1.内置数据类型统计
class Greater20
{
public:
   bool operator()(int val)
   {
       return val > 20;
   }
};
​
void test()
{
    vector<int>v;
    v.push_back(10);
    v.push_back(40);
    v.push_back(30);
    v.push_back(20);
       
    int num = count_if(v.begin(), v.end(), Greater20());
    
    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 AgeGreater18
{
public:
    bool operator()(const Person & p)
    {
        return p.m_Age == 18;
    }
};
​
void test1()
{
    vector<Person>v;
    
    Person p1("zhangsan",18);
    Person p2("lisi",18);
    Person p3("wangwu",19);
    Person p4("zhaoliu",18);
    
    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);
    v.push_back(p4);
    
    int num = count_if(v.begin(), v.end(), AgeGreater18());
    cout << "18岁的人数：" << num << "个" << endl;
}
​
int main()
{
    test();
    test1();
    return 0;
}

3.常用排序算法

算法简介：

sort对容器内元素进行排序

random_shuffle洗牌 指定范围内的元素随机调整次序

merge容器元素合并，并存储到另一容器中

reverse反转指定范围的元素

1.sort

功能描述：

对容器内元素进行排序

函数原型：

sort(iterator beg,iterator end,Pred);按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置

beg开始迭代器

end结束迭代器

_Pred谓词

示例

#include<iostream>
#include<vector>
#include<algorithm>
#include<functional>
using namespace std;
​
class print
{
public:
    operator()(int val)
    {
        cout << val << " ";
    }
};
​
void test()
{
    vector<int>v;
    
    v.push_back(10);
    v.push_back(30);
    v.push_back(50);
    v.push_back(20);
    v.push_back(40);
    
    //利用sort进行升序
    sort(v.begin(), v.end());
    for_each(v.begin(), v.end(), print());
    cout << endl;
    
    //改为降序
    sort(v.begin(), v.end(), greater<int>());//greater内建函数
    for_each(v.begin(), v.end(), print());
    cout << endl;
}
​
int main()
{
    test();
    return 0;
}

2.random_shuffle

功能描述：

洗牌指定范围内的元素随机调整次序

函数原型：

random_shuffle(iterator beg,iterator end);

指定范围内的元素随机调整次序

beg开始迭代器

end结束迭代器

示例：

#include<iostream>
#include<vector>
#include<algorithm>
#include<ctime>
using namespace std;
​
//常用排序算法 random_shuffle
class print
{
public:
    operator()(int val)
    {
        cout << val << " ";
    }
};
​
void test()
{
    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(), print());
}
​
int main()
{
    test();
    return 0;
}

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

3.merge

功能描述：

两个容器元素合并，并存储到另一容器中

函数原型：

merge(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest);

容器元素合并，并存储到另一容器中

注意：两个容器必须是有序的，而且两个均为升序或降序

beg1容器1开始迭代器

end1容器1结束迭代器

beg2容器2开始迭代器

end2客器2结束送代器

dest目标容器开始迭代器

示例：

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
​
//常用的排序算法 merge
//仿函数
class print
{
public:
    operator()(int val)
    {
        cout << val << " ";
    }
};
​
void test()
{
    vector<int>v1;
    vector<int>v2;
    
    for(int i = 0;i < 10; i++)
    {
        v1.push_back(i);
        v2.push_back(i+1);
    }
    
    //目标容器
    vector<int>vTarget;
    vTarget.resize(v1.size() + v2.size());
    merge(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
    
    for_each(vTarget.begin(), vTarget.end(), print());
    cout << endl;
}
​
int main()
{
    test();
    return 0;
}

4.reverse

功能描述：

将容器内元素进行反转

函数原型： reverse(iterator beg,iterator end);

反转指定范围的元素

beg开始迭代器

end结束迭代器

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
​
//常用排序算法 reverse
class print
{
public:
    operator()(int val)
    {
        cout << val << " ";
    }
};
​
void test()
{
    vector<int>v;
    
    for(int i = 0;i < 10; i++)
    {
        v.push_back(i);
    }
    cout << "反转前：" << endl;
    for_each(v.begin(), v.end(), print());
    cout << endl;
    
    reverse(v.begin(), v.end());
    
    cout << "反转后：" << endl;
    
    for_each(v.begin(), v.end(), print());
}
​
int main()
{
    test();
    return 0;
}

4.常用拷贝和替换算法

算法简介：

copy容器内指定范围的元素拷贝到另一容器中

replace将容器内指定范围的旧元素修改为新元素

replace_if容器内指定范围满足条件的元素替换为新元素

swap互换两个容器的元素

1.swap

功能描述：

容器内指定范围的元素拷贝到另一容器中

函数原型：

copy(iterator beg,iterator end,iterator dest);

按值查找元素，找到返回指定位置迭代器，找不到就返回结束迭代器位置

beg开始迭代器

end结束迭代器

dest目标超始迭代器

示例:

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
​
//常用拷贝和替换算法 copy
class print
{
public:
    operator()(int val)
    {
        cout << val << " ";
    }
};
​
void test()
{
    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(), print());
    cout << endl;
}
​
int main()
{
    test();
    return 0;
}

2.replace

功能描述：

将容器内指定范围的旧元素核改为新元素

函数原型：

replace(iterator beg,iterator end, oldvalue, newvalue);

将区间内旧元素替换成新元素

beg开始迭代器

end结束迭代器

oldvalue旧元素

newvalue新元素

示例：

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
​
//常用拷贝和替换算法replace
class print
{
public:
    operator()(int val)
    {
        cout << val << " ";
    }
};
​
void test()
{
    vector<int>v;
    v.push_back(20);
    v.push_back(30);
    v.push_back(40);
    v.push_back(30);
    v.push_back(40);
    v.push_back(10);
    v.push_back(20);
    v.push_back(20);
    
    cout << "替换前：" << endl;
    for_each(v.begin(), v.end(), print());
    cout << endl;
    
    //将20替换为200
    replace(v.begin(), v.end(), 20, 200);
    cout << "替换后：" << endl;
    for_each(v.begin(), v.end(), print());
    cout << endl;
}
​
int main()
{
    test();
    return 0;
}

3.replace_if

功能描述：

将区间内满足条件的元素，苔换成指定元素

函数原型：

replace_if(iterator beg,iterator end,_pred,newvalue);

按条件换元素，满足条件的替换成指定元素

beg开始迭代器

end结束迭代器

_pred谓词

newvalue替换的新元素

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
​
//常用拷贝和替换算法replace_if
class print
{
public:
    operator()(int val)
    {
        cout << val << " ";
    }
};
​
class Greater
{
public:
    bool operator()(int val)
    {
        return val > 30;
    }
};
​
void test()
{
    vector<int>v;
    v.push_back(20);
    v.push_back(30);
    v.push_back(40);
    v.push_back(30);
    v.push_back(40);
    v.push_back(10);
    v.push_back(20);
    v.push_back(20);
    
    cout << "替换前：" << endl;
    for_each(v.begin(), v.end(), print());
    cout << endl;
    
    //将大于30的替换为100
    replace_if(v.begin(), v.end(), Greater(), 100);
    cout << "替换后：" << endl;
    for_each(v.begin(), v.end(), print());
    cout << endl;
}
​
int main()
{
    test();
    return 0;
}

总结：replace_if按条件查找，可以利用仿函数灵活筛选满足的条件

4.swap

功能描述：

互换两个容器的元素

函数原型： swap(container c1,container c2);互换两个容器的元素

c1容器1

c2容器2

示例

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
​
//常用拷贝和替换算法 swap
class print
{
public:
    operator()(int val)
    {
        cout << val << " ";
    }
};
​
void test()
{
    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(), print());
    cout << endl;
    for_each(v2.begin(), v2.end(), print());
    cout << endl;
    
    cout << "--------------------------" << endl;
    cout << "交换后：" << endl;
    swap(v1, v2);
    for_each(v1.begin(), v1.end(), print());
    cout << endl;
    for_each(v2.begin(), v2.end(), print());
    cout << endl;
}
​
int main()
{
    test();
    return 0;
}

5.常用算法生成算法

注意：

算术生成算法属于小型算法，使用时包含的头文件为include<numeric>

算法简介： accumulate计算容器元素累计总和

fill向容器中添加元素

1.accumulate

功能描述：

计算区间内容器元素累计总和

函数原型： accumulate(iterator beg,iterator end,value);

计算容器元素累计总和

beg开始迭代器

end结束迭代器

value起始值

示例：

#include<iostream>
#include<vector>
#include<numeric>
using namespace std;
​
//常用算法生成算法
class print
{
public:
    operator()(int val)
    {
        cout << val << " ";
    }
};
​
void test()
{
    vector<int>v;
    
    for(int i = 0;i <= 100; i++)
    {
        v.push_back(i);
    }
    
    int total = accumulate(v.begin(), v.end(), 0);
    
    cout << "累计求和值为：" << total << endl;
}
​
int main()
{
    test();
    return 0;
}

总结：accumulate使用时头文件注意是numeric，这个算法很实用

2.fill

功能描述：

向容器中填充相定的元素

函数原型：

fill(iterator beg,iterator end,value);

向容器中填充元素

beg开始迭代器

end结束迭代器

value填充的值

示例：

#include<iostream>
#include<vector>
#include<numeric>
#include<algorithm>
using namespace std;
​
//常用算法生成算法
class print
{
public:
    operator()(int val)
    {
        cout << val << " ";
    }
};
​
void test()
{
    vector<int>v;
    v.resize(10);
    
    //后期重新填充
    fill(v.begin(), v.end(), 100);
    
    for_each(v.begin(), v.end(), print());
}
​
int main()
{
    test();
    return 0;
}

6.常用集合算法

算法简介：

set_intersection求两个容器的交集

set_union求两个容器的并集

set_difference求两个容器的差集

 

1.set_intersection

功能描述：

求两个容器的交集

函数原型：

set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);求两个集合的交集

示例：

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
​
//常用集合算法
class print
{
public:
    operator()(int val)
    {
        cout << val << " ";
    }
};
​
void test()
{
    vector<int>v1;
    vector<int>v2;
    
    for(int i = 0;i < 10; i++)
    {
        v1.push_back(i);
        v2.push_back(i + 5);
    }
    
    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, print());
}
​
int main()
{
    test();
    return 0;
}

总结：

求交集的两个集合必须的有序序列

目标容器开辟空间需要从两个容器中取小值

set_intersection返回值既是交集中最后一个元素的位置

2.set_union

功能描述：

求两个集合的并集

函数原型：

set_union(iterator begl, iterator end1, iterator beg2, iterator end2, iterator dest);

求两个集合的并集I

注意：两个集合必须是有序序列

beg1 容器1开始迭代器

end1 容器1结束迭代器

beg2 容器2开始迭代器

end2 容器2结束迭代器

dest目标容器开始迭代器

示例：

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
​
//常用集合算法
class print
{
public:
    operator()(int val)
    {
        cout << val << " ";
    }
};
​
void test()
{
    vector<int>v1;
    vector<int>v2;
    
    for(int i = 0;i < 10; i++)
    {
        v1.push_back(i);
        v2.push_back(i + 5);
    }
    
    vector<int>vTarget;
    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, print());
}
​
int main()
{
    test();
    return 0;
}

总结：

求并集的两个集合必须的有序序列

目标容器开辟空间需要两个容器相加

set_union返回值既是并集中最后一个元素的位置

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>
#include<vector>
#include<algorithm>
using namespace std;
​
//常用集合算法
class print
{
public:
    operator()(int val)
    {
        cout << val << " ";
    }
};
​
void test()
{
    vector<int>v1;
    vector<int>v2;
    
    for(int i = 0;i < 10; i++)
    {
        v1.push_back(i);
        v2.push_back(i + 5);
    }
    
    vector<int>vTarget;
    vTarget.resize(max(v1.size(),v2.size()));
    
    vector<int>::iterator itEnd = set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
    
    cout << "v1和v2的差集：" << endl;
    for_each(vTarget.begin(), itEnd, print());
    cout << endl;
    
    itEnd = set_difference(v2.begin(), v2.end(), v1.begin(), v1.end(), vTarget.begin());
    cout << "v2和v1的差集：" << endl;
    for_each(vTarget.begin(), itEnd, print());
    cout << endl;
}
​
int main()
{
    test();
    return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/2809.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【AWS入门】通过AWS存储网关（Storage Gate Way）实现文件共享

【AWS入门】通过AWS存储网关（Storage Gate Way）实现文件共享

目录1. 创建网关2. 创建文件共享3. Windows文件共享4. LINUX文件共享1. 创建网关 配置缓存存储需要加载一会儿&#xff0c;此处需要等候 根据上述配置&#xff0c;会自动生成一个EC2实例 2. 创建文件共享 网关&#xff1a;选择上述步骤中创建的网关&#xff0c;选择即可 文…
阅读更多...
电路设计的一些概念

电路设计的一些概念

锁存器的产生 论述1 (转)时序电路&#xff0c;生成触发器&#xff0c;触发器是有使能端的&#xff0c;使能端无效时数据不变&#xff0c;这是触发器的特性。 组合逻辑&#xff0c;由于数据要保持不变&#xff0c;只能通过锁存器来保存。 第一个代码&#xff0c;由于是时序逻…
阅读更多...
基于XML的自动装配~

基于XML的自动装配~

基于XML的自动装配之场景模拟&#xff1a; 自动装配&#xff1a;根据指定的策略&#xff0c;在IOC容器中匹配某一个bean&#xff0c;自动为指定的bean中所依赖的类类型或者接口类型赋值 之前我们学过的依赖注入&#xff0c;我们在为不同属性赋值时&#xff0c;例如类类型的属性…
阅读更多...
可别再用BeanUtils了（性能拉胯），试试这款转换神器

可别再用BeanUtils了（性能拉胯），试试这款转换神器

老铁们是不是经常为写一些实体转换的原始代码感到头疼&#xff0c;尤其是实体字段特别多的时候。有的人会说&#xff0c;我直接使用get/set方法。没错&#xff0c;get/set方法的确可以解决&#xff0c;而且也是性能较高的处理方法&#xff0c;但是大家有没有想过&#xff0c;要…
阅读更多...
数据结构与算法——堆的基本存储

数据结构与算法——堆的基本存储

目录 一、概念及其介绍 二、适用说明 三、结构图示 四、Java 实例代码 五.堆和栈的区别 一、概念及其介绍 堆(Heap)是计算机科学中一类特殊的数据结构的统称。 堆通常是一个可以被看做一棵完全二叉树的数组对象。 堆满足下列性质&#xff1a; 堆中某个节点的值总是不大…
阅读更多...
MySQL主从复制

MySQL主从复制

主从复制概述 如何提升数据库并发能力 在实际工作中&#xff0c;我们常常将 Redis 作为缓存与 MySQL 配合来使用&#xff0c;当有请求的时候&#xff0c;首先会从缓存中进行查找&#xff0c;如果存在就直接取出。如果不存在再访问数据库&#xff0c;这样就 提升了读取的效率&…
阅读更多...
I2C和SPI总线以及通信

I2C和SPI总线以及通信

通讯属性 概括 Serial/parallel 串行/并行Synchronous/asynchronous 同步/异步Point-to-point / bus 点对点 总线Half-duplex/full-duplex 半双工/全双工Master-slave/ equal partners 主从/对等single-ending / differential 单端/差分 点对点和总线 点对点通讯 只有两个通…
阅读更多...
【简陋Web应用2】人脸检测——基于Flask和PaddleHub

【简陋Web应用2】人脸检测——基于Flask和PaddleHub

文章目录&#x1f6a9; 前言&#x1f33a; 效果演示&#x1f966; 分析与设计&#x1f349; 实现&#x1f36c; 1. 部署人脸检测模型&#x1f36d; 2. 使用Flask构建app2.1 目录结构2.2 forms.py2.3 utils.py2.4 app.py2.5 index.html&#x1f95d; Bug(s)&#x1f6a9; 前言 本…
阅读更多...
V2G模式下含分布式能源网优化运行研究（Matlab代码实现）

V2G模式下含分布式能源网优化运行研究（Matlab代码实现）

&#x1f4a5;&#x1f4a5;&#x1f49e;&#x1f49e;欢迎来到本博客❤️❤️&#x1f4a5;&#x1f4a5; &#x1f4cb;&#x1f4cb;&#x1f4cb;本文目录如下&#xff1a;&#x1f381;&#x1f381;&#x1f381; 目录 &#x1f4a5;1 概述 &#x1f4da;2 运行结果 &am…
阅读更多...
手写一个简单的RPC框架

手写一个简单的RPC框架

学习RPC框架&#xff0c;由繁化简&#xff0c;了解其本质原理 文章目录项目简介什么是RPC&#xff1f;项目模块项目代码common模块client模块server模块framework模块测试项目简介 什么是RPC&#xff1f; RPC&#xff08;Remote Procedure Call&#xff09;即远程过程调用&am…
阅读更多...
Cursor：GPT-4 驱动的强大代码编辑器

Cursor：GPT-4 驱动的强大代码编辑器

Cursor &#xff08;https://www.cursor.so/&#xff09;是 GPT-4 驱动的一款强大代码编辑器&#xff0c;可以辅助程序员进行日常的编码。下面通过一个实际的例子来展示 Cursor 如何帮助你编程。这个例子做的事情是网页抓取。抓取的目标是百度首页上的百度热搜&#xff0c;如下…
阅读更多...
SWA Object Detection随机权重平均【论文+代码】

SWA Object Detection随机权重平均【论文+代码】

随机权重平均摘要IntroductionSWA实验部分消融实验摘要 您想在不增加推断成本和不改变检测器的情况下提高对象检测器的1.0 AP吗&#xff1f;让我们告诉您一个这样的秘方。这个秘方令人惊讶地简单&#xff1a;使用循环学习率训练您的检测器额外的12个epoches&#xff0c;然后将…
阅读更多...
最强的Python可视化神器，你有用过么？

最强的Python可视化神器，你有用过么？

数据分析离不开数据可视化&#xff0c;我们最常用的就是Pandas&#xff0c;Matplotlib&#xff0c;Pyecharts当然还有Tableau&#xff0c;看到一篇文章介绍Plotly制图后我也跃跃欲试&#xff0c;查看了相关资料开始尝试用它制图。 1、Plotly Plotly是一款用来做数据分析和可视…
阅读更多...
【数据结构】Java实现队列与循环队列

【数据结构】Java实现队列与循环队列

目录 1. 概念 2. 队列的使用 3. 自己动手实现队列 3.1 MyQueue接口 3.2 LinkedQueue类 3.3 入队列 3.4 出队列 3.5 获取队头元素 3.6 获取队列中有效元素个数与检测队列是否为空 3.7 toString方法 4. 整体实现 4.1 LinkedQueue类 4.2 Test类 4.3 测试结果 5. 循…
阅读更多...
while实现1到100相加求和-课后程序(JavaScript前端开发案例教程-黑马程序员编著-第2章-课后作业)

while实现1到100相加求和-课后程序(JavaScript前端开发案例教程-黑马程序员编著-第2章-课后作业)

【案例2-7】while实现1到100相加求和 一、案例描述 考核知识点 while循环语句 练习目标 掌握while循环语句。 需求分析 1-100之间的数相加求和&#xff0c;本案例通过while循环语句来实现。 案例分析 效果如图2-10所示。1-100所有数的和 具体实现步骤如下&#xff1a; 在&l…
阅读更多...
【进阶数据结构】——红黑树

【进阶数据结构】——红黑树

&#x1f308;感谢阅读East-sunrise学习分享——[进阶数据结构]红黑树 博主水平有限&#xff0c;如有差错&#xff0c;欢迎斧正&#x1f64f;感谢有你 码字不易&#xff0c;若有收获&#xff0c;期待你的点赞关注&#x1f499;我们一起进步&#x1f680; &#x1f308;我们上一…
阅读更多...
SpringCloud之 LoadBalancer和Feign负载均衡

SpringCloud之 LoadBalancer和Feign负载均衡

文章目录LoadBalancer 负载均衡一、LoadBalanced 负载均衡&#x1f33d;①观察负载均衡现象&#x1f33d;②LoadBalanced 源码剖析二、自定义负载均衡三、OpenFeign 实现负载均衡&#x1f346;①添加依赖&#x1f346;②启动类添加 EnableFeignClients&#x1f346;③创建客户端…
阅读更多...
MySQL的COUNT语句，竟然都能被面试官虐的这么惨！？

MySQL的COUNT语句，竟然都能被面试官虐的这么惨！？

关于数据库中行数统计&#xff0c;无论是MySQL还是Oracle&#xff0c;都有一个函数可以使用&#xff0c;那就是COUNT 但是&#xff0c;就是这个常用的COUNT函数&#xff0c;却暗藏着很多玄机&#xff0c;尤其是在面试的时候&#xff0c;一不小心就会被虐。不信的话请尝试回答下…
阅读更多...
一文了解Jackson注解@JsonFormat及失效解决

一文了解Jackson注解@JsonFormat及失效解决

背景 项目中使用WRITE_DATES_AS_TIMESTAMPS: true转换日期格式为时间戳未生效。如下&#xff1a; spring:jackson:time-zone: Asia/Shanghaiserialization:WRITE_DATES_AS_TIMESTAMPS: true尝试是否关于时间的注解是否会生效&#xff0c;使用JsonForma和JsonFiled均失效。 常…
阅读更多...
【Docker】CAdvisor+InfluxDB+Granfana容器监控

【Docker】CAdvisor+InfluxDB+Granfana容器监控

文章目录原生命令 docker stats容器监控3剑客CIGCAdvisorInfluxDBGranfanacompose容器编排&#xff0c;一套带走新建目录新建3件套组合的 docker-compose.yml检查配置&#xff0c;有问题才有输出 docker-compose config -q启动docker-compose文件 docker-compose up -d测试浏览…
阅读更多...
最新文章

Copyright @ 2022~2023