封装的一个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的实现，不是很完善目前。

 

#include <iterator>
#include <iostream>
#include "sorted_vector_algo.h"
using namespace std;

using std::vector;
using namespace sorted_vector_algo;  //将std的lower_bound等方法源码整理出来
//using std::lower_bound; //二分查找，在有序数组上时间复杂度为O(logn)
//using std::upper_bound;
/*
 *std::sort采用的是成熟的"快速排序算法"(目前大部分STL版本已经不是采用简单的快速排序，而是结合内插排序算法)。
 可以保证很好的平均性能、复杂度为n*log(n)，由于单纯的快速排序在理论上有最差的情况，性能很低，其最坏算法复杂度为n*n，
 但目前大部分的STL版本都已经在这方面做了优化。
 std::stable_sort采用的是"归并排序"，分派足够内存时，其算法复杂度为n*log(n), 否则其复杂度为n*log(n)*log(n)，
 其优点是会保持相等元素之间的相对位置在排序前后保持一致。
 * */

template <class T, class Compare = std::less<T> >
struct sorted_vector {
    vector<T> V;
    Compare cmp;

    typedef typename vector<T>::size_type size_type;
    typedef typename vector<T>::iterator iterator;
    typedef typename vector<T>::const_iterator const_iterator;
    typedef typename vector<T>::reference reference;
    typedef typename vector<T>::const_reference const_reference;   
    iterator begin() { return V.begin(); }
    iterator end() { return V.end(); }
    const_iterator begin() const { return V.begin(); }
    const_iterator end() const { return V.end(); }

    sorted_vector(const Compare& c = Compare()): V(), cmp(c) {}

    template <class InputIterator>
    sorted_vector(InputIterator first, InputIterator last,
                const Compare& c = Compare()): V(first, last), cmp(c)
    {
        std::sort(begin(), end(), cmp);
    }

    iterator insert(const T& t) {
        iterator i = sorted_vector_algo::upper_bound(begin(), end(), t, cmp);
        if (i == end() || cmp(t, *i))
            V.insert(i, t);
        return i;
    }
    iterator erase(const T& t) {
        iterator i = std::lower_bound(begin(), end(), t, cmp);
        iterator j = std::upper_bound(begin(), end(), t, cmp);

        return V.erase(i, j);
    }

    //针对多维索引的属性值查找，需提供自定义的比较方法。只能查找当前容器中有序的属性值。
    template <typename _Tp, class _Compare> 
    const_iterator find(const _Tp& t, _Compare cmp) {
        const_iterator i = lower_bound(t, cmp);
        return i == end() || cmp(t, *i) ? end() : i;
    }

    template <typename _Tp, typename _Compare> 
    iterator lower_bound (const _Tp& val, _Compare cmp) {
        return  sorted_vector_algo::lower_bound(begin(), end(), val, cmp);
    }

    const_iterator find(const T& t) const {
        const_iterator i =  sorted_vector_algo::lower_bound(begin(), end(), t, cmp);
        return i == end() || cmp(t, *i) ? end() : i;
    }

    iterator lower_bound (const T& val) {
        return  sorted_vector_algo::lower_bound(begin(), end(), val, cmp);
    }
    iterator upper_bound (const T& val) {
        return  sorted_vector_algo::upper_bound(begin(), end(), val, cmp);
    }

    bool empty() const {
        return V.empty();
    }
    reference operator[] (size_type n) {
        return V[n];
    }
    const_reference operator[] (size_type n) const{
        return V[n];
    }

    std::size_t size(){
        return V.size();
    }
};