Day20:C++STL算法篇(1/2)

//find()：区间查找
	vector<int>vecData = { 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 的元素：
    vector<int>vecData = { 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
	list<int >mylist= {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
	vector<int>vec_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<int> 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<int> 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<int> 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<int> 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<int> 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<int> revec = { 1,0,3,3,3,2,2,88,99,199};
list<int> 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<int> 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<int> 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<int> 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<int> 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<int> vec = { 0,3,4,2,7,3,6,3,6,432,32,2 };
	sort(vec.begin(), vec.end());
	//上述是缺省语句，等效于  传入一个仿函数
	sort(vec.begin(), vec.end(), less<int>());
	print(vec);
	sort(vec.begin(), vec.end(), greater<int>());
	print(vec);
	/*②自定义数据类型的sort*/
	vector<Wbm> 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<double> 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<int> vec = { 1,2,3,4,5,0,6,7,8,9 };
	vector<int> 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<int> 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<int> 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<int> 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<double> 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<int> 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<int> num = { 22,33,45,8,23,66,45,34,244 };
vector<int> 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<int> 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<int> 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<int> re = { 1,2,3,4,5,0,8,9, 6,7 };
vector<int> 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<int> 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<int> move = { 1,2,3,4,5,6 };
vector<int> 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<int> vec = { 1,2,3,4,5,6 };
vector<int> 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<int> vec = { 1,2,3,4,5,6 };
vector<int> 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<int> 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<int> vec = { 1,2,3,4,5,6 };
	vector<int> 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<int> 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<int> score = { 98,45,65,77,45,43 };
	vector<int> 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<int> 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<int> rep = { 1,2,3,4,5,6,7,1,2,3,1,2,3 };
	vector<int> 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<int> 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<int> rep = { 0,2,3,4,5,6,7,0,2,3,0,2,3 };
	vector<int> 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<int> 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<int> test = { 11,2,3,4,5,6,7,8,9 };
	vector<int> 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<int> test = { 11,2,3,4,5,6,7,8,9 };
	vector<int> 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<int> 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<int> 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来算，然后存前四个即可

②采用下面的unique_copy函数

15.unique_copy:去重，结果另存

（3个参数,第三个为目标参数的起始位置）

配合sort食用更佳！！！

	//15.去重另存
	vector<int> uniqr(4);
	vector<int> uniqr2(6);
	vector<int> uniq = { 1,1,3,4,4,3,3,2,2,2,4,4,4 };
	sort(uniq.begin(), uniq.end(),less<int>());
	unique_copy(uniq.begin(), uniq.end(), uniqr.begin());
	unique_copy(uniq.begin(), uniq.end(), uniqr2.begin());
	print(uniqr);
	print(uniqr2);