c++的查找算法总结

一1：find 算法函数：

• 函数原型：template<class InputIterator, class T> InputIterator find(InputIterator first, InputIterator last, const T& value);
• 功能：在指定范围 [first, last) 内查找第一个等于 value 的元素。
• 返回值：如果找到，则返回指向该元素的迭代器；如果找不到，则返回 last。

• find_if 算法函数：

• 2：find_if算法函数

• 函数原型：template<class InputIterator, class UnaryPredicate> InputIterator find_if(InputIterator first, InputIterator last, UnaryPredicate pred);
• 功能：在指定范围 [first, last) 内查找第一个满足谓词 pred 的元素。
• 返回值：如如果找到，则返回指向该元素的迭代器；如果找不到，则返回 last。

  bool myprint(int val)
  {
  	return val > 30;
  }
  void test01()
  {
  	vector<int>v;
  	v.push_back(1);
  	v.push_back(23);
  	v.push_back(54);
  	v.push_back(22);
  	v.push_back(88);
  	vector<int>::iterator it = find(v.begin(), v.end(), 20);
  	//find部分源码
  	/*for (; _First != _Last; ++_First) {
  		if (*_First == _Val) {
  			break;
  		}
  	}*/
  	if (it == v.end())
  	{
  		cout << "查找失败" << endl;
  	}
  	else
  	{
  		cout << "查找成功" << *it << endl;
  	}
  	//查找失败
  	//find_if部分源码
  	/*for (; _UFirst != _ULast; ++_UFirst) {
  		if (_Pred(*_UFirst)) //返回bool类型
  		{
  			break;
  		}
  	}*/
  	it = find_if(v.begin(), v.end(), myprint);
  	if (it == v.end())
  	{
  		cout << "查找失败" << endl;
  	}
  	else
  	{
  		cout << "查找成功" << *it << endl;
  	}
  	//查找成功54
  }
  //查找对象
  class maker
  {
  public:
  	maker(string name, int age)
  	{
  		this->name = name;
  		this->age = age;
  	}
  	bool operator==(const maker& m)
  	{
  		return this->name == m.name && this->age == m.age;
  	}
  public:
  	string name;
  	int age;
  };
  //struct myfunc
  //{
  //	bool operator()(const maker& m)
  //	{
  //		return m.name == "aaa" && m.age == 19;//这样就写死了，因此使用适配器
  //	}
  //};
  //使用适配器
  struct myfunc:public binary_function<maker,maker,bool>
  {
  	bool operator()(const maker& m1,const maker&m2)const
  	{
  		return m1.name == m2.name && m1.age == m2.age;
  	}
  };
  void test02()
  {
  	vector<maker>v;
  	v.push_back(maker("aaa", 19));
  	v.push_back(maker("vvv", 22));
  	v.push_back(maker("fff", 222));
  	vector<maker>::iterator it = find(v.begin(), v.end(), maker("aaa", 19));
  	//会报错：禁止显示状态二进制“ == ”:“maker”不定义该运算符或到预定义运算符可接收的类型的转换
  	//maker1==maker2不可以，因此要重载==
  	if (it == v.end())
  	{
  		cout << "查找失败" << endl;
  	}
  	else
  	{
  		cout << "查找成功" << it->name <<" "<<it->age << endl;
  	}
  	it = find_if(v.begin(), v.end(), bind2nd(myfunc(),maker("aaa",19)));
  	if (it == v.end())
  	{
  		cout << "查找失败" << endl;
  	}
  	else
  	{
  		cout << "查找成功" << it->name << " " << it->age << endl;
  	}
  }

二：adjacent_find 算法函数用于在指定范围内查找相邻的两个元素，满足指定的条件。

template<class ForwardIterator> ForwardIterator adjacent_find(ForwardIterator first, ForwardIterator last);

功能：
在范围 [first, last) 内查找第一对相邻的元素，满足相等的条件。

返回值：
如果找到相邻的一对元素满足条件，则返回指向第一个相邻元素的迭代器；如果没有找到，则返回 last。

注意事项：

• adjacent_find 函数默认使用 operator== 运算符进行元素的比较，如果需要使用其他比较方式，可以自定义谓词。

总结：
adjacent_find 算法用于在指定范围内查找相邻的两个元素，满足指定的条件

