STL-常用算法

最新推荐文章于 2023-05-24 08:04:36 发布
最新推荐文章于 2023-05-24 08:04:36 发布
阅读量120 收藏
点赞数
分类专栏： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50866517/article/details/117663476
版权

算法

介绍

1.STL将算法库分成4组：

  1. 非修改式序列操作。（对区间中的每个元素进行操作，但不修改容器的内容。例如：find(),for_each()）
  2. 修改式序列操作。（对区间中的每个元素进行操作，可以修改内容、值、值的排列顺序。例如：transform()、randm_shuffle（）、copy（））
  3. 排序和相关操作。（包括多个排序函数，例如：sort(),其他各种函数，包括集合操作）
  4. 通用数字运算。（将区间的内容积累、计算两个容器的内部乘积、计算小计、计算相连对象差的函数。都是数组的操作特性，vector可能使用这些操作）。

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

  1. 是所有STL头文件中最大的一个，范围涉及到比较、 交换、查找、遍历操作、复制、修改等等
  2. 体积很小，只包括几个在序列上面进行简单数学运算的模板函数
  3. 定义了一些模板类,用以声明函数对象。

常用遍历算法

1.for_each:遍历容器元素
在这里插入图片描述

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

在这里插入图片描述

2.transform算法 将指定容器区间元素搬运到另一容器中

在这里插入图片描述
在这里插入图片描述

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


int myTransInt1(int val)
{
    return val;
}

class myTransInt2
{
public:
    int operator ()(int val)
    {
        return val;
    }
};

int main()
{
    vector<int> v1;
    v1.push_back(10);
    v1.push_back(20);
    v1.push_back(30);
    v1.push_back(40);

    //将v1容器的元素 把运到v2中

    vector<int> v2;
    //预先：设置v2的大小（重要）
    v2.resize(v1.size());

    //transform(v1.begin(),v1.end(),v2.begin(), 搬运方式);
    //transform(v1.begin(),v1.end(),v2.begin(),myTransInt);

    transform(v1.begin(),v1.end(),v2.begin(),myTransInt2());


    for_each(v2.begin(),v2.end(),[](int val){cout<<val<<" ";});
    cout<<endl;

}

在这里插入图片描述

常用查找算法

1.find算法查找元素
在这里插入图片描述

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

 class Person
 { 
 public:
 string name; 
 int age; 
 public: 
	 Person(string name, int age) 
		  { 
		  this-> name = name;
		  this-> age = age;
		  } 
	  bool operator==(const Person & ob) 
		  {
	 if (this-> name == ob.name && this->age == ob.age) 
		 return true;
	 return false;
	 } 
	  }; 
  int main() 
	  {
	  vector<int> v1; 
	  v1.push_back(10); 
	  v1.push_back(20); 
	  v1.push_back(30); 
	  v1.push_back(40); 
	  vector<int>::iterator ret; 
	  ret = find(v1.begin(), v1.end(), 20); 
	  if (ret != v1.end()) 
		  {
		  cout << "找到的数据为:" << *ret << endl; 
		 }
	  vector<Person> v2; 
	  v2.push_back(Person("小华", 18));
	  v2.push_back(Person("小法", 19)); 
	  v2.push_back(Person("Tom", 20)); 
	  v2.push_back(Person("小明", 21)); 
	  Person tmp("Tom", 20); 
	 vector<Person>::iterator ret2; //定义了一个名为ret2的变量，它的数据类型是由vector<int>定义的iterator类型。
	  //对于find寻找自定义数据 需要重载==
		 ret2 = find(v2.begin(),v2.end(),tmp);
 if(ret2 != v2.end()) 
		  {
		  cout<<"找到的数据name="<<(*ret2).name<<",age="<<(*ret2).age<<endl; 
	 } 
}

在这里插入图片描述
总结： 利用find可以在容器中找指定的元素，返回值是迭代器
对于find寻找自定义数据 需要重载==

find_if条件查找

在这里插入图片描述

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

bool myGreaterThan20(int val)
{
    return val>20;
}


class MyGreaterThan20
{
public:
    bool operator ()(int val)
    {
        return val>20;
    }
};

