STL相关算法

最新推荐文章于 2024-07-23 17:36:37 发布
最新推荐文章于 2024-07-23 17:36:37 发布
阅读量616 收藏 15
点赞数 25
文章标签： 算法 c++ java c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_83614570/article/details/140556162
版权

STL相关算法

算法基础

算法概述

  1. 算法部分主要由头文件，和组成。
  2. 是所有STL头文件中最大的一个，其中常用到的功能范围涉及到比较、交换、查找、遍历操作、复制、修改、反转、排序、合并等等。
  3. 体积很小，只包括几个在序列上面进行简单数学运算的模板函数，包括加法和乘法在序列上的一些操作。
  4. 中则定义了一些模板类，用以声明函数对象。
  5. STL提供了大量实现算法的模版函数，只要我们熟悉了STL之后，许多代码可以被大大的化简，只需要通过调用一两个算法模板，就可以完成所需要的功能，从而大大地提升效率。

STL中算法分类

  1. 操作对象
    直接改变容器的内容
    将原容器的内容复制一份,修改其副本,然后传回该副本
  2. 功能:

非可变序列算法 指不直接修改其所操作的容器内容的算法

  1. 计数算法 count、count_if
  2. 搜索算法 search、find、find_if、find_first_of、…
  3. 比较算法 equal、mismatch、lexicographical_compare

可变序列算法 指可以修改它们所操作的容器内容的算法

  1. 删除算法 remove、remove_if、remove_copy、…
  2. 修改算法 for_each、transform
  3. 排序算法 sort、stable_sort、partial_sort、
  1. 排序算法 包括对序列进行排序和合并的算法、搜索算法以及有序序列上的集合操作
  2. 数值算法 对容器内容进行数值计算

算法中函数对象和谓词

函数对象

重载函数调用操作符的类，其对象常称为函数对象（function object），即它们是行为类似函数的对象，也叫仿函数(functor),其实就是重载“()”操作符，使得类对象可以像函数那样调用。

注意:

  1. 函数对象(仿函数)是一个类，不是一个函数。
  2. 函数对象(仿函数)重载了”() ”操作符使得它可以像函数一样调用。

分类:假定某个类有一个重载的operator()，而且重载的operator()要求获取一个参数，我们就将这个类称为“一元仿函数”（unary functor）；
相反，如果重载的operator()要求获取两个参数，就将这个类称为“二元仿函数”（binary functor）。

函数对象的作用主要是什么？ STL提供的算法往往都有两个版本，其中一个版本表现出最常用的某种运算，另一版本则允许用户通过template参数的形式来指定所要采取的策略。

//函数对象是重载了函数调用符号的类
struct MyPrint{
	voidoperator()(int val){
		cout << val << endl;
	}
};

void test01(){

	//如何使用
	MyPrint print01;
	print01(10);//重载了()操作符的类实例化的对象，可以像普通函数那样调用,可以有参数 ，可以有返回值
}

//函数对象超出了普通函数的概念，可以保存函数的调用状态
struct HePrint{
	HePrint(){
		mCount =0;
	}
	voidoperator()(int val){
		cout << val << endl;
		mCount++;
	}
	int mCount;
};
void test02(){

	HePrint print;
	print(10);
	print(20);
	print(30);
	print(40);
	cout << print.mCount << endl;
}

//函数对象可以做参数和返回值
struct OurPrint{
	voidoperator()(int val){
		cout << val << endl;
	}
};

void doBusiness(OurPrint print){
	print(20);
}

void test03(){
	//函数对象做参数
	doBusiness(OurPrint());
}

谓词

谓词是指普通函数或重载的operator()返回值是bool类型的函数对象(仿函数)。如果operator接受一个参数，那么叫做一元谓词,如果接受两个参数，那么叫做二元谓词，谓词可作为一个判断式。

struct GreaterThanFive{
	booloperator()(int v){
		return v >5;
	}
};

//一元谓词
void test01(){
	
	vector<int> v;
	for(int i =0; i <10;i++){
		v.push_back(i);
	}

	vector<int>::iterator ret = find_if(v.begin(), v.end(), GreaterThanFive());
	if(ret == v.end()){
		cout <<"没有找到!"<< endl;
	}
	else{
		cout <<"找到:"<<*ret << endl;
	}

}