class maker2
{
public:
	maker2(string name, int age)
	{
		this->name = name;
		this->age = age;
	}
public:
	string name;
	int age;
};
struct myfind
{
	bool operator()(maker2& m1, maker2& m2)
	{
		return m1.name == m2.name && m1.age == m2.age;
	}
};
//adjacent_find算法，查找相邻重复元素
void test03()
{
	vector<int>v = { 2,3,4,4,7,8,3,55 };
	//adjacent_find部分源码
	///*NODISCARD _CONSTEXPR20 _FwdIt adjacent_find(const _FwdIt _First*/, const _FwdIt _Last) { // find first matching successor
	//	return _STD adjacent_find(_First, _Last, equal_to<>{});
	auto it=adjacent_find(v.begin(), v.end());
	//返回第一个相同元素的地址
	if (it == v.end())
	{
		cout << "查找相邻元素失败" << endl;
	}
	else
	{
		cout << "查找成功" << *it << endl;
	}
	//NODISCARD _CONSTEXPR20 _FwdIt adjacent_find(const _FwdIt _First, _FwdIt _Last, _Pr _Pred) {
	//	if (_UFirst != _ULast) {
	//		for (auto _UNext = _UFirst; ++_UNext != _ULast; _UFirst = _UNext) {
	//			if (_Pred(*_UFirst, *_UNext)) //函数返回bool类型
	// {
	//				_ULast = _UFirst;
	//				break;
	//			}
	//		}
	//	}
	vector<maker2>v2;
	v2.push_back(maker2("bbb", 20));
	v2.push_back(maker2("bbb2", 66));
	v2.push_back(maker2("bbb3", 44));
	v2.push_back(maker2("bbb3", 44));
	v2.push_back(maker2("bbb5", 33));
	//auto it2 = adjacent_find(v2.begin(), v2.end());//err,
	//对类类型“std::equal_to<void>”的对象的调用: 未找到匹配的调用运算符
	auto it2 = adjacent_find(v2.begin(), v2.end(),myfind());
		if (it2 == v2.end())
		{
			cout << "查找失败" << endl;
		}
		else
		{
			cout << "查找成功" << it2->name << " " << it2->age << endl;
		}
}

 

binary_search 算法函数用于在有序范围内进行二分查找，判断指定的值是否存在。

template<class ForwardIterator, class T> bool binary_search(ForwardIterator first, ForwardIterator last, const T& value);

功能：
在有序范围 [first, last) 内进行二分查找，判断值 value 是否存在。

返回值：
如果存在指定值，则返回 true；如果不存在指定值，则返回 false。

注意事项：

• binary_search 函数要求有序范围，如果范围未排序，则结果不确定。
• 对于能够重复出现的元素，binary_search 只能判断是否存在，无法返回具体位置。
• 如果需要返回具体位置，可以使用 lower_bound 和 upper_bound 算法。

总结：
binary_search 算法用于在有序范围内进行二分查找，判断指定的值是否存在。

 

//binary_search算法二分查找
// 返回true 或者false
//无序序列不可用
class student
{
public:
	student(string name, int age)
	{
		this->name = name;
		this->age = age;
	}
	bool operator>(const student s)const
	{
		return this->age > s.age;
	}
	bool operator<(const student s)const
	{
		return this->age < s.age;
	}
public:
	string name;
	int age;
};
void test04()
{
	vector<int>v = { 1,2,3,4,5,6 };
	bool flag = binary_search(v.begin(), v.end(), 3);
	if (flag)
	{
		cout << "找到" << endl;
	}
	else
	{
		cout << "未找到" << endl;
	}
	vector<student>vs;
	vs.push_back(student("bbb1", 1));
	vs.push_back(student("bbb3", 2));
	vs.push_back(student("bbb4", 3));
	vs.push_back(student("a", 4));
	//部分源码
	//_NODISCARD _CONSTEXPR20 bool binary_search(_FwdIt _First, _FwdIt _Last, const _Ty & _Val, _Pr _Pred) {
	//	_UFirst = _STD lower_bound(_UFirst, _ULast, _Val, _Pass_fn(_Pred));
	//	return _UFirst != _ULast && !_Pred(_Val, *_UFirst);
	
	//bool flag2 = binary_search(v.begin(), v.end(), student("bbb4", 36));//err
	//	对类类型“std::less<void>”的对象的调用: 未找到匹配的调用运算符
	//初始是less<>()默认是基础类型，因此要在<>加student,重载小于号
	bool flag2 = binary_search(vs.begin(), vs.end(), student("bbb4", 3),less<student>());
//大于和重载大于号
	//bool flag2 = binary_search(vs.begin(), vs.end(), student("bbb4", 2), greater<student>());
	//注意：如果使用的是less ，那么你写的数据要是升序的，greater则要求是降序的
	//比age则要求age是有序的，name随便
	if (flag2)
	{
		cout << "找到" << endl;
	}
	else
	{
		cout << "未找到" << endl;
	}
}

count 算法函数用于计算指定值在指定范围内出现的次数。

template<class InputIterator, class T> typename iterator_traits<InputIterator>::difference_type count(InputIterator first, InputIterator last, const T& value);

功能：
计算范围 [first, last) 内等于指定值 value 的元素的个数。

返回值：
返回等于指定值的元素个数。

注意事项：

• count 函数可以用于任何支持迭代器的容器（如向量、链表、数组等）。
• 需要包含 <algorithm> 头文件。

总结：
count 算法用于计算指定值在指定范围内出现的次数。

 

void test05()
{
	vector<int>v = { 1,2,3,4,1,2,1 };
	//查一有多少个
	int n = count(v.begin(), v.end(), 1);
	cout << n << endl;
	//大于1的元素有多少个
	n = count_if(v.begin(), v.end(), [](int val)->bool {return val > 1; });//->4
	cout << n << endl;
}