STL算法总结之查找算法示例

STL算法总结之查找算法示例

1.adjacent_find：

// 所有容器适用(线性的)
adjacent_find(begin,end);
adjacent_find(begin,end,Predicate);

在范围[first,last)之间寻找第一次出现的两个连续相等的元素，如果存在，则返回指向第一个元素迭代器，否则返回last.还可以使用自己定义的二元断言（就是自定义的判断方法）

#include<vector>
#include<iostream>
#include<stdio.h>
#include<algorithm>
using namespace std;
/**
自定义的方法，判断的相等的条件是
i=j*2
*/
bool myfunction (int i, int j){
return (i==j*2);
}
/**
//所有容器适用(线性的)
adjacent_find(b,e);
adjacent_find(b,e,p);

在范围[first,last)之间寻找第一次出现的两个
连续相等的元素，如果存在，则返回指向第一个元素迭代器，否则返回last.
还可以使用自己定义的判断方法
*/
int main(){
int myints[] = {10,20,30,30,40,20,10,20};
//将数组中的元素录入myvector
vector<int> myvector (myints,myints+8);
vector<int>::iterator it;//迭代器

printf("初始元素\n");
for(it=myvector.begin();it!=myvector.end();++it)
cout<<*it<<" ";
cout<<endl;

//使用默认的比较方法
it = adjacent_find (myvector.begin(), myvector.end());

if (it!=myvector.end())
cout << "第一个连续的元素是: " << *it << endl;

//使用自定义的比较方法
it = adjacent_find (myvector.begin(), myvector.end(), myfunction);

if (it!=myvector.end())
cout << "第二个连续的元素是: " << *it << endl;

return 0;
}
/*****
Output
初始元素
10 20 30 30 40 20 10 20
第一个连续的元素是: 30
第二个连续的元素是: 40
*/

2.binary_search和includes：

binary_search()  //二分查找，返回bool值，
binary_search(begin,end,value);
binary_search(begin,end,value,cmp);

includes()  //包含查找，判断容器是否是包含关系，返回bool值。
includes(begin1,end1,begin2,end2);
includes(begin1,end1,begin2,end2,cmp);

binary_search():如果在[first,end)范围内存在任一元素和val相等，则返回true,

否则返回false.必须是已经排序的容器

includes():两个区间必须已经排序，判断区间1是否包含区间2，范围同样是[first,end)

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;
/**
//所有容器适用(O(log(n)))
已序区间查找算法
binary_search()  //二分查找，返回bool值，
binary_search(begin,end,value);
binary_search(begin,end,value,cmp);

includes()  //包含查找，判断容器是否是包含关系，返回bool值。
includes(begin1,end1,begin2,end2);
includes(begin1,end1,begin2,end2,cmp);
*/
bool myfunction (int i,int j){
return (i<j);
}
int main(){
int myints[] = {1,2,3,4,5,4,3,2,1};
vector<int> v(myints,myints+9);  // 1 2 3 4 5 4 3 2 1

//使用默认的比较
sort (v.begin(), v.end());

cout << "查找 3...  ";
if (binary_search (v.begin(), v.end(), 3))
cout << "发现!\n"; else cout << "没有发现.\n";

//使用自定义的比较
sort (v.begin(), v.end(), myfunction);

cout << "查找 6... ";
if (binary_search (v.begin(), v.end(), 6, myfunction))
cout << "发现!\n"; else cout << "没有发现.\n";
cout<<endl;
/**----------------------------includes()容器包含查找---------------------------**/
int container[] = {5,15,10,25,20,35,30,50,45,40};
int continent[] = {40,30,20,10};

sort (container,container+10);
sort (continent,continent+4);

//使用默认的比较
if ( includes(container,container+10,continent,continent+4) )
cout << "容器container 包含容器continent!" << endl;

//使用自定义的比较
if ( includes(container,container+10,continent,continent+4, myfunction) )
cout << "容器container 包含容器continent!" << endl;

return 0;
}

/**
Output
查找 3...  发现!
查找 6... 没有发现.

容器container 包含容器continent!
容器container 包含容器continent!
*/

3.count和count_if：

count：
count (begin,end,value);
count_if：
count_if (begin,end,predicate);

关联容器的等效成员函数
set.count
multiset.count
map.count
multimap.count

count：这个函数使用一对迭代器和一个值做参数，返回这个值出现次数的统计结果

count_if：返回区间中满足指定条件的元素数目