//二元谓词
struct MyCompare{
	booloperator()(int v1,int v2){
		return v1 > v2;
	}
};

void test02(){

	vector<int> v;
	srand((unsignedint)time(NULL));
	for(int i =0; i <10; i++){
		v.push_back(rand()%100);
	}

	for(vector<int>::iterator it = v.begin(); it != v.end(); it ++){
		cout <<*it <<" ";
	}
	cout << endl;
	//排序算法
	sort(v.begin(), v.end(), MyCompare());

	for(vector<int>::iterator it = v.begin(); it != v.end(); it++){
		cout <<*it <<" ";
	}
	cout << endl;
}

空间配置器

在软件开发，程序设计中，我们不免因为程序需求，使用很多的小块内存（基本类型以及小内存的自定义类型）。在程序中动态申请，释放。
　　
这个过程过程并不是一定能够控制好的，于是乎，
问题1：就出现了内存碎片问题。
问题2：一直在因为小块内存而进行内存申请，调用malloc，系统调用产生性能问题。

策略：如果申请的内存大小超过128，那么空间配置器就自动调用一级空间配置器。反之调用二级空间配置器。

一级空间配置器，STL源码中的一级空间配置器命名为class __malloc_alloc_template ，它很简单，就是对malloc，free，realloc等系统分配函数的一层封装。

二级空间配置器，由一个内存池和自由链表配合实现的。

算法概述

算法主要是由头文件<algorithm><functional><numeric>组成。
<algorithm>是所有STL头文件中最大的一个,其中常用的功能涉及到比较，交换，查找,遍历，复制，修改，反转，排序，合并等…
<numeric>体积很小，只包括在几个序列容器上进行的简单运算的模板函数.
<functional> 定义了一些模板类,用以声明函数对象。

常用遍历算法

/*
    遍历算法 遍历容器元素
	@param beg 开始迭代器
	@param end 结束迭代器
	@param _callback  函数回调或者函数对象
	@return 函数对象
*/
for_each(iterator beg, iterator end, _callback);
/*
	transform算法 将指定容器区间元素搬运到另一容器中
	注意 : transform 不会给目标容器分配内存，所以需要我们提前分配好内存
	@param beg1 源容器开始迭代器
	@param end1 源容器结束迭代器
	@param beg2 目标容器开始迭代器
	@param _cakkback 回调函数或者函数对象
	@return 返回目标容器迭代器
*/
transform(iterator beg1, iterator end1, iterator beg2, _callbakc)

for_each:

/*

template<class _InIt,class _Fn1> inline
void for_each(_InIt _First, _InIt _Last, _Fn1 _Func)
{
	for (; _First != _Last; ++_First)
		_Func(*_First);
}

*/

//普通函数
void print01(int val){
	cout << val <<" ";
}
//函数对象
struct print001{
	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(), print001());
	cout << endl;

}

struct print02{
	print02(){
		mCount =0;
	}
	void operator()(int val){
		cout << val <<" ";
		mCount++;
	}
	int mCount;
};

//for_each返回值
void test02(){

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

	print02& p = for_each(v.begin(), v.end(), print02());
	cout << endl;
	cout << p.mCount << endl;
}

struct print03 :public binary_function<int,int,void>{
	voidoperator()(int val,int bindParam)const{
		cout << val + bindParam <<" ";
	}
};

//for_each绑定参数输出
void test03(){
	
	vector<int> v;
	for(int i =0; i <10; i++){
		v.push_back(i);
	}

	for_each(v.begin(), v.end(), bind2nd(print03(),100));
}

transform:

//transform 将一个容器中的值搬运到另一个容器中
/*
	template<class _InIt, class _OutIt, class _Fn1> inline 
	_OutIt _Transform(_InIt _First, _InIt _Last,_OutIt _Dest, _Fn1 _Func)
	{	

		for (; _First != _Last; ++_First, ++_Dest)
			*_Dest = _Func(*_First);
		return (_Dest);
	}

	template<class _InIt1,class _InIt2,class _OutIt,class _Fn2> inline
	_OutIt _Transform(_InIt1 _First1, _InIt1 _Last1,_InIt2 _First2, _OutIt _Dest, _Fn2 _Func)
	{	
		for (; _First1 != _Last1; ++_First1, ++_First2, ++_Dest)
			*_Dest = _Func(*_First1, *_First2);
		return (_Dest);
	}
*/