int main()
{
    vector<int> v1;
    v1.push_back(10);
    v1.push_back(20);
    v1.push_back(30);
    v1.push_back(40);

    //寻找第一个大于20的数
    vector<int>::iterator ret;//定义了一个名为ret的变量，它的数据类型是由vector<int>定义的iterator类型。
    //ret=find_if(v1.begin(),v1.end(),myGreaterThan20);

    ret=find_if(v1.begin(),v1.end(),MyGreaterThan20());
    if(ret !=v1.end())
    {
        cout<<"寻找到数据为:"<<*ret<<endl;
    }

}

在这里插入图片描述
总结：find_if按条件查找使查找更加灵活，提供的仿函数可以改变不同的策略

adjacent_find算法 查找相邻重复元素

在这里插入图片描述

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

int main()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(5);
    v.push_back(2);
    v.push_back(4);
    v.push_back(4);
    v.push_back(3);


    //查找相邻重复元素
    vector<int>::iterator it = adjacent_find(v.begin(), v.end());
    if (it == v.end()) {
    cout << "找不到!" << endl;
    }else
    {
        cout << "找到相邻重复元素为:" << *it << endl;
    }
}

在这里插入图片描述
总结：面试题中如果出现查找相邻重复元素，记得用STL中的adjacent_find算法

binary_search算法 二分查找法（容器必须有序）

在这里插入图片描述

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

int main()
{
    vector<int> v;
    v.push_back(10);
    v.push_back(20);
    v.push_back(30);
    v.push_back(40);
    v.push_back(50);

    bool ret=binary_search(v.begin(),v.end(),30);
    if(ret==true)
    {
        cout<<"找到"<<endl;
    }else
    {
        cout<<"没找到"<<endl;
    }
}

在这里插入图片描述
总结：二分查找法查找效率很高，值得注意的是查找的容器中元素必须的有序序列

count算法统计元素出现次数

在这里插入图片描述

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

int main()
{
    vector<int> v;
    v.push_back(10);
    v.push_back(20);
    v.push_back(10);
    v.push_back(40);
    v.push_back(50);

    cout<<count(v.begin(),v.end(),10)<<endl;
}

在这里插入图片描述

统计自定义数据类型时候，需要配合重载operator==

#include<algorithm>
#include<iostream>
#include <vector>
#include<string>
using namespace std;
class Person
{
public:
    string name;
    int age;
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;
        }
    }
};


int main()
{
    vector<Person> v;

    v.push_back(Person("Tom", 35));
    v.push_back(Person("小关", 35));
    v.push_back(Person("小张", 35));
    v.push_back(Person("Lucy", 30));
    v.push_back(Person("小明", 25));

    Person tmp("小华",20);

    int num = count(v.begin(), v.end(), tmp); 
    cout << "num = " << num << endl;
}

在这里插入图片描述

count_if算法 统计元素出现次数

在这里插入图片描述

#include<algorithm>
#include<iostream>
#include <vector>
#include<string>
using namespace std;
bool myGreaterThan10(int val)
{
    return val>10;
}


class MyGreaterThan10
{
public:
    bool operator ()(int val)
    {
        return val>10;
    }
};

int main()
{
    vector<int> v1;
    v1.push_back(10);
    v1.push_back(20);
    v1.push_back(10);
    v1.push_back(40);
    v1.push_back(10);

    //普通函数
    cout<<count_if(v1.begin(),v1.end(),myGreaterThan10)<<endl;
    //函数对象
    cout<<count_if(v1.begin(),v1.end(),MyGreaterThan10())<<endl;
    //内建函数对象
    cout<<count_if(v1.begin(),v1.end(),bind2nd(greater<int>(),10))<<endl;

}

在这里插入图片描述

常用排序算法

1.merge算法 容器元素合并，并存储到另一容器中（每个容器必须有 序）

在这里插入图片描述

#include<algorithm>
#include<iostream>
#include <vector>
using namespace std;
class myPrint
{
public:
    void operator ()(int val)
    {
        cout<<val<<" ";
    }
};

