STL常用算法汇总

最新推荐文章于 2024-09-03 11:25:36 发布
最新推荐文章于 2024-09-03 11:25:36 发布
阅读量1.2k 收藏
点赞数
文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sad_liu/article/details/130252550
版权

文章目录

STL常用算法

概述

  • <algorithm>， <functional>， <numeric>//头文件

遍历算法

transform&for_each

功能描述
  • transform搬运容器到另一个容器中
  • for_each遍历容器
函数原型
  • transform(iterator beg1, iterator end1, iterator beg2, _func);
//beg1源容器开始迭代器
//end1源容器结束迭代器
//beg2目标容器开始迭代器
//func函数或者函数对象

  • for_each(iterator beg, iterator end, _func);
//func函数或者函数对象(只需要写函数名即可)
//beg容器开始迭代器
//end容器结束迭代器
示例
#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

class Transform
{
public:
    int operator()(int v)
    {
        return v+100;//在搬运过程中可以做逻辑上的运算
    }

    
};

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

void test01()
{
    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(vTarget.begin(), vTarget.end(), MyPrint());
    //100 101 102 103 104 105 106 107 108 109 
    cout << endl;
}

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

查找算法

find

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

一定注意是返回的迭代器

函数原型
  • find(iterator beg, iterator end, value);
//按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
//beg开始迭代器
//end结束迭代器
//value查找的元素
示例
#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

//查找指定数据类型 
void test01()
{
	vector<int> v;
	for(int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	
	vector<int>::iterator it = find(v.begin(), v.end(), 11);
	
	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;
	}
	
	//了解底层代码 重载== 运算符 在底层==是在if里面 所以返回bool 
	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() 
{
	Person p1("张三", 18);
	Person p2("李四", 19);
	Person p3("王五", 20);
	
	vector<Person> v;
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	
	//p2出错 在Person类中重载== 让底层find直到如何 对比person数据类型 
	vector<Person>::iterator it = find(v.begin(), v.end(), p2);
	
	if(it == v.end())
	{
		cout << "没有找到！" << endl;
	}
	else
	{
		cout << "找到：" << it->m_Name << " " << it->m_Age << endl;
	}
}

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

find_if

功能描述
  • 按条件查找元素
函数原型
  • find_if(iterator beg, iterator end, _Pred);
//按值查找元素， 找到返回指定位置迭代器，找不到返回结束迭代器位置
//beg开始迭代器
//end结束迭代器
//_Pred函数或者谓词(返回bool类型的仿函数)
示例
#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

class GreatFive
{
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(), GreatFive());
	
	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;
	}
	
	
	string m_Name;
	int m_Age;
};

class GreaterNt
{
public:
	bool operator()(const Person& p)
	{
		return p.m_Age > 19;
	}
};

//查找自定义数据类型 
void test02() 
{
	Person p1("张三", 18);
	Person p2("李四", 19);
	Person p3("王五", 20);
	
	vector<Person> v;
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	
	//p2出错 在Person类中重载== 让底层find直到如何 对比person数据类型 
	vector<Person>::iterator it = find_if(v.begin(), v.end(), GreaterNt());
	
	if(it == v.end())
	{
		cout << "没有找到！" << endl;
	}
	else
	{
		cout << "找到：" << it->m_Name << " " << it->m_Age << endl;
	}
}

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

adjacent_find

功能描述
  • 查找相邻重复元素
函数原型
  • adjacent_find(iterator beg, iterator end);
//查找相邻重复元素，返回响铃重复元素的第一个位置的迭代器
//beg开始迭代器
//end结束迭代器
示例
#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;


//查找指定数据类型 
void test01()
{
	vector<int> v;
	v.push_back(0);
	v.push_back(1);
	v.push_back(0);
	v.push_back(2);
	v.push_back(3);
	v.push_back(2);
	v.push_back(2);
	
	vector<int>::iterator pos = adjacent_find(v.begin(), v.end());
	
	if(pos == v.end())
	{
		cout << "没有找到！" << endl;
	}
	else
	{
		cout << "找到：" << *pos << endl;//找到3 
	}
}


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

binary_search

