函数库 vector&二分查找&迭代器

vector成员函数

1）、vecto<T> v; //创建一个空的vector<T>对象，这个对象的元素的类型为T，T是需要指定的。

2）、vector<T>  v(n); //创建一个vector<T>对象，v.size()为n， 每个元素的值都会是系统默认的值，如果T是类，就会是默认构造函数来初始化。

3）、vector<T> v(n, value);//跟第二个差不多，区别就是初始化不是默认值，而是用指定的value值来初始化这N个元素

4）、vector<T> v(iter1, iter2);//用迭代器来指定一个范围内的元素来初始化。如：

          vector<int> v;
          for (int i = 1; i <= 10; i++)
                 v.push_back(i);
          vector<int> v1(v.begin(), v.end());

二、常用的操作

v.push_back(value);//把value放到对象v的末尾

v.pop_back(); //把对象v的末尾的值删除，并缩减其容量

v.capacity();//返回v的容量

v.max_size();//返回v最大可以存放的元素的个数

v.size();//返回v中元素的个数

v.empty();//如果v中元素个数为0，那么就返回true,否则返回false

v.reserve(n, value);//设置v的容量为n，那么原来如果为m, m < n, 则m-n这些元素都用value来初始化

v.front();//返回v的第一个元素

v.back();//返回v的最后一个元素

v1.swap(v2);//交换v1\v2的内容

v.clear();//清空所有元素，并将其容量变为0

v.begin();//返回指向第一个元素的迭代器

v.end();//返回指向最后一个元素之后的迭代器

v.rbegin();//返回指向最后一个元素的迭代器

v.rend();//返回指向第一个元素之前的迭代器

v.insert(iterator, value);//在迭代器iterator指向的元素之前插入value

v.insert(iterator, n, value);//在迭代器iterator指向的元素之前插入n个value

v.earse(iterator);//删除迭代器iterator指向的元素删除掉

v.earse(iteBegin, iteEnd);//删除两个迭代器指定的范围内的元素

v[i] //像数组一样来访问元素，但是不会进行越界检查，跟数组一样不检查的

v.at(i);//返回v中下标为i的元素。这个成员函数会起先越界检查，如果越界会抛出out_of_range

如：

try

{

        for (int i = 0; i <= v.size(); i++)

              cout << v.at(i) << " ";

 }

catch (out_of_range)

{

        cout << "out of range" << endl;

}    

//那么这里就是输出out of range.

三、重载的运算符

1、 v1 = v2; //调用复制构造函数来完成赋值

2、v1 == v2; //按字典顺序来比较，如果相等，返回true。下面的几个也一样的道理

3、v1 < v2;

4、v1 > v2;

5、v1 ！= v2

STL二分查找（函数库）

STL包含四种不同的二分查找算法，binary_search    lower_bound  upper_bound   equal_range.他们作用的range是已sorted。

binary_search试图在已排序的[first, last)中寻找元素value。如果[first, last)内有等价于value的元素，它会返回true，否则返回false，它不返回查找位置。

lower_bound它试图在已排序的[first,last)中寻找元素value。如果[first, last)具有等价于value的元素，lower_bound返回一个iterator指向其中第一个元素。如果没有这样的元素存在，它便返回假设这样的元素存在的话，会出现的位置。即指向第一个不小于value的元素。如果value大于[first, last)的任何一个元素，则返回last。

upper_bound它试图在已排序的[first,last)中寻找value，返回可安插value的最后一个合适的位置。如果value存在，lower_bound 返回的是指向该元素的iterator。相较之下upper_bound并不这么做，它返回value可被安插的最后一个合适位置。如果value存在，那么它返回的iterator将指向value的下一个位置，而非value自身。

equal_range的返回值本质上结合了lower_bound和upper_bound两者的返回值。其返回值是一对iterator i 和 j ， 其中i是value可安插的第一个位置，j则是value可安插的最后一个位置。可以推演出：[i，j)中的每个元素都等价于value，而且[i, j)是[first, last)之中符合上述性质的一个最大子区间。  算法lower_bound返回该range的第一个iterator， 算法upper_bound返回该range的past-the-end iterator，算法equal_range则是以pair的形式将两者都返回。

 

[cpp]  view plain copy