int main()
{
    vector<int> v1;
    v1.push_back(1);
     v1.push_back(3);
     v1.push_back(5);
    v1.push_back(7);
    vector<int> v2;

    v2.push_back(2);
     v2.push_back(4);
     v2.push_back(6);
    v2.push_back(8);
    //预先：设置v3的大小
    vector<int> v3;
    v3.resize(v1.size()+v2.size());

    //合并 需要两个有序序列

    merge(v1.begin(),v1.end(),v2.begin(),v2.end(),v3.begin());
    for_each(v3.begin(),v3.end(),myPrint());
    cout<<endl;
}

在这里插入图片描述
总结：merge合并的两个容器必须的有序序列。

sort算法 容器元素排序

在这里插入图片描述

#include<algorithm>
#include<iostream>
#include <vector>
using namespace std;
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(20);
    v.push_back(40);
    //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();
    return 0;
}

在这里插入图片描述

random_shuffle算法 对指定范围内的元素随机调整次序

在这里插入图片描述

#include<algorithm>
#include<iostream>
#include <vector>
#include<time.h>
using namespace std;
int main()
{
    vector<int> v1;
     v1.push_back(1);
     v1.push_back(3);
     v1.push_back(5);
     v1.push_back(7);

     //srand设置随机种子
     srand(time(NULL));

     for_each(v1.begin(),v1.end(),[](int val){cout<<val<<" ";});
     cout<<endl;
     //打乱顺序
     random_shuffle(v1.begin(),v1.end());
     for_each(v1.begin(),v1.end(),[](int val){cout<<val<<" ";});

     cout<<endl;

}

在这里插入图片描述
总结：random_shuffle洗牌算法比较实用，使用时记得加随机数种子

reverse算法 反转指定范围的元素

在这里插入图片描述

include<algorithm>
#include<iostream>
#include <vector>
using namespace std;
 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(50);
     v.push_back(20);
     v.push_back(40);
     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;
 }

在这里插入图片描述
总结：reverse反转区间内元素，面试题可能涉及到

常用拷贝和替换算法

1、copy算法 将容器内指定范围的元素拷贝到另一容器中
在这里插入图片描述

#include<algorithm>
#include<iostream>
#include <vector>
#include<iterator>
using namespace std;
 int main()
 {
    vector<int> v1;
     v1.push_back(1);
     v1.push_back(3);
     v1.push_back(5);
     v1.push_back(7);
     vector<int> v2;
    //预先：设置大小
     v2.resize(v1.size());
     copy(v1.begin(),v1.end(),v2.begin());
     for_each(v2.begin(),v2.end(),[](int val){cout<<val<<" ";});
     cout<<endl;//1 3 5 7
     //：用copy输出(了解)
     copy(v2.begin(),v2.end(), ostream_iterator<int>(cout," ") );
   }

在这里插入图片描述

2.replace算法 将容器内指定范围的旧元素修改为新元素
在这里插入图片描述

#include<algorithm>
#include<iostream>
#include <vector>
using namespace std;
 class myPrint
 {
 public:
void operator()(int val)
{ cout << val << " ";
}
 };
int main()
 {
     vector<int> v;
     v.push_back(20);
     v.push_back(30);
     v.push_back(20);
     v.push_back(40);
     v.push_back(50);
     v.push_back(10);
     v.push_back(20);
     cout << "替换前：" << endl;
     for_each(v.begin(), v.end(), myPrint());
     cout << endl;
     //将容器中的20 替换成 2000
     cout << "替换后：" << endl;
     replace(v.begin(), v.end(), 20,2000);
     for_each(v.begin(), v.end(), myPrint());
     cout << endl;
 }

在这里插入图片描述

3.replace_if算法 将容器内指定范围满足条件的元素替换为新元素

在这里插入图片描述

include<algorithm>
#include<iostream>
#include <vector>
using namespace std;
class myPrint
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};
class ReplaceGreater30
{
public:
    bool operator()(int val)
    {

        return val >= 30;
    }
};
int main()
{
    vector<int> v;
    v.push_back(20);
    v.push_back(30);
    v.push_back(20);
    v.push_back(40);
    v.push_back(50);
    v.push_back(10);
    v.push_back(20);
    cout << "替换前：" << endl;
    for_each(v.begin(), v.end(), myPrint());
    cout << endl; //将容器中大于等于的30 替换成 3000


    cout << "替换后：" << endl;
    replace_if(v.begin(), v.end(), ReplaceGreater30(), 3000);
    for_each(v.begin(), v.end(), myPrint());
    cout << endl;
}