功能描述
  • 查找指定元素是否存在
函数原型
  • bool binary_search(iterator beg, iterator end, value);
//查找指定的元素，查到返回true 否则返回false
//beg开始迭代器
//end结束迭代器
//value查找的元素

注意只能在有序序列中使用，原理是二分查找法

示例
#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;


//查找指定数据类型 
void test01()
{
	vector<int> v;
	for(int i = 0; i < 10; i++) 
	{
		v.push_back(i);
	}
	
	bool temp = binary_search(v.begin(), v.end(), 9);
	
	if(!temp)
	{
		cout << "没有找到！" << endl;
	}
	else
	{
		cout << "找到了" << endl;
	}
}


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

count

功能描述
  • 统计元素个数
函数原型
  • count(iterator beg, iterator end, value);
//beg开始迭代器
//end结束迭代器
//value统计的元素
示例
#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;


//统计内置数据类型 
void test01()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(1);
	v.push_back(1);
	v.push_back(2);
	v.push_back(1);
	
	cout << count(v.begin(), v.end(), 1) << endl;//4
	
}

//统计自定义数据类型

class Person
{
public:
	
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	
	//同find 底层都在if语句里面 
	bool operator== (const Person& p)
	{
		//只统计年龄一样的 若还加上年龄一样则还需this->m_Name = p.m_Name 
		if(this->m_Age == p.m_Age)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	
	string m_Name;
	int m_Age;
};
 
void test02()
{
	Person p1("aaa", 10);
	Person p2("bbb", 10);
	Person p3("ccc", 10);
	Person p4("ddd", 20);
	
	vector<Person> v;
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	
	Person p5("eee", 10);
	//同find一样里面放的变量 
	cout << count(v.begin(), v.end(), p5) << endl;//3
}


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

count_if

功能描述
  • 按条件统计元素个数
函数原型
  • count_if(iterator beg, iterator end, _Pred);
//按条件统计元素出现个数
//beg开始迭代器
//end结束迭代器
//_Pred谓词
示例
#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;


//统计内置数据类型 

class Greater5
{
public:
	bool operator()(int val)
	{
		return val > 5;
	}
};

void test01()
{
	vector<int> v;
	for(int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	
	cout << count_if(v.begin(), v.end(), Greater5()) << endl;
	
}

//统计自定义数据类型

class Person
{
public:
	
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	
	string m_Name;
	int m_Age;
};

class Greaterten
{
public:
	bool operator()(const Person& p)
	{
		return p.m_Age > 10;
	}
};
 
void test02()
{
	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 30);
	Person p4("ddd", 40);
	
	vector<Person> v;
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	
	cout << count_if(v.begin(), v.end(), Greaterten()) << endl;
}


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

排序算法

