STL 重要的算法（最常见）_stl的算法函数

STL中算法大致分为四类：

#include < algorithm >

1. 非可变序列算法：指 不直接修改其所操作的容器内容的算法。
2. 可变序列算法：指 可以修改它们所操作的容器内容的算法。
3. 排序算法：包括对序列进行排序和合并的算法、搜索算法以及有序序列上的集合操作。
4. 数值算法：对容器内容进行数值计算。

查找算法

• find: 利用底层元素的等于操作符，对指定范围内的元素与输入值进行比较。当匹配时，结束搜索，返回该元素的一个InputIterator。

【注意】如果找到了就直接返回，并不会继续找下去，所以判断没有找到的条件就是迭代器或者 指针指向了末尾元素的下一位就可以确定没有找到。

int main() {
	// using std::find with array and pointer:
	int myints[] = { 10, 20, 30, 40 };
	int * p = find(myints, myints + 4, 30);

	if (p != myints + 4) {
		std::cout << "Element found in myints: " << *p << '\n';
	}
	else {
		std::cout << "Element not found in myints\n";
	}

	// using std::find with vector and iterator:
	std::vector<int> myvector(myints, myints + 4);
	std::vector<int>::iterator it;

	it = find(myvector.begin(), myvector.end(), 30);
	if (it != myvector.end()) {
		std::cout << "Element found in myvector: " << *it << '\n';
	}
	else {
		std::cout << "Element not found in myvector\n";
	}

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

• search: 给出两个范围，查找成功指向第一个范围内第一次出现子序列(第二个范围)的位置，查找失败指向 last1 重载版本使用自定义的比较操作。

bool mypredicate(int i, int j) {
	return (i == j);
}

int main() {
	std::vector<int> v;

	// v: 10 20 30 40 50 60 70 80 90
	for (int i = 1; i < 10; i++)
		v.push_back(i * 10);

	// using default comparison:
	int needle1[] = { 40,50,60,70 };
	std::vector<int>::iterator it;
	it = search(v.begin(), v.end(), needle1, needle1 + 4);

	if (it != v.end()) {
		cout << (it - v.begin()) << '\n';
	}
	else {
		cout << "needle1 not found\n";
	}

	// using predicate comparison:
	int n[] = { 20,30,50 };
	it =search(v.begin(), v.end(), n, n + 3, mypredicate);

	if (it != v.end()) {
		cout << (it - v.begin()) << '\n';
	}
	else {
		cout << " not found\n";
	}

	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

排序和通用算法

• merge:合并两个有序序列，存放到另一个序列。重载版本使用自定义的比较。

int main () {
  int first[] = {5,10,15,20,25};
  int second[] = {50,40,30,20,10};
  std::vector<int> v(10);

  std::sort (first,first+5);
  std::sort (second,second+5);
  std::merge (first,first+5,second,second+5,v.begin());

  std::cout << "The resulting vector contains:";
  for (std::vector<int>::iterator it=v.begin(); it!=v.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

• reverse:将指定范围内元素重新反序排序。

int main() {
	vector<int>v;
	for (int i = 0; i < 10; ++i) {
		v.push_back(i);
	}
	reverse(v.begin(), v.end());
	for (int i = 0; i < 10; ++i) {
		printf("%d ", v[i]);
	}
	cout << endl;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

• sort:以升序重新排列指定范围内的元素。重载版本使用自定义的比较操作。

int main() {
	int a[10] = { 1,4,6,3,2,8,5,9,0 ,7};
	vector<int>v(a,a+10);
	sort(v.begin(), v.end());
	for (auto&e : v) {
		cout << ' ' << e;
	}
	cout << endl;
	return 0;
}
1
2
3
4
5
6
7
8
9
10

默认是升序，但是可以自定以一个降序排序

//自定以函数
bool mcp(int x,int y) {
	return x > y;
}

int main() {
	int a[10] = { 1,4,6,3,2,8,5,9,0 ,7};
	vector<int>v(a,a+10);
	sort(v.begin(), v.end(),mcp);
	for (auto&e : v) {
		cout << ' ' << e;
	}
	cout << endl;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

删除和替换算法

• copy:复制序列
  但是注意的是 复制到了一个新的空间内。

int main() {
	int myints[] = { 10,20,30,40,50,60,70 };
	std::vector<int> myvector(7);
	std::vector<int>::iterator it;

	std::copy(myints, myints + 7, myvector.begin());

	std::cout << "myvector contains:";
	for (it = myvector.begin(); it != myvector.end(); ++it)
		std::cout << ' ' << *it;

	std::cout << '\n';
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• remove:删除指定范围内所有等于指定元素的元素。
  注意，该函数不是真正删除函数。内置函数不适合使用remove和remove_if函数。

int main() {
	int myints[] = { 10,20,30,40,50,60,70,20,20 ,30};
	int* end = myints + sizeof(myints) / sizeof(int);
	end = remove(myints, end, 20);
		std::cout << "myvector contains:";
	for (int* i = myints; i < end; ++i) {
		cout << ' ' << *i;
	}
	std::cout << '\n';
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11

• replace:将指定范围内所有等于vold的元素都用vnew代替。

int main() {
	int myints[] = { 10,20,30,40,50,60,70,20,20 ,30};
	vector<int>v(myints,myints+10);
	replace(v.begin(), v.end(),20,200);
	
	std::cout << "v contains:";
	for (auto&e : v) {
		cout << ' ' << e;
	}
	std::cout << '\n';
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

• swap: 交换存储在两个对象中的值。

关系算法

• equal: 如果两个序列在标志范围内元素都相等，返回true。重载版本使用输入的操作符代替默认的等于操作符。

• includes: 判断第一个指定范围内的所有元素是否都被第二个范围包含，使用底层元素的<操作符，成功返回true。重载版本使用用户输入的函数。

• max: 返回两个元素中较大一个。重载版本使用自定义比较操作。

• min: 返回两个元素中较小一个。重载版本使用自定义比较操作。

---

以上这些都是经常用到的函数，如果想浏览更多函数
参考 -------》 这篇博客 《-------点这里