在这里插入图片描述
总结：replace_if按条件查找，可以利用仿函数灵活筛选满足的条件。

4.swap算法 互换两个容器的元素
在这里插入图片描述

#include<algorithm>
#include<iostream>
#include <vector>
using namespace std;
 class myPrint
 {
 public:
     void operator()(int val)
     {

         cout << val << " ";
     }
 };
 int main()
 {

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;
swap(v1, v2);
for_each(v1.begin(), v1.end(), myPrint());
cout << endl;
for_each(v2.begin(), v2.end(), myPrint());
cout << endl;
 }

在这里插入图片描述

五级标题
算术生成算法

1、accumulate算法 计算容器元素累计总和
在这里插入图片描述

#include<algorithm>
#include<iostream>
#include <vector>
#include<numeric>
using namespace std;
 int main()
 {
     vector<int> v1;
     v1.push_back(1);
      v1.push_back(3);
     v1.push_back(5);
      v1.push_back(7);

      int sum=accumulate(v1.begin(),v1.end(),100);
      cout<<"sum="<<sum<<endl;

 }

在这里插入图片描述
总结：accumulate使用时头文件注意是 numeric，这个算法很实用。

2、fill算法 向容器中添加元素
在这里插入图片描述

#include<algorithm>
#include<iostream>
#include <vector>
#include<iterator>
using namespace std;
 int main()
 {
    vector<int> v;
    v.resize(5);
    fill(v.begin(),v.end(),100);

    copy(v.begin(),v.end(),ostream_iterator<int>(cout," "));
    cout<<endl;
 }

在这里插入图片描述
总结：利用fill可以将容器区间内元素填充为 指定的值。

常用集合算法

1、setintersection算法 求两个set集合的交集

在这里插入图片描述

2、set_union算法 求两个set集合的并集
在这里插入图片描述

3、set_difference算法 求两个set集合的差集

在这里插入图片描述

例：
在这里插入图片描述

#include<algorithm>
#include<iostream>
#include <vector>
#include<iterator>
using namespace std;
int main()

{
     vector<int> A;
     A.push_back(1);
     A.push_back(3);
     A.push_back(5);
     A.push_back(7);
     A.push_back(9);
     vector<int> B;
     B.push_back(7);
     B.push_back(9);
     B.push_back(2);
     B.push_back(4);
     B.push_back(6);
     //求交集
     vector<int> v1;
    //存放交集
     v1.resize(min(A.size(),B.size()));
     vector<int>::iterator myEnd= set_intersection(A.begin(),A.end(),B.begin(),B.end(), v1.begin());
 copy(v1.begin(), myEnd, ostream_iterator<int>(cout," ") );
     cout<<endl;
     //求并集
     vector<int> v2;//存放并集
     v2.resize(A.size()+B.size() );
     myEnd = set_union(A.begin(),A.end(),B.begin(),B.end(), v2.begin());
     copy(v2.begin(), myEnd, ostream_iterator<int>(cout," ") );
     cout<<endl;
     //求差集 A 差 B
     vector<int> v3;//存放并集
     v3.resize( A.size() );
     myEnd = set_difference(A.begin(),A.end(),B.begin(),B.end(), v3.begin());
     copy(v3.begin(), myEnd, ostream_iterator<int>(cout," ") );
     cout<<endl;
}

在这里插入图片描述

STL比赛练习

