C++标准库---lower_bound&upper_bound

lower_bound(应用于有序区间)

这是二分查找（binary search）的一种版本，试图在已排序的[first,last)中寻找元素value：

如果[first,last)具有与value相等的元素(s),便返回一个迭代器，指向其中第一个元素；

如果没有这样的元素存在，便返回“假设这样的元素存在时应该出现的位置”，也就是说，它返回一个迭代器，指向第一个“不小于value”的元素；

如果value大于{first,last)内的任何一个元素，则返回last。

另外一种理解，其返回值是“在不破坏排序状态的原则下，可插入value的第一个位置”。

STL源码：

template <class ForwardIterator,class T>
inline ForwardIterator lower_bound(ForwardIterator first,ForwardIterator last,const T& value)
{
    return _lower_bound(first,last,value,distance_type(first),iterator_category(first)); 
}


//forward_iterator版本
template <class ForwardIterator,class T,class Distance>
ForwardIterator _lower_bound(ForwardIteartor first,ForwardIterator last,const T& value,Distance*,forward_iterator_tag)
{
    Distance len=0;
	distacne(first,last,len);
	Diatacne half;
	ForwardIterator middle;


	while(len>0)
	{
	   half=len>>1;                //除以2
	   middle=first;               //迭代器必须有初始值，才能应用advance
	   advance(middle,half);       //middle+=half;   支持所有容器迭代器的操作
	   if(*middle<value)
	   {
	       first=middle;
		   ++first;
		   len=len-half-1;
	   }
	   else
	     len=half;
	}
	return first;
}

//random_access_iterator版本
template <class RandomAccessIterator,class T,class Distance>
RandomAccessIterator _lower_bound(RandomAccessIterator first,RandomAccessIterator last,const T& value,Distance*,random_access_iterator_tag)
{
    Distance len=last-first;
	Diatacne half;
    RandomAccessIterator middle;


	while(len>0)
	{
	   half=len>>1;                //除以2
	   middle=first+half;            
	   if(*middle<value)
	   {
	       first=middle+1;
		   len=len-half-1;
	   }
	   else
	     len=half;
	}
	return first;
}

代码示例：

//测试lower_bound
#include<iostream>
#include<algorithm>
#include<iterator>
#include<vector>
#include<set>

using namespace std;

int main()
{
	//vector 测试---序列式容器 
	vector<int> coll;
	vector<int>::iterator pos;

	coll.push_back(1);
	coll.push_back(1);
	coll.push_back(3);
	coll.push_back(3);
	coll.push_back(3);
	coll.push_back(3);
	coll.push_back(5);
	coll.push_back(7);
	coll.push_back(9);
	

	copy(coll.begin(),coll.end(),ostream_iterator<int>(cout," "));//1 1 3 3 3 3 5 7 9
	cout<<endl;

	pos=lower_bound(coll.begin(),coll.end(),2);//如果找不到与value值相同的元素，则返回第一个“不小于value”的元素的位置
	                                           //即返回的是第一个元素'3'的位置
	cout<<"lower_bound 2:  ";

	copy(pos,coll.end(),ostream_iterator<int>(cout," "));
	cout<<endl;

	pos=lower_bound(coll.begin(),coll.end(),3);//如果找到与value值相同的元素，则返回第一个该元素值的位置
	                                           //即返回的是第一个元素'3'的位置  

	cout<<"lower_bound 3:  ";

	copy(pos,coll.end(),ostream_iterator<int>(cout," "));
	cout<<endl;

	//multiset测试---关联式容器
	multiset<int> coll1;
	multiset<int>::iterator pos1;

	coll1.insert(1);
	coll1.insert(3);
	coll1.insert(5);
	coll1.insert(7);
	coll1.insert(7);
	coll1.insert(7);
	coll1.insert(9);
	coll1.insert(9);


	copy(coll1.begin(),coll1.end(),ostream_iterator<int>(cout," "));
	cout<<endl;

	pos1=lower_bound(coll1.begin(),coll1.end(),7);//如果找到与value值相同的元素，则返回第一个该元素值的位置
	                                              //即返回第一个元素'7'的位置

	cout<<"lower_bound 7:  ";

	copy(pos1,coll1.end(),ostream_iterator<int>(cout," "));
	cout<<endl;
	

	pos1=lower_bound(coll1.begin(),coll1.end(),8);//如果找不到与value值相同的元素，则返回第一个“不小于value”的元素的位置
	                                              //即返回的是第一个元素'9'的位置

	cout<<"lower_bound 8:  ";

	copy(pos1,coll1.end(),ostream_iterator<int>(cout," "));
	cout<<endl;

	system("pause");
	return 0;
}

upper_bound (应用于有序区间)

算法upper_bound是二分查找（binary search）法的一个版本。它视图在已排序的[first,last)中寻找value。更明确地说，它会返回“在不破坏顺序的情况下，可插入value的最后一个合适的位置”。

由于STL规范“区间圈定”时的起头和结尾并不对称（是的，[first,last)包含first但不包含last）,所以upper_bound与lower_bound的返回值意义大有不同。如果你查找某值，而它的确出现在区间之内，
则lower_bound返回的是一个指向该元素的迭代器。然而upper_bound不这么做，因为upper_bound所返回的是在不破坏排序状态的情况下，value可被插入“最后一个”合适位置。如果value存在，那么它返回的迭代器将指向value的下一位置，而非指向value本身。

STL源码：