  • sort//对容器内元素进行排序
random_shuffle//洗牌 指定存储到另一容器中
merge//容器元素合并，并存到另一容器中
reverse//反转指定范围元素

sort

函数原型
  • sort(iterator beg, iterator end, _Pred);
//beg开始迭代器
//end结束迭代器
//_Pred谓词(不加默认升序)
示例
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>

using namespace std;

void Myprint(int val)
{
	cout << val << " ";
}

//自己写一个谓词 
class Greater
{
public:
	bool operator()(int val1, int val2)
	{
		return val1 > val2;
	}
};

void test01()
{
	vector<int> v;
	v.push_back(10);
	v.push_back(20);
	v.push_back(50);
	v.push_back(70);
	v.push_back(30);
	v.push_back(40);
	
	sort(v.begin(), v.end(), greater<int>());//#include<functional>
//	sort(v.begin(), v.end());//没有谓词默认升序 
	
//	for_each(v.begin(), v.end(), Myprint);//遍历算法 
	for(vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
}



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

random_shuffle

函数原型
  • random_shuffle(iterator beg, iterator end);
//指定范围内元素随机调整次序
//beg开始迭代器
//end结束迭代器
示例
#include <iostream>
#include <vector>
#include <algorithm>
#include <ctime>

using namespace std;


void test01()
{
	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(vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
}



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

merge

函数原型
  • merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
//beg1开始迭代器
//end1结束迭代器
//beg2开始迭代器
//end2结束迭代器
//目标容器开始迭代器

传入的两组数据必须是有序的数据，排完之后仍然是一个有序序列

示例
#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

void myprint(int val)
{
	cout << val << " ";
}

void test01()
{
	vector<int> v1;
	vector<int> v2;
	for(int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	
	for(int i = 10; i < 20; i++)
	{
		v2.push_back(i);
	}
	
	
	vector<int> v3;
	//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);
}



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

reverse

  • reverse(iterator beg, iterator end);
//反转指定范围的元素
//beg开始迭代器
//end结束迭代器
示例
#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

void myprint(int val)
{
	cout << val << " ";
}

void test01()
{
	vector<int> v1;
	for(int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	
	cout << "反转前：" << endl;
	for_each(v1.begin(), v1.end(), myprint);
	cout << endl;
	
	reverse(v1.begin(), v1.end());
	
	cout << "反转后：" << endl;
	for_each(v1.begin(), v1.end(), myprint);
	cout << endl;
}



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

拷贝和替换算法

  • copy//容器内指定范围的元素拷贝到另一容器中
replace//将容器内指定范围的旧元素替换为新元素
replace_if//容器内指定范围满足条件的元素替换为新元素
swap//互换两个容器的元素

copy

函数原型
  • copy(iterator beg, iterator end, iterator dest);
//beg开始迭代器
//end结束迭代器
//目标容器的迭代器
示例
#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

void myprint(int val)
{
	cout << val << " ";
}

void test01()
{
	vector<int> v1;
	vector<int> v2;
	for(int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	
	v2.resize(v1.size());//v2不能为空 提前开辟空间
	copy(v1.begin(), v1.end(), v2.begin());
	for_each(v2.begin(), v2.end(), myprint);
	cout << endl;
}



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

replace

函数原型
  • replace(iterator beg, iterator end, oldvalue, newvalue);
//将区间内旧元素替换成新元素
//beg开始迭代器
//end结束迭代器
//oldvalue旧元素
//newvalue新元素
示例
#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

void myprint(int val)
{
	cout << val << " ";
}

void test01()
{
	vector<int> v1;
	v1.push_back(10);
	v1.push_back(20);
	v1.push_back(50);
	v1.push_back(10);
	v1.push_back(10);
	v1.push_back(10);
	
	cout << "替换前：" << endl;
	for_each(v1.begin(), v1.end(), myprint);
	cout << endl;
	
	cout << "替换后：" << endl;
	replace(v1.begin(), v1.end(), 10, 100);
	for_each(v1.begin(), v1.end(), myprint);
	cout << endl;
}



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

replace_if

函数原型
  • replace_if(iterator beg, iterator end, _Pred, newvalue);
//按条件替换元素
//beg开始迭代器
//end结束迭代器
//_Pred谓词
//newvalue新元素
示例
#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

void myprint(int val)
{
	cout << val << " ";
}

class Greater10
{
public:
	bool operator()(int val)
	{
		if(val > 10)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
};

void test01()
{
	vector<int> v1;
	v1.push_back(10);
	v1.push_back(20);
	v1.push_back(50);
	v1.push_back(10);
	v1.push_back(10);
	v1.push_back(10);
	
	cout << "替换前：" << endl;
	for_each(v1.begin(), v1.end(), myprint);
	cout << endl;
	
	cout << "替换后：" << endl;
	replace_if(v1.begin(), v1.end(), Greater10(), 100);
	for_each(v1.begin(), v1.end(), myprint);
	cout << endl;
}



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

swap

函数原型
  • swap(container c1, container c2);
//互换两个容器
//c1容器
//c2容器
示例
#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

void myprint(int val)
{
	cout << val << " ";
}

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

void test01()
{
	vector<int> v1;
	for(int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	
	vector<int> v2;
	for(int i = 0; i < 10; i++)
	{
		v2.push_back(i+10);
	}
	
	cout << "交换前：" << endl;
	for_each(v1.begin(), v1.end(), myprint);
	cout << endl;
	for_each(v2.begin(), v2.end(), myprint);
	cout << endl;
	
	swap(v1, v2);
	cout << "交换后：" << endl;
	for_each(v1.begin(), v1.end(), myprint);
	cout << endl;
	for_each(v2.begin(), v2.end(), myprint);
	cout << endl;
}



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

算术生成算法

  • accumulate//计算容器元素累计总和
fill//向容器中添加元素

accumulate

函数原型
  • accumulate(iterator beg, iterator end, value);
//计算容器总和
//beg开始迭代器
//end结束迭代器
//value为起始值

注意包含头文件<numeric>

示例
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>

using namespace std;


void test01()
{
	vector<int> v1;
	for(int i = 0; i <= 100; i++)
	{
		v1.push_back(i);
	}
	
	//参数三为累加起始值 
	int value = accumulate(v1.begin(), v1.end(), 0);//5050 
	cout << value << endl;
}



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

fill

函数原型
  • fill(iterator beg, iterator end, value);
//向容器中填充元素
//beg开始迭代器
//end结束迭代器
//value填充的值
示例
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>

using namespace std;

void myprint(int val)
{
	cout << val << " ";
}

void test01()
{
	vector<int> v1;
	v1.resize(10);//填充10个0 
	for_each(v1.begin(), v1.end(), myprint);
	cout << endl;
	
    //重新填充 变为100
	fill(v1.begin(), v1.end(), 100);
	
	for_each(v1.begin(), v1.end(), myprint);
	cout << endl;
}



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

常用集合算法

  • set_intersection//求两个容器的交集
set_union//求两个容器的并集
set_difference//求两个容器的差集

注意：需要两个容器都是有序序列

set_intersection

函数原型
  • set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
//beg1开始迭代器
//end1结束迭代器
//beg2开始迭代器
//end2结束迭代器
//dest目标容器开始迭代器
示例
#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

void myprint(int val)
{
	cout << val << " ";
}

void test01()
{
	vector<int> v1;
	vector<int> v2;
	vector<int> v3;//目标容器 
	
	for(int i = 0; i < 10; i++) 
	{
		v1.push_back(i);//0~9
		v2.push_back(i+5);//5~14
	}
	
	//取小算法min包含头文件<algorithm>
	//最特殊情况 A是B的子集 
	v3.resize(min(v1.size(), v2.size()));
	
	//返回的是交集元素的最后一个迭代器itEnd 
	vector<int>::iterator itEnd = set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), v3.begin());
	
	//使用v3.end()的话输出5 6 7 8 9 0 0 0 0 0 因为resize之后可能比交集元素空间大 
	for_each(v3.begin(), itEnd, myprint);
}



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

set_intersection返回的是最后一个交集的迭代器。注意填itEnd，而不是v3.end()

set_union

函数原型
  • set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
//求两个集合的并集
//beg1开始迭代器
//end1结束迭代器
//beg2开始迭代器
//end2结束迭代器
//dest目标容器开始迭代器
示例
#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

void myprint(int val)
{
	cout << val << " ";
}

void test01()
{
	vector<int> v1;
	vector<int> v2;
	vector<int> v3;//目标容器 
	
	for(int i = 0; i < 10; i++) 
	{
		v1.push_back(i);//0~9
		v2.push_back(i+5);//5~14
	}
	
	//最特殊情况 A和B没有交集 
	v3.resize(v1.size()+v2.size());
	
	//返回的是的最后一个迭代器itEnd 
	vector<int>::iterator itEnd = set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), v3.begin());
	 
	for_each(v3.begin(), itEnd, myprint);
}



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

set_difference

函数原型
  • set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest)
//求两个集合的差集
//beg1开始迭代器
//end1结束迭代器
//beg2开始迭代器
//end2结束迭代器
//dest目标容器开始迭代器

分为两种情况：A和B的差集与B和A的差集是不相同的

示例
#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

void myprint(int val)
{
	cout << val << " ";
}

void test01()
{
	vector<int> v1;
	vector<int> v2;
	vector<int> v3;//目标容器 
	
	for(int i = 0; i < 10; i++) 
	{
		v1.push_back(i);//0~9
		v2.push_back(i+5);//5~14
	}
	
	//最特殊情况 A和B没有交集 取连个容器中大的那个 
	v3.resize(max(v1.size(), v2.size()));
	
	//返回的是的最后一个迭代器itEnd 
	vector<int>::iterator itEnd = set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), v3.begin());
	
	cout << "v1和v2的差集为："  << endl;
	for_each(v3.begin(), itEnd, myprint);
	cout << endl;
	
	itEnd = set_difference(v2.begin(), v2.end(), v1.begin(), v1.end(), v3.begin());
	
	cout << "v2和v1的差集为："  << endl;
	for_each(v3.begin(), itEnd, myprint);
	cout << endl;
}



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

舞台再大，你不上台，永远是个观众；平台再好，你不参与，永远是个局外人。能力再大，你不行动，只能看着别人成功！

sad_liu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
STL中常用的算法
蓬莱道人的博客
03-05 1051
为了处理容器内的元素，STL提供了一些标准算法，包括查找、排序、拷贝、重新排序、修改、数值运算等基本而普遍的算法。算法并非容器内的成员函数，而是一种搭配迭代器使用的全局函数。这么做有一个重要的优势，所有算法只需要实现一份，就可以对所有容器运作，不必为每一种容器量身定做。 1、非更易型算法 2、更易型算法 3、移除型算法 4、变序型算法 5、排序算法 6、已排序区间算法 7、数...
C++ STL 常用算法
summer
10-27 6251
标准库定义了一组泛型算法：因为它们实现共同的操作，所以称之为“算法”；而“泛型”指的是它们可以操作在多种容器类型上——不但 可作用于 vector 或 list 这些标准库类型，还可用在内置数组类型、甚至其他类型的序列上。大多数算法是通过遍历由两个迭代器标记 的一段元素来实现其功能。算法通过迭代器访问元素，这些迭代器标记了要遍历的元素范围。 使用泛型算法必须包含 algorithm 头文件：
STL常用算法
qq_24472227的博客
06-06 1590
1、常用遍历算法 2、常用查找算法 3、常用排序算法 4、常用拷贝和替换算法 5、常用算术生成算法 6、常用集合算法
STL中的常用算法（一）
weixin_51196603的博客
11-01 276
STL中的常用算法： 写在前面的话： 好长时间没有写博客了，大概算一下，应该有几个月了，前段时间因为其他的事情比较忙，一直没有闲下来，但其实我老早就把后面的博客都准备好了，然后也想找一个比较清闲的时间更新，现在临近8月底了，事情也少了很多，也就决定重新开始更新之前还没有完结的部分。 之前已经基本介绍了C++STL的常用容器，接下来就是STL中的常用算法了； ...
C++STL常用算法(超详细!)
qq_62855390的博客
12-24 1949
v1中是有4的,但是它结果显示为未找到,就是因为v1是无序的。，找到返回相邻元素的第一个位置的迭代器,找不到返回结束迭代器。，找到返回指定元素的迭代器，找不到返回结束迭代器end（），找到返回指定元素的迭代器，找不到返回结束迭代器end（）注:两个容器必须是有序的,合并完之后也是一个有序序列。,也就是最特殊的那种情况--大容器和小容器无交集。,也就是最特殊的那种情况--大容器和小容器无交集。,也就是最特殊的那种情况--大容器包小容器。返回值:并集中最后一个元素的迭代器位置。
STL常见算法总结
sinat_31608641的博客
11-19 4212
一、各种常见算法的用法 accumlate ： iterator 对标志的序列中的元素之和，加到一个由 init 指定的初始值上。重载的版本不再做加法，而是传进来的二元操作符被应用到元素上。adjacent_different ：创建一个新序列，该序列的每个新值都代表了当前元素与上一个元素的差。重载版本用指定的二元操作计算相邻元素的差。adjacent_find ：在 iterator 对标志的元素范围内，查找一对相邻的重复元素，如果找到返回一个 ForwardIterator ，指向这对元素的第一
STL【算法】| 常用算法大集合
weixin_45926547的博客
03-08 1771
文章目录一、简介1.1 类别1.1.1 _if结尾1.1.2 _copy尾词1.1.3 算法类别二、非变动性算法2.1 简介2.2 常见算法2.2.1 元素计数2.2.2 最大值和最小值2.2.3 搜寻元素三、变动性算法3.1 简介3.2 常用3.3 移除性算法四、变序性算法五、排序算法六、已序区间算法七、数值算法 一、简介 STL算法都被设计用来处理一个或多个迭代器区间；多数情况下只需提供起点即可； STL算法采用覆盖模式而非安插模式； 1.1 类别 1.1.1 _if结尾 当此类算法有两种形式
C++ STL 常见算法(比较详细)
热门推荐
xyqqwer的博客
07-28 3万+
有需要可以关注微信公众号：算法那些事儿 标准库定义了一组泛型算法：因为它们实现共同的操作，所以称之为“算法”;而“泛型”指的是它们可以操作在多种容器类型上，不但可作用于标准库类型，还可用在内置数组类型，甚至其他类型的序列上大多数算法是通过遍历由两个迭代器标记的一段元素来实现其功能使用泛型算法必须包含头文件算法。： #include &lt;algorithm&gt; 标准库还定义了...
c语言赋值截断
hutaotaotao的博客
09-02 474
c语言赋值过程与截断行为
【C++】智能指针——auto_ptr，unique_ptr，shared_ptr
2301_79796701的博客
09-01 1218
1.智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时 ++或--，这个操作不是原子的，引用计数原来是1，++了两次，可能还是2.这样引用计数就错 乱了。旧的智能指针的会转移给新的智能指针，而旧的智能指针的会被置空。解决方案：在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了，weak_ptr不会增加引用计数，代码示意。该问题是有类似于链表节点的结构引起的，当外部的智能指针都释放了，就拿不内部的智能指针，那么节点就不会释放。使用方法参考官方文档。
C++友类匿名对象，运算符重载
m0_75109289的博客
09-02 207
【代码】C++友类匿名对象，运算符重载。
适用于 Visual Studio 的 C++ 万能头
Xi Xu 的博客
08-25 3955
修改版本是根据 GNU General Public License v3.0 or later 分发的。原始文件是根据 GNU General Public License v3.0 or later 分发的。用于在 Visual Studio 上预编译的 C++ 包含。文件的修改版本，与 Visual Studio 兼容。此文件是 GCC 13.1.0 中。此文件的配置方法可在互联网上搜索。修改由本文作者完成。
怎么解决 hash 碰撞，用 C++ 实现 hashMap？
zhanghaiou07657的博客
08-29 2737
如果要自己实现一个简单的哈希映射，可以定义一个结构体来表示哈希表中的节点，包含键值对和指向下一个节点的指针（如果采用链地址法）。在插入操作时，计算键的哈希值，若该位置已被占用且键不相同，则根据选择的解决碰撞的方法（如链地址法）将新元素插入到链表中。在查找操作时，同样计算键的哈希值，然后遍历对应的链表（如果是链地址法）来查找目标键值对。“哈希碰撞是在哈希函数计算过程中可能出现的不同输入产生相同哈希值的情况。链地址法是将哈希值相同的元素存储在一个链表中，当进行查找等操作时，遍历对应的链表来找到目标元素。
C++竞赛初阶L1-15-第六单元-多维数组(34~35课)551: T456501 计算矩阵边缘元素之和
最新发布
麓小墨哥的博客
09-03 333
所谓矩阵边缘的元素，就是第一行和最后一行的元素以及第一列和最后一列的元素。第 1 行包含两个整数，分别为行数 m 和列数 n，两个整数之间空格隔开。第 2 行开始有 m 行数据，每行包含 n 个整数，整数之间空格隔开。输入一个整数矩阵，计算位于矩阵边缘的元素之和。对应矩阵的边缘元素和。
C++ | Leetcode C++题解之第390题消除游戏
Ddddddd_158的博客
09-02 166
C++ | Leetcode C++题解之第390题消除游戏
STL相关知识点
weixin_51927889的博客
09-03 374
主要介绍STL中容器的相关知识点
C++战列舰小游戏Lv. 1.2版本(半成品)
YYDS314的博客
08-31 1869
C++代码
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、付费专栏及课程。

余额充值