C++常见算法大全（自用）

参考链接！！！

查找算法

• adjacent_find : 查重复数，返回首个元素iter

• binary_search`: 二分查找

• count: 区间统计

• count_if: 范围查找统计个数

• equal: 比较

• equal_range :区间元素比较

• find:区间查找元素

• find_first_of:区间查找第一次出现值

• find_if : 条件查找

• upper_bound:查找最后一个大于等于val的位置

• lower_bound: 查找第一个大于等于val的位置

• search:子序列查找位置

• search_n:子序列查找出现次数

排序和通用算法

排序和通用算法就是用来给容器排序，主要的排序算法主要是有以下14个：

• merge: 归并排序，存于新容器

• inpace_merge: 归并排序，覆盖原区间

• sort: 排序，更改原容器顺序

• stable_sort: 排序，保存原容器数据顺序

• nth_element: 关键字排序

• partition:范围排序

• partial_sort:范围排序

• partial_sort_copy:范围排序外加复制操作

• stable_partition: 范围排序，保存原容器顺序

• random_shuffle: 随机排序

• reverse:逆序原容器

• reverse_copy: 逆序容器保存到新容器

• rotate:移动元素到容器末尾

• rotate_copy:移动元素到新容器

删除和替换算法

删除和替换算法一般都会修改容器的存储现状，一般处理删除和替换的算法主要有以下的15种：

• copy: 拷贝函数

• copy_backward: 逆序拷贝

• iter_swap: 交换

• remove: 删除

  remove_copy: 删除元素复制到新容器

• remove_if:条件删除

• remove_copy_if:条件删除拷贝到新容器

• replace:替换

• replace_copy: 替换，结果放到新容器

• replace_if: 条件替换

• replace_copy_if:条件替换，结果另存

• swap: 交换

• swap_range:区间交换

• unique:去重

• unique_copy:去重，结果另存

排列组合算法

提供计算给定集合按一定顺序的所有可能排列组合 ，主要有以下两个:

next_permutation:下一个排序序列的组合

prev_permutation:上一个排序序列的组合

算术运算算法主要用来做容器的算术运算，使用的时候加上numeric头文件，主要有以下4个：

accumulate:区间求和

partial_sum:相邻元素的和，相当于计算原数组的前缀和数组

inner_product:序列内积运算

adjacent_difference:相邻元素的差

生成和异变算法

生成和一遍算法总共有以下6个下，相对于来说for_each用的相对于来说更多一些:

for_each:迭代访问

fill:填充方式初始容器

fill_n:指定长度填充容器

generate_n:填充前n个位置

transform:一元转换和二元转换

关系算法

关系算法类似与条件表达式一样的作用，主要用来判断容器中元素是否相等等运算，主要有以下8个：

equal:两容器元素是否都相同

includes:是否是包含关系

lexicographical_compare:比较两个序列

max:求最大值

max_element:返回最大值的iterator

min:求最小值

min_element:求最小值的iterator

mismatch:找到第一个不同的位置

集合算法

集合算法主要是集合上的一些运算，例如集合加法：并集，集合的减法：差集，还有交集。主要有以下4个：

set_union:并集

set_intersection:交集

set_difference:差集

set_symmetric_difference:对称差集

堆算法

堆算法，就是把容器当做堆去操作，主要算法函数只有以下4个：

make_heap:生成一个堆

pop_heap:出堆

push_heap:入堆

sort_heap:堆排序

简单测试

// STL算法.cpp: 定义应用程序的入口点。
//
#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
#include <string>
#include <array>
#include <queue>
#include <stack>
#include <functional>
#include <numeric>

class TestList {
public:
	TestList() {}
	~TestList() {}

	template <typename T>
	void show(const T& vec) {
		for (auto& x : vec) {
			std::cout << x << ' ';
		}
		std::cout << '\n';
	}

	//查找第一个重复元素位置
	void adjacent_find() {
		std::cout << *std::adjacent_find(a6.begin(), a6.end()) << '\n';
		if (std::adjacent_find(a3.begin(), a3.end(), std::greater<int>()) == a3.end()) {
			std::cout << "序列绝对升序\n";
		}
		if (std::adjacent_find(a4.begin(), a4.end(), std::less<int>()) == a4.end()) {
			std::cout << "序列绝对降序\n";
		}
	}

	//归并排序
	void merge() {
		std::vector<int> dst(a1.size() + a2.size());
		std::merge(a1.begin(), a1.end(), a2.begin(), a2.end(), dst.begin());
		for (auto& x : dst) {
			std::cout << x << " ";
		}
	}

	void nth_element() {
		std::nth_element(a5.begin(), a5.begin() + 0, a5.end());
		show(a5);
	}

	void unique() {
		show(a6);
		a6.erase(std::unique(a6.begin(), a6.end()), a6.end());
		show(a6);
	}

	void swap() {
		std::swap(a1, a2);
	}

	void next_permutation() {
		while (std::next_permutation(a1.begin(), a1.end())) {
			show(a1);
		}
	}

	void accumulate() {
		//val + n
		std::cout << std::accumulate(a1.begin(), a1.end(), 0) << '\n';

		//计算前缀和
		std::vector<int> dst(a1.size());
		std::partial_sum(a2.begin(), a2.end(), dst.begin());
		show(dst);

		//内积
		//val + a_i * b_i
		std::cout << std::inner_product(a1.begin(), a1.end(), a2.begin(), 0);

		std::vector<int> dst2(a5.size());
		//3221 4 4 -7 2 4 2 -10
		std::adjacent_difference(a5.begin(), a5.end(), dst2.begin());
		show(dst2);
	}

	void generate_n() {
		std::vector<int> dst(10);
		//iota()
		std::generate_n(dst.begin(), 4, [=]() {return 10; });
		show(dst);
	}

	void make_heap() {
		//大顶堆
		std::make_heap(a5.begin(), a5.end());
		show(a5);

		//将最大元素移动到末尾
		std::pop_heap(a5.begin(), a5.end());
		show(a5);
		a5.pop_back(); //删除最大元素

		a5.push_back(100);
		//最大元素push入堆
		std::push_heap(a5.begin(), a5.end());
		show(a5); 

		//大顶堆：升序排列
		std::sort_heap(a5.begin(), a5.end());
		show(a5);
	}
private:
	//奇数升序
	std::vector<int> a1{ 1,3,5,7,9,11 };
	//奇数无序
	std::vector<int> a11{ 1,7,3,5,11,7 };
	//偶数升序
	std::vector<int> a2{ 2,4,6,8,10,12 };
	//偶数无序
	std::vector<int> a22{ 6,8,10,2,6,4,12 };
	//无重复1-10升序
	std::vector<int> a3{ 1,2,3,4,5,6,7,8,9,10 };
	//有重复1-10升序
	std::vector<int> a33{ 1,1,2,2,3,3,4,4,5,6,7,8,9,9,10 };
	//无重复10-1降序
	std::vector<int> a4{ 10,9,8,7,6,5,4,3,2,1 };
	//有重复10-1降序
	std::vector<int> a44{ 10,10,9,8,7,7,7,6,6,5,5,3,2,1,1 };
	//1-10乱序
	std::vector<int> a5{ 1,5,9,2,4,8,10,0 };
	//成对元素
	std::vector<int> a6{ 1,1,2,2,3,3,4,4,0,0,9,9 };
};

int main()
{
	TestList ls;
	//ls.adjacent_find();
	//ls.merge();
	//ls.nth_element();
	//ls.unique();
	//ls.swap();
	//ls.next_permutation();
	//ls.accumulate();
	ls.make_heap();
	return 0;
}