struct transformTest01{
	int operator()(int val){
		return val +100;
	}
};
struct print01{
	void operator()(int val){
		cout << val <<" ";
	}
};
void test01(){

	vector<int> vSource;
	for(int i =0; i <10;i ++){
		vSource.push_back(i +1);
	}

	//目标容器
	vector<int> vTarget;
	//给vTarget开辟空间
	vTarget.resize(vSource.size());
	//将vSource中的元素搬运到vTarget
	vector<int>::iterator it = transform(vSource.begin(), vSource.end(), vTarget.begin(), transformTest01());
	//打印
	for_each(vTarget.begin(), vTarget.end(), print01()); cout << endl;
	
}

//将容器1和容器2中的元素相加放入到第三个容器中
struct transformTest02{
	intoperator()(int v1,int v2){
		return v1 + v2;
	}
};
void test02(){

	vector<int> vSource1;
	vector<int> vSource2;
	for(int i =0; i <10; i++){
		vSource1.push_back(i +1);	
	}

	//目标容器
	vector<int> vTarget;
	//给vTarget开辟空间
	vTarget.resize(vSource1.size());
	transform(vSource1.begin(), vSource1.end(), vSource2.begin(),vTarget.begin(), transformTest02());
	//打印
	for_each(vTarget.begin(), vTarget.end(), print01()); cout << endl;
}

常用查找算法

/*
	find算法 查找元素
	@param beg 容器开始迭代器
	@param end 容器结束迭代器
	@param value 查找的元素
	@return 返回查找元素的位置
*/
find(iterator beg, iterator end, value)
/*
	adjacent_find算法 查找相邻重复元素
	@param beg 容器开始迭代器
	@param end 容器结束迭代器
	@param  _callback 回调函数或者谓词(返回bool类型的函数对象)
	@return 返回相邻元素的第一个位置的迭代器
*/
adjacent_find(iterator beg, iterator end, _callback);
/*
	binary_search算法 二分查找法
	注意: 在无序序列中不可用
	@param beg 容器开始迭代器
	@param end 容器结束迭代器
	@param value 查找的元素
	@return bool 查找返回true 否则false
*/
bool binary_search(iterator beg, iterator end, value);
/*
	find_if算法 条件查找
	@param beg 容器开始迭代器
	@param end 容器结束迭代器
	@param  callback 回调函数或者谓词(返回bool类型的函数对象)
	@return bool 查找返回true 否则false
*/
find_if(iterator beg, iterator end, _callback);
/*
	count算法 统计元素出现次数
	@param beg 容器开始迭代器
	@param end 容器结束迭代器
	@param  value回调函数或者谓词(返回bool类型的函数对象)
	@return int返回元素个数
*/
count(iterator beg, iterator end, value);
/*
	count算法 统计元素出现次数
	@param beg 容器开始迭代器
	@param end 容器结束迭代器
	@param  callback 回调函数或者谓词(返回bool类型的函数对象)
	@return int返回元素个数
*/
count_if(iterator beg, iterator end, _callback);

常用排序算法

/*
	merge算法 容器元素合并，并存储到另一容器中
	@param beg1 容器1开始迭代器
	@param end1 容器1结束迭代器
	@param beg2 容器2开始迭代器
	@param end2 容器2结束迭代器
	@param dest  目标容器开始迭代器
*/
merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest)
/*
	sort算法 容器元素排序
	注意:两个容器必须是有序的
	@param beg 容器1开始迭代器
	@param end 容器1结束迭代器
	@param _callback 回调函数或者谓词(返回bool类型的函数对象)
*/
sort(iterator beg, iterator end, _callback)
/*
	random_shuffle算法 对指定范围内的元素随机调整次序
	@param beg 容器开始迭代器
	@param end 容器结束迭代器
*/
random_shuffle(iterator beg, iterator end)
/*
	reverse算法 反转指定范围的元素
	@param beg 容器开始迭代器
	@param end 容器结束迭代器
*/
reverse(iterator beg, iterator end)

