C++ STL算法篇(二) day18

[小瓜偷学编程]

已于 2023-09-25 11:19:10 修改

阅读量35

点赞数

分类专栏：励志学习C瓜瓜文章标签： c++ 算法开发语言学习笔记

于 2023-09-22 15:56:00 首次发布

本文链接：https://blog.csdn.net/qq_44924388/article/details/133102135

版权

励志学习C瓜瓜专栏收录该内容

19 篇文章 0 订阅

订阅专栏

C++ STL算法篇(二) day18

拷贝和修改算法

copy: 区间拷贝
copy_backward: 逆向拷贝
remove:删除
remove_copy: 删除另存
remove_if:条件删除
remove_copy_if:条件删除结果另存
replace: 修改
replace _copy: 修改结果另存
replace_if:条件替换
replace_copy_if:条件替换，结果另存
iter_swap:迭代器交换
swap:容器交换
swap_ranges: 区间交换
unique: 去重操作
unique_copy: 去重结果另存

#include <iostream>
#include <algorithm>
#include <vector>
#include <list>
class student
{
public:
	student(std::string name = "", int age = 0) :name(name), age(age) {}
	std::string getName()const { return name; };
	int getAge()const { return age; };
protected:
	std::string name;
	int age;
};

void CopyAlter()
{
	//1.copy算法-------------------------------------------------------------------
	int arr[5]{ 1,2,3,4,5 };
	std::vector<int> vec;
	copy(arr, arr + 5, std::back_inserter(vec));
	copy(vec.begin(), vec.end(), std::ostream_iterator<int>(std::cout, " "));
	std::cout << std::endl;

	//2.copy_backward逆向拷贝------------------------------------------------------------------
	std::vector<int> rvec(vec.size());
	std::copy_backward(vec.begin(), vec.end(), rvec.end());
	copy(rvec.begin(), rvec.end(), std::ostream_iterator<int>(std::cout, " "));
	std::cout << std::endl;

	//3. remove删除算法 数组伪删除: 数组后面往前移动,覆盖前面-----------------------------------
	auto iter = remove(vec.begin(), vec.end(), 2);
	std::cout << "size:" << vec.size() << std::endl;
	copy(vec.begin(), vec.end(), std::ostream_iterator<int>(std::cout, " "));
	std::cout << std::endl;

	//4.remove_copy删除结果另存------------------------------------------------------------------
	std::vector<int> rcopy;
	remove_copy(vec.begin(), vec.end(), std::back_inserter(rcopy), 1);
	copy(vec.begin(), vec.end(), std::ostream_iterator<int>(std::cout, " "));
	std::cout << std::endl;
	copy(rcopy.begin(), rcopy.end(), std::ostream_iterator<int>(std::cout, " "));
	std::cout << std::endl;

	//5.remove_if条件删除------------------------------------------------------------------
	std::vector<int> data = { 1,2,3,4,5,6,7,8,9 };
	auto it = remove_if(data.begin(), data.end(),
		[](const int& data) {return data % 2 == 0; }
	);
	copy(data.begin(), data.end(), std::ostream_iterator<int>(std::cout, " "));
	std::cout << std::endl;

	//6.remove_copy_if条件删除结果另存------------------------------------------------------------------
	std::vector<int> maxData;
	remove_copy_if(data.begin(), data.end(), std::back_inserter(maxData),
		[](const int& data) {return data < 5; });
	copy(maxData.begin(), maxData.end(), std::ostream_iterator<int>(std::cout, " "));
	std::cout << std::endl;

	//7.replace修改指定数据为一个新的值,修改所有的一样的------------------------------------------------------------------
	std::replace(maxData.begin(), maxData.end(), 9, 999);
	copy(maxData.begin(), maxData.end(), std::ostream_iterator<int>(std::cout, " "));
	std::cout << std::endl;

	//8.replace_copy修改后的结果另存------------------------------------------------------------------
	std::vector<int> cMax;
	std::replace_copy(maxData.begin(), maxData.end(), std::back_inserter(cMax), 999, 111);
	copy(maxData.begin(), maxData.end(), std::ostream_iterator<int>(std::cout, " "));
	std::cout << std::endl;
	copy(cMax.begin(), cMax.end(), std::ostream_iterator<int>(std::cout, " "));
	std::cout << std::endl;

	//9.replace_if条件修改------------------------------------------------------------------
	std::replace_if(cMax.begin(), cMax.end(),
		[](const int& data) {return data == 111; }, 222);
	copy(cMax.begin(), cMax.end(), std::ostream_iterator<int>(std::cout, " "));
	std::cout << std::endl;

	//10.replace_copy_if条件修改结果另存------------------------------------------------------------------
	std::vector<int> result;
	std::replace_copy_if(cMax.begin(), cMax.end(), std::back_inserter(result),
		[](const int& data) {return data == 222; }, 333);
	copy(cMax.begin(), cMax.end(), std::ostream_iterator<int>(std::cout, " "));
	std::cout << std::endl;
	copy(result.begin(), result.end(), std::ostream_iterator<int>(std::cout, " "));
	std::cout << std::endl;

	//11.iter_swap迭代器交换------------------------------------------------------------------
	std::vector<int> one = { 1,2,3,4,5,6,7,9 };
	iter_swap(one.begin(), one.end() - 1);
	copy(one.begin(), one.end(), std::ostream_iterator<int>(std::cout, " "));
	std::cout << std::endl;

	//12.swap_ranges区间交换------------------------------------------------------------------
	std::vector<int> two = { 11,22,33,44,55 };
	swap_ranges(one.begin(), one.begin() + 3, two.begin());
	copy(one.begin(), one.end(), std::ostream_iterator<int>(std::cout, " "));
	std::cout << std::endl;
	copy(two.begin(), two.end(), std::ostream_iterator<int>(std::cout, " "));
	std::cout << std::endl;

	//13.unique去重------------------------------------------------------------------------------
	std::string  str = "sdfasdaddaaa21122xzxc2f******";
	unique(str.begin(), str.end());
	std::cout << str << std::endl;

	//14.unique_copy结果另存-----------------------------------------------------------------------------
	std::string  unstr;
	unique_copy(str.begin(), str.end(), std::back_inserter(unstr));
	std::cout << unstr << std::endl;
}

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

