《effective STL》中有句忠告，儘量用演算法替代手寫迴圈；查詢少不了迴圈遍歷，在這裡總結下常用的STL查詢演算法；

查詢有三種，即點線面：
點就是查詢目標為單個元素；
線就是查詢目標為區間；
面就是查詢目標為集合；

針對每個類別的查詢，預設的比較函式是相等，為了滿足更豐富的需求，演算法也都提供了自定義比較函式的版本；

1. 單個元素查詢

find() 比較條件為相等的查詢

find()從給定區間中查詢單個元素,定義：

template <class InputIterator, class T>
InputIterator find (InputIterator first, InputIterator last, const
 
 T& val);

示例，從myvector中查詢30：

int myints[] = { 10, 20, 30, 40 };
std::vector<int> myvector (myints,myints+4);
it = find (myvector.begin(), myvector.end(), 30);
if (it != myvector.end())
    std::cout << "Element found in myvector: " << *it << '\n';
else
    std::cout << "Element not found in myvector\n"
 
;

find_if() 自定義比較函式

std::find_if():從給定區間中找出滿足比較函式的第一個元素；
示例,從myvector中查詢能夠被30整除的第一個元素：

bool cmpFunction (int i) {
  return ((i%30)==0);
}
it = std::find_if (myvector.begin(), myvector.end(), cmpFunction);
std::cout << "first:" <<  *it <<std::endl;

count() count_if()統計元素出現次數

std::count()：統計區間中某個元素出現的次數；
std:count_if()：count()的自定義比較函式版本

search_n() 查詢單個元素重複出現的位置

search_n(): find用來查詢單個元素，search_n則用來查詢區間中重複出現n次的元素；

示例：查詢myvector中30連續出現2次的位置：

int myints[]={10,20,30,30,20,10,10,20};
std::vector<int> myvector (myints,myints+8);
it = std::search_n (myvector.begin(), myvector.end(), 2, 30);

search_n() 支援自定義比較函式；

adjacent_find() 查詢區間中重複元素出現的位置

adjacent_find() 查詢區間中重複元素出現的位置，該演算法支援自定義比較函式；

lower_bound() 有序區間中查詢元素邊界

lower_bound()用來在一個排序的區間中查詢第一個不小於給定元素的值：
示例：查詢容器v中不小於20的下界：

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); 
std::cout << "lower_bound at position " << (low- v.begin()) << '\n';

類似演算法有upper_bound(),查詢有序區間中第一個大於給定元素的值；

equal_range(),查詢有序區間的上下邊界；

（一次返回lower_bound()和upper_bound());

binary_search() 有序區間的二分查詢

binary_search() 用來在一個有序區間中使用二分法查詢元素是否在這個區間中，注，這個演算法的返回值為bool，
不是下標位置，其內部的演算法邏輯和lower_bound（）相似，行為表現為：

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

示例：從有序區間v中找3是否存在：

int myints[] = {1,2,3,4,5,4,3,2,1};
std::vector<int> v(myints,myints+9);                         // 1 2 3 4 5 4 3 2 1
std::sort (v.begin(), v.end());
if (std::binary_search (v.begin(), v.end(), 3))
    std::cout << "found!\n"; else std::cout << "not found.\n";

min_element() 查詢最小元素

min_element() 在給定區間中查找出最小值;

int myints[] = {3,7,2,5,6,4,9};
std::cout << "The smallest element is " << *std::min_element(myints,myints+7) << '\n';

類似演算法有：max_element() 查詢最大值；

2. 區間查詢 search()

search() 查詢子區間首次出現的位置

find()用來查詢單個元素，search()則用來查詢一個子區間；
示例：從myvector中查找出現子區間[20，30]的位置:

  int needle1[] = {20,30};
  it = std::search (myvector.begin(), myvector.end(), needle1, needle1+2);
  if (it!=myvector.end())
    std::cout << "needle1 found at position " << (it-myvector.begin()) << '\n';

search支援自定義比較函式；
示例：查詢給定區間中每個元素比目標區間小1的子區間；

bool cmpFunction (int i, int j) {
  return (i-j==1);
}
int myints[] = {1,2,3,4,5,1,2,3,4,5};
std::vector<int> haystack (myints,myints+10);

int needle2[] = {1,2,3};
// using predicate comparison:
it = std::search (haystack.begin(), haystack.end(), needle2, needle2+3, cmpFunction);

find_end() 查詢子區間最後一次出現的位置

search() 用來查詢子區間第一次出現的位置，而find_end()用來查詢子區間最後一次出現的位置：
find_end()支援自定義比較函式；

equal() 判斷兩個區間是否相等

equal（）用來判斷兩個區間是否相等，該演算法支援自定義比較函式；

mismatch() 查詢兩個區間首次出現不同的位置；

mismatch() 查詢兩個區間首先出現不同的位置，這個演算法也支援自定義比較函式；

3. 集合查詢

find_first_of 查詢集合中的任意一個元素

find_first_of()用來查詢給定集合中的任意一個元素:
示例：從haystack中查詢A,B,C出現的位置：

  int mychars[] = {'a','b','c','A','B','C'};
  std::vector<char> haystack (mychars,mychars+6);
  int needle[] = {'C','B','A'};
  // using default comparison:
  it = find_first_of (haystack.begin(), haystack.end(), needle, needle+3);

find_first_of支援自定義比較函式；