algorithm 内的方法的用法

最新推荐文章于 2022-08-03 17:11:42 发布

蓝鲸

最新推荐文章于 2022-08-03 17:11:42 发布

阅读量415

点赞数

文章标签： STL algorithm

本文链接：https://blog.csdn.net/qq_42635159/article/details/88383986

版权

adjacent_find():

(1)第一种用法:

adjacent_find(it1,it2);其中it1/it2都是同一个向量的迭代器,并且该语法的作用是寻找该范围中第一个出现的相同的两个元素的第一个元素的迭代器
int s[12]={1,1,2,2,3,4,5,6,6,73,4,5};
vectorvi;
vi.insert(vi.begin(),s,s+11);
vector::iterator it;
it=adjacent_find(vi.begin(),vi.end());
cout<<*it;

在这里插入图片描述
(2)第二种用法:

使用二元断言//我对二元还不太懂大概意思就是自己设计一个bool型函数(因为是断言，也就是只返回true或false)并且只传入两个参数(达到二元的目的),然后自己可以在函数内定义前后两者之间的关系来返回数据

    bool function(int i,int j){
    	return(i==j+1);
    }
    int main(){
    	int s[12]={3,1,1,2,3,2,5,6,6,73,4,5};
    	vector<int>vi;
    	vi.insert(vi.begin(),s,s+11);
    	vector<int>::iterator it;
    	it=adjacent_find(vi.begin(),vi.end(),function);
    	cout<<*it;
    	return 0;
    }

在这里我设置了断言是当前一个数据是后边数据加1时返回true那么it则会指向第一个符合该断言的数据
注意当搜索不到符合二元断言或没有连续的两个数时迭代器会指向vi.end(); 而只有经过it–;后 *it才是最后一个数据。
在这里插入图片描述
binary_search():
(1)首先该方法返回bool类型数据
可以有这种用法：binary_search(it1,it2,k);
该句语法的含义是在it1到it2迭代器之间的数据包括it1不包括it2查找k数据若查找成功返回真否则返回假，
需要注意的一点是:必须在查找前将该组数据进行升序排序。
(2)还有另一种用法：binary_search(it1,it2,k,function());
其中function()是自己定义的二元函数；
经过多组测试在使用第二种方法时可以不用排序，但是在二元函数中不能出现==、>=、<=、比较符号只能出现<、>比较符号。

copy():

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

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

这种用法在insert()方法总同样可以运用。

copy_backward():
它只有一种用法:
copy_backward(it1,it2,it3);
它的意思是将it1到it2之间的数据复制后从it3指代位置往前赋值当要赋值的位置有数据时会覆盖原来的数据，位置不够时能赋值多少赋值多少。

#include <iostream>     // std::cout
#include <algorithm>    // std::copy_backward
#include <vector>       // std::vector

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

  // set some values:
  for (int i=1; i<=5; i++)
    myvector.push_back(i*10);          // myvector: 10 20 30 40 50

  myvector.resize(myvector.size()+3);  // allocate space for 3 more elements

  std::copy_backward ( myvector.begin(), myvector.begin()+5, myvector.end() );

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

  return 0;
  //Output:
//myvector contains: 10 20 30 10 20 30 40 50

count():
该方法可以查找指定位置之间某数据的个数：

#include <iostream>     // std::cout
#include <algorithm>    // std::count
#include <vector>       // std::vector

int main () {
  // counting elements in array:
  int myints[] = {10,20,30,30,20,10,10,20};   // 8 elements
  int mycount = std::count (myints, myints+8, 10);
  std::cout << "10 appears " << mycount << " times.\n";

  // counting elements in container:
  std::vector<int> myvector (myints, myints+8);
  mycount = std::count (myvector.begin(), myvector.end(), 20);
  std::cout << "20 appears " << mycount  << " times.\n";

  return 0;
}
//Output:
//10 appears 3 times.
//20 appears 3 times

count_if():

它与count()的区别就是它能在count()方法中加入一个一元断言：

#include <iostream>     // std::cout
#include <algorithm>    // std::count_if
#include <vector>       // std::vector

bool IsOdd (int i) { return ((i%2)==1); }

int main () {
  std::vector<int> myvector;
  for (int i=1; i<10; i++) myvector.push_back(i); // myvector: 1 2 3 4 5 6 7 8 9

  int mycount = count_if (myvector.begin(), myvector.end(), IsOdd);
  std::cout << "myvector contains " << mycount  << " odd values.\n";

  return 0;
}
//Output:
//myvector contains 5 odd values

