c++学习24STL（六）STL常用算法

最新推荐文章于 2023-10-10 09:38:28 发布
最新推荐文章于 2023-10-10 09:38:28 发布
阅读量285 收藏
点赞数 1
分类专栏： C++ 文章标签： 算法 c++ 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46066548/article/details/126676652
版权

STL常用算法

概述

  • 算法主要是由头文件 <algorithm> <functional> <numeric>组成
  • <algorithm>是所有STL头文件中最大的一个，范围涉及到比较、交换、查找、遍历操作、复制、修改等等
  • <numeric>体积很小，只包括几个在序列上面进行简单数学运算的模板函数
  • <functional>定义了一些模板类，用以声明函数对象

常用遍历算法

  • for_each // 遍历容器
  • transform //搬运容器到另一个容器中

for_each

功能描述：
实现遍历容器

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

//beg 开始迭代器
//end 结束迭代器
//_func 函数或函数对象

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
//遍历算法for_each
//普通函数
void print01(int val) {
    cout << val << " ";
}
//仿函数
class print02 {
public:
    void operator()(int val) {
        cout << val << " ";
    }
};
void test01() {
    vector<int> v;
    for (int i = 0;i < 10;i++) {
        v.push_back(i);
    }
    //1.
    for_each(v.begin(), v.end(), print01);
    cout << endl;
    //2.
    for_each(v.begin(), v.end(), print02());
    cout << endl;
}
int main() {
    test01();
    system("pause");
    return 0;
}

transform

功能描述：
搬运容器到另一个容器

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

//beg1源容器开始迭代器
//end1 源容器结束迭代器
//beg2 目标容器开始迭代器
//_func 函数或者函数对象

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

