C++博客-C小加-随笔分类-模板

优先队列（二叉堆）模板

C小加 — Sat, 15 Sep 2012 06:40:00 GMT

template<class T,int MAX=100003>
class BinaryHeap
{
    private:
    int Size;
    T * Tarr;
    public:
    BinaryHeap();
    void insert(T x);
    T deleteMin();
    ~BinaryHeap();
};

template<class T,int MAX>
BinaryHeap<T,MAX>::BinaryHeap()
{
    Tarr=new T[MAX+1];
    if(Tarr==NULL) {cout<<"创建数组失败"<<endl;return ;}
    Size=0;
}
template<class T,int MAX>
void BinaryHeap<T,MAX>::insert(T x)
{
    ++Size;
    if(Size==MAX) return;
    int i;
    for(i=Size;Tarr[i/2]>x;i/=2)
        Tarr[i]=Tarr[i/2];
    Tarr[i]=x;
}
template<class T,int MAX>
T BinaryHeap<T,MAX>::deleteMin()
{
    if(Size==0) return 0;
    T minem=Tarr[1];
    T lastem=Tarr[Size--];
    int i,child;
    for(i=1;i*2<=Size;i=child)
    {
        child=i*2;
        if(child!=Size-1&&Tarr[child+1]<Tarr[child])
        ++child;
        if(lastem>Tarr[child])
            Tarr[i]=Tarr[child];
        else
            break;

    }
    Tarr[i]=lastem;

    return minem;
}

template<class T,int MAX>
BinaryHeap<T,MAX>::~BinaryHeap()
{
    delete[] Tarr;

}

C小加 2012-09-15 14:40 发表评论

哈希模板

C小加 — Wed, 12 Sep 2012 12:06:00 GMT

const int  MAX=1000003;
template <class T>
class hash
{
private:
    int pos;
    int next[MAX];
    int head[MAX];
    T key[MAX];
public:
    hash();
    bool search(T x);
    void push(T x);

};
template <class T>
hash::hash()
{
    pos=0;
    memset(next,-1,sizeof(next));
    memset(head,-1,sizeof(head));
    //memset(key,-1,sizeof(key));
}
template <class T>
inline bool hash::search(const T x)
{
    int temp=x%MAX;
    int t=head[temp];
    while(t!=-1)
    {
        if (key[t]==x)
        {
            return 1;
        }
        t=next[t];
    }
    return 0;
}
template <class T>
inline void hash::push(const T x)
{
    int temp=x%MAX;
    if (head[temp]!=-1)
    {
        next[pos]=head[temp];
    }
    head[temp]=pos;
    key[pos]=x;
    pos++;
}

C小加 2012-09-12 20:06 发表评论

hash_map哈希映照容器的实现

C小加 — Wed, 18 Apr 2012 12:18:00 GMT

hash_map，顾名思义，就是利用hash_set存储结构的写map映照容器，普通的map用的是红黑树存储结构写的。元素的检索时间对比，hash_set近似为O(1)，红黑树为O(logn)。Hash_map的空间开销要比map 的空间开销大，尤其是我用数组模拟指针写的hash_map。

所以，如果有必要采取映射结构的时候，能用hash_map就别用map。

需要注意的是，hash_map遍历出来的元素不是有序的。

Hash_map和普通hash_set相比的话，hash_map比hash_set多了一张value表，也就是映射表。

下面是hash_map的模板，和hash_set的模板差不多。

template<class KeyType,int MaxHash>
struct HashFunction
{
    int operator()(const KeyType& key)
    {
        int h=key%MaxHash;
        if (h<0) h+=MaxHash;
        return h;
    }
};

template<class KeyType,class ValueType,int KeyContain,int MaxHash,class HashFun=HashFunction >
class HashMap
{
public:
    HashMap():hashfun(){Clear();}
    ValueType& operator[](const KeyType& key)
    {
        int h=hashfun(key);
        int pos=head[h];
        for(;pos!=0;pos=next[pos])
        {
            if(keys[pos]==key)
                return values[pos];
        }
        next[++top]=head[h];
        head[h]=top;
        keys[top]=key;
        values[top]=ValueType();//初始化
        ++sz;
        return values[top];
    }
    void Clear()
    {
        memset(head,0,sizeof(head));
        memset(next,0,(top+1)*sizeof(int));
        top=0;
        sz=0;
    }
    unsigned int size() const {return sz;}

private:
    unsigned int sz;
    HashFun hashfun;
    int head[MaxHash];
    int next[KeyContain];
    KeyType keys[KeyContain];
    ValueType values[KeyContain];
    int top;
};

C小加 2012-04-18 20:18 发表评论

C++任意类型转换模板

C小加 — Thu, 12 Apr 2012 07:13:00 GMT

#include
#include
#include<string>
using namespace std;

template<class out_type,class in_value>
out_type convert(const in_value & t)
{
stringstream stream;
stream<//向流中传值
out_type result;//这里存储转换结果
stream>>result;//向result中写入值
return result;
}

int main()
{
    string s;
    while(cin>>s)
    {
        double valdou=convert<double>(s);
        int valint=convert<int>(s);
        cout<        cout<

    }

    return 0;
}

C小加 2012-04-12 15:13 发表评论

次方求模模板

C小加 — Fri, 06 Apr 2012 06:51:00 GMT

template<class IntType>
inline IntType ModPow(IntType m,IntType n,IntType p) //m的n次方模p
{
    if(n==0) return 1;
    if (n==1) return m%p;
        IntType tmp=ModPow(m,n>>1,p);
    return (tmp*tmp%p)*((n%2?m:1)%p)%p;
}

C小加 2012-04-06 14:51 发表评论