STL常用算法

最新推荐文章于 2024-08-09 10:25:03 发布
最新推荐文章于 2024-08-09 10:25:03 发布
阅读量152 收藏
点赞数 3
文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71637218/article/details/138158171
版权
本文介绍了C++中使用迭代器进行`for_each`,`transform`,`find`,`find_if`,`sort`,`random_shuffle`,`set_intersection`,`set_union`和`set_difference`等常见算法的操作，展示了如何在`vector`容器上执行这些操作以及处理整数和自定义类对象.
摘要由CSDN通过智能技术生成

遍历

#include<vector>
#include<iostream>
#include<algorithm>

class MyPrint
{
public:
	void operator()(int val)
	{
		std::cout << val << " ";
	}
};


//for_each
void test01()
{
	std::vector<int> vec;
	for (int i = 0;i < 10;i++)
	{
		vec.push_back(i);
	}
	std::for_each(vec.begin(), vec.end(), MyPrint());
	std::cout << std::endl;
}
//transform
void test02()
{
	std::vector<int> vec;
	for (int i = 0;i < 10;i++)
	{
		vec.push_back(i);
	}
	std::vector<int> vet;
	std::transform(vec.begin(), vec.end(), std::back_inserter(vet), [](int val) {
		return val * 2;
		});
	for (auto& val : vet)
	{
		std::cout << val << " ";
	}
	std::cout << std::endl;

}
//int main()
//{
//	test01();
//	test02();
//}

查找

#include<vector>
#include<iostream>
#include<algorithm>
#include<random>
#include<string>

//find

