Day20:C++STL算法篇(1/2)
目录
一、STL查找算法
1.基本查找:
①find():区间查找
②find_if:条件查找
③find_first_of: 查找区间第一次出现值
④adjacent_find: 查找第一次重复的数
⑤search:子序列查找a，找子串
⑥search_n: 子序列查找出现次数
2.统计查找
①count：区间统计
②count_if: 条件统计个数
③equal:比较
3.有序查找
①binary_search：
②upper_bound:大于
③lower_bound：大于等于
④equal_range：包含上面的两个结果
二、STL排序算法
1.sort():排序，更改原容器顺序
说明:
2.stable_sort: 排序，保存原容器数据顺序
3.merge: 归并排序，两个有序的容器
4.inplace_merge: 归并排序，覆盖原区间
5. nth_element: 关键字排序(选一个基准作为中间参数进行排序,注：参数1起始，参数3是末)
6. partition:范围排序(通过子函数描述的条件，返回true放到左边，返回false放到右边)
7. stable_partition: 范围排序，保存原容器顺序
8. partial_sort:范围排序
9. partial_sort_copy:范围排序外加复制操作
10.random_shuffle: 随机排序，乱序算法
11.reverse:逆序原容器（两个参数，区间的起止）
12.reverse_copy: 逆序容器保存到新容器
13. rotate:移动元素到容器末尾
14. rotate_copy:移动元素到新容器(另存)
三、删除替换算法
1.copy: 拷贝函数
2.copy_backward: 逆序拷贝
3.remove: 删除->伪删除(往前依次移动1个位置，size()大小不变)
4.remove_copy: 删除元素复制到新容器
5.remove_if:条件删除
6.remove_copy_if:条件删除拷贝到新容器(实现真正的删除)
7.replace:替换
8.replace_copy: 替换，结果放到新容器
9.replace_if: 条件替换
10.replace_copy_if:条件替换,结果另存
11.iter_swap: 交换: 交换两个迭代器所指向元素
12.swap: 交换
13.swap_ranges:区间交换
14.unique:去”重“ (起末区间)
15.unique_copy:去重，结果另存
一、STL查找算法
常用的头文件:①仿函数头文件
②算法
1.基本查找:
注：大部分都是返回一个迭代器，且参数1和2分别都是起止(last)区间。
①find():区间查找
(i)底层是==(所以在做自定义类型查找时->重载==)(ii)找不到返回last
//find()：区间查找
vectorvecData = { 2,3,4,5,62,24,5,6,6,75645 };
auto pfind = find(vecData.begin(), vecData.end(), 75645);
if (pfind != vecData.end())/*注意：若没有找到,去访问end()会越界！！！*/
{
cout << *pfind << endl;
} ②find_if:条件查找
第三个参数-->计算查找准则常用一个lambda表达式(甚至返回类型都可省略)(没必要去定义在外面再定义一个函数指针进来or写一个class来重载()模仿函数行为(仿函数))
查找容器中第一个符合的 value 的元素：
//find_if查找 numbers 中第一个大于 value 的元素：
vectorvecData = { 2,3,4,5,62,24,5,6,6,75645 };
auto pfind_if = find_if(vecData.begin(), vecData.end(), [](int x)->bool{return x > 50; });
cout << *pfind_if << endl; 输出：62
//注：62是第一个符合要求的数字。
③find_first_of: 查找区间第一次出现值
过程:前两个参数对应一个容器的起止，后两个参数也对应另一个容器的起止位置，遍历前者容器，一旦val在另一个容器中存在，那么就返回指向第一个符合的val 的迭代器
//find_first_of
listmylist= {9, 8, 3,6, 4, 56, 53};
auto pfof=find_first_of(vecData.begin(), vecData.end(), mylist.begin(), mylist.end());
cout << *pfof << endl; 输出：3
//逐个遍历前一个容器，3是第一个在后一个容器中的元素。
④adjacent_find: 查找第一次重复的数
//adjacent_find
vectorvec_adjecent = {1,3,4,5,5,7,7,7,7,7};
auto p_adjacent_find = adjacent_find(vec_adjecent.begin(), vec_adjecent.end());
cout << *p_adjacent_find << endl; 输出：5 //5是第一次开始重复的元素。
⑤search:子序列查找a，找子串
(可整数、可string)必须要保证顺序一致，返回子串的位置（迭代器）
//search 找子串
vector revec = { 1,0,3,3,3,2,2,88,99,199};
int searchData[] = { 0,3,3,3,2 };
auto it = search(revec.begin(), revec.end(), searchData, searchData + 3);
cout << *it << endl; //通过迭代打印元素，知道它在那个位置 输出：0
//通过输出迭代器的，知道它的第一个元素0在什么位置(指向目标容器的第一个目标数)
⑥search_n: 子序列查找出现次数
注：其他库里面也有，使用时最好加上std::声明是标准库里面的
(i)形式一：search_n(起,终,次数n,元素k)->返回连续出现n次的元素k
/*search_n第一种写法(四个参数)*/
vector revec = { 1,0,3,3,3,2,2,88,99,199};
auto sn = std::search_n(revec.begin(), revec.end(), 3, 3);
//value: _Val
cout << *sn << endl;
输出：3
//查找 count 个 val 第一次连续出现的位置（返回指向第一个位置的迭代器）
(ii)形式二：search_n(起,终,次数n,元素k,准则(一般是lambda表达式))，返回一个正向迭代器，当函数查找成功时，该迭代器指向查找到的子序列中的第一个元素；反之，如果查找失败，则该迭代器的指向和 last 迭代器相同
vector revec = { 1,0,3,3,3,2,2,88,99,199};
//找3个满足Lambda 表达式的值
auto sn = std::search_n(revec.begin(), revec.end(),
3, 3, [](int a, int b) {return a > b; });
cout << *sn << endl; 输出：88
//因为88,99,199是连续的三个符合要求的值，返回一个指向Val=88的iterator
2.统计查找
①count：区间统计
第三个参数要给给需要统计的元素k，返回出现的次数
vector revec = { 1,0,3,3,3,3,2,2,88,99,199};
cout << count(revec.begin(), revec.end(), 3) << endl; 输出：4
②count_if: 条件统计个数
第三个参数变成一个准则(①lambda表达式(最常用)②自己的普通函数③仿函数(类的()运算符的重载))
vector revec = { 1,0,3,3,3,3,2,2,88,99,199};
cout << count_if(revec.begin(), revec.end(), [](int x) {return x > 60; }) << endl; 输出： 3
//符合要求的共3个
③equal:比较
参数是两个容器(类型可以不同),逐一比较两个容器中的参数是否一一相同返回bool类型。
vector revec = { 1,0,3,3,3,2,2,88,99,199};
list myList = { 1,0,3,3,3,2,2,88,99,199 };
cout << boolalpha << equal(revec.begin(), revec.end(), myList.begin(), myList.end()) << endl; 输出：true //容器内的元素一模一样
3.有序查找
注：(原容器的数据必须是有序的，否则此类算法无效->无序的可以先排序！)
①binary_search：
二分查找(找到返回1，否则0)
//10.二分查找
vector testData = { 1,2,3,4,5,6,7,8,9 };
cout << boolalpha << binary_search(testData.begin(), testData.end(), 2) << endl; 输出： true //找到了
②upper_bound:大于
查找最后一个大于查找的值，返回值是一个迭代器,返回指向大于key的第一个值的位置
vector testData = { 1,2,3,4,5,6,7,8,9 };
auto uper = upper_bound(testData.begin(), testData.end(), 6);
cout << *uper << endl; 输出：7 // 大于6的后面第一个位置指向7
③lower_bound：大于等于
大于等于查找的值，返回值是一个迭代器,返回指向大于等于key的第一个值的位置
//大于等于
vector testData = { 1,2,3,4,5,6,7,8,9 };
auto lower = lower_bound(testData.begin(), testData.end(), 6);
cout << *lower << endl; ④equal_range：包含上面的两个结果
区间比较---有序序列(相当于合并了上面的两个结果)返回类型是pair数对类型(first和second仍然存储的是迭代器类型)。
vector testData = { 1,2,3,4,5,6,7,8,9 };
auto pair = equal_range(testData.begin(),testData.end(), 6);
cout << *pair.first << "\t" << *pair.second << endl; 二、STL排序算法
注意：list容器用的是内置sort()而非用以下的相关排序函数。
1.sort():排序，更改原容器顺序
说明:
①第三个参数默认的排序准则less<>，也可以传入greater<>
②第三个参数也可以自己写排序准则,可以是
(i)lambda表达式(相对较为麻烦->要给公共接口)
(ii)仿函数
(iii)普通的函数指针)
class Wbm
{
public:
Wbm(string name, int age) :name(name), age(age) {}
string& GetName()
{
return name;
}
int& GetAge()
{
return age;
}
void print()
{
cout << name << "\t" << age << endl;
}
protected:
string name;
int age;
};
void test_sort()
{
//1.sort
/*①普通数据的sort*/
vector vec = { 0,3,4,2,7,3,6,3,6,432,32,2 };
sort(vec.begin(), vec.end());
//上述是缺省语句，等效于 传入一个仿函数
sort(vec.begin(), vec.end(), less());
print(vec);
sort(vec.begin(), vec.end(), greater());
print(vec);
/*②自定义数据类型的sort*/
vector bmwData;
bmwData.push_back(Wbm("abc", 18));
bmwData.push_back(Wbm("cca", 39));
bmwData.push_back(Wbm("bba", 58));
sort(bmwData.begin(), bmwData.end(), [](Wbm a, Wbm b)->bool{return a.GetAge() < b.GetAge(); });
/* sort(bmwData.begin(), bmwData.end(), [](Wbm a, Wbm b){return a.GetAge() < b.GetAge(); });*/
/*lambda最简单的写法，省略掉->bool*/
for (auto v : bmwData)
{
v.print();
}
sort(bmwData.begin(), bmwData.end(), [](Wbm a, Wbm b) {return a.GetName() < b.GetName(); });
for (auto v : bmwData)
{
v.print();
}
} 输出：
0 2 2 3 3 3 4 6 6 7 32 432
432 32 7 6 6 4 3 3 3 2 2 0
abc 18
cca 39
bba 58
-------------------***----------------------
abc 18
bba 58
cca 39
2.stable_sort: 排序，保存原容器数据顺序
(保持元素的相对位置排序，需要给一个“模糊”的比较准则->比如实数按整数比较)
//2.保持元素的相位置排序
bool com_as_int(double a, double b)
{
return int(a) < int(b);
}
void testStableSort()
{
vector num = { 1.33,2.33,1.22,3.22,3.44,3.66 };
stable_sort(num.begin(), num.end(), com_as_int);
print(num);
} 输出：1.33 1.22 2.33 3.22 3.44 3.66
3.merge: 归并排序，两个有序的容器
(也可以是一个容器的两个区间)存于新容器(不改变原容器)
//3.归并排序
void testMerge()
{
//3.不会更改原容器归并
vector vec = { 1,2,3,4,5,0,6,7,8,9 };
vector result(vec.size());
merge(vec.begin(), vec.begin() + 5, vec.begin() + 5, vec.end(), result.begin());
print(result);
} 输出：
0 1 2 3 4 5 6 7 8 9
4.inplace_merge: 归并排序，覆盖原区间
(参数1：起始位置，参数2：中间位置，参数3：结束位置)
void testMerge()
{
//4.改变原容器
vector vec = { 1,2,3,4,5,0,6,7,8,9 };
inplace_merge(vec.begin(), vec.begin() + 5, vec.end());
print(vec);
} 输出：
0 1 2 3 4 5 6 7 8 9
5. nth_element: 关键字排序(选一个基准作为中间参数进行排序,注：参数1起始，参数3是末)
//5.关键字排序
vector test = { 1,2,3,4,5,0,8,9, 6,7 };
nth_element(test.begin(), test.begin() + 5, test.end());
print(test); 输出：0 1 2 3 4 5 6 7 8 9
6. partition:范围排序(通过子函数描述的条件，返回true放到左边，返回false放到右边)
注：会修改原容器
//6.分类处理
//通过子函数描述条件，返回true放到左边 ，返回false放到右边
vector score = { 98,10,98,23,45,65,34,56,67 };
partition(score.begin(), score.end(), [](int a) {return a > 60; });
print(score); 输出：98 67 98 65 45 23 34 56 10
7. stable_partition: 范围排序，保存原容器顺序
(通过子函数描述的条件，返回true放到左边(同时还要保证原来的相对顺序)，返回false放到右边)
void testStableSort()
{
vector num = { 1.33,2.33,1.22,3.22,3.44,3.66 };
stable_sort(num.begin(), num.end(), com_as_int);
//print(num);
//7.保持原容器顺序 去分类处理
stable_partition(num.begin(), num.end(), bind(com_as_int, std::placeholders::_1, 2.0));
print(num);
} 8. partial_sort:范围排序
(参数1：起始，参数2：需要排序的右端点,参数3：末位置(与参数2构成一个无序的区间))
//8.局部排序
vector num = { 22,33,45,8,23,66,45,34,244 };
partial_sort(num.begin(), num.begin() + 5, num.end());
print(num); 输出：8 22 23 33 34 66 45 45 244
/*仅仅排序了前五个
9. partial_sort_copy:范围排序外加复制操作
(参数1和参数2构成需要局部排序的区间，参数3和4是一个res容器存储排完序之后的目标存储容器的区间)
//9.局部排序，结果另存
vector num = { 22,33,45,8,23,66,45,34,244 };
vector result(5);
partial_sort_copy(num.begin(), num.begin() + 5, result.begin(), result.end());
print(result); 输出： 8 22 23 33 34
10.random_shuffle: 随机排序，乱序算法
每次结果不同，要一个随机函数种子(每次运行都不一样)(例：做拼图游戏)
（两个参数，区间的起止）
//10.乱序算法 ，每次结果不同，要一个随机函数种子
vector num = { 22,33,45,8,23,66,45,34,244 };
srand((unsigned int)time(nullptr));
random_shuffle(num.begin(), num.end());
print(num); 输出： 45 23 8 33 34 66 45 22 244
11.reverse:逆序原容器（两个参数，区间的起止）
逆序原容器（两个参数，区间的起止）
//11.逆序反转
vector re = { 1,2,3,4,5,0,8,9, 6,7 };
reverse(re.begin(), re.end());
print(re); 输出：7 6 9 8 0 5 4 3 2 1
12.reverse_copy: 逆序容器保存到新容器
（3个参数->区间的起,止,需要存储容器的起始位置）
//12.反转另存
vector re = { 1,2,3,4,5,0,8,9, 6,7 };
vector rec(re.size());
reverse_copy(re.begin(), re.end(), rec.begin());
print(rec); 输出：7 6 9 8 0 5 4 3 2 1
/*原来re是不变的！！！！
13. rotate:移动元素到容器末尾
（3个参数->需要移动区间的起,止,目标移到哪个部分的后面，如end()）
//13.移位操作
vector move = { 1,2,3,4,5,6 };
rotate(move.begin(), move.begin() + 2, move.end());
print(move); 输出：3 4 5 6 1 2
14. rotate_copy:移动元素到新容器(另存)
（4个参数->需要移动区间的起,止,目标移到哪个部分的后面-如end(),需要存储容器的起始位置）
//14.移位结果另存
vector move = { 1,2,3,4,5,6 };
vector moveResult(move.size());
rotate_copy(move.begin(), move.begin() + 3, move.end(), moveResult.begin());
print(moveResult); 输出：4 5 6 1 2 3
三、删除替换算法
1.copy: 拷贝函数
三个参数 ：原容器的起+末+目标容器的起始
注意：目标被拷贝到的容器，必须定长(比如list就不行！vector声明的时候要声明长度！！->常用原容器的size())
//1.正向拷贝
vector vec = { 1,2,3,4,5,6 };
vector nvec(vec.size());
copy(vec.begin(), vec.end(), nvec.begin());
print(nvec); 输出： 1 2 3 4 5 6
2.copy_backward: 逆序拷贝
第三参数是改成末位置iter。整体的顺序和实现效果同copy
//2.你想拷贝，从最后开始赋值
vector vec = { 1,2,3,4,5,6 };
vector rvec(vec.size());
copy_backward(vec.begin(), vec.end(), rvec.end());
print(rvec); 输出：1 2 3 4 5 6
3.remove: 删除->伪删除(往前依次移动1个位置，size()大小不变)
//3.删除--->伪删除
vector vec = { 1,2,3,3,4,5,3,6 };
auto it = remove(vec.begin(), vec.end(), 3);
cout << vec.size() << endl;
print(vec); 输出： 8 //元素个数不变
1 2 4 5 6 5 3 6//仅删除第一次遇到的连续的目标需要的val，后面的val就不会删除了——>可以先排序！
4.remove_copy: 删除元素复制到新容器
(4个参数,原容器的起始+末+目标容器起始+目标删除元素）
//4.伪删除结果另存
vector vec = { 1,2,3,4,5,6 };
vector result(vec.size() - 1);
remove_copy(vec.begin(), vec.end(), result.begin(), 2);
print(result); 输出： 1 3 4 5 6
5.remove_if:条件删除
--->仅仅是把不符合要求的结果放到容器的后面（ 三个参数：始末+计算准则）（remove_if常和erase一起出现实现真正的删除or用下面的copy）删除
//5.条件删除 remove_if
vector score = { 98,45,65,77,45,43 };
remove_if(score.begin(), score.end(), [](int x) {return x < 60; });
print(score);//先打印大于等于60分的人，最后面一部分是不符合要求的， 输出： 98 65 77 77 45 43
6.remove_copy_if:条件删除拷贝到新容器(实现真正的删除)
->应用：将及格的人真正筛选出来（四个参数->（起+末+目标容器的起+计算准则））
//6.条件删除结果另存
vector score = { 98,45,65,77,45,43 };
vector ok(count_if(score.begin(), score.end(),
[](int x) {return x >= 60; }));
remove_copy_if(score.begin(), score.end(), ok.begin(),
[](int x) {return x < 60; });
print(ok); 输出：98 65 77
//注意这里搞定长vector的时候，用到了count_if得知要开多大的vector
7.replace:替换
->四个参数，(始+末+原始需要替换的数据+需要修改成的数据) all替换
//7.替换算法(修改) replace
vector rep = { 1,2,3,4,5,6,7,1,2,3,1,2,3 };
replace(rep.begin(), rep.end(), 1, 100);
print(rep); 输出： 100 2 3 4 5 6 7 100 2 3 100 2 3
8.replace_copy: 替换，结果放到新容器
->5个参数(始+末+目标容器的起始位置+原始需要替换的数据+需要修改成的数据)
//8.替换后结果另存
vector rep = { 1,2,3,4,5,6,7,1,2,3,1,2,3 };
vector repc(rep.size());
replace_copy(rep.begin(), rep.end(), repc.begin(), 1, 0);/*1->0*/
print(repc); 输出： 0 2 3 4 5 6 7 0 2 3 0 2
9.replace_if: 条件替换
->四个参数（区间起+始+计算准则+符合要求的目标data需要替换成的值）
//9.条件替换
vector rep = { 1,2,3,4,5,6,7,1,2,3,1,2,3 };
replace_if(rep.begin(), rep.end(), [](int x) {return x < 6; }, 0);
print(rep); 输出： 0 0 0 0 0 6 7 0 0 0 0 0 0
10.replace_copy_if:条件替换,结果另存
->五个参数(起+末+目标容器的起始+计算准则+更换成目标的Val)
//10.条件替换，结果另存
vector rep = { 0,2,3,4,5,6,7,0,2,3,0,2,3 };
vector repif(rep.size());
replace_copy_if(rep.begin(), rep.end(), repif.begin(),
[](int x) {return x == 0; }, 1);
print(repif); 输出： 1 2 3 4 5 6 7 1 2 3 1 2 3
11.iter_swap: 交换: 交换两个迭代器所指向元素
//11.交换 iter_swap
vector test = { 11,2,3,4,5,6,7,8,9 };
iter_swap(test.begin(), test.end() - 1);
print(test); 输出： 9 2 3 4 5 6 7 8 11
12.swap: 交换
->最妙的地方：不需要两个容器size一样
注意：底层是实例化为同一种数据类型的vector容器(故两个不相同数据类型是不能够进行交换的) 参数（容器1名，容器2名）
//12.swap 不需要两个容器长度一样
vector test = { 11,2,3,4,5,6,7,8,9 };
vector test2 = { 2,2 };
swap(test, test2);
print(test);
print(test2); 输出：
2 2
11 2 3 4 5 6 7 8 9
13.swap_ranges:区间交换
->3个参数(容器1的某区间的起始+last位置+容器2需要修改起始位置)
//13.区间交换 swap_range
vector test = { 11,2,3,4,5,6,7,8,9 };
vector test2 = { 2,2 };
swap_ranges(test2.begin(), test2.begin() + 1, test.begin());
print(test2); 输出：
2 2 3 4 5 6 7 8 9
11 2
14.unique:去”重“ (起末区间)
->连续相同保留一个，想要去重可以先排序，再调用 =>真去重->放到set容器中
//14.去重(连续相同保留一个) 想要去重可以先排序，在调用
vector uniq = { 1,1,3,4,4,3,3,2,2,2,4,4,4 };
unique(uniq.begin(), uniq.end());
print(uniq); 输出： 1 3 4 3 2 4 3 2 2 2 4 4 4
//14.去重(连续相同保留一个) 想要去重可以先排序，在调用
vector uniq = { 1,1,3,4,4,3,3,2,2,2,4,4,4 };
sort(uniq.begin(), uniq.end());
print(uniq);
unique(uniq.begin(), uniq.end());
print(uniq);/*最好看一下不重复的元素的个数，单独存一下，or采用下面的copy函数*/ 输出：
1 1 2 2 2 3 3 3 4 4 4 4 4
1 2 3 4 2 3 3 3 4 4 4 4 4
注：看第二行是先排序再unique的结果，显然前四个为目标结果->
①可以开一个定长vector，大小用count来算，然后存前四个即可
or
②采用下面的unique_copy函数
15.unique_copy:去重，结果另存
（3个参数,第三个为目标参数的起始位置）
配合sort食用更佳！！！
//15.去重另存
vector uniqr(4);
vector uniqr2(6);
vector uniq = { 1,1,3,4,4,3,3,2,2,2,4,4,4 };
sort(uniq.begin(), uniq.end(),less());
unique_copy(uniq.begin(), uniq.end(), uniqr.begin());
unique_copy(uniq.begin(), uniq.end(), uniqr2.begin());
print(uniqr);
print(uniqr2); 输出：
1 2 3 4
1 2 3 4 0 0
注意：看uniqr2的后两个数值，均为0！(因为排完序了，再调用此函数方能达到真正的去重效果，另存到此，后面两个元素为默认值0！)