//transform
class Transform1 {
public:
	int operator()(int v) {
		return v;
	}
};
class print01 {
public:
	void operator()(int val) {
		cout << val << " ";
	}
};
void test01() {
	vector<int> v;
	for (int i = 0;i < 10;i++) {
		v.push_back(i*10);
	}
	vector<int> v1;//目标容器
	v1.resize(v.size());//设置目标容器大小 目标容器需要提前开辟空间
	transform(v.begin(), v.end(), v1.begin(),Transform1() );
	for_each(v1.begin(), v1.end(), print01());//0 10 20 30 40 50 60 70 80 90
	cout << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

注意：搬运容器需要提前给目标容器开辟空间

常用查找算法

  • find //查找元素
  • find_if //按条件查找元素
  • adjacent_find //查找相邻重复元素
  • binary_search //二分查找法
  • count //统计元素个数
  • count_if //按条件统计元素个数

find

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

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

//beg 开始迭代器
//end 结束迭代器
//value 查找的元素

#include<iostream>
using namespace std;
#include<algorithm>
#include<vector>
//find 
//查找 内置数据类型
void test01() {
	vector<int> v;
	for (int i = 0;i < 10;i++) {
		v.push_back(i);
	}
	//查找容器中是否有5这个元素
	vector<int>::iterator it = find(v.begin(), v.end(), 5);
	if (it != v.end()) {
		cout << "容器中有5这个元素" << endl;
	}
	else {
		cout << "容器中没有5这个元素" << endl;
	}
}
//查找自定义数据类型
class Person {
public:
	Person(string name, int age) {

		this->m_Name = name;
		this->m_Age = age;
	}
	//重载== 底层find知道如何对比person数据类型
	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() {
	vector<Person> v1;
	Person p1("张三", 16);
	Person p2("里斯", 14);
	Person p3("万物", 156);
	Person p4("赵六", 126);
	v1.push_back(p1);
	v1.push_back(p2);
	v1.push_back(p3);
	v1.push_back(p4);
	vector<Person>::iterator it = find(v1.begin(), v1.end(), p2);
	Person pp("张三", 16);
	vector<Person>::iterator it = find(v1.begin(), v1.end(), pp);
	if (it != v1.end()) {
		cout << "容器中有pp这个元素" << endl;
	}
	else {
		cout << "容器中没有p2这个元素" << endl;
	}
}
int main() {
	test01();
	test02();
	system("pause");
	return 0;
}

find_if

功能描述：
按条件查找元素

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

//按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
//beg 开始迭代器
//end 结束迭代器
//_Pred 函数或谓词（返回bool类型的仿函数）

#include<iostream>
using namespace std;
#include<algorithm>
#include<vector>
//find_if
//内置数据类型
class GreaterFive {
public:
	bool operator()(int val) {
		return val > 5;
	}
};
void test01() {
	vector<int> v;
	v.push_back(1);
	v.push_back(1);
	v.push_back(7);
	v.push_back(6);
	v.push_back(5);
	vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive());
	if (it != v.end()) {
		cout << "找到了大于5的数字" << endl;
		cout << "在这个容器中第一个大于5的数字是" << *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 Greater20 {
public:
	bool operator()(const Person& p) {
		return p.m_Age > 20;
	}
};
void test02() {
	vector<Person> v;
	Person p1("aaa", 15);
	Person p2("bbb", 16);
	Person p3("ccc", 24);
	Person p4("ggg", 21);
	Person p5("eee", 17);
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	v.push_back(p5);
	//找年龄大于20的
	vector<Person>::iterator it = find_if(v.begin(), v.end(), Greater20());
	if (it != v.end()) {
		cout << "在容器v中找到年龄大于20的人" << endl;
		cout << "第一个的姓名为" << (*it).m_Name << " 年龄为 " << (*it).m_Age << endl;
	}
	else {
		cout << "没有找到年龄大于20的" << endl;
	}
}
int main() {
	test01();
	test02();
	system("pause");
	return 0;
}

adjacent_find

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

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

//查找相邻重复元素，返回相邻元素的第一个位置的迭代器
//beg 开始迭代器
//end 结束迭代器

#include<iostream>
using namespace std;
#include<algorithm>
#include<vector>
//adjacent_find
void test01() {
	vector<int> v;
	v.push_back(5);
	v.push_back(4);
	v.push_back(1);
	v.push_back(5);
	v.push_back(5);
	v.push_back(6);
	v.push_back(8);
	v.push_back(8);
	vector<int>::iterator it = adjacent_find(v.begin(), v.end());
	if (it != v.end()) {
		cout << "找到了重复相邻元素" << endl;
		cout << "最早的相邻元素为" << *it << endl;
	}
	else {
		cout << "没有重复的相邻元素" << endl;
	}
}
int main() {
	test01();
	system("pause");
	return 0;
}

binary_search(二分查找)

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

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

//查找指定的元素，查到返回true,否则 false
//注意：在无序序列中不可用
//beg 开始迭代器
//end 结束迭代器
//value 查找的元素

#include<iostream>
using namespace std;
#include<algorithm>
#include<vector>
//binary_search
void test01() {
	vector<int> v;
	for (int i = 0; i < 10;i++) {
		v.push_back(i);
	}
	//v.push_back(1); //原本容器是有序的，增加一个数变成无序，发现查找存在元素的显示出错
	bool res = binary_search(v.begin(), v.end(),9);
	cout << res << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

注意：此方法在无序序列中查找是时好时坏，结果不稳定,故不能用于无序序列

count

功能描述：
统计元素个数

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

//统计元素出现次数
//beg 开始迭代器
//end 结束迭代器
//value 统计的元素

#include<iostream>
using namespace std;
#include<algorithm>
#include<vector>
//count
//1.统计内置数据类型
void test01() {
	vector<int> v;
	v.push_back(1);
	v.push_back(1);
	v.push_back(4);
	v.push_back(1);
	v.push_back(6);
	v.push_back(7);
	int num=count(v.begin(), v.end(), 1);
	cout << "容器中1的个数为：" << num << endl;
}
//2.统计自定义数据类型
class Person {
public:
	Person(string name, int age) {
		this->m_Name = name;
		this->m_Age = age;
	}
	//告诉编译器自定义类型相同的判断
	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() {
	vector<Person> v;
	Person p1("a", 13);
	Person p2("b", 23);
	Person p3("s", 33);
	Person p4("c", 43);
	Person p5("h", 53);
	Person p6("a", 13);
	Person p7("a", 13);
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	v.push_back(p5);
	v.push_back(p6);
	v.push_back(p7);
	Person p("a", 13);
	int num = count(v.begin(), v.end(), p);
	cout << "姓名为a年龄为13的有" << num << "个" << endl;
}
int main() {
	test01();
	test02();
	system("pause");
	return 0;
}

count_if

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

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

//beg 开始迭代器
//end 结束迭代器
//_Pred 谓词

#include<iostream>
using namespace std;
#include<algorithm>
#include<vector>
//count_if
//1.统计内置数据类型
class Greater3 {
public:
	bool operator()(int val){
		return val>3;
	}
};
void test01() {
	vector<int> v;
	v.push_back(1);
	v.push_back(1);
	v.push_back(4);
	v.push_back(1);
	v.push_back(6);
	v.push_back(7);
	int num = count_if(v.begin(), v.end(), Greater3());
	cout << "容器中1的个数为：" << num << endl;
}
//2.统计自定义数据类型
class Person {
public:
	Person(string name, int age) {
		this->m_Name = name;
		this->m_Age = age;
	}
	string m_Name;
	int m_Age;
};
class MyCompare30 {
public:
	bool operator()(const Person& p) {
		if (p.m_Age > 30) {
			return true;
		}
		else {
			return false;
		}
	}
};
void test02() {
	vector<Person> v;
	Person p1("a", 13);
	Person p2("b", 23);
	Person p3("s", 33);
	Person p4("c", 43);
	Person p5("h", 53);
	Person p6("a", 13);
	Person p7("a", 13);
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	v.push_back(p5);
	v.push_back(p6);
	v.push_back(p7);
	int num = count_if(v.begin(), v.end(), MyCompare30());
	cout << "大于30的人员个数：" << num << endl;	
}
int main() {
	test01();
	test02();
	system("pause");
	return 0;
}

常用排序算法

算法简介

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

sort

功能描述：
对容器内元素进行排序

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

//beg 开始迭代器
//end 结束迭代器
//_Pred 谓词

#include<iostream>
using namespace std;
#include<algorithm>
#include<vector>
#include<functional>
//sort
void myPrint(int val) {
	cout << val << " ";
}
void test01() {
	vector<int> v;
	v.push_back(10);
	v.push_back(40);
	v.push_back(50);
	v.push_back(20);
	v.push_back(30);
	//默认升序排序
	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();
	system("pause");
	return 0;
}

random_shuffle

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

函数原型
random_suffle(iterator beg,iterator end);

//beg 开始迭代器
//end 结束迭代器

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<ctime>
//random_shuffle
void myPrint(int val) {
	cout << val << " ";
}
void test01() {
	vector<int> v;
	for (int i = 0;i < 10;i++) {
		v.push_back(i);
	}
	//打乱顺序前的遍历
	for_each(v.begin(), v.end(), myPrint);
	cout << endl;
	//打乱顺序的遍历
	random_shuffle(v.begin(), v.end());
	for_each(v.begin(), v.end(), myPrint);
	cout << endl;
}
int main() {
	//加入随机数种子，使每次程序启动的随机数都不一样
	srand((unsigned int)time(NULL));
	test01();
	system("pause");
	return 0;
}

merge

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

函数原型
merge(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator des);

//注意两个容器必须是有序的
//beg1 容器1开始迭代器
//end1 容器1结束迭代器
//beg2 容器2开始迭代器
//end2 容器2结束迭代器
//dest 目标容器开始迭代器

#include<iostream>
using namespace std;
#include<algorithm>
#include<vector>
//merge
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.push_back(i*2);
	}
	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;
}
int main() {
	test01();
	system("pause");
	return 0;
}

reverse

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

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

//beg 开始迭代器
//end 结束迭代器

#include<iostream>
using namespace std;
#include<algorithm>
#include<vector>
//reverse
void myPrint(int val) {
	cout << val << " ";
}
void test01() {
	vector<int> v1;
	//有序的容器
	for (int i = 0;i < 10;i++) {
		v1.push_back(i);
	}
	reverse(v1.begin(), v1.end());
	for_each(v1.begin(), v1.end(), myPrint);
	cout << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

常用拷贝和替换算法

算法简介

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

copy

功能描述：
容器内指定范围的元素拷贝到另一个容器中

函数原型
copy(iterator beg,iterator end,iterator dest);

//beg 开始迭代器
//end 结束迭代器
//dest 目标容器的起始迭代器

#include<iostream>
using namespace std;
#include<algorithm>
#include<vector>
//copy
void myPrint(int val) {
	cout << val << " ";
}
void test01() {
	vector<int> v;
	//有序的容器
	for (int i = 0;i < 10;i++) {
		v.push_back(i);
	}
	vector<int> v1;
	//提前开辟空间
	v1.resize(v.size());
	copy(v.begin(), v.end(), v1.begin());
	for_each(v1.begin(), v1.end(), myPrint);
	cout << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

replace

功能描述
将容器内指定范围的旧元素改为新元素

函数原型
replace(iterator beg,iterator end,oldvalue,newvalue);

//beg 开始迭代器
//end 结束迭代器
//oldvalue 旧元素
//newvalue 新元素

#include<iostream>
using namespace std;
#include<algorithm>
#include<vector>
//replace
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;
	cout << "替换后:" << endl;
	replace(v1.begin(), v1.end(), 2, 100);
	for_each(v1.begin(), v1.end(), myPrint);
	cout << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

replace会替换满足条件的所有元素

replace_if

功能描述：
将区间内所有满足条件的元素替换成指定元素

函数原型
replace_if(iterator beg,iterator end,_Pred,newvalue);

//beg 开始迭代器
//end 结束迭代器
//_Pred 谓词
//newvalue 替换的新元素

#include<iostream>
using namespace std;
#include<algorithm>
#include<vector>
//replace_if
void myPrint(int val) {
	cout << val << " ";
}
class MyCompare {
public:
	bool operator()(int val) {
		return val > 5;
	}
};
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;
	cout << "替换后:" << endl;
	//将大于5的替换成3
	replace_if(v1.begin(), v1.end(), MyCompare(), 3);
	for_each(v1.begin(), v1.end(), myPrint);
	cout << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

swap

swap(container c1,container c2);

//c1 容器1
//c2 容器2

#include<iostream>
using namespace std;
#include<algorithm>
#include<vector>
//swap
void myPrint(int val) {
	cout << val << " ";
}

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();
	system("pause");
	return 0;
}

交换的容器必须是同种类型

常用算数生成算法

注意：
算数生成算法属于小型算法，使用时需包含的头文件为**#include <numeric>**

算法简介

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

accumulate

功能描述：
计算区间内 容器元素 累计总和

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

// beg 开始迭代器
//end 结束迭代器
//value 起始值

#include<iostream>
using namespace std;
#include<numeric>
#include<vector>
//accumulate
void test01() {
	vector<int> v;
	for (int i = 0;i <= 100;i++) {
		v.push_back(i);
	}
	//参数3 起始累加值
	int total=accumulate(v.begin(), v.end(),100);
	cout << "total=" << total << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

fill

功能描述
向容器中填充指定的元素

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

//beg 开始迭代器
//end 结束迭代器
//value 填充的值

#include<iostream>
using namespace std;
#include<numeric>
#include<vector>
#include<algorithm>
//fill
void printV(int val) {
	cout << val << " ";
}
void test01() {
	vector<int> v;
	v.resize(8);
	fill(v.begin(), v.end(), 8);
	for_each(v.begin(), v.end(), printV);
	cout << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

常用集合算法

算法简介

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

set_intersection

功能描述
求两个容器的交集

函数原型
set_intersection(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest);

//beg1 容器1的开始迭代器
//end1 容器1的结束迭代器
//beg2 容器2的开始迭代器
//end2 容器2的结束迭代器
//dest 目标容器开始迭代器

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
void printV(int val) {
	cout << val << " ";
}
void test01() {
	vector<int> v1;
	vector<int> v2;
	for (int i = 0;i < 10;i++) {
		v1.push_back(i);
		v2.push_back(i+5);
	}
	vector<int> vTarget;
	//目标容器开辟空间的大小最大为容器中较小的
	//vTarget.resize(v1.size() > v2.size() ? v2.size() : v1.size());
	vTarget.resize(min(v1.size(), v2.size()));
	vector<int>::iterator itEnd=set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
	for_each(vTarget.begin(), itEnd,printV);
	cout << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

总结：

  1. 求交集的两个结合必须是有序序列
  2. 目标容器开辟的空间需要从两个容器中取小值
  3. set_intersction返回值是交集中最后一个一个元素的位置

set_union

功能描述：
求两个集合的并集

函数原型
set_union(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest);

//beg1 容器1的开始迭代器
//end1 容器1的结束迭代器
//beg2 容器2的开始迭代器
//end2 容器2的结束迭代器
//dest 目标容器开始迭代器

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
//set_union
void printV(int val) {
	cout << val << " ";
}
void test01() {
	vector<int> v1;
	vector<int> v2;
	for (int i = 0;i < 10;i++) {
		v1.push_back(i);
		v2.push_back(i + 5);
	}
	vector<int> vTarget;
	//开辟空间： 最极端：两个容器没有交集，大小就是两个容器相加
	vTarget.resize(v1.size()+v2.size());
	vector<int>::iterator itEnd = set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
	for_each(vTarget.begin(), itEnd, printV);
	cout << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

总结：

  1. 求并集的两个集合必须是有序序列
  2. 目标容器开辟空间需要两个容器相加
  3. set_union返回值是并集中最后一个元素的位置

set_difference

功能描述：
求两个集合的差集

函数原型
set_difference(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest);

//beg1 容器1的开始迭代器
//end1 容器1的结束迭代器
//beg2 容器2的开始迭代器
//end2 容器2的结束迭代器
//dest 目标容器开始迭代器
注意：
两个集合必须是有序序列

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
//set_difference
void printV(int val) {
	cout << val << " ";
}
void test01() {
	vector<int> v1;
	vector<int> v2;
	for (int i = 0;i < 10;i++) {
		v1.push_back(i);
		v2.push_back(i + 5);
	}
	vector<int> vTarget;
	//开辟空间： 最极端：两个容器没有交集，大小就是最大的容器
	vTarget.resize(max(v1.size(),v2.size()));
	vector<int>::iterator itEnd = set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
	for_each(vTarget.begin(), itEnd, printV);
	cout << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

差集取决于谁在参数前面，如上述代码输出的将是v1和v2的差集

言顶
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python-数据分析（6-numpy）
zaibiketaide的专栏
09-01 620
Numpy 6 Numpy 6.1 Numpy介绍与安装 Numpy是什么？ Numpy(Numerical Python)是目前Python数值计算中最为重要的基础包。大多数计算包都提供了基于Numpy的科学函数功能，将Numpy的数组对象作为数据交换的通用语。 Numpy特点 提供高效多维数组 提供了基于数组的便捷算术操作以及广播机制 对数据进行快速的矩阵计算 对硬盘中数组数据进行读写操作 Numpy安装 直接在dos命令行中pip install numpy 即可。 6.2 Numpy基本操作
std中稳定排序算法_八大经典排序算法
weixin_36295010的博客
01-30 544
一、插入排序-直接插入排序(Straight Insertion Sort)直接插入排序(Straight Insertion Sort)的基本思想是：把n个待排序的元素看成为一个有序表和一个无序表。开始时有序表中只包含1个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，将它插入到有序表中的适当位置，使之成为新的有序表，重复n-1次可完成排序过程。#include usi...
经典文献阅读之--STD(激光SLAM回环检测算法)
lovely_yoshino的博客
10-10 8356
各位也知道，我们在之前的博客中，介绍了很多回环的方法，比如Scan Context，Lris, BoW3D等方法。之前作者也在《》一文中，给到了一些回环检测算法的介绍。最近林博新开源了一个回环检测算法《我们从博主中的实验中发现，确实效果不错，同时相关的代码也已经在上开源了。图1。(a)显示从查询点云中提取的稳定三角形描述符(STD)。(b)显示从历史点云中提取的STD。（c）显示了这两帧点云之间STD匹配的示例。正确匹配的STD描述符由白色框标示，并且通过STD提供的姿态进行点云配准。
std中稳定排序算法_稳定排序算法
weixin_29545475的博客
12-11 266
常用排序算法？稳定性：稳定排序算法会让原本有相等键值的纪录维持相对次序。也就是如果一个排序算法是稳定的，当有两个相等键值的纪录R和S，且在原本的列表中R出现在S之前，在排序过的列表中R也将会是在S之前。冒泡排序算法：比较相邻的元素，按照顺序进行交换，一次遍历后，就会有一个最大（最小）交换至顶端，重复步骤即可。python实现：arr = [54,26,93,17,77,31,44,55,20] ...
C++ STL常用算法
weixin_45406155的博客
07-22 484
目录 1. 常用遍历算法 1.1 for_each遍历容器 1.2 transorm 搬运容器到另一个容器中 2. 常用查找算法 2.1 find查找算法 2.2 find_if条件查询 2.3 adjacent_find 查找相邻重复元素. 2.4 binary_search 二分查找 2.5 count 统计元素个数 2.6 count_if 条件统计 3.排序算法 3.1 sort对容器元素排序 3.2 random_shuffle 随机调整顺序 3.3 merge容器元.
C++常用stl算法.pdf
11-22
这篇文档主要讨论了C++ STL中的一些常用算法，包括函数对象适配器，如`for_each`、`bind`等。让我们深入探讨这些概念。 首先，函数对象在C++中是一个重要的概念，它是一个类，通过重载`()`操作符使得类的对象能够像...
c++模板stl常用算法
09-01
stl常用算法，模板stl常用算法，
C++标准库STL源码
最新发布
03-24
SGI STL的源码是学习和理解STL实现原理的宝贵资源。它展示了如何使用C++的语言特性和编程技巧来设计和实现高效、灵活、可重用的组件。通过研究SGI STL的源码,可以深入理解STL的内部工作机制,提高编程技能和设计能力...
c++非变易算法-stl算法
09-04
本文主要介绍了C++ STL算法库中的非变易算法，是一些原则上不会变更操作数据的算法，包括：逐个查找算法、元素搜索算法、元素统计算法、序列匹配算法、子序列搜索算法、这些函数均包含于头文件，本文给出的所有代码...
c++ SGI STL源代码学习
06-04
侯捷老师推荐C++ SGI STL标准库源代码，可用于学习c++各种容器、常用算法、迭代器等的底层实现。c++进阶必备，必知必会内容。
算法第4版 标准库 Std，jar文件和源码
09-10
此文件包好了算法第4版所需要运行的标准库Std*库。编译文件（class文件），源代码（java代码）。由于上传内容不能超过60M后续。下载完成后留言给你分享algs4-data.zip文件
【C++】基础学习笔记
QiHai的博客
07-17 1365
大家好呀，这里是我对c++在学习类和对象前的一些基础的理解(〃'▽'〃)希望大家能够指正出我的错误，我们一起共同进步！下面会介绍了解的是c++语法中的好啦，话不多说，直接开始吧~
std中常用算法函数记录
专注于C/C++数据结构、算法的研究与探讨
05-18 483
accumulte 元素累计和，将元素的值全部进行累加 binary_search 二分查找，从有序的（从小到大）中二分查找一个元素（排序用sort函数） copy  从某个开始迭代器到结束迭代器，拷贝到某容器的起始迭代器位置 copy_n 拷贝n个 count 计数 count_if equal_range 试图在有序区间中寻找某值(返回一个上下限区间pair)
C++STL算法汇总-慢慢完善
Xjtusexx的博客
03-07 300
非修改序列操作函数：这类函数不会修改原始序列，主要包括查找、计数、比较、判断等操作，例如find、count、equal等。修改序列操作函数：这类函数会修改原始序列，主要包括删除、替换、旋转、排序等操作，例如remove、replace、reverse、sort等。变异序列操作函数：这类函数会修改原始序列，并返回一个新的序列，主要包括拷贝、移动、填充、生成等操作，例如copy、move、fill、generate等。
std中稳定排序算法_JS中的算法.排序
weixin_42377790的博客
12-25 101
。点击上方蓝字关注我哦101. 算法简单说程序中的算法，就是观察规律，用代码实现逻辑02. 冒泡排序冒泡排序(英语：Bubble Sort)又称为泡式排序，是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到...
Qt std常用算法
pejay23的博客
05-29 1966
QStringList list; list<<"one"<<"two"<<"three"; qDebug()<<list; QVector<QString> vect(3); std::copy(list.begin(),list.end(),vect.begin()); qDebug()<<vect<<endl<<"__________"; /* v.
algorithm函数一览
王川的私房菜
02-02 998
库函数 accumulate 累加序列的所有元素 adjacent_difference 计算序列中的相邻元素是否不同 adjacent_find 查找相邻的两个相同(或者有其他关联)元素 any_of 如果对于任意元素的谓词测试都为true,则返回true （C++11） all_of 如果对于所有元素的谓词测试都为true,则返回true （C++11） b
C++标准模板（STL）- 算法 （std::copy_n）
qq_40788199的博客
10-22 1088
1) 若 count>0 ，则准确复制来自始于 first 的范围的 count 个值到始于 result 的范围。正式而言，对于每个非负整数 i < n 进行 *(result + i) = *(first + i) 。不同于 std::copy ，本算法容许重叠。 2) 同 (1) ，但按照 policy 执行。此重载仅若 std::is_execution_policy_v 为 true 才参与重载决议。
C++11标准模板（STL）- 算法（std::rotate）
qq_40788199的博客
11-09 1633
1) 进行元素范围上的左旋转。 具体而言， std::rotate 交换范围 [first, last) 中的元素，方式满足元素 n_first 成为新范围的首个元素，而 n_first - 1 成为最后元素。 此函数的前提条件是 [first, n_first) 和 [n_first, last) 为合法范围。
c++竞赛常用stl
09-13
在C++竞赛中，常用的STL（Standard Template Library）组件有vector、stack以及算法函数next_permutation。vector是一个动态数组容器，可以方便地进行元素的插入、删除和访问。stack是一个后进先出（LIFO）的容器，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值