数据结构随笔3(哈希表)

写了一个哈希表模板类，用于统计一篇文章中不同单词出现的次数。哈希表使用char*作为key,使用桶式链表指针数组(指向结点链表的指针数组)来索引，字符串哈希函数是在网上搜来的。模板参数一个是值类型，另一个NBARREL是指针数组的大小，通常是越大哈希值冲突就越少，结点链表长度也就越短，当然查找就越快。

为了方便统计，为哈希表增加了一个IncValue函数，提高效率。统计的时候使用了快速排序，为了提高效率，
把上次的快排模板稍微修改了一下，直接对指针数组进行排序，就不用进行值的交换了。

/********************************************************************
    created:    2007/12/30
    filename:   hashtable.h
    author:     dj
    purpose:    哈希表模板类
*********************************************************************/

   #ifndef __HASHTABLE_H__
#define __HASHTABLE_H__

#define SAFE_DELETE(p) {if(p) { delete [] (p); (p) = NULL;}}

template<typename T>
void quicksort(T* v, int n)
{
    if (n<=1)
        return;
    int last = 0;
    int pivot = rand()%n;
    swap(v, 0, pivot);
    for (int i = 1; i < n; i++)
    {
        if ((*v[i])>(*v[0]))
            swap(v, ++last, i);
    }
    swap(v, last, 0);
    quicksort(&v[0], last);
    quicksort(&v[last+1], n-last-1);
}

template<typename T>
void swap(T* v, int i, int j)
{
    T tmp = v[i];
    v[i] = v[j];
    v[j] = tmp;
}

template<typename T, int NBARREL = 100>
class HashTable
{
public:
    HashTable():m_nCount(0)
    {
        memset(m_pNodes, NULL, sizeof(void*)*NBARREL);
    }
    ~HashTable()
    {
        FreeTable();
    }
    bool Exists(const char* sName)
    {
        int h = Hash(sName);
        HashNode* p = m_pNodes[h];
        while(p)
        {
            if (strcmp(p->name, sName)==0)
                return true;
            p = p->next;
        }
        return false;
    }
    bool AddNode(const char* sName, const T& tValue)
    {
        if (Exists(sName))
            return false;
        int h = Hash(sName);
        HashNode* node = new HashNode(sName, tValue);
        node->next = m_pNodes[h];
        m_pNodes[h] = node;
        m_nCount++;
        return true;
    }
    T GetValue(const char* sName)
    {
        int h = Hash(sName);
        HashNode* p = m_pNodes[h];
        while(p)
        {
            if (strcmp(p->name, sName)==0)
                return p->value;
            p = p->next;
        }
        return NULL;
    }
    bool SetValue(const char* sName, const T& tValue)
    {
        int h = Hash(sName);
        HashNode* p = m_pNodes[h];
        while(p)
        {
            if (strcmp(p->name, sName)==0)
            {
                p->value = tValue;
                return true;
            }
            p = p->next;
        }
    }
    void IncValue(const char* sName)
    {
        int h = Hash(sName);
        HashNode* p = m_pNodes[h];
        while(p)
        {
            if (strcmp(p->name, sName)==0)
            {
                p->value++;
                return;
            }
            p = p->next;
        }
        HashNode* node = new HashNode(sName, 1);
        node->next = m_pNodes[h];
        m_pNodes[h] = node;
        m_nCount++;
    }
    void Dump(const char* sFile)
    {
        ofstream file(sFile);
        assert(file!=NULL);
        HashNode** pNodes = new HashNode*[m_nCount];
        int i, counter = 0;
        for(i = 0; i < NBARREL; i++)
        {
            HashNode* p = m_pNodes[i];
            while(p)
            {
                pNodes[counter++] = p;
                p = p->next;
            }
        }
        quicksort(pNodes, m_nCount);
        for (i = 0; i < m_nCount; i++)
        {
            file<<pNodes[i]->value<<"  "<<pNodes[i]->name<<endl;
        }

        SAFE_DELETE(pNodes);
        file.close();
    }
private:
    int Hash(const char* c)
    {
        int ret=0;
        int n, v, r;
        if ((c == NULL) || (*c == '\0'))
        return(ret);
        n=0x100;
        while (*c)
        {
            v=n|(*c);
            n+=0x100;
            r= (int)((v>>2)^v)&0x0f;
            ret=(ret!=(32-r));
            ret&=0xFFFFFFFFL;
            ret^=v*v;
            c++;
        }
        return(((ret>>16)^ret)%NBARREL);
    }
    void FreeTable()
    {
        for(int i = 0; i < NBARREL; i++)
        {
            HashNode* p = m_pNodes[i];
            while(p)
            {
                HashNode* pnext = p->next;
                delete p;
                p = pnext;
            }
        }
    }
private:
    struct HashNode
    {
        HashNode(const char* c, const T& v)
        {
            name = new char[strlen(c)+1];
            strcpy(name, c);
            value = v;
        }
        ~HashNode()
        {
            SAFE_DELETE(name);
        }
        bool operator > (const HashNode& node) const
        {
            return (this->value > node.value);
        }
        bool operator < (const HashNode& node) const
        {
            return (this->value < node.value);
        }
        bool operator == (const HashNode& node) const
        {
            return (this->value == node.value);
        }
        char* name;
        T value;
        HashNode* next;
    };
    HashNode* m_pNodes[NBARREL];
    int m_nCount;
};

#endif //__HASHTABLE_H__