多重集合set 的list实现详解

#ifndef MINIMULTISET_H
#define    MINIMULTISET_H
#include
#include
#include

using namespace std;

template
class miniMultiSet
{
    public:
        typedef typename list ::iterator iterator ;
        typedef typename list ::const_iterator const_iterator ;
        //miniMultiSet的迭代器就是list的迭代器

        miniMultiSet() ;

        miniMultiSet(T* first , T* last) ;
            //多重集，[first , last)
        bool empty() const ;

        int size() const ;

        int count(const T& item) const ;
        //返回item在多重集中重复出现的次数

        iterator find(const T& item) ;
        //指向第一个匹配元素，否则指向end

        const_iterator find(const T& item) const ;

        pair   equal_range(const T& item) ;

        pair   equal_range(const T& item) const ;
        //返回迭代器对 ， 使得所有匹配item的元素都在区间[first ,last) ;

        iterator insert(const T& item) ;

        int erase(const T& item) ;

        void erase(iterator pos) ;

        void erase(iterator first , iterator last) ;

        iterator begin() ;

        const_iterator begin() const ;

        iterator end() ;

        const_iterator end() const ;

    private:
        list multisetList ;//使用list来实现多重集
        int distance(iterator first , iterator last) ;
        //返回区间[first, last)内的元素个数
        int distance(const_iterator first , const_iterator last) const;
        //常量版本
};

template
int miniMultiSet ::distance(iterator first , iterator last)
{
    int cnt ;
    iterator iter = first;
    while(iter != last)
    {
        cnt ++ ;
        iter ++ ;
    }
    return cnt ;

}

template
int miniMultiSet ::distance(const_iterator first , const_iterator last) const
{
    int cnt ;
    iterator iter = first ;
    while(iter != last)
    {
        cnt ++ ;
        iter ++ ;
    }
    return cnt ;
}

template
miniMultiSet ::miniMultiSet()
{

}

template
miniMultiSet ::miniMultiSet(T* first , T* last)
{
    T* tmp = first ;

    while(tmp != last)
    {
        insert(*tmp);
        tmp ++ ;
    }
}

template
bool miniMultiSet ::empty() const
{
    return multisetList.empty() ;
}

template
int miniMultiSet ::size() const
{
    return multisetList.size() ;
}

template
int miniMultiSet ::count(const T& item) const
{
    int cnt = 0 ;
    const_iterator iter ;
    pair   p ;
     p = equal_range(item) ;

     if (p.first == end())
     {
         cnt = 0 ;
     }
     else
     {
         iter = p.first ;
         while(iter != p.second)
         {
             cnt ++ ;
             iter ++ ;
         }
     }

    return cnt ;
}

template
miniMultiSet ::iterator miniMultiSet ::find(const T& item)
{
    iterator iter = begin() ;
    while((iter != end()) && (*iter != item)  )
        iter ++ ;
    return iter ;

}

template
miniMultiSet ::const_iterator  miniMultiSet ::find(const T& item) const
{
    const_iterator iter = begin() ;

    while((iter != end()) &&(*iter != item) )
        iter ++ ;

    return iter ;

}

template
pair ::iterator , miniMultiSet ::iterator >  miniMultiSet ::equal_range(const T& item)
{
    pair p ;
    p.first = find(item);
    if (p.first == end())
    {
        p.second = end();
        return  p ;
    }

    iterator iter = p.first ;

    while((iter != end()) && (*iter == item))
    {
        iter ++ ;
        p.second = iter ;
    }

    return p ;
}

template
pair ::const_iterator , miniMultiSet ::const_iterator >  miniMultiSet ::equal_range(const T& item) const
{
    pair p ;

    p.first = find(item) ;

    if (p.first == end())
    {
        p.second = end() ;
        return p ;
    }

    const_iterator iter = p.first ;
    while((iter != end()) && (*iter == item))
    {
        iter ++ ;
        p.second = iter ;
    }

    return p ;

}

template
miniMultiSet ::iterator miniMultiSet ::insert(const T& item)
{
    iterator iter ;
    iter = find(item);

    multisetList.insert(iter,item) ;

    iter = find(item) ;

    return iter ;

}

template
int miniMultiSet ::erase(const T& item)
{
    int cnt = 0 ;
    iterator iter = find(item) ;

    if (iter != end())
    {
        while((*iter == item) && (iter != end()))
        {
            multisetList.erase(iter ++ );
            cnt     ++  ;
        }
    }
    else
        cnt = 0 ;

        return cnt ;
}

template
void miniMultiSet ::erase(iterator pos)
{
    multisetList.erase(pos) ;
}

template
void miniMultiSet ::erase(iterator first , iterator last)
{
    iterator iter = first ;

    while(iter != last)
    {
        multisetList.erase(iter ++ ) ;
    }
}

template
miniMultiSet ::iterator  miniMultiSet ::begin()
{
    iterator iter = multisetList.begin() ;
    return iter ;
}

template
miniMultiSet ::const_iterator  miniMultiSet ::begin() const
{
    return multisetList.begin() ;
}

template
miniMultiSet ::iterator miniMultiSet ::end()
{
    return multisetList.end() ;   
}

template
miniMultiSet ::const_iterator  miniMultiSet ::end() const
{
    return multisetList.end() ;   
}

#endif