常用拷贝和替换算法

/*
	copy算法 将容器内指定范围的元素拷贝到另一容器中
	@param beg 容器开始迭代器
	@param end 容器结束迭代器
	@param dest 目标容器结束迭代器
*/
copy(iterator beg, iterator end, iterator dest)
/*
	replace算法 将容器内指定范围的旧元素修改为新元素
	@param beg 容器开始迭代器
	@param end 容器结束迭代器
	@param oldvalue 旧元素
	@param oldvalue 新元素
*/
replace(iterator beg, iterator end, oldvalue, newvalue)
/*
	replace_if算法 将容器内指定范围满足条件的元素替换为新元素
	@param beg 容器开始迭代器
	@param end 容器结束迭代器
	@param callback函数回调或者谓词(返回Bool类型的函数对象)
	@param oldvalue 新元素
*/
replace_if(iterator beg, iterator end, _callback, newvalue)
/*
	swap算法 互换两个容器的元素
	@param c1容器1
	@param c2容器2
*/
swap(container c1, container c2)

常用算数生成算法

/*
	accumulate算法 计算容器元素累计总和
	@param beg 容器开始迭代器
	@param end 容器结束迭代器
	@param value累加值
*/
accumulate(iterator beg, iterator end, value)
/*
	fill算法 向容器中添加元素
	@param beg 容器开始迭代器
	@param end 容器结束迭代器
	@param value t填充元素
*/
fill(iterator beg, iterator end, value)

常用集合算法