equal():
有两种用法
一是不加二元断言的向量与数组进行比较的方式，它们要数量相同，类型相同，如果它们每一个元素都相同那么返回真
二是可以在原来的条件上加上二元断言如果每一个元素都符合二元断言那么就返回真。

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
bool asd(int i,int j){
	return (j==i+1);
}
int main(){
	int m[]={20,40,60,80,100};
	vector<int>s(m,m+5);

	if(equal(s.begin(),s.end(),m))cout<<"666";
	else cout<<"555";
	
	cout<<endl;
	
	m[0]=21;
	m[1]=41;
	m[2]=61;
	m[3]=81;
	m[4]=101;
	if(equal(s.begin(),s.end(),m,asd))cout<<"666";
	else cout<<"555";
} 
//output:666
  //     666

equal_range():
适用于有顺序的向量若果（当然在不排序的情况下也是可以用的），虽然该方法有默认用法和二元断言方法，这里这里只讲二元断言因为默认的就是前值小于后值的情况
在排序的情况下：
用反向迭代器bounds接受equal_range()返回的数据。
而且在比较的关系中迭代器始终指向较小的数据
bounds.first,指向的第一个符合二元断言的两个数中的较小的一个
bounds.second,指向的第二个符合二元断言的两个数中的较小的一个
而且注意在比较中都要包含特定的k即语法;
equal_range(it1,it2,k,myfuction);

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
bool asd(int i,int j){
	return (i>j);
}
int main(){
	int m[]={10,20,30,30,20,10,10,20};
	vector<int>s(m,m+8);//10 10 10 20 20 20 30 30
	pair<vector<int>::iterator,vector<int>::iterator>bounds;
	sort(s.begin(),s.end());
	bounds=equal_range(s.begin(),s.end(),10);
	cout<<bounds.first-s.begin()<<endl;
	cout<<bounds.second-s.begin();cout<<endl;
	sort(s.begin(),s.end(),asd);//30 30 20 20 20 10 10 10
	
bounds=equal_range(s.begin(),s.end(),10,asd); 
cout<<bounds.first-s.begin()<<endl;
	cout<<bounds.second-s.begin();	
	return 0;
} 
//output:0
//       3
//       5
//       8

fill()与fill_n():

fill()的用法fill(it1,it2,k);it1和it2是指代某向量的迭代器,k是该向量同类的元素，该语句表示在it1到it2之间充满k元素
fill_n()用法：
fill_n(it1,n,k); it1是指代某向量的迭代器n表示的个数，k是该向量的同类的元素。
该语句表示的是从it1指代的位置开始在往后边的n为都变为k。

find()、find_if()、find_end()、find_first_of()：

find()用法：find(array,array+n,k)在该数组中从开始到n位置查找第一个与k相同的数据的迭代器。其中前两项也可以是迭代器 find_if()用法与find()类似只是k元素的位置换成了二元断言 find_end()用法：用于查找子序列 find_end(it1,it2,n1,n1+n);it1和it2分别是指代某向量的迭代器,而n1表示的是数组名所以n1~n1+n表示的是一个子序列当在向量中能找到该子序列时，返回最后一个子序列的起始的迭代器;而且还可以再在其中加入二元断言不等式二元断言等式二元断言都行。 find_first_of()与find_end()类似只是该方法查找的是第一个符合条件的子序列的第一个迭代器

for_each():

