封装的一个sorted_vector示例，实现了stl::set的一部分接口

STL set能保证最坏情况下的查找和插入效率，logN。但是维护红黑树开销较大。set内的元素按照一定的逻辑顺序组织，查找、插入等操作的结果都和排序规则有关。

适合STL set的情况为： 1、集合很大，以至于O(N)远大于O(longN)。2、查找和插入的次数一样多，且需要考虑插入的效率。3、集合内的元素以随机顺序插入。4、查找和插入交叉进行。

在对插入效率要求不高，或者特定情况下插入效率可以接受时，使用sorted vector也可以实现O(longN)的查找。而且std的sort、lower_bound、upper_bound、binary_search方法，在支持随机存取的sorted vector上时间复杂度都是O(longN)。

封装了一个sorted vector的实现，不是很完善目前。

 1 #include <iterator>
 2 #include <iostream>
 3 #include "sorted_vector_algo.h"
 4 using namespace std;
 5
 6 using std::vector;
 7 using namespace sorted_vector_algo;  //将std的lower_bound等方法源码整理出来
 8 //using std::lower_bound; //二分查找，在有序数组上时间复杂度为O(logn)
 9 //using std::upper_bound;
10 /*
11  *std::sort采用的是成熟的"快速排序算法"(目前大部分STL版本已经不是采用简单的快速排序，而是结合内插排序算法)。
12  可以保证很好的平均性能、复杂度为n*log(n)，由于单纯的快速排序在理论上有最差的情况，性能很低，其最坏算法复杂度为n*n，
13  但目前大部分的STL版本都已经在这方面做了优化。
14  std::stable_sort采用的是"归并排序"，分派足够内存时，其算法复杂度为n*log(n), 否则其复杂度为n*log(n)*log(n)，
15  其优点是会保持相等元素之间的相对位置在排序前后保持一致。
16  * */
17
18 template <class T, class Compare = std::less<T> >
19 struct sorted_vector {
20     vector<T> V;
21     Compare cmp;
22
23     typedef typename vector<T>::size_type size_type;
24     typedef typename vector<T>::iterator iterator;
25     typedef typename vector<T>::const_iterator const_iterator;
26     typedef typename vector<T>::reference reference;
27     typedef typename vector<T>::const_reference const_reference;
28     iterator begin() { return V.begin(); }
29     iterator end() { return V.end(); }
30     const_iterator begin() const { return V.begin(); }
31     const_iterator end() const { return V.end(); }
32
33     sorted_vector(const Compare& c = Compare()): V(), cmp(c) {}
34
35     template <class InputIterator>
36     sorted_vector(InputIterator first, InputIterator last,
37                 const Compare& c = Compare()): V(first, last), cmp(c)
38     {
39         std::sort(begin(), end(), cmp);
40     }
41
42     iterator insert(const T& t) {
43         iterator i = sorted_vector_algo::upper_bound(begin(), end(), t, cmp);
44         if (i == end() || cmp(t, *i))
45             V.insert(i, t);
46         return i;
47     }
48     iterator erase(const T& t) {
49         iterator i = std::lower_bound(begin(), end(), t, cmp);
50         iterator j = std::upper_bound(begin(), end(), t, cmp);
51
52         return V.erase(i, j);
53     }
54
55     //针对多维索引的属性值查找，需提供自定义的比较方法。只能查找当前容器中有序的属性值。
56     template <typename _Tp, class _Compare>
57     const_iterator find(const _Tp& t, _Compare cmp) {
58         const_iterator i = lower_bound(t, cmp);
59         return i == end() || cmp(t, *i) ? end() : i;
60     }
61
62     template <typename _Tp, typename _Compare>
63     iterator lower_bound (const _Tp& val, _Compare cmp) {
64         return  sorted_vector_algo::lower_bound(begin(), end(), val, cmp);
65     }
66
67     const_iterator find(const T& t) const {
68         const_iterator i =  sorted_vector_algo::lower_bound(begin(), end(), t, cmp);
69         return i == end() || cmp(t, *i) ? end() : i;
70     }
71
72     iterator lower_bound (const T& val) {
73         return  sorted_vector_algo::lower_bound(begin(), end(), val, cmp);
74     }
75     iterator upper_bound (const T& val) {
76         return  sorted_vector_algo::upper_bound(begin(), end(), val, cmp);
77     }
78
79     bool empty() const {
80         return V.empty();
81     }
82     reference operator[] (size_type n) {
83         return V[n];
84     }
85     const_reference operator[] (size_type n) const{
86         return V[n];
87     }
88
89     std::size_t size(){
90         return V.size();
91     }
92 };