/*
	set_intersection算法 求两个set集合的交集
	注意:两个集合必须是有序序列
	@param beg1 容器1开始迭代器
	@param end1 容器1结束迭代器
	@param beg2 容器2开始迭代器
	@param end2 容器2结束迭代器
	@param dest  目标容器开始迭代器
	@return 目标容器的最后一个元素的迭代器地址
*/
set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest)
/*
	set_union算法 求两个set集合的并集
	注意:两个集合必须是有序序列
	@param beg1 容器1开始迭代器
	@param end1 容器1结束迭代器
	@param beg2 容器2开始迭代器
	@param end2 容器2结束迭代器
	@param dest  目标容器开始迭代器
	@return 目标容器的最后一个元素的迭代器地址
*/
set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest)
/*
	set_difference算法 求两个set集合的差集
	注意:两个集合必须是有序序列
	@param beg1 容器1开始迭代器
	@param end1 容器1结束迭代器
	@param beg2 容器2开始迭代器
	@param end2 容器2结束迭代器
	@param dest  目标容器开始迭代器
	@return 目标容器的最后一个元素的迭代器地址
*/
set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest)
程序员_小兵
关注
  • 25
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
STL数值算法源码
06-14
参考自侯捷先生的《STL源码剖析》，C++ STL 的数值算法(Numeric algorithms)是一组对容器元素进行数值计算的模板函数，包括容器元素求和 accumulate 、两序列元素的内积 inner_product 、容器元素的一系列部分元素和...
c++模板stl常用算法
09-01
stl常用算法，模板stl常用算法，
常用的STL查找算法
09-03
STL（Standard Template Library，标准模板库）是C++编程语言中的一个重要组成部分，它提供了一系列高效、可重用的数据结构和算法。在STL中，查找算法是非常常见且实用的功能，用于在序列容器（如数组、向量、列表等...
STL.rar_stl算法
09-24
STL，全称为Standard Template Library（标准模板库），是C++编程语言中不可或缺的一部分，它提供了高效且可重用的...通过阅读提供的`STL.pdf`文档，你可以更深入地学习这些概念和其他STL算法，以提升你的编程能力。
【18】输出字符菱形
2301_78786609的博客
07-19 398
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 348
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
AtCoder Beginner Contest 363
2301_80105412的博客
07-21 574
AtCoder Beginner Contest 363 ABCDE
算法题目整合5
最新发布
qq_62571233的博客
07-23 655
思路：利用left和right记录连续相同的字符串索引，计算长度len，如果是0,1,2,4这种情况直接输出-1并return。如果是奇数直接输出，如果是偶数的话，可以拆成3和len-3两个部分。的最小值是101100，求其第4554小即在从后数的四个问号位置分别加上‘3’，‘5’，‘5’，‘4’即可，即551153；表示当前卡牌正面（或反面）加上上一个取余结果再对3取余的值，举个例子，比如说。），由于不同的取余方案搭配上正反面的组合，共有6中结果，所以在。，表示当前卡牌正面为1，当遍历的。
【Hot100】LeetCode—152. 乘积最大子数组
weixin_44382896的博客
07-23 160
【代码】【Hot100】LeetCode—152. 乘积最大子数组。
插入和选择排序
c23856的博客
07-20 468
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
2024.7.19 刷题总结
TheJustice_的博客
07-19 259
543.二叉树的直径，这道题是一道考察递归的题目，按照树的一般算法，维护一个最大直径答案值，定义一个递归函数，开头是递归返回条件，即当前节点为空节点就返回0，否则分别往左和往右递归，维护每个节点的最大深度为左右最大深度中的最大值再加一，答案用左右节点的最大深度的和再加一来维护.124.二叉树中的最大路径和，这是一道考察递归的题目，从根节点出发，类似于dfs，分别递归寻找左右节点的路径和，直到叶子节点再返回，从叶子节点往上更新以每个节点为根节点的最大路径，直到返回根节点，用一个变量来维护答案.
完全二叉树的节点个数-递归
qq_45031559的博客
07-19 274
完全二叉树的节点个数-递归
python实现图像缩放算法
qq_42568323的博客
07-20 356
它通过选择离目标像素最近的原始像素的颜色值来确定目标像素的颜色值。它通过考虑目标像素周围16个像素的颜色值，使用双三次插值公式计算出目标像素的颜色值。相较于双线性插值，双三次插值能生成更平滑、更细腻的图像效果。它通过考虑目标像素周围四个像素的颜色值，使用双线性插值公式计算出目标像素的颜色值。尽管最近邻插值在某些应用场景中足够使用，但在需要更高质量图像的场景中，通常会选择更加复杂的插值方法，如双线性插值或双三次插值。双三次插值是图像缩放中高质量的方法之一，适合需要高质量图像处理的应用场景。
傻瓜图解 -- 算法刷题之路之链表初探（八 ）旋转链表
aoyuanyuan0921的博客
07-19 196
今天来学习的算法题是leecode61旋转链表，是一道简单的入门题，话不多说！原子本来写了一大推书面解释！我直接上图，如果有疑问的话私信我交流一下！
算法第十一天：leetcode707.设计链表
m0_75068978的博客
07-19 1459
的链接如下表所示，您可直接复制下面网址进入力扣学习，在观看下面的内容之前一定要先做一遍哦，这样才能印象深刻！题目描述：你可以选择使用单链表或者双链表，设计并实现自己的链表。val和next。val是当前节点的值，next是指向下一个节点的指针/引用。如果是双向链表，则还需要属性prev以指示链表中的上一个节点。假设链表中的所有节点下标从开始。实现index-1valvalvalindexindexindexindex// 链表变为 1->2->3// 返回 2。
【刷题汇总 -- 压缩字符串(一)、chika和蜜柑、 01背包】
m0_69455439的博客
07-19 1145
今日刷题汇总day018 -- 压缩字符串(一)、chika和蜜柑、 01背包
算法——滑动窗口（day5）
fax_player的博客
07-20 832
（上一题是通过缩小窗口来求长度最小，所以每一次缩小都有可能得到最小长度）（而本题是求最大连续长度，只需要在去除所有重复项后计算就行了）
Java实现七大排序（二）
lllsure的博客
07-23 368
冒泡排序、快速排序、归并排序
上海市计算机学会竞赛平台2022年9月月赛丙组二叉树的遍历
a121677_的博客
07-20 202
有一棵二叉树，结点数量不超过 2626 个，树上的每个结点都有一个大写字母。给定这棵二叉树的前序遍历及中序遍历，请输出它的后序遍历。设输入的字符串长度为 𝑛n，
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、付费专栏及课程。

余额充值