void test01()
{
	std::random_device rd;
	std::mt19937 gen(rd());
	std::uniform_int_distribution<int> dist(1, 100);
	std::vector<int> vec;
	for (int i = 0;i < 10;i++)
	{
		vec.push_back(dist(gen));
	}
	for (auto& val : vec)
	{
		std::cout << val << " ";
	}
	std::cout << std::endl;
	auto it = std::find(vec.begin(), vec.end(), 5);
	if (it == vec.end())
	{
		std::cout << "没有找到" << std::endl;
	}
	else
	{
		std::cout << "找到" << *it << std::endl;
	}
}
class Person
{
private:
	std::string m_name;
	int m_age;
public:
	Person(std::string name, int age) :m_name(name), m_age(age) {

	};
	friend std::ostream& operator<<(std::ostream& os, const Person& p) {
		os << "姓名: " << p.m_name << ", 年龄: " << p.m_age;
		return os;
	}
	bool operator==(Person p)
	{
		if (this->m_name == p.m_name && this->m_age == p.m_age)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
};
void test02()
{
	std::vector<Person> vec;
	Person p1("lh", 19);
	Person p2("lb", 29);
	Person p3("lg", 39);
	Person p4("lk", 49);
	Person p5("lo", 59);
	vec.push_back(p1);
	vec.push_back(p2);
	vec.push_back(p3);
	vec.push_back(p4);
	vec.push_back(p5);
	for (auto& val : vec)
	{
		std::cout << val << std::endl;
	}
	
	auto it = std::find(vec.begin(), vec.end(), p2);
	if (it == vec.end())
	{
		std::cout << "没有找到" << std::endl;
	}
	else
	{
		std::cout << "找到" << *it << std::endl;
	}
}

//find_if
class GreateFive
{
public:
	bool operator()(int val)
	{
		return val > 5;
	}
};
void test03()
{
	std::random_device rd;
	std::mt19937 gen(rd());
	std::uniform_int_distribution<int> dist(1, 10);
	std::vector<int> vec;
	for (int i = 0;i < 10;i++)
	{
		vec.push_back(dist(gen));
	}
	for (auto& val : vec)
	{
		std::cout << val << " ";
	}
	std::cout << std::endl;
	auto it = std::find_if(vec.begin(), vec.end(), GreateFive());
	if (it == vec.end())
	{
		std::cout << "没有找到" << std::endl;
	}
	else
	{
		std::cout << "找到" << *it << std::endl;
	}
}

//adjanent_find 第一个相邻重复元素

void test04()
{
	std::random_device rd;
	std::mt19937 gen(rd());
	std::uniform_int_distribution<int> dist(1, 9);
	std::vector<int> vec;
	for (int i = 0;i < 10;i++)
	{
		vec.push_back(dist(gen));
	}
	for (auto& val : vec)
	{
		std::cout << val << " ";
	}
	std::cout << std::endl;
	auto it = std::adjacent_find(vec.begin(), vec.end());
	if (it == vec.end())
	{
		std::cout << "没有找到" << std::endl;
	}
	else
	{
		std::cout << "找到" << *it << std::endl;
	}
}

//binary_search 查找指定元素是否存在 无序序列不可用
void test05()
{
	std::random_device rd;
	std::mt19937 gen(rd());
	std::uniform_int_distribution<int> dist(1, 100);
	std::vector<int> vec;
	for (int i = 0;i < 10;i++)
	{
		vec.push_back(i);
	}
	for (auto& val : vec)
	{
		std::cout << val << " ";
	}
	std::cout << std::endl;
	auto it = std::binary_search(vec.begin(), vec.end(),9);
	if (!it)
	{
		std::cout << "没有找到" << std::endl;
	}
	else
	{
		std::cout << "找到"  << std::endl;
	}
}

//count 统计元素个数
void test06()
{
	std::random_device rd;
	std::mt19937 gen(rd());
	std::uniform_int_distribution<int> dist(1, 10);
	std::vector<int> vec;
	for (int i = 0;i < 10;i++)
	{
		vec.push_back(dist(gen));
	}
	for (auto& val : vec)
	{
		std::cout << val << " ";
	}
	std::cout << std::endl;
	auto it = std::count(vec.begin(), vec.end(), 5);
	std::cout << it;
}

//count if

void test07()
{
	std::random_device rd;
	std::mt19937 gen(rd());
	std::uniform_int_distribution<int> dist(1, 10);
	std::vector<int> vec;
	for (int i = 0;i < 10;i++)
	{
		vec.push_back(dist(gen));
	}
	for (auto& val : vec)
	{
		std::cout << val << " ";
	}
	std::cout << std::endl;
	auto it = std::count_if(vec.begin(), vec.end(), GreateFive());
	std::cout << it;
}
int main()
{
	//test01();
	//test02();
	//test03();
	//test04();
	//test05();
	//test06();
	test07();
}

排序

#include<vector>
#include<iostream>
#include<algorithm>
#include<random>
#include<string>
#if 0
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_int_distribution<int> dist(1, 100);
std::vector<int> vec;
for (int i = 0;i < 10;i++)
{
	vec.push_back(dist(gen));
}
for (auto& val : vec)
{
	std::cout << val << " ";
}
std::cout << std::endl;
auto it = std::find(vec.begin(), vec.end(), 5);
#endif

//sort

void test01()
{
	std::random_device rd;
	std::mt19937 gen(rd());
	std::uniform_int_distribution<int> dist(1, 100);
	std::vector<int> vec;
	for (int i = 0;i < 10;i++)
	{
		vec.push_back(dist(gen));
	}
	for (auto& val : vec)
	{
		std::cout << val << " ";
	}
	std::cout << std::endl;
	std::sort(vec.begin(), vec.end());
	for (auto& val : vec)
	{
		std::cout << val << " ";
	}
}

//random_shuffle 打乱排序
void test02()
{
	std::random_device rd;
	std::mt19937 gen(rd());
	std::uniform_int_distribution<int> dist(1, 100);
	std::vector<int> vec;
	for (int i = 0;i < 10;i++)
	{
		vec.push_back(dist(gen));
	}
	for (auto& val : vec)
	{
		std::cout << val << " ";
	}
	std::cout << std::endl;
	for (int i = 0;i < 3;i++)
	{
		std::random_shuffle(vec.begin(), vec.end());
		for (auto& val : vec)
		{
			std::cout << val << " ";
		}
		std::cout << std::endl;
		std::sort(vec.begin(), vec.end());
		for (auto& val : vec)
		{
			std::cout << val << " ";
		}
		std::cout << std::endl;
	}
}
//merge 合并两个容器到新容器，两个容器必须有序
void test03()
{
	std::vector<int> v1, v2;
	for (int i = 0;i < 10;i++)
	{
		v1.push_back(i);
	}
	for (int i = 10;i >20;i++)
	{
		v2.push_back(i);
	}
	std::vector<int> v3;
	v3.resize(v1.size()+v2.size());
	std::merge(v1.begin(), v1.end(), v2.begin(), v2.end(), v3.begin());
	for (auto& val:v3)
	{
		std::cout << val << " ";
	}
	std::cout << std::endl;
}
//reverse 反转容器

void test04()
{
	std::vector<int> vec;
	for (int i = 0;i < 10;i++)
	{
		vec.push_back(i);
	}
	for (auto& val : vec)
	{
		std::cout << val << " ";
	}
	std::cout << std::endl;
	std::reverse(vec.begin(), vec.end());
	for (auto& val : vec)
	{
		std::cout << val << " ";
	}
	std::cout << std::endl;
}

int main()
{
	//test01();
	//test02();
	//test03();

	test04();
}

拷贝和替换

#include<vector>
#include<iostream>
#include<algorithm>
#include<random>
#include<string>

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

void test01()
{
	std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<int> dist(1, 100);
    std::vector<int> vec;
    for (int i = 0;i < 10;i++)
    {
	vec.push_back(dist(gen));
    }
    for (auto& val : vec)
    {
        std::cout << val << " ";
    }
    std::cout << std::endl;
    std::vector<int> vet;
    vet.resize(vec.size());
    std::copy(vec.begin(), vec.end(), vet.begin());
    for (auto& val : vet)
    {
        std::cout << val << " ";
    }
    std::cout << std::endl;
}

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

void test02()
{

    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<int> dist(1, 9);
    std::vector<int> vec;
    for (int i = 0;i < 10;i++)
    {
        vec.push_back(dist(gen));
    }
    for (auto& val : vec)
    {
        std::cout << val << " ";
    }
    std::cout << std::endl;
    std::replace(vec.begin(), vec.end(), 5,10);
    for (auto& val : vec)
    {
        std::cout << val << " ";
    }
    std::cout << std::endl;
}

//replace_if 将容器内指定范围满足条件的旧元素修改为新元素
class LessFive
{
public:
    bool operator()(int val)
    {
        return val < 5;
    }
};
void test03()
{
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<int> dist(1, 9);
    std::vector<int> vec;
    for (int i = 0;i < 10;i++)
    {
        vec.push_back(dist(gen));
    }
    for (auto& val : vec)
    {
        std::cout << val << " ";
    }
    std::cout << std::endl;
    std::replace_if(vec.begin(), vec.end(), LessFive(), 7);
    for (auto& val : vec)
    {
        std::cout << val << " ";
    }
    std::cout << std::endl;
}

//swap 互换两个容器的内容

void test04()
{
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<int> dist(1, 100);
    std::vector<int> v1,v2;
    for (int i = 0;i < 10;i++)
    {
        v1.push_back(dist(gen));
        v2.push_back(dist(gen));  
    }
    for (auto& val : v1)
    {
        std::cout << val << " ";
    }
    std::cout << std::endl;
    for (auto& val : v2)
    {
        std::cout << val << " ";
    }
    std::cout << std::endl;
    std::swap(v1, v2);
    for (auto& val : v1)
    {
        std::cout << val << " ";
    }
    std::cout << std::endl;
    for (auto& val : v2)
    {
        std::cout << val << " ";
    }
    std::cout << std::endl;
}
int main()
{
    //test01();
    //test02();
    //test03();
    test04();
}

算术生成

#include<vector>
#include<iostream>
#include<algorithm>
#include<random>
#include<string>
#include<numeric>
//生成n位在min到max范围内的随机数的vector
std::vector<int> random(int n,int min,int max)
{
	std::random_device rd;
	std::mt19937 gen(rd());
	std::uniform_int_distribution<int> dist(min, max);
	std::vector<int> vec;
	for (int i = 0;i < n; i++)
	{
		vec.push_back(dist(gen));
	}
	return vec;
}

//accumulate计算容器内元素数量和

void test01()
{
	std::vector<int> vec = random(10, 1, 10);
	for (auto& val : vec)
	{
		std::cout << val << " ";
	}
	std::cout << std::endl;
	auto sum = std::accumulate(vec.begin(), vec.end(), 0);  //起始值
	std::cout << "总和为" << sum << std::endl;
}

//fill向容器填充元素

void test02()
{
	std::vector<int> vec;
	vec.resize(10);
	for (auto& val : vec)
	{
		std::cout << val << " ";
	}
	std::cout << std::endl;
	std::fill(vec.begin(), vec.end(), 6);
	for (auto& val : vec)
	{
		std::cout << val << " ";
	}
	std::cout << std::endl;
}
int main()
{
	test01();
	test02();
}

集合算法

#include <vector>
#include <iostream>
#include <algorithm>
#include <random>
#include <string>
#include <numeric>

class Myprintf {
public:
    void operator()(int val)
    {
        std::cout << val << " ";
    }
};



// set_intersection求两个容器的交集 必须有序
void test01()
{
    std::vector<int> v1;
    std::vector<int> v2;
    for (int i = 0;i < 10;i++)
    {
        v1.push_back(i);
        v2.push_back(i + 1);
    }
    std::vector<int> vec;
    vec.resize(std::min(v1.size(), v2.size()));
    auto val = std::set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), vec.begin());
    std::for_each(vec.begin(), val, Myprintf());
    std::cout << std::endl;
}