比赛规则： 某市举行一场演讲比赛（ speech_contest ），共有24个人参加。比赛共三 轮，前两轮为淘汰赛，第三轮为决赛。
比赛方式：分组比赛，每组6个人；选手每次要随机分组，进行比赛；
第一轮分为4个小组，每组6个人。比如编号为: 100-123. 整体进行抽签 （draw）后顺序演讲。当小组演讲完后，淘汰组内排名最后的三个选手，然后 继续下一个小组的比赛。
第二轮分为2个小组，每组6人。比赛完毕，淘汰组内排名最后的三个选手，然 后继续下一个小组的比赛。
第三轮只剩下1组6个人，本轮为决赛，选出前三名。 比赛评分：10个评委打 分，去除最低、最高分，求平均分每个选手演讲完由10个评委分别打分。该选 手的最终得分是去掉一个最高分和一个最低分，求得剩下的8个成绩的平均分。 选手的名次按得分降序排列。 用STL编程，求解这个问题 1） 请打印出所有选手的名字与参赛号，并以参赛号 的升序排列。 2） 打印每一轮比赛后，小组比赛成绩和小组晋级名单 需求分析： 1) 产生选手 （ ABCDEFGHIJKLMNOPQRSTUVWX ） 姓名、得 分；
选手编号
第1轮 选手抽签 选手比赛 查看比赛结果
第2轮 选手抽签 选手比赛 查看比赛结果
第3轮 选手抽签 选手比赛 查看比赛结果
实现思路：
需要把选手信息、选手得分信息、选手比赛抽签信息、选手的晋级 信息保存在容器中，需要涉及到各个容器的选型。 选手可以设计一个类 Speaker（姓名和得分） 所有选手的编号可以单独放在一个vector容器中，做 抽签用 所有选手编号和选手信息，可以放在容器内

#include <iostream>
#include<string.h>
#include<iterator>
#include<vector>//编号容器
#include<map>//编号，选手
#include<algorithm>
#include<time.h>
#include<deque>
using namespace std;
class Speaker
{
public:
    string name;
    int score[3];
public:
    Speaker()
    {

    }
    Speaker(string name)
    {
        this->name = name;
        memset(score, 0, sizeof(score));//string.h
    }
};

void createSpeaker(vector<int>& v, map<int, Speaker>& m)
{
    string tmp = "ABCDEFGHIJKLMNOPQRSTUVWX";
    for (int i = 0; i < 24; i++)
    {
        //存放选手编号
        v.push_back(100 + i);
        //存放《编号,选手》
        string name = "选手";
        name += tmp[i];
        m.insert(make_pair(i + 100, Speaker(name)));
    }
}

void printSpeechResault(int index, vector<int>& v, map<int, Speaker>& m, vector<int>& v1)
{
    cout << "第" << index << "轮比赛成绩如下" << endl;
    int count = 0;
    int n = 0;
    vector<int>::iterator mit = v1.begin();
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
    {
        if (count % 6 == 0)
        {
            n = count / 6 + 1;
            cout << "第" << n << "组的成绩如下:" << endl;
        }
        count++;
        cout << "姓名:" << m[*it].name << ", 得分:" << m[*it].score[index-1] << endl;
        //每个组的成绩打印完 立马打印晋级名单
        if (count % 6 == 0)
        {
            cout << "第" << n << "组的晋级名单如下:" << endl;
            for (int i = 0; i < 3; i++, mit++)
            {
                cout << "姓名:" << m[*mit].name << ", 得分:" << m[*mit].score[index-1] << endl;
            }
        }
    }
}



void speech_contest(int index, vector<int>& v, map<int, Speaker>& m, vector<int>& v1)
{
    int count = 0;
    //设计一个<分数,编号>的map容器 存放每一组的《分数，编号》
    multimap<int, int, greater<int>> m2;
    //选手逐一登台比赛
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
    {
        count++;
        //*it 代表一名选手编号
       //10个评委打分
        deque<int> d;
        for (int i = 0; i < 10; i++)
        {
            int score = rand() % 41 + 60;//60~100
            d.push_back(score);
        }
        //对d容器排序
        sort(d.begin(), d.end());
        //去掉最高分 以及最低分
        d.pop_back();
        d.pop_front();
        //求取总分数
        int sum = accumulate(d.begin(), d.end(), 0);
        //求平均分 并赋值给选手的score[index‐1]
        //map<int,Speaker>
        int avg = sum / d.size();
        (m[*it]).score[index-1] = avg;
        m2.insert(make_pair(avg, *it));
        if (count % 6 == 0)//刚好已经有6人 把上面的6人的成绩取前3
        {
            //90 80 70 60 50 40
           //遍历m2容器 取出前3名的 编号
            int i = 0;
            for (multimap<int, int, greater<int>>::iterator mit = m2.begin(); \
                mit != m2.end() && i < 3; mit++, i++)
            {

                //将晋级的编号 放入晋级的容器v1中
                v1.push_back((*mit).second);
            }
            //将上一组的m2清空
            m2.clear();//清空
        }
    }
}

