• 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查找算法

    常用的头文件:①仿函数头文件<functional> ②算法<alogorithm>

    1.基本查找:

                  注：大部分都是返回一个迭代器，且参数1和2分别都是起止(last)区间。

            ①find():区间查找

                     (i)底层是==(所以在做自定义类型查找时->重载==)(ii)找不到返回last

    1. //find()：区间查找
    2. 	vector<int>vecData = { 2,3,4,5,62,24,5,6,6,75645 };
    3. 	auto pfind = find(vecData.begin(), vecData.end(), 75645);
    4. 	if (pfind != vecData.end())/*注意：若没有找到,去访问end()会越界！！！*/
    5. 	{
    6. 		cout << *pfind << endl;
    7. 	}

            ②find_if:条件查找

                    第三个参数-->计算查找准则常用一个lambda表达式(甚至返回类型都可省略)(没必要去定义在外面再定义一个函数指针进来or写一个class来重载()模仿函数行为(仿函数))

                    查找容器中第一个符合的 value 的元素：

    1. 	//find_if查找 numbers 中第一个大于 value 的元素：
    2.     vector<int>vecData = { 2,3,4,5,62,24,5,6,6,75645 };
    3. 	auto pfind_if = find_if(vecData.begin(), vecData.end(), [](int x)->bool{return x > 50; });
    4. 	cout << *pfind_if << endl;

    输出：62

            //注：62是第一个符合要求的数字。 

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

                    过程:前两个参数对应一个容器的起止，后两个参数也对应另一个容器的起止位置，遍历前者容器，一旦val在另一个容器中存在，那么就返回指向第一个符合的val 的迭代器

    1. //find_first_of
    2. 	list<int >mylist= {9, 8, 3,6, 4, 56, 53};
    3. 	auto pfof=find_first_of(vecData.begin(), vecData.end(), mylist.begin(), mylist.end());
    4. 	cout << *pfof << endl;

    输出：3 

                    //逐个遍历前一个容器，3是第一个在后一个容器中的元素。 

            ④adjacent_find: 查找第一次重复的数

    1. 	//adjacent_find
    2. 	vector<int>vec_adjecent = {1,3,4,5,5,7,7,7,7,7};
    3. 	auto p_adjacent_find = adjacent_find(vec_adjecent.begin(), vec_adjecent.end());
    4. 	cout << *p_adjacent_find << endl;

    输出：5                           //5是第一次开始重复的元素。 

            ⑤search:子序列查找a，找子串

                    (可整数、可string)必须要保证顺序一致，返回子串的位置（迭代器）

    1. //search 找子串	
    2. vector<int> revec = { 1,0,3,3,3,2,2,88,99,199};
    3. int searchData[] = { 0,3,3,3,2 };
    4. auto it = search(revec.begin(), revec.end(), searchData, searchData + 3);
    5. cout << *it << endl;  //通过迭代打印元素，知道它在那个位置

    输出：0               

     //通过输出迭代器的，知道它的第一个元素0在什么位置(指向目标容器的第一个目标数) 

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

                    注：其他库里面也有，使用时最好加上std::声明是标准库里面的  

                       (i)形式一：search_n(起,终,次数n,元素k)->返回连续出现n次的元素k

    1. /*search_n第一种写法(四个参数)*/
    2. vector<int> revec = { 1,0,3,3,3,2,2,88,99,199};
    3. auto sn = std::search_n(revec.begin(), revec.end(), 3, 3); 
    4.  //value: _Val
    5. cout << *sn << endl;

    输出：3       

    //查找 count 个 val 第一次连续出现的位置（返回指向第一个位置的迭代器）

                       (ii)形式二：search_n(起,终,次数n,元素k,准则(一般是lambda表达式))，返回一个正向迭代器，当函数查找成功时，该迭代器指向查找到的子序列中的第一个元素；反之，如果查找失败，则该迭代器的指向和 last 迭代器相同

    1.     vector<int> revec = { 1,0,3,3,3,2,2,88,99,199};
    2.     //找3个满足Lambda 表达式的值
    3. 	auto sn = std::search_n(revec.begin(), revec.end(), 
    4.         3, 3, [](int a, int b) {return a > b; });
    5. 	cout << *sn << endl;

    输出：88               

    //因为88,99,199是连续的三个符合要求的值，返回一个指向Val=88的iterator

    2.统计查找

            ①count：区间统计

                    第三个参数要给给需要统计的元素k，返回出现的次数

    1. vector<int> revec = { 1,0,3,3,3,3,2,2,88,99,199};
    2. cout << count(revec.begin(), revec.end(), 3) << endl;

    输出：4 

            ②count_if: 条件统计个数

                    第三个参数变成一个准则(①lambda表达式(最常用)②自己的普通函数③仿函数(类的()运算符的重载))

    1. vector<int> revec = { 1,0,3,3,3,3,2,2,88,99,199};
    2. cout << count_if(revec.begin(), revec.end(), [](int x) {return x > 60; }) << endl;

    输出： 3

    //符合要求的共3个

            ③equal:比较

                    参数是两个容器(类型可以不同),逐一比较两个容器中的参数是否一一相同返回bool类型。

    1. vector<int> revec = { 1,0,3,3,3,2,2,88,99,199};
    2. list<int> myList = { 1,0,3,3,3,2,2,88,99,199 };
    3. cout << boolalpha << equal(revec.begin(), revec.end(), myList.begin(), myList.end()) << endl;

     输出：true   //容器内的元素一模一样

    3.有序查找

            注：(原容器的数据必须是有序的，否则此类算法无效->无序的可以先排序！)

            ①binary_search：

                    二分查找(找到返回1，否则0)

    1. //10.二分查找
    2. vector<int> testData = { 1,2,3,4,5,6,7,8,9 };
    3. cout << boolalpha << binary_search(testData.begin(), testData.end(), 2) << endl;

    输出： true //找到了

            ②upper_bound:大于

                    查找最后一个大于查找的值，返回值是一个迭代器,返回指向大于key的第一个值的位置

    1. vector<int> testData = { 1,2,3,4,5,6,7,8,9 };
    2. auto uper = upper_bound(testData.begin(), testData.end(), 6);
    3. cout << *uper << endl;

     输出：7  // 大于6的后面第一个位置指向7

            ③lower_bound：大于等于

                    大于等于查找的值，返回值是一个迭代器,返回指向大于等于key的第一个值的位置

    1. //大于等于
    2. vector<int> testData = { 1,2,3,4,5,6,7,8,9 };
    3. auto lower = lower_bound(testData.begin(), testData.end(), 6);
    4. cout << *lower << endl;

            ④equal_range：包含上面的两个结果

                    区间比较---有序序列(相当于合并了上面的两个结果)返回类型是pair数对类型(first和second仍然存储的是迭代器类型)。

    1. vector<int> testData = { 1,2,3,4,5,6,7,8,9 };
    2. auto pair = equal_range(testData.begin(),testData.end(), 6);
    3. cout << *pair.first << "\t" << *pair.second << endl;

    二、STL排序算法

            注意：list容器用的是内置sort()而非用以下的相关排序函数。

            1.sort():排序，更改原容器顺序

                    说明:

            ①第三个参数默认的排序准则less<>，也可以传入greater<>

            ②第三个参数也可以自己写排序准则,可以是

                    (i)lambda表达式(相对较为麻烦->要给公共接口)

                    (ii)仿函数

                    (iii)普通的函数指针)

    1. class Wbm
    2. {
    3. public:
    4. 	Wbm(string name, int age) :name(name), age(age) {}
    5. 	string& GetName()
    6. 	{
    7. 		return name;
    8. 	}
    9. 	int& GetAge()
    10. 	{
    11. 		return age;
    12. 	}
    13. 	void print()
    14. 	{
    15. 		cout << name << "\t" << age << endl;
    16. 	}
    17. protected:
    18. 	string name;
    19. 	int age;
    20. };
    21. void test_sort()
    22. {
    23. 	//1.sort
    24. 	/*①普通数据的sort*/
    25. 	vector<int> vec = { 0,3,4,2,7,3,6,3,6,432,32,2 };
    26. 	sort(vec.begin(), vec.end());
    27. 	//上述是缺省语句，等效于  传入一个仿函数
    28. 	sort(vec.begin(), vec.end(), less<int>());
    29. 	print(vec);
    30. 	sort(vec.begin(), vec.end(), greater<int>());
    31. 	print(vec);
    32. 	/*②自定义数据类型的sort*/
    33. 	vector<Wbm> bmwData;
    34. 	bmwData.push_back(Wbm("abc", 18));
    35. 	bmwData.push_back(Wbm("cca", 39));
    36. 	bmwData.push_back(Wbm("bba", 58));
    37. 	sort(bmwData.begin(), bmwData.end(), [](Wbm a, Wbm b)->bool{return a.GetAge() < b.GetAge(); });
    38. 	/*	sort(bmwData.begin(), bmwData.end(), [](Wbm a, Wbm b){return a.GetAge() < b.GetAge(); });*/
    39. 	/*lambda最简单的写法，省略掉->bool*/
    40. 	for (auto v : bmwData)
    41. 	{
    42. 		v.print();
    43. 	}
    44. 	sort(bmwData.begin(), bmwData.end(), [](Wbm a, Wbm b) {return a.GetName() < b.GetName(); });
    45. 	for (auto v : bmwData)
    46. 	{
    47. 		v.print();
    48. 	}
    49. }

    输出：

    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: 排序，保存原容器数据顺序

                    (保持元素的相对位置排序，需要给一个“模糊”的比较准则->比如实数按整数比较)

    1. //2.保持元素的相位置排序
    2. bool com_as_int(double a, double b)
    3. {
    4. 	return int(a) < int(b);
    5. }
    6. void testStableSort()
    7. {
    8. 	vector<double> num = { 1.33,2.33,1.22,3.22,3.44,3.66 };
    9. 	stable_sort(num.begin(), num.end(), com_as_int);
    10. 	print(num);
    11. }

            输出：1.33    1.22    2.33    3.22    3.44    3.66

            3.merge: 归并排序，两个有序的容器

            (也可以是一个容器的两个区间)存于新容器(不改变原容器)

    1. //3.归并排序
    2. void testMerge()
    3. {
    4. 	//3.不会更改原容器归并
    5. 	vector<int> vec = { 1,2,3,4,5,0,6,7,8,9 };
    6. 	vector<int> result(vec.size());
    7. 	merge(vec.begin(), vec.begin() + 5, vec.begin() + 5, vec.end(), result.begin());
    8. 	print(result);
    9. }

    输出：

    0       1       2       3       4       5       6       7       8       9

            4.inplace_merge: 归并排序，覆盖原区间

                    (参数1：起始位置，参数2：中间位置，参数3：结束位置)

    1. void testMerge()
    2. {
    3. 	//4.改变原容器
    4. 	vector<int> vec = { 1,2,3,4,5,0,6,7,8,9 };
    5. 	inplace_merge(vec.begin(), vec.begin() + 5, vec.end());
    6. 	print(vec);
    7. }

    输出：

    0       1       2       3       4       5       6       7       8       9

            5. nth_element: 关键字排序(选一个基准作为中间参数进行排序,注：参数1起始，参数3是末)

    1. //5.关键字排序
    2. vector<int> test = { 1,2,3,4,5,0,8,9, 6,7 };
    3. nth_element(test.begin(), test.begin() + 5, test.end());
    4. print(test);

    输出：0       1       2       3       4       5       6       7       8       9

            6. partition:范围排序(通过子函数描述的条件，返回true放到左边，返回false放到右边)

                    注：会修改原容器

    1. //6.分类处理
    2. //通过子函数描述条件，返回true放到左边 ，返回false放到右边
    3. vector<int> score = { 98,10,98,23,45,65,34,56,67 };
    4. partition(score.begin(), score.end(), [](int a) {return a > 60; });
    5. print(score);

    输出：98      67      98      65      45      23      34      56      10

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

                    (通过子函数描述的条件，返回true放到左边(同时还要保证原来的相对顺序)，返回false放到右边)

    1. void testStableSort()
    2. {
    3. 	vector<double> num = { 1.33,2.33,1.22,3.22,3.44,3.66 };
    4. 	stable_sort(num.begin(), num.end(), com_as_int);
    5. 	//print(num);
    6. 	//7.保持原容器顺序 去分类处理
    7. 	stable_partition(num.begin(), num.end(), bind(com_as_int, std::placeholders::_1, 2.0));
    8. 	print(num);
    9. }

            8. partial_sort:范围排序

                    (参数1：起始，参数2：需要排序的右端点,参数3：末位置(与参数2构成一个无序的区间))

    1. //8.局部排序
    2. vector<int> num = { 22,33,45,8,23,66,45,34,244 };
    3. partial_sort(num.begin(), num.begin() + 5, num.end());
    4. print(num);

    输出：8       22      23      33      34      66      45      45      244

    /*仅仅排序了前五个

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

                    (参数1和参数2构成需要局部排序的区间，参数3和4是一个res容器存储排完序之后的目标存储容器的区间)

    1. //9.局部排序，结果另存
    2. vector<int> num = { 22,33,45,8,23,66,45,34,244 };
    3. vector<int> result(5);
    4. partial_sort_copy(num.begin(), num.begin() + 5, result.begin(), result.end());
    5. print(result);

    输出： 8       22      23      33      34

            10.random_shuffle: 随机排序，乱序算法

                    每次结果不同，要一个随机函数种子(每次运行都不一样)(例：做拼图游戏)  

                    （两个参数，区间的起止）

    1. //10.乱序算法 ，每次结果不同，要一个随机函数种子
    2. vector<int> num = { 22,33,45,8,23,66,45,34,244 };	
    3. srand((unsigned int)time(nullptr));
    4. random_shuffle(num.begin(), num.end());
    5. print(num);

    输出： 45      23      8       33      34      66      45      22      244 

             11.reverse:逆序原容器（两个参数，区间的起止）

                    逆序原容器（两个参数，区间的起止）

    1. //11.逆序反转
    2. vector<int> re = { 1,2,3,4,5,0,8,9, 6,7 };
    3. reverse(re.begin(), re.end());
    4. print(re);

            输出：7       6       9       8       0       5       4       3       2       1

                  12.reverse_copy: 逆序容器保存到新容器  

             （3个参数->区间的起,止,需要存储容器的起始位置）

    1. //12.反转另存
    2. vector<int> re = { 1,2,3,4,5,0,8,9, 6,7 };
    3. vector<int> rec(re.size());
    4. reverse_copy(re.begin(), re.end(), rec.begin());
    5. print(rec);

            输出：7       6       9       8       0       5       4       3       2       1

    /*原来re是不变的！！！！

            13. rotate:移动元素到容器末尾

                    （3个参数->需要移动区间的起,止,目标移到哪个部分的后面，如end()）

    1. //13.移位操作
    2. vector<int> move = { 1,2,3,4,5,6 };
    3. rotate(move.begin(), move.begin() + 2, move.end());
    4. print(move);

    输出：3       4       5       6       1       2

            14. rotate_copy:移动元素到新容器(另存)

                    （4个参数->需要移动区间的起,止,目标移到哪个部分的后面-如end(),需要存储容器的起始位置）

    1. //14.移位结果另存
    2. vector<int> move = { 1,2,3,4,5,6 };
    3. vector<int> moveResult(move.size());
    4. rotate_copy(move.begin(), move.begin() + 3, move.end(), moveResult.begin());
    5. print(moveResult);

    输出：4       5       6       1       2       3

    三、删除替换算法 

            1.copy: 拷贝函数 

                    三个参数 ：原容器的起+末+目标容器的起始

                    注意：目标被拷贝到的容器，必须定长(比如list就不行！vector声明的时候要声明长度！！->常用原容器的size())

    1. //1.正向拷贝
    2. vector<int> vec = { 1,2,3,4,5,6 };
    3. vector<int> nvec(vec.size());
    4. copy(vec.begin(), vec.end(), nvec.begin());
    5. print(nvec);

    输出： 1       2       3       4       5       6

            2.copy_backward: 逆序拷贝

                    第三参数是改成末位置iter。整体的顺序和实现效果同copy

    1. //2.你想拷贝，从最后开始赋值
    2. vector<int> vec = { 1,2,3,4,5,6 };
    3. vector<int> rvec(vec.size());
    4. copy_backward(vec.begin(), vec.end(), rvec.end());
    5. print(rvec);

    输出：1       2       3       4       5       6

            3.remove: 删除->伪删除(往前依次移动1个位置，size()大小不变)

    1. //3.删除--->伪删除
    2. vector<int> vec = { 1,2,3,3,4,5,3,6 };
    3. auto it = remove(vec.begin(), vec.end(), 3);
    4. cout << vec.size() << endl;
    5. print(vec);

    输出： 8        //元素个数不变
    1       2       4       5       6       5       3       6//仅删除第一次遇到的连续的目标需要的val，后面的val就不会删除了——>可以先排序！

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

                    (4个参数,原容器的起始+末+目标容器起始+目标删除元素）

    1. 	//4.伪删除结果另存
    2. 	vector<int> vec = { 1,2,3,4,5,6 };
    3. 	vector<int> result(vec.size() - 1);
    4. 	remove_copy(vec.begin(), vec.end(), result.begin(), 2);
    5. 	print(result);

    输出： 1       3       4       5       6

            5.remove_if:条件删除

                    --->仅仅是把不符合要求的结果放到容器的后面（ 三个参数：始末+计算准则）（remove_if常和erase一起出现实现真正的删除or用下面的copy）删除

    1.     //5.条件删除 remove_if
    2. 	vector<int> score = { 98,45,65,77,45,43 };
    3. 	remove_if(score.begin(), score.end(), [](int x) {return x < 60; });
    4. 	print(score);//先打印大于等于60分的人，最后面一部分是不符合要求的，

    输出： 98      65      77      77      45      43

            6.remove_copy_if:条件删除拷贝到新容器(实现真正的删除)

                    ->应用：将及格的人真正筛选出来（四个参数->（起+末+目标容器的起+计算准则））

    1.     //6.条件删除结果另存
    2. 	vector<int> score = { 98,45,65,77,45,43 };
    3. 	vector<int> ok(count_if(score.begin(), score.end(),
    4.  [](int x) {return x >= 60; }));
    5. 	remove_copy_if(score.begin(), score.end(), ok.begin(), 
    6.  [](int x) {return x < 60; });
    7. 	print(ok);

     输出：98      65      77

    //注意这里搞定长vector的时候，用到了count_if得知要开多大的vector

            7.replace:替换 

                    ->四个参数，(始+末+原始需要替换的数据+需要修改成的数据)  all替换

    1. 	//7.替换算法(修改) replace
    2. 	vector<int> rep = { 1,2,3,4,5,6,7,1,2,3,1,2,3 };
    3. 	replace(rep.begin(), rep.end(), 1, 100);
    4. 	print(rep);

    输出： 100     2       3       4       5       6       7       100     2       3       100     2       3

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

                    ->5个参数(始+末+目标容器的起始位置+原始需要替换的数据+需要修改成的数据)

    1. 	//8.替换后结果另存
    2.     vector<int> rep = { 1,2,3,4,5,6,7,1,2,3,1,2,3 };
    3. 	vector<int> repc(rep.size());
    4. 	replace_copy(rep.begin(), rep.end(), repc.begin(), 1, 0);/*1->0*/
    5. 	print(repc);

    输出： 0       2       3       4       5       6       7       0       2       3       0       2

            9.replace_if: 条件替换

                      ->四个参数（区间起+始+计算准则+符合要求的目标data需要替换成的值）

    1.     //9.条件替换
    2. 	vector<int> rep = { 1,2,3,4,5,6,7,1,2,3,1,2,3 };
    3. 	replace_if(rep.begin(), rep.end(), [](int x) {return x < 6; }, 0);
    4. 	print(rep);

    输出： 0       0       0       0       0       6       7       0       0       0       0       0       0

            10.replace_copy_if:条件替换,结果另存

                    ->五个参数(起+末+目标容器的起始+计算准则+更换成目标的Val)

    1.      //10.条件替换，结果另存
    2. 	vector<int> rep = { 0,2,3,4,5,6,7,0,2,3,0,2,3 };
    3. 	vector<int> repif(rep.size());
    4. 	replace_copy_if(rep.begin(), rep.end(), repif.begin(),
    5. 		[](int x) {return x == 0; }, 1);
    6. 	print(repif);

    输出： 1       2       3       4       5       6       7       1       2       3       1       2       3

            11.iter_swap: 交换:  交换两个迭代器所指向元素

    1.     //11.交换 iter_swap
    2. 	vector<int> test = { 11,2,3,4,5,6,7,8,9 };
    3. 	iter_swap(test.begin(), test.end() - 1);
    4. 	print(test);

    输出： 9       2       3       4       5       6       7       8       11

            12.swap: 交换

                    ->最妙的地方：不需要两个容器size一样

                     注意：底层是实例化为同一种数据类型的vector容器(故两个不相同数据类型是不能够进行交换的)     参数（容器1名，容器2名）

    1. 	//12.swap 不需要两个容器长度一样
    2.     vector<int> test = { 11,2,3,4,5,6,7,8,9 };
    3. 	vector<int> test2 = { 2,2 };
    4. 	swap(test, test2);
    5. 	print(test);	
    6. 	print(test2);

    输出：

    2       2
    11      2       3       4       5       6       7       8       9

            13.swap_ranges:区间交换        

                    ->3个参数(容器1的某区间的起始+last位置+容器2需要修改起始位置)

    1. 	//13.区间交换  swap_range
    2. 	vector<int> test = { 11,2,3,4,5,6,7,8,9 };
    3. 	vector<int> test2 = { 2,2 };              
    4. 	swap_ranges(test2.begin(), test2.begin() + 1, test.begin());
    5. 	print(test2);

    输出：

     2       2       3       4       5       6       7       8       9
    11      2

            14.unique:去”重“ (起末区间)

                    ->连续相同保留一个，想要去重可以先排序，再调用 =>真去重->放到set容器中

    1. 	//14.去重(连续相同保留一个)  想要去重可以先排序，在调用
    2. 	vector<int> uniq = { 1,1,3,4,4,3,3,2,2,2,4,4,4 };
    3. 	unique(uniq.begin(), uniq.end());
    4. 	print(uniq);

    输出： 1       3       4       3       2       4       3       2       2       2       4       4       4

    1. //14.去重(连续相同保留一个)  想要去重可以先排序，在调用
    2. 	vector<int> uniq = { 1,1,3,4,4,3,3,2,2,2,4,4,4 };
    3. 	sort(uniq.begin(), uniq.end());
    4. 	print(uniq);
    5. 	unique(uniq.begin(), uniq.end());
    6. 	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食用更佳！！！

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

    输出： 

    1       2       3       4
    1       2       3       4       0       0

                   注意：看uniqr2的后两个数值，均为0！(因为排完序了，再调用此函数方能达到真正的去重效果，另存到此，后面两个元素为默认值0！)

                   

  • 相关阅读:
    拉格朗日插值法+python实现
    js匹配查找JSON中属性并返回路径
    RTQ2117C-QA多协议USB Type-C车载快充(RTQ2117C)
    vue 浅解watch cli computed props ref vue slot axios nexttick devtools说明使用
    智能网联汽车道路试验监管系统技术要求
    Linux：kubernetes（k8s）有状态的服务部署（14）
    远程连接PostgreSQL：配置指南与安全建议
    Prism 入门03，模块化介绍使用
    禁止methtype联网
    2022年海外电商运营三大关键讲解
  • 原文地址：https://blog.csdn.net/zjjaibc/article/details/125524612