//set_union 求两个元素的并集 必须有序
void test02()
{
        std::vector<int> v1;
        std::vector<int> v2;
        for (int i = 0;i < 10;i++)
        {
            v1.push_back(i);
            v2.push_back(i + 1);
        }
        std::vector<int> vec;
        vec.resize(v1.size()+v2.size());
        auto val = std::set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), vec.begin());
        std::for_each(vec.begin(), val, Myprintf());
        std::cout << std::endl;
}

//set_difference 求两个集合的差集 必须有序

void test03()
{
    std::vector<int> v1;
    std::vector<int> v2;
    for (int i = 0;i < 10;i++)
    {
        v1.push_back(i);
        v2.push_back(i + 1);
    }
    std::vector<int> vec;
    vec.resize(v1.size() + v2.size());
    auto val = std::set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), vec.begin());
    std::for_each(vec.begin(), val, Myprintf());
    std::cout << std::endl;
}


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

z53545556
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
STL常用算法大全
12-02
STL 常用算法大全 STL（Standard Template Library）提供了丰富的算法库，涵盖了查找、排序、数值计算等多方面的算法。这些算法可以帮助开发者快速、高效地处理数据。 查找算法（13 个） 1. `adjacent_find`：在...
C++中STL常用算法
兰天禄的博客
04-02 882
STL的常用算法1、常用的遍历算法1、for_each:遍历容器元素2、transform算法 将指定容器区间元素搬运到另一容器中2、常用的查找算法2.1、find算法 查找元素2、find_if条件查找2.3、adjacent_find算法 查找相邻重复元素2.4、binary_search算法 二分查找法（容器必须有序）2.5、count算法 统计元素出现次数2.6、count_if算法 统计...
C++STL常用算法
hcx的博客
02-04 962
包含容器中常用的遍历算法、查找算法、排序算法、拷贝、替换算法、算术生成算法、集合算法。注意要包含相应的头文件
详解c++STL—STL常用算法
怀秋秋意的博客
05-22 1022
详解c++STL—STL常用算法
c++---STL常用算法
m0_50046535的博客
04-25 3343
概述： 算法主要是由头文件<algorithm><functional><numeric>组成 <algorithm>是所有stl头文件中最大的一个，涉及比较，交换，查找，遍历，复制，修改等操作 <numeric>体积很小，只包括几个在序列上进行简单数学运算的模板函数 <functional>定义了一些类模板，用以声明函数对象 一、常用遍历算法 for_each 遍历容器 transform 搬运容...
C++STL常用算法(超详细!)
qq_62855390的博客
12-24 1889
v1中是有4的,但是它结果显示为未找到,就是因为v1是无序的。，找到返回相邻元素的第一个位置的迭代器,找不到返回结束迭代器。，找到返回指定元素的迭代器，找不到返回结束迭代器end（），找到返回指定元素的迭代器，找不到返回结束迭代器end（）注:两个容器必须是有序的,合并完之后也是一个有序序列。,也就是最特殊的那种情况--大容器和小容器无交集。,也就是最特殊的那种情况--大容器和小容器无交集。,也就是最特殊的那种情况--大容器包小容器。返回值:并集中最后一个元素的迭代器位置。
c++提高篇——STL常用算法
qq_52302919的博客
02-24 2328
算法主要是由头文件 组成。是所有STL头文件中最大的一个，范围涉及到比较、交换、查找、追历操作、复制、修改等等。体积很小,只包括几个在序列上面进行简单数学运算的模板函数。定义了—些模板类.用以声明函数对象。
STL常用算法总结
qq_36534594的博客
03-22 523
常用遍历算法 头文件：<algorithm> <functional> <numeric> <algorithm>是所有STL文件中最大的一个，范围涉及比较、交换、查找、遍历操作、复制、修改等等 <functional>体积很小，只包含几个在序列上面进行简单数学运算的模板函数 <numeric>定义了一些模板类，用以声明函数对象 常用遍历算法 1. for_each//遍历容器 2. transform //搬运容器到另一个容器中
STL常用算法——遍历算法
万里顾一程的博客
10-28 451
ransform() 可以将函数应用到容器的元素上，并将这个函数返回的值保存到另一个容器中，它返回的迭代器指向输出容器所保存的最后一个元素的下一个位置。for_each：遍历容器，对容器中的每一个元素调用函数或函数对象。
STL常用算法——排序算法
万里顾一程的博客
10-31 1246
合并排序，merge() 函数用于将 2 个有序序列合并为 1 个有序容器，前提是这 2 个有序容器的排序规则相同（要么都是升序，要么都是降序）。并且最终借助该函数获得的新有序容器，其排序规则也和这 2 个有序容器要相同。sort() 函数在对自定义的类对象实现排序时，需要在该类的内部提供移动构造函数和移动赋值运算符。sort()：对容器或普通数组中范围内的元素进行排序，默认进行升序排序，也可以自定义排序规则。reverse()函数：将容器指定范围内的元素进行反转。函数原型：该函数有以下两种格式。
c++模板stl常用算法
09-01
### C++模板STL常用算法 #### 前言 C++是一种强大的编程语言，它支持多种编程范式，包括面向对象编程、泛型编程等。其中，泛型编程是通过模板来实现的，模板允许程序员编写能处理多种类型数据的代码。标准模板库...
STL常用算法简介
11-14
STL常用算法简介 STL常用算法简介 STL常用算法简介 STL常用算法简介 STL常用算法简介
stl常用算法(Algorithms)介绍(stl排序算法、非变序型队列)
09-04
在这个话题中，我们将深入探讨STL中的一些常用算法，特别是排序算法和非变序型队列算法。 首先，让我们来看一下排序算法。在STL中，最常用的排序算法是`std::sort`，它位于`<algorithm>`头文件中。`std::sort`可以...
STL中的迭代器失效（vector为例）
2302_80190394的博客
08-08 330
STL中的迭代器失效（vector为例）
c++ error: ‘*’ does not name a type； did you mean ‘**’?
xiaozhi
08-08 443
c++ error: ‘*’ does not name a type； did you mean ‘**’?
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
最新发布
qq_19319481的博客
08-09 219
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
C++ - 函数重载
jiaowenjie的专栏
08-06 327
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
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、付费专栏及课程。

余额充值