int main(int argc, char* argv[])
{
    //创建24名选手、将选手<编号,选手>放入map容器中 选手编号放vector<>容器中
    vector<int> v;//选手编号
    map<int, Speaker> m;//<编号,选手>
     //创建选手24名
    createSpeaker(v, m);
    //设置种子
    srand(time(NULL));
    //第一轮：参加的选手抽签
    random_shuffle(v.begin(), v.end());
    //进行第一轮比赛
   //1表示当前轮数 v选手编号 m选手信息 v1晋级容器
    vector<int> v1;
    speech_contest(1, v, m, v1);
    //打印第一轮比赛结果：所有参与比赛的成绩 晋级的名单
    printSpeechResault(1, v, m, v1);
    //第二轮比赛：参加的选手抽签
    random_shuffle(v1.begin(), v1.end());
    //进行第二轮比赛
    //1表示当前轮数 v选手编号 m选手信息 v1晋级容器
    vector<int> v2;
    speech_contest(2, v1, m, v2);
    //打印第一轮比赛结果：所有参与比赛的成绩 晋级的名单
    printSpeechResault(2, v1, m, v2);
    //第二轮比赛：参加的选手抽签
    random_shuffle(v2.begin(), v2.end());
    //进行第二轮比赛
    //1表示当前轮数 v选手编号 m选手信息 v1晋级容器
    vector<int> v3;
    speech_contest(3, v2, m, v3);
    //打印第一轮比赛结果：所有参与比赛的成绩 晋级的名单
    printSpeechResault(3, v2, m, v3);
    return 0;
}

在这里插入图片描述

