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!)

               

你可能感兴趣的:(C++,数据结构&算法,c++,数据结构,算法)