运行结果

排序组合算法

全排列算法：
- next_permutation：从小到大
- prev_permutation：从大到小
next_permutation只能获得上一个排列，如果要获得全排列，那么就需要先对数组进行升序排序，prev_permutation与next_permutation用法一样
定义如下
- next_permutaion(起始地址，末尾地址)
- next_permutaion(起始地址，末尾地址，自定义排序)

#include <iostream>
#include <algorithm>
#include <vector>
int main()
{
	std::vector<int> vec{ 1,3,4,2 };
	//进行全排列时要将容器里的元素排序成有序的
	//有序从小到大
	sort(vec.begin(), vec.end(), std::less<int>());
	int index = 0;
	do
	{
		index++;
		std::cout << "第：" << index << "组合";
		copy(vec.begin(), vec.end(), std::ostream_iterator<int>(std::cout, " "));
		std::cout << std::endl;
	} while (next_permutation(vec.begin(), vec.end()));
	//逆序从大到小
	std::cout << std::endl;
	sort(vec.begin(), vec.end(), std::greater<int>());
	index = 0;
	do
	{
		index++;
		std::cout << "第：" << index << "组合";
		copy(vec.begin(), vec.end(), std::ostream_iterator<int>(std::cout, " "));
		std::cout << std::endl;
	} while (prev_permutation(vec.begin(), vec.end()));
	return 0;
}

运行结果

算术类算法

头文件：包含头文件 #include <numeric>
accumulate：求和算法
partial_sum：逐步求和
inner_product：求积这个积是笛卡尔积，一般用在矩阵乘积中
adjacent_difference：逐步求差

#include <iostream>
#include <algorithm>
#include <vector>
#include <numeric>
int main()
{
	//1.accumulate求和-------------------------------------------------------------------------
	std::vector<int> vec{ 1,3,2,4,5,6 };
	int sum = 0;
	sum = accumulate(vec.begin(), vec.end(), sum);
	std::cout << sum << std::endl;

	//2.partial_sum逐步求和--------------------------------------------------------------------
	std::vector<int> vec2;
	partial_sum(vec.begin(), vec.end(), std::back_inserter(vec2));
	copy(vec2.begin(), vec2.end(), std::ostream_iterator<int>(std::cout, " "));
	std::cout << std::endl;

	//3.inner_product求积,这个积是笛卡尔积，一般用在矩阵乘积中---------------------------------
	std::vector<int> one{ 1,2,3 };
	std::vector<int> two{ 4,5,6 };
	std::cout << inner_product(one.begin(), one.end(), two.begin(), 0) << std::endl;

	//4.adjacent_difference求差-----------------------------------------------------------------
	//这个求差是后一个减前一个
	std::vector<int> data{ 1,3,4,2 };
	std::vector<int> temp;
	adjacent_difference(data.begin(), data.end(), std::back_inserter(temp));
	copy(temp.begin(), temp.end(), std::ostream_iterator<int>(std::cout, " "));
	std::cout << std::endl;
	return 0;
}

运行结果

关系算法

equal：比较算法
includes：是否包含关系
lexicographical_compare: 比较序列
max：最大值，max_element迭代器版
min：最小值，min_element迭代器版
mismatch: 查找第一次不同的地方

#include <iostream>
#include <algorithm>
#include <vector>
#include <numeric>
int main()
{
	//1.equal是否相等-------------------------------------------------------------------------
	std::vector<int> one{ 1,2,3,4 };
	std::vector<int> two{ 1,3,2,4 };
	std::cout << std::boolalpha << equal(one.begin(), one.end(), two.begin(), two.end()) << std::endl;
	
	//2.includes是否是包含关系-------------------------------------------------------------------------
	//使用这个函数的两个容器原容器必须是有序的，而且必须是从小到大有序
	std::vector<int> data{ 2,3,4 };
	std::cout << std::boolalpha << includes(one.begin(), one.end(), data.begin(), data.end()) << std::endl;
	
	//3.lexicographical_compare比较序列-------------------------------------------------------------------
	//第一个序列小于第二个序列，返回true，反之返回false
	std::string str1 = "1Xiaogua";
	std::string str2 = "2Dagua";
	std::cout << lexicographical_compare(str1.begin(), str1.end(),
		str2.begin(), str2.end()) << std::endl;
	if (str1 < str2)
	{
		std::cout << "不如这个True" << std::endl;
	}

	//4.最值---------------------------------------------------------------------------------------
	//max：最大值，max_element迭代器版 min：最小值 ，min_element迭代器版最值
	std::cout << std::max(1, 2) << std::endl;
	std::cout << std::min(1, 2) << std::endl;
	std::cout << *std::max_element(one.begin(), one.end()) << std::endl;
	std::cout << *std::min_element(two.begin(), two.end()) << std::endl;

	//5.mismatch查找第一次不同的位置
	auto result= mismatch(one.begin(), one.end(), two.begin(), two.end());
	std::cout << "one容器中与two容器不同的位置：" << *result.first << std::endl;
	std::cout << "one容器与two容器中不同的位置：" << *result.second << std::endl;
	return 0;
}