template <class ForwardIterator,class T>
inline ForwardIterator upper_bound(ForwardIterator first,ForwardIterator last,const T& value)
{
    return _upper_bound(first,last,value,distance_type(first),iterator_category(first)); 
}

//forward_iterator版本
template <class ForwardIterator,class T,class Distance>
ForwardIterator _upper_bound(ForwardIteartor first,ForwardIterator last,const T& value,Distance*,forward_iterator_tag)
{
    Distance len=0;
	distacne(first,last,len);
	Diatacne half;
	ForwardIterator middle;

	while(len>0)
	{
	   half=len>>1;                //除以2
	   middle=first;               //迭代器必须有初始值，才能应用advance
	   advance(middle,half);       //middle+=half;   支持所有容器迭代器的操作
	   if(value<*middle)
	   {
		   len=half;
	   }
	   else
	   {
	       first=middle;
		   ++first;
		   len=len-half-1;
	   }
	}
	return first;
}

//random_access_iterator版本
template <class RandomAccessIterator,class T,class Distance>
RandomAccessIterator _upper_bound(RandomAccessIterator first,RandomAccessIterator last,const T& value,Distance*,random_access_iterator_tag)
{
    Distance len=last-first;
	Diatacne half;
    RandomAccessIterator middle;

	while(len>0)
	{
	   half=len>>1;                //除以2
	   middle=first+half;            
	  if(value<*middle)
	   {
		   len=half;
	   }
	   else
	   {
	       first=middle+1;
		   len=len-half-1;
	   }
	}
	return first;
}

示例代码：

//测试upper_bound
#include<iostream>
#include<algorithm>
#include<iterator>
#include<vector>
#include<set>

using namespace std;

int main()
{
	//vector 测试---序列式容器 
	vector<int> coll;
	vector<int>::iterator pos;

	coll.push_back(1);
	coll.push_back(1);
	coll.push_back(3);
	coll.push_back(3);
	coll.push_back(3);
	coll.push_back(3);
	coll.push_back(5);
	coll.push_back(7);
	coll.push_back(9);
	

	copy(coll.begin(),coll.end(),ostream_iterator<int>(cout," "));//1 1 3 3 3 3 5 7 9
	cout<<endl;

	pos=upper_bound(coll.begin(),coll.end(),2);//如果找不到与value值相同的元素，则返回第一个“不小于value”的元素的位置
	                                           //即返回的是第一个元素'3'的位置
	cout<<"lower_bound 2:  ";

	copy(pos,coll.end(),ostream_iterator<int>(cout," "));
	cout<<endl;

	pos=upper_bound(coll.begin(),coll.end(),3);//如果找到与value值相同的元素，则返回第一个该元素值的位置
	                                           //即返回的是第一个元素'3'的位置  

	cout<<"lower_bound 3:  ";

	copy(pos,coll.end(),ostream_iterator<int>(cout," "));
	cout<<endl;

	//multiset测试---关联式容器
	multiset<int> coll1;
	multiset<int>::iterator pos1;

	coll1.insert(1);
	coll1.insert(3);
	coll1.insert(5);
	coll1.insert(7);
	coll1.insert(7);
	coll1.insert(7);
	coll1.insert(9);
	coll1.insert(9);


	copy(coll1.begin(),coll1.end(),ostream_iterator<int>(cout," "));
	cout<<endl;

	pos1=upper_bound(coll1.begin(),coll1.end(),7);//如果找到与value值相同的元素，则返回第一个该元素值的位置
	                                              //即返回第一个元素'7'的位置

	cout<<"lower_bound 7:  ";

	copy(pos1,coll1.end(),ostream_iterator<int>(cout," "));
	cout<<endl;
	

	pos1=upper_bound(coll1.begin(),coll1.end(),8);//如果找不到与value值相同的元素，则返回第一个“不小于value”的元素的位置
	                                              //即返回的是第一个元素'9'的位置

	cout<<"lower_bound 8:  ";

	copy(pos1,coll1.end(),ostream_iterator<int>(cout," "));
	cout<<endl;

	system("pause");
	return 0;
}

binary_search (应用于有序区间)

算法binary_search是一种二分查找法，试图在已排序的[first,last)中寻找元素value。如果[first,last)内有等同于value的元素，便返回true，否则返回false。

返回单纯的bool只是说明该有序区间有你要找的value，但是value的具体位置在那里，就得通过upp_bound和lower_bound来精确的查找，提供准确的信息。

事实上，binary_search便是利用lower_bound先找出“假设value存在的话，应该出现的位置”，然后再对比该位置上的值是否为我们所要查找的目标，并返回对比结果。

STL源码：

template<class ForwardIterator,class T>
bool binary_search(ForwardIterator first,ForwardIterator last,const T& value)
{
    ForwardIterator i=lower_bound(first,last,value);
	return i!=last && !(value<*i);
}

代码示例：

#include<iostream>
#include<algorithm>
#include<vector>

using namespace std;

int main()
{
	vector<int> coll;
	vector<int>::iterator pos;

	coll.push_back(1);
	coll.push_back(1);
	coll.push_back(3);
	coll.push_back(3);
	coll.push_back(3);
	coll.push_back(3);
	coll.push_back(5);
	coll.push_back(7);
	coll.push_back(9);

	if(binary_search(coll.begin(),coll.end(),2))
	{
		cout<<"value Found!"<<endl;
	}
	else
	{
		cout<<"value Not Found!"<<endl;
	}

	system("pause");
	return 0;
}