第一种用法for(it1,it2,fuction);it1是向量的迭代器,fution()是自己定义的一元函数并且是依次将迭代器指向的内容依次传入的也就是*it,并可以在一元函数内做一些操作
第二种用法就是对象类型函数用法即传入的一元函数可以是这种类型的：
struct myclass{
void operator()(int i){ //语句 }
}myobject; myobject可以代替fuction的位置

generator()、generator_n()

generator(),作为一个发生器第一种用法：
generator(it1,it2,fuction);it1、it2，仍然是向量的迭代器,而fuction是无参有返回值的自定义函数，返回值用于给迭代器执行的位置赋值。
fuction的位置同样可以放置对象类函数。
generator_n()用于对数组进行这样的操作，generator(array,k,fuction);
array是数组名，k代表的是前k个数据,fuction仍然是无参的有返回值的自定义的函数

inplace_merge():

该函数是归并函数，简单来说是
在某一向量中在某一元素之前包括该元素以排序，在该元素之后也排序，且前后两种排序规则相同:
inplace_merge(it1,it2,it3);这三个迭代器分别是设定的初始位置、中间位置、末端位置。
详情还可以查询：https://blog.csdn.net/guang_jing/article/details/39316757

iter_swap():

该方法用于交换迭代器指向的两个元素,可以是同一个向量中的也可以是不同向量的，还可以是还可以数组名+k形式表示的是数组的第k个元素。
以达到交换元素的目的。

lower_bound()、upper_bound():

该两个方法表示的是上下界的关系,并且返回的是迭代器，
下面的程序就是表示经过排序之后，寻找同一元素的上下界,分别得到相应的迭代器之后，减去begin()迭代器就得到上下界的位置。

#include <iostream>     // std::cout
#include <algorithm>    // std::lower_bound, std::upper_bound, std::sort
#include <vector>       // std::vector

int main () {
  int myints[] = {10,20,30,30,20,10,10,20};
  std::vector<int> v(myints,myints+8);           // 10 20 30 30 20 10 10 20

  std::sort (v.begin(), v.end());                // 10 10 10 20 20 20 30 30

  std::vector<int>::iterator low,up;
  low=std::lower_bound (v.begin(), v.end(), 20); //          ^
  up= std::upper_bound (v.begin(), v.end(), 20); //                   ^

  std::cout << "lower_bound at position " << (low- v.begin()) << '\n';
  std::cout << "upper_bound at position " << (up - v.begin()) << '\n';

  return 0;
}

//Output:
//lower_bound at position 3
//upper_bound at position 6

make_heap、push_heap、pop_heap、sort_heap：

make_heap: 根据指定的迭代器区间以及一个可选的比较函数，来创建一个heap. O(N)
push_heap: 把指定区间的最后一个元素插入到heap中. O(logN)
pop_heap: 弹出heap顶元素, 将其放置于区间末尾. O(logN)
sort_heap：堆排序算法，通常通过反复调用pop_heap来实现. N*O(logN)
转自：https://www.cnblogs.com/deathmr/p/9015644.html

max_element()、min_element()

这两个方法分别球数组或向量中的最大值最小值。
只需要传入数组的范围或向量的迭代器就行。
还可以传入二元断言但我就得没必要只要使用默认的就行，当加入特别的二元断言的时候不一定是在求最大最小值。

merge():

merge();“结合”方法：

