c++入门笔记-stl常用算法-遍历/查找/排序

概述：

        算法主要是由头文件组成

        是所有STL头文件中最大的一个 范围涉及到比较、交换、查找、遍历操作、复

        制、修改等

        体积很小 只包括几个在序列上面进行简单数学运算的模版函数

        定义了一些模版类 用以声明函数对象

常用遍历算法

        for_each  //遍历容器

        transform  //搬用容器到另一个容器中

 for_each:

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

        //beg 开始迭代器

        //end 结束迭代器

        //_func 函数或函数对象

        注意⚠️：普通函数放入的是函数名 

                        仿函数要把匿名的函数对象放进来 所以加了()

#include 
using namespace std;
#include 
#include 


//普通函数
void print01(int val){
    cout << val << " ";
}

//仿函数
class print02{
public:
    void operator()(int val){
        cout << val << " ";
    }
};
void test01()
{
    vectorv;
    //插入数据0～9
    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();
    return 0;
}

输出结果：

0 1 2 3 4 5 6 7 8 9 

0 1 2 3 4 5 6 7 8 9 

transform:

        函数原型：transform(iterator beg1, iterator end1, iterator beg2, _func);

        //beg1 源容器开始迭代器

        //end1 源容器结束迭代器

        //beg2 目标容器开始迭代器

        //_func 函数或函数对象

#include 
using namespace std;
#include 
#include 

//搬运仿函数
class Tansform
{
public:
    //这里的搬运相当于把每一个int数据从源容器拿出来再返回到目标容器
    int operator()(int v){
        //这里v+100就相当于在搬运过程中每个元素数据加了100放入目标容器
        return v+100;
    }
};

//遍历仿函数
class MyPrint
{
public:
    void operator()(int val){
        cout << val << " ";
    }
};
void test01()
{
    //源容器
    vectorv;
    //插入数据0～9
    for(int i=0; i<10; i++){
        v.push_back(i);
    }
    
    //目标容器
    vectorvTarget;
    
    //目标容器必须提前开辟容量空间 不然放不进去
    vTarget.resize(v.size());
    
    //开始搬运操作
    transform(v.begin(), v.end(), vTarget.begin(), Tansform());
    
    //开始遍历操作
    for_each(vTarget.begin(), vTarget.end(), MyPrint());
    cout << endl;
}


int main() {
    test01();
    return 0;
}

输出结果：

100 101 102 103 104 105 106 107 108 109                  

常用查找算法

        find  //查找元素

        find_if  //按条件查找元素

        adjacent_find  //查找相邻重复元素

        binary_search  //二分查找法

        count  //统计元素个数

        count_if  //按条件统计元素个数

find：

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

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

        //beg 开始迭代器

        //end 结束迭代器

        //value 查找的元素

       

#include 
using namespace std;
#include 
#include 
#include 

//查找内置的数据类型
void test01()
{
    vectorv;
    //插入数据0～9
    for(int i=0; i<10; i++){
        v.push_back(i);
    }
    
    //查找容器中是否有7这个元素 会返回一个迭代器
    vector::iterator it = find(v.begin(), v.end(), 7);
    if(it == v.end()){
        cout << "未找到" << endl;
    }else{
        cout << "找到：" << *it << endl;
    }
}

class Person
{
public:
    Person(string name, int age){
        this->name = name;
        this->age = age;
    }
    
    //重载== 让底层find知道如何对比Person数据类型
    bool operator==(const Person &p)
    {
        if(this->name == p.name && this->age == p.age){
            return true;
        }else{
            return false;
        }
    }
    string name;
    int age;
    
};
//查找自定义的数据类型
void test02(){
    vectorv;
    
    Person p1("张三",10);
    Person p2("李四",25);
    Person p3("王五",80);
    
    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);
    
    Person pTest("李四",25);
    //查找一下容器中有没有叫李四而且年龄是25的人
    vector::iterator it = find(v.begin(), v.end(), pTest);
    if(it == v.end()){
        cout << "未找到" << endl;
    }else{
        cout << "找到了 姓名是：" << it->name << " 年龄是："  << it->age << endl;
    }
}

int main() {
    test01();
    test02();
    return 0;
}

输出结果：

找到：7

找到了 姓名是：李四 年龄是：25

 find_if:

        功能：按条件查找元素

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

        //beg 开始迭代器

        //end 结束迭代器

        //_Pred 函数或者谓词(返回bool类型的仿函数)

#include 
using namespace std;
#include 
#include 
#include 