D@@
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STL复数类乘法，加法运算效率测试，寻找程序性能瓶颈
yw8355507的专栏
01-07 919
前言：      这一段时间遇上了烦心事，差不多一个月没有更新博客和github了，打算在这周之内把拉下的内容都补上吧。      这次要写的内容，是我在实验室开发的项目中遇到的问题，主要是关于性能优化。实验室的项目代码写完之后，发现运行的速度实在是太慢了，于是需要找到性能的瓶颈，在第二版程序上修复这个问题。 我的github： 我实现的代码全部贴在我的github
STL算法（二）
weixin_61438881的博客
02-12 712
目录 一、排列组合 二、算术类算法 （1）求和 （2）逐步求和 （3）求内积运算 矩阵乘法 (4)求相邻元素差值 三、生成异变算法 （1）for_each访问 (2)fill 填充一部分元素 (3)fill_n (4)填充前n个位置 通过函数去复制 (5) transform使用方式和for_each类似 四、关系类算法 （1）equal （2）includes （3）lexicographical_compare （4）mismatch 五、集合运算 （1）set_.
C++ STL-常用算法
qq_60406853的博客
06-16 188
C++ 常用算法
【43C++STL-常用算法----1、常用遍历算法】
qq_45986997的博客
09-07 205
这些常用的遍历算法需要你掌握
STL-常用算法(二.拷贝 替换 算术 集合)
最新发布
好好学习，天天向上
05-24 569
STL-常用算法(二.拷贝 替换 算术 集合)
【C++提高编程】5.STL - 常用算法
糊涂懿的博客
03-10 841
目录：1. 模板的概念1. 函数模板1. 类模板 1. 模板的概念 1. 函数模板 1. 类模板 只读
C++ STL-常用算法 常用遍历算法 for_each transform
UUUUU22的博客
03-15 325
C++ STL-常用算法 常用遍历算法 for_each transform
c++提高 第五章 STL-常用算法之遍历算法
weixin_46432435的博客
05-07 125
5 STL-常用算法 概述： 算法主要由头文件<algorithm><functional><numeric>组成 <algorithm>是所有STL头文件中最大的一个，范围涉及到比较、交换、查找、遍历操作、复制、修改等等 <numeric>体积很小，只包括几个在序列上面进行简单数学运算的模板函数 <functional> 定义了一些模板类，用以声明函数对象 5.1常用遍历算法 学习目标：
【47C++STL-常用算法----5、常用算术生成算法】
qq_45986997的博客
09-08 396
C++中常用的算术产成算法，你必须掌握，因为它好用
爱上c++的第十五天：STL-常用算法
喜欢吃豆的博客
03-16 990
想比人家打代码更快？只用手速可不够，来了解一下STL的算法吧！！！
c++模板stl常用算法
09-01
stl常用算法，模板stl常用算法，
浅析STL中的常用算法
09-05
在这个话题中，我们将深入探讨STL中的常用算法，这些算法通常用于处理和操作容器中的数据。 首先，我们讨论非变异算法，即那些不会改变原有数据结构的算法。这类算法主要涉及对序列数据的操作，如查找、统计和匹配...
STL常用算法
06-18
STL常用算法 七十个 12
STL常用算法大全
12-02
STL 常用算法大全 STL（Standard Template Library）提供了丰富的算法库，涵盖了查找、排序、数值计算等多方面的算法。这些算法可以帮助开发者快速、高效地处理数据。 查找算法（13 个） 1. `adjacent_find`：在...
常用的STL查找算法
09-03
本篇文章将详细介绍几种常用的STL查找算法。 首先，我们要了解查找的基本类别：点、线、面。点查找是指寻找单个元素；线查找涉及查找一个区间内的特定元素；而面查找则是指在整个集合中搜索满足条件的元素。 1. **...
运算符重载
热门推荐
weixin_50866517的博客
02-21 2万+
运算符重载其实就是定义一个函数，在函数体内实现想要的功能，当用到该运算符时，编译器会自动调用这个函数。当重载 () 时，不是创造了一种新的调用函数的方式，而是创建一个可以传递任意数目参数的运算符函数。运算符重载，就是对已有的运算符重新进行定义，赋予其另一种功能，简化操作 让已有的运算符 适应不同的数据类型。多数C++运算符都可以重载，重载的运算符不必是成员函数，但必须至少有一个操作数是用户定义的类型。下表大多数运算符都可以通过成员或非成员函数进行重载，但下面的运算符只能通过成员函数重载。
c++函数指针
weixin_50866517的博客
01-27 1万+
函数指针函数指针基础知识深入探讨函数指针使用typedef进行简化 函数指针基础知识 1.完成函数指针需要的工作： 获取函数的地址 声明一个函数指针 使用函数指针来调用函数 1.获取函数地址:只要使用函数名即可。也就是说，如果think()是一个函数，则think()就是该函数的地址。要将函数作为参数进行传递，必须传递函数名。一定要区分传递的是函数的地址还是函数的返回值： process(think); thought(think()); process（）调用使得process()函数能够在其内部调
C++ this指针详解
weixin_50866517的博客
01-22 6235
this指针this指针介绍成员函数的参数和成员变量重名，this区分在类的普通成员函数中返回对象本身 this指针介绍 1.this 指针是 C++实现封装的一 种机制，它将对象和该对象调用的成员函数连接在一起，在外部看来，每一个对象 都拥有自己的函数成员。每个对象用有独立的数据。每个对象共享同一个方法。this 是 C++ 中的一个关键字，也是一个 const 指针，它指向当前对象，通过它可以访问当前对象的所有成员。 成员函数的参数和成员变量重名，this区分 代码演示： #include <io
C++嵌套类
weixin_50866517的博客
04-20 3560
嵌套类介绍二级目录三级目录 介绍 在c++中，可以将类的声明放在另一个类中。在另一个类中声明的类被称为嵌套类，它通过提供新的类型类作用域来避免混乱。包含类的成员函数可以创建和使用被嵌套类的对象；而仅当声明位于公有部分，才能在包含类的外面使用嵌套类，而且必须使用作用域解析运算符。 对类进行嵌套与包含并不不同。包含意味着将类对象作为另一个类的成员，而对类进行嵌套不创建类成员，而是定义了一种类型，该类型仅在包含嵌套类声明的类中有效。 对类进行嵌套通常是为了帮助实现另一个类，并避免名称冲突。Queue类示例嵌套了结

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值