#include<iostream>
#include<vector>
#include<set>
#include<algorithm>
using namespace std;
/**
奇数
*/
bool IsOdd (int i){
return i&1;
}
int main(){
int mycount;

// 数组计数元素
int myints[] = {10,20,30,30,20,10,10,20};  //8个元素
mycount = (int) count (myints, myints+8, 10);
cout << "10 出现 " << mycount << " 次.\n";

//新建一个vector
vector<int> myvector (myints, myints+8);
mycount = (int) count (myvector.begin(), myvector.end(), 20);//有几个20
cout << "20 出现 " << mycount  << " 次.\n";

/****************
Output:
10 出现 3 次.
20 出现 3 次.
****************/

//清除vector
myvector.clear();
for (int i=1; i<10; i++) myvector.push_back(i); // myvector: 1 2 3 4 5 6 7 8 9

cout<<"\nmyvector: 1 2 3 4 5 6 7 8 9 \n";
//    mycount = (int) count_if (myvector.begin(), myvector.end(), IsOdd);
mycount = (int) count_if (myvector.begin(), myvector.end(), bind2nd(modulus<int>(),2));//表示param1 % 2
cout << "myvector 包含 " << mycount  << " 奇数元素.\n";//奇数
//  如果求偶数的个数                                            not1,1表示一个参数取反
mycount = (int) count_if (myvector.begin(), myvector.end(), not1(bind2nd(modulus<int>(),2)));//表示!(param1 % 2)
cout << "myvector 包含 " << mycount  << " 偶数元素.\n";//偶数
/****************
Output:
myvector 包含 5 奇数元素.
****************/
//                                               函数适配器  函数对象
//         bind2nd(op,value);表示绑定第二个数                   param1 > 4  这里表示统计大于4的个数
mycount=count_if(myvector.begin(),myvector.end(),bind2nd(greater<int>(),4));
cout<<"有"<<mycount<<"个数大于4"<<endl;
//拓展练习                                                      4 > param2
mycount=count_if(myvector.begin(),myvector.end(),bind1st(greater<int>(),4));
cout<<"有"<<mycount<<"个数小于4"<<endl;
//                                                              4 < param2
mycount=count_if(myvector.begin(),myvector.end(),bind1st(less<int>(),4));
cout<<"有"<<mycount<<"个数大于4"<<endl;
//                                                              param1 >= 4
mycount=count_if(myvector.begin(),myvector.end(),bind2nd(greater_equal<int>(),4));
cout<<"有"<<mycount<<"个数大于等于4"<<endl;
//                                                              param1 <= 4
mycount=count_if(myvector.begin(),myvector.end(),bind2nd(less_equal<int>(),4));
cout<<"有"<<mycount<<"个数小于等于4"<<endl;

/****关联容器****/
multiset<int> ms(myvector.begin(),myvector.end());
ms.insert(myvector.begin(),myvector.begin()+6);
ms.insert(myvector.begin(),myvector.begin()+4);
ms.insert(myvector.begin(),myvector.begin()+2);
ms.insert(1);

multiset<int>::iterator ims=ms.begin();
while(ims!=ms.end()){
cout<<*ims++<<" ";
}cout<<endl;

//两种方法求1的个数
int cnt=count(ms.begin(),ms.end(),1);//所有容器适用但是比较慢些
cout<<"multiset里有"<<cnt<<"个1."<<endl;

cnt=ms.count(1);//关联容器专享   set已经排序可以快速计数
cout<<"multiset里有"<<cnt<<"个1."<<endl;

return 0;
}

4.lower_bound，upper_bound，equal_range：

所有容器适用(O(log(n)))    已序区间查找算法

lower_bound()  //找第一个符合的元素，返回位置迭代器
lower_bound (begin,end,value);
lower_bound (begin,end,value,cmp);

upper_bound()  //找最后一个符合的元素，返回位置迭代器
upper_bound (begin,end,value);
upper_bound (begin,end,value,cmp);

equal_range()  //找一对迭代器pair(<>,<>),查找到一个区间
equal_range (begin,end,value);
equal_range (begin,end,value,cmp);

关联式容器有等效的成员函数，性能更佳

lower_bound() 找第一个符合的元素，返回位置迭代器
upper_bound() 找最后一个符合的元素，返回位置迭代器
equal_range() 在[first,last)之中找出符合的元素的最大子区间

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
/**
判断i是否比j大
*/
bool mygreater(int i,int j){
return (i>j);
}
int main(){
int myints[] = {10,20,30,30,20,10,10,20};
vector<int> v(myints,myints+8);  // 10 20 30 30 20 10 10 20
vector<int>::iterator low,up;

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

cout<<"10 10 10 20 20 20 30 30\n";

low=lower_bound (v.begin(), v.end(), 20); //          ^
up= upper_bound (v.begin(), v.end(), 20); //                   ^

cout << "20 lower_bound at position " << int(low- v.begin()) + 1 << endl;
cout << "20 upper_bound at position " << int(up - v.begin()) + 1 << endl;

cout << endl;

/**-------------------------------------------------------------------------------**/

pair<vector<int>::iterator,vector<int>::iterator> bounds;

//使用默认的比较方法
//  sort (v.begin(), v.end());  // 10 10 10 20 20 20 30 30
bounds=equal_range (v.begin(), v.end(), 20);  //          ^        ^
cout<<"10 10 10 20 20 20 30 30\n";
cout << "20 bounds at positions " << int(bounds.first - v.begin());
cout << " and " << int(bounds.second - v.begin()) << endl;

// using "mygreater" as comp:
sort (v.begin(), v.end(), mygreater);  // 30 30 20 20 20 10 10 10
bounds=equal_range (v.begin(), v.end(), 20, mygreater); //       ^        ^

cout<<endl<<"30 30 20 20 20 10 10 10"<<endl;

cout << "20 bounds at positions " << int(bounds.first - v.begin());
cout << " and " << int(bounds.second - v.begin()) << endl;

return 0;
}
/******
Output:
10 10 10 20 20 20 30 30
20 lower_bound at position 4
20 upper_bound at position 7

10 10 10 20 20 20 30 30
bounds at positions 3 and 6

30 30 20 20 20 10 10 10
bounds at positions 2 and 5
*/