	int s[]={4,12,76,323,1},m[]={6,21,9,3,1};
	vector<int>ve(10);
	  merge(s,s+5,m,m+5,ve.begin());
	  vector<int>:: iterator it;
	  for(it=ve.begin();it!=ve.end();it++)
	  cout<<*it<<" ";
	  //output:4 6 12 21 9 31 76 323 1

而且在结合之前一定要分配好空间
可见结合的方法是先同时比较第一个元素的大小，先插入小的在插入大的，在向下进行比较插入。

mismatch():

“配错”方法，返回反向迭代器，原理是：通过比较对应位置，返回不符合条件的迭代器，并且可以加入二元断言：

// mismatch algorithm example
#include <iostream>     // std::cout
#include <algorithm>    // std::mismatch
#include <vector>       // std::vector
#include <utility>      // std::pair

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

int main () {
  std::vector<int> myvector;
  for (int i=1; i<6; i++) myvector.push_back (i*10); // myvector: 10 20 30 40 50

  int myints[] = {10,20,80,320,1024};                //   myints: 10 20 80 320 1024

  std::pair<std::vector<int>::iterator,int*> mypair;

  // using default comparison:
  mypair = std::mismatch (myvector.begin(), myvector.end(), myints);
  std::cout << "First mismatching elements: " << *mypair.first;
  std::cout << " and " << *mypair.second << '\n';

  ++mypair.first; ++mypair.second;

  // using predicate comparison:
  mypair = std::mismatch (mypair.first, myvector.end(), mypair.second, mypredicate);
  std::cout << "Second mismatching elements: " << *mypair.first;
  std::cout << " and " << *mypair.second << '\n';

  return 0;
}
//Edit & Run
//

//Output:
//First mismatching elements: 30 and 80
//Second mismatching elements: 40 and 320

next_permutation()、prev_permutation():

next_permutation()该方法是进行排列的，并且是遵循一定规则的，首先要理解全排列问题，该方法是由当前存储的状态，到最终的状态结束并返回false。而prev_permutation();则是一相反的排序方法进行排序的。

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
int main(){
	vector<int>ve;
	ve.push_back(2);
	ve.push_back(1);
	ve.push_back(3);
	ve.push_back(4);
	
	
	do{
		vector<int>::iterator it;
		for(it=ve.begin();it!=ve.end();it++)
		cout<<*it<<" ";
		cout<<endl;
		
		
		
	}while(next_permutation(ve.begin(),ve.end()));
	
	
	return 0;
	
	
	
}

在这里插入图片描述

nth_element():

用法：nth_element(it1,it2,it3);it1,it3表示指代的范围，而it2表示具体的指代的对象，该方法能将小于it2指代的元素的都放到前边，大于的都放到后边但不排序，自己也可以定义二元断言，将大于的放到前边，默认的是（i < j）;

partial_sort()：

该方法用于将部分元素进行排序，用法：
partial_sort(it1,it2,it3);该三个迭代器都是指向同一个容器的，该语句表示的是在it1到it3指代的范围内只将it1到it2之间的元素进行排序。同样可以自己设计二元断言进行升序或降序排列。

partial_sort_copy():

用法：partial_sort_copy(it1,it2,it3,it4)；
表示的是首先取出it1到it2之间的元素，可以自己二元断言进行升序排列或降序排列，放入到另一容器中的it3到it4的范围内：
注意的是后一容器应是在定义时设置好容器大小并没有赋值,若要插入的元素的个数大于后一容器的大小则插入的个数以提前设置的大小为准。

partition():

该“分裂”方法用法：
partition(it1,it2,fuction);
表示的是在it1到it2指代的元素的范围内进行分类,符合一元断言fuction的在前边，并返回一个迭代器并且是从返回的迭代器开始到it2指代的位置是不符合一元断言的元素。

random_shuffle():

通过输入两个迭代器，将会打乱该范围内的元素。

remove()、remove_if()、remove_copy()、remove_copy_if():

remove(it1,it2,k);在it1到it2范围内删除所有k元素。
remove_if();就是在remove的基础删可以在k的位置换成一元断言。
remove_copy(it1,it2,it3,k);表示的是将迭代器指代的范围内删除k元素后删除位置进行前移空出位置赋初始值，即保持元素的个数不变，在原来it3指代位置开始插入并将原来的元素“挤”到后边，经过测试如果原来有元素且大小确定时在该语句之后大小变的不定了，因此最保险的用法就是在定义时设置好大小，并不赋值。
remove_copy_if()，就是在remove_copy()中可以将k元素的地方换成一元断言。

replace()、replace_if()、replace_copy()、replace_copy_if():

replace():replace(it1,it2,k1,k2)，在该范围内中所有k1值都替代k2； replace_if();即可在上句中k1的位置加入一元断言 replace_copy()、replace_copy_if() 可与remove_copy()、remove_copy_if()类比。

reverse()、reverse_copy():

该“翻转方法”
reverse(it1,it2);将该范围内的元素进行翻转。
reverse(it1,it2,it3);将范围内的元素翻转后在令一容器中it3指代的位置进行插入。

rotate()、rotate_copy():

rotate(it1,it2,it3);it1到it3是指要进行翻转的范围,而it2是指要翻转的翻转点。
rotate(it1,it2,it3,it4)；其中it1、it2、it4与上文的内容是对应的，而it3是新容器的迭代器。

search()、search_n():

用法：search(it1,it2,it3,it4);it1、it2表示的是一个s1容器的两个迭代器这样就形成了一个范围,it3、it4是另一个s2容器的迭代器,该语句就是判断在s2容器的范围中是否有容器s1范围中的元素，若有返回s2中那一串元素的第一个元素否则返回最后一个元素。
用法：search(it1,it2,k,n);表示在该范围内若有一连串的n个k则返回这一系列的第一个元素的迭代器，否则指向最后的迭代器,可以使用二元断言,但目前还没搞懂它的用法。

set_difference()、set_intersection()、set_symmetric_difference()、set_union()

set_difference();表示的是差集的意思。
set_difference(it1,it2,it3,it4,it5)；it1、it2可以是指向s1的容器也可以是数组;
it3,it4也可以是指向s2容器或数组,it3是指向s3容器的。并且前两个容器一定要是有大到小有序的
该语句表示的是从s1容器的范围中一个一个的取出元素与s2容器范围中的元素一一对比若没有对应的元素则插入到s3容器中。
set_intersection()则表示的交集的意思因此可以类比上面。
set_symmetric_difference()；与set_difference()的不同的区别是差集只是找到前一个容器中有而另一个容器中没有的元素插入.
而该语法是对称差集，即后一个容器中有的元素前一个容器中没有的也要插入。
set_union()表示的是并集即包含前后两容器的元素但不重复,语法与上面相同.
它们都是在有顺序的情况下进行操作的。

sort():

能对向量容器和数组进行排序，并可以通过设置二元断言进行升序或降序排列。

stable_partition()

用法：
stable_partition(it1,it2,fuction);
该语句返回一个迭代器it3，在it1到it3之间是符合一元断言的数据,it3到it2是不符合的数据。

蓝鲸

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
algorithm 内的方法的用法

adjacent_find():(1)第一种用法:adjacent_find(it1,it2);其中it1/it2都是同一个向量的迭代器,并且该语法的作用是寻找该范围中第一个出现的相同的两个元素的第一个元素的迭代器int s[12]={1,1,2,2,3,4,5,6,6,73,4,5};vectorvi;vi.insert(vi.begin(),s,s+11);vector::i...
复制链接

扫一扫