class GreaterSeven
{
public:
    //条件查找 顾名思义就是给出一个判断为真的条件
    //所以用的bool返回类型的谓词
    bool operator()(int val){
        return val > 7;
    }
};
//查找内置的数据类型
void test01()
{
    vectorv;
    //插入数据0～9
    for(int i=0; i<10; i++){
        v.push_back(i);
    }
    
    //查找第一个大于7的数字 找到返回元素的迭代器 未找到返回end()
    vector::iterator it = find_if(v.begin(), v.end(), GreaterSeven());
    if(it == v.end()){
        cout << "未找到" << endl;
    }else{
        cout << "找到了第一个大于7的数字为：" << *it << endl;
    }
}

class Person
{
public:
    Person(string name, int age){
        this->name = name;
        this->age = age;
    }
    string name;
    int age;
    
};
class AgeGreater50
{
public:
    //条件查找 顾名思义就是给出一个判断为真的条件
    //所以用的bool返回类型的谓词
    //已经给出了判断条件中的Person里的年龄大于50为真
    //所以不需要再像find一样重载==运算符了
    bool operator()(Person &p){
        return p.age > 50;
    }
};
//查找自定义的数据类型
void test02(){
    vectorv;
    
    Person p1("张三",10);
    Person p2("李四",25);
    Person p3("王五",80);
    
    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);
    
    Person pTest("李四",25);
    //查找一下年龄大于50的人 返回Person类型的迭代器
    vector::iterator it = find_if(v.begin(), v.end(), AgeGreater50());
    if(it == v.end()){
        cout << "未找到" << endl;
    }else{
        cout << "找到了 姓名：" << it->name << " 年龄：" << it->age << endl;
    }
}

int main() {
    test01();
    test02();
    return 0;
}

输出结果：

找到了第一个大于7的数字为：8

找到了 姓名：王五 年龄：80

adjacent_find:

        功能描述：查找相邻重复元素 

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

        //beg 开始迭代器

        //end 结束迭代器

#include 
using namespace std;
#include 
#include 

void test01(){
    vectorv;
    v.push_back(0);
    v.push_back(2);
    v.push_back(5);
    v.push_back(9);
    v.push_back(2);
    v.push_back(2);
    
    //寻找相邻重复元素 这里迭代器返回的是第一个2的位置
    vector::iterator it = adjacent_find(v.begin(), v.end());
    
    if(it == v.end()){
        cout << "未找到相邻重复元素" << endl;
    }else{
        cout << "找到了相邻重复元素：" << *it << endl;
    }
}

int main() {
    test01();
    return 0;
}

输出结果：

找到了相邻重复元素：2

binary_search:

        功能：查找指定的元素是否存在

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

        注意⚠️：二分查找法只支持有序序列

        //beg 开始迭代器

        //end 结束迭代器

        //value 查找的元素

#include 
using namespace std;
#include 
#include 

void test01(){
    vectorv;
    
    //这里我们插入的是0～9的有序序列
    //二分查找法不支持无序序列的查找
    //不然输出结果会不正确
    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() {
    test01();
    return 0;
}

输出结果：

找到了元素

count：

        功能：统计元素个数

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

        //beg  开始迭代器

        //end 结束迭代器

        //value 统计的元素

#include 
using namespace std;
#include 
#include 
#include 

//统计内置数据类型
void test01(){
    vectorv;
    
    v.push_back(10);
    v.push_back(60);
    v.push_back(60);
    v.push_back(30);
    v.push_back(60);
    
    int num = count(v.begin(), v.end(), 60);
    cout << "60元素的个数为：" << num << endl;
}

//统计自定义数据类型
class Person
{
public:
    Person(string name, int age){
        this->name = name;
        this->age = age;
    }
    
    //重载 == 运算符
    bool operator==(const Person &p)
    {
        if(this->age == p.age){
            return true;
        }else{
            return false;
        }
    }
    string name;
    int age;
};
void test02(){
    vectorv;
    Person p1("张三",30);
    Person p2("李四",55);
    Person p3("王五",20);
    Person p4("赵六",55);
    
    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);
    v.push_back(p4);
    
    Person p("山姆",55);
    
    //统计一下和山姆同岁数的人有多少
    cout << "和山姆同岁数的人数有: " << count(v.begin(), v.end(), p)
    << "人"<< endl;
}
int main() {
    test01();
    test02();
    return 0;
}

 输出结果：

60元素的个数为：3

和山姆同岁数的人数有: 2人

count_if:

        功能：按条件统计元素个数

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

        //beg 开始迭代器

        //end 结束迭代器

        //_Pred 谓词

#include 
using namespace std;
#include 
#include 
#include 