1. #include <algorithm>  
2. #include <iostream>  
3. #include <iterator>  
4. #include <vector>  
5. using namespace std;  
6. int main()  
7. {  
8.     vector<int> v;  
9.     vector<int>::iterator iter;  
10.     pair<vector<int>::iterator, vector<int>::iterator> vecpair;  
11.   
12.   
13.     for(int i = 1; i<= 20; i++) {  
14.         v.push_back(i%6);  
15.     }  
16.     sort(v.begin(), v.end());  
17.     cout << "array: " << endl << "  ";  
18.     copy(v.begin(), v.end(), ostream_iterator<int>(cout, " "));  
19.     cout << endl << endl;  
20.   
21.   
22.     /*  lower_bound */  
23.     cout << "lower_bound function, value = 3: " << endl;  
24.     iter = lower_bound(v.begin(), v.end(), 3);  
25.     cout << "  [first, iter] = ";  
26.     copy(v.begin(), iter, ostream_iterator<int>(cout, " "));  
27.     cout << endl;  
28.     cout << "  [iter, last] = ";  
29.     copy(iter, v.end(), ostream_iterator<int>(cout, " "));  
30.     cout << endl << endl;  
31.   
32.   
33.     /*  upper_bound */  
34.     cout << "upper_bound function, value = 3: " << endl;  
35.     iter = upper_bound(v.begin(), v.end(), 3);  
36.     cout << "  [first, iter] = ";  
37.     copy(v.begin(), iter, ostream_iterator<int>(cout, " "));  
38.     cout << endl;  
39.     cout << "  [iter, last] = ";  
40.     copy(iter, v.end(), ostream_iterator<int>(cout, " "));  
41.     cout << endl << endl;  
42.   
43.   
44.     /*  equal_range */  
45.     cout << "euqual_range function value = 3: " << endl;  
46.     vecpair = equal_range(v.begin(), v.end(), 3);  
47.   
48.   
49.     cout << " [vecpair->first, vecpair->second] = ";  
50.     copy(vecpair.first, vecpair.second, ostream_iterator<int>(cout, " "));  
51.     cout << endl << endl;  
52.   
53.   
54.     /*  binary_search */  
55.     cout << "binary_search function value = 3: " << endl;  
56.     cout << "3 is " << (binary_search(v.begin(), v.end(), 3) ? "": "not ") << " in array" << endl;  
57.     cout << endl;  
58.   
59.   
60.     /*  binary_search */  
61.     cout << "binary_search function value = 6: " << endl;  
62.     cout << "6 is " << (binary_search(v.begin(), v.end(), 6) ? "": "not ") << " in array" << endl;  
63.     cout << endl;  
64. }  
65.   
66.   
67. ./bsearch   
68. array:   
69.   0 0 0 1 1 1 1 2 2 2 2 3 3 3 4 4 4 5 5 5   
70.   
71.   
72. lower_bound function, value = 3:   
73.   [first, iter] = 0 0 0 1 1 1 1 2 2 2 2   
74.   [iter, last] = 3 3 3 4 4 4 5 5 5   
75.   
76.   
77. upper_bound function, value = 3:   
78.   [first, iter] = 0 0 0 1 1 1 1 2 2 2 2 3 3 3   
79.   [iter, last] = 4 4 4 5 5 5   
80.   
81.   
82. euqual_range function value = 3:   
83.  [vecpair->first, vecpair->second] = 3 3 3   
84.   
85.   
86. binary_search function value = 3:   
87. 3 is  in array  
88.   
89.   
90. binary_search function value = 6:   
91. 6 is not  in array  

迭代器成员函数

1、定义一个迭代器，有const的是用const限定的迭代器，不允许修改通过*来修改其值，

     有reverse的是逆序迭代器

  vector<int>::iterator it = v.begin(); //

  vector<int>::const_iterator cit = v.begin();

  vector<int>::reverse_iterator rit = v.rbegin();

  vector<int>::const_reverse_iterator crit = v.rbegin();

这样定义以后可以执行以下操作：

++it 、--it、*it、=、 == 、 ！=、+、-、【】

顺序输出元素：

for (vector<int>::const_iterator cit = v.begin(); cit != v.end(); cit++)

       cout << *cit << " ";

cout << endl;

逆序输出元素：

for (vector<int>::const_reverse_iterator crit = v.rbegin(); crit != v.rend(); crit ++)

     cout << *crit << " ";

cout << endl;

转载于:https://www.cnblogs.com/ghh1995/p/4349037.html