//统计内置数据类型
class Greater30
{
public:
    bool operator()(int val){ //谓词
        return val > 30;
    }
};
void test01(){
    vectorv;
    
    v.push_back(10);
    v.push_back(60);
    v.push_back(50);
    v.push_back(30);
    v.push_back(60);
    
    //统计大于30的元素个数
    //第三个参数为函数对象谓词
    int num = count_if(v.begin(), v.end(), Greater30());
    
    cout << "大于30的元素个数为：" << num << endl;
}

//统计自定义数据类型
class Person
{
public:
    Person(string name, int age){
        this->name = name;
        this->age = age;
    }
    
    string name;
    int age;
};

class AgeGreater50
{
public:
    bool operator()(const Person &p){
        return p.age > 50;
    }
};
void test02(){
    vectorv;
    Person p1("张三",30);
    Person p2("李四",55);
    Person p3("王五",20);
    Person p4("赵六",55);
    
    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);
    v.push_back(p4);
    
    
    //统计一下大于50岁的人数
    int num = count_if(v.begin(), v.end(), AgeGreater50());
    
    cout << "大于50岁的人数为：" << num << endl;
}
int main() {
    test01();
    test02();
    return 0;
}

 输出结果：

大于30的元素个数为：3

大于50岁的人数为：2

常用排序算法 

算法简介：

        sort  //对容器内元素进行排序

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

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

        reverse //反转指定范围的元素

sort：

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

        //beg 开始迭代器

        //end 结束迭代器

        //_Pred 谓词

#include 
using namespace std;
#include 
#include 
#include 

//常用排序算法 sort
void myPrint(int val){
    cout << val << " ";
}
void test01(){
    vectorv;
    
    v.push_back(10);
    v.push_back(60);
    v.push_back(50);
    v.push_back(30);
    v.push_back(60);
    
    //利用sort进行升序
    sort(v.begin(), v.end());
    
    //for_each第三个参数可以是普通的函数的函数名
    //也可以是仿函数的匿名对象
    for_each(v.begin(), v.end(), myPrint);
    cout << endl;
    //改变为降序
    //这里第三个参数我们使用内建的函数对象greater
    //需要加入头文件functional
    sort(v.begin(), v.end(), greater());
    
    for_each(v.begin(), v.end(), myPrint);
    cout << endl;
}

int main() {
    test01();
    return 0;
}

输出结果：

10 30 50 60 60 

60 60 50 30 10 

random_shuffle:

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

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

        //beg 开始迭代器

        //end 结束迭代器        

#include 
using namespace std;
#include 
#include 
#include 
//常用排序算法 random_shuffle
void myPrint(int val){
    cout << val << " ";
}
void test01(){
    //这里我们放一个随机的时间种子
    //让输出的打乱结果每一次都不一样
    //记的包含头文件ctime
    srand((unsigned int)time(NULL));
    
    vectorv;
    
    //这里我们插入10个有序的数
    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();
    return 0;
}

  输出结果：

6 0 3 5 7 8 4 1 2 9 

 merge：

        功能：两个容器元素合并 并储存到另一个容器中

        函数原型：merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest)

        //beg1 源容器1开始迭代器

        //end1 源容器1结束迭代器

        //beg2 源容器2开始迭代器

        //end2 源容器2结束迭代器

        //dest 目标容器开始迭代器

        注意⚠️：合并的两个容器必须是有序的 合并完容器也是有序的

#include 
using namespace std;
#include 
#include 

//常用排序算法 merge
void myPrint(int val){
    cout << val << " ";
}
void test01(){
    vectorv1;
    vectorv2;
    
    //这里我们插入10个有序的数
    for(int i=0; i<10; i++){
        v1.push_back(i);
        v2.push_back(i+1);
    }
    
    //目标容器
    vectorvTarget;
    
    //给目标容器分配空间
    vTarget.resize(v1.size()+v2.size());
    
    //融合两个容器并传入目标容器
    merge(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
    
    //遍历输出
    for_each(vTarget.begin(), vTarget.end(), myPrint);
    cout << endl;
}

int main() {
    test01();
    return 0;
}

输出结果：

0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10

 reverse：

        功能：将容器元素进行反转

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

        //beg 开始迭代器

        //end 结束迭代器

#include 
using namespace std;
#include 
#include 

//常用排序算法 reverse
void myPrint(int val){
    cout << val << " ";
}
void test01(){
    vectorv;
    v.push_back(50);
    v.push_back(20);
    v.push_back(10);
    v.push_back(30);
    v.push_back(45);
    
    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();
    return 0;
}

输出结果：

反转前：

50 20 10 30 45 

反转后：

45 30 10 20 50 

暑期编程PK赛 得CSDN机械键盘等精美礼品！