算法学习-哈希表

    之前在大学学习数据结构的时候，学过数组和链表。数组的优点就是可以直接定位，速度快，但是缺点就是插入删除，效率就慢了很多。链表的可以快速的插入删除，但是不能直接定位，需要遍历才可以。他们使用在不同的场景下面。

    有时候，又想快速的插入，又想快速的定位怎么办？这就需要把这两者优点糅合起来，哈希表就这么产生了。

    哈希表的原理：一个动态数组，保存着元素的地址。通过一个公式，把元素的key（唯一），算出一个数值index。数组index位置就保存这个元素的指针。

    这样存数据以及取数据，都可以通过这个公式，得到同一个位置。这个公式的目的，就是将key和数组的位置映射起来，当然没有任何的一个公式能够保证算出来的key和数组位置是一一对应的，也就是说，多个key算出来的index结果是同一个，这就是哈希冲突，稍后具体怎么解决它。

    整个哈希表，最重要的就是这个映射公式，不但能够将字符串变成数值，而且能够平均分布。最常用的就是Times33算法

inline UINT CMyMap::HashKey(LPCTSTR key) const

{

UINT nHash = 5381;

while (*key)

nHash = (nHash << 5) + nHash + *key++;

return nHash;

}

5381是一个经验值，php就是使用这个值。

下面就是我写的代码。

#pragma once
#include "Bucket.h"
class HashTable
{
public:
    HashTable(void);
    ~HashTable(void);
    static unsigned long hash_inline(const char* arKey,unsigned int nKeyLength);
    bool add(const char* arKey,void* value);
    void* getData(const char* arKey);
    bool remove(const char* arKey);
    bool resize(unsigned int nSize);
    unsigned int nTableSize;
    unsigned int nTableMask;
    unsigned int nNumOfElements;
    Bucket *pBucketCursor;
    Bucket **arBuckets;
    Bucket *pListHead;
    Bucket *pListTail;
private:
    void init();
};
#include "stdafx.h"
#include "HashTable.h"
#include <iostream>
#include <string.h>
using namespace std;
typedef unsigned long ulong;
typedef unsigned int uint;

HashTable::HashTable(void)
{
    init();
}

HashTable::~HashTable(void)
{
    delete [] arBuckets;
}

ulong HashTable::hash_inline( const char* arKey,uint nKeyLength )
{
    register ulong hash=5381;
//     for (; nKeyLength >= 8; nKeyLength -= 8)
//     {
//         const char *arKeyTemp=arKey;
//         for(int i=0;i!=8;++i){
//             hash = ((hash << 5) + hash) + *arKey++;
//             if(*arKey){
//                 arKey=arKeyTemp;
//             }
//         }    
// 
//     }
//     switch (nKeyLength) 
//     {
//         case 7: hash = ((hash << 5) + hash) + *arKey++; /* fallthrough... */
//         case 6: hash = ((hash << 5) + hash) + *arKey++; /* fallthrough... */
//         case 5: hash = ((hash << 5) + hash) + *arKey++; /* fallthrough... */
//         case 4: hash = ((hash << 5) + hash) + *arKey++; /* fallthrough... */
//         case 3: hash = ((hash << 5) + hash) + *arKey++; /* fallthrough... */
//         case 2: hash = ((hash << 5) + hash) + *arKey++; /* fallthrough... */
//         case 1: hash = ((hash << 5) + hash) + *arKey++; break;
//         case 0: break;
//     }
    while (*arKey)
    {
        hash=(hash<<5)+hash+*arKey++;
    }
    return hash;
}

void HashTable::init()
{
    nTableSize=8;
    nTableMask=nTableSize-1;
    arBuckets=new Bucket*[nTableSize]();
    nNumOfElements=0;
}

bool HashTable::add(const char* arKey,void* value )
{
    ulong h=hash_inline(arKey,nTableSize);
    uint nIndex=nTableMask&h;
    Bucket *pbucket=arBuckets[nIndex];
    if (pbucket==NULL)
    {
        pbucket=new Bucket(arKey,value,h);
        arBuckets[nIndex]=pbucket;
        ++nNumOfElements;
        if(nNumOfElements==1)
        {
            pListHead=pbucket;
            pListTail=pbucket;
        }else{
            pbucket->pListPre=pListTail;
            pListTail->pListNext=pbucket;
            pListTail=pbucket;
        }
        //cout<<"add key "<<pbucket->arKey<<endl;
    }else{
        if(strcmp(pbucket->arKey,arKey)==0){
            //cout<<"key "<<arKey<<" is existed"<<endl;
            return false;
        }else{
            Bucket *pNewBucket=new Bucket(arKey,value,h);
            while (pbucket->pNext!=NULL)
            {
                pbucket=pbucket->pNext;
            }
            pbucket->pNext=pNewBucket;
            pNewBucket->pPre=pbucket;
            pNewBucket->pListPre=pListTail;
            pListTail->pListNext=pNewBucket;
            pListTail=pNewBucket;
            //cout<<"key "<<pbucket->arKey<<" next key is "<<pNewBucket->arKey<<endl;
            ++nNumOfElements;
        }
    }
    if(nNumOfElements>=nTableSize){
        resize(nTableSize*2);
    }
    return true;
}

bool HashTable::resize( unsigned int nSize )
{
    Bucket **arPBucketTemp=new Bucket*[nSize]();
    Bucket *pListHeadTemp=NULL;
    Bucket *pListTailTemp=NULL;
    nTableSize=nSize;
    nTableMask=nTableSize-1;
    Bucket *pBucketCursorTemp=pListHead;
    uint nNumOfElementsTemp=0;
    //cout<<"--------------rehash-----------------"<<endl;
    //cout<<"resize size:"<<nSize<<endl;
    while (pBucketCursorTemp!=NULL)
    {
        /*//cout<<"resize pBucket key:"<<pBucketCursorTemp->arKey<<endl;*/
        Bucket *pbucket=pBucketCursorTemp;
        pBucketCursorTemp=pBucketCursorTemp->pListNext;
        ulong h=hash_inline(pbucket->arKey,nTableSize);
        pbucket->nKeyLength=nTableSize;
        pbucket->h=h;
        uint nIndex=h&nTableMask;
        Bucket *pbucketindex=arPBucketTemp[nIndex];
        if (pbucketindex==NULL)
        {    
            arPBucketTemp[nIndex]=pbucket;
            ++nNumOfElementsTemp;
            if(nNumOfElementsTemp==1)
            {
                pListHeadTemp=pbucket;
                pListTailTemp=pbucket;
                pbucket->pListPre=NULL;
                pbucket->pListNext=NULL;
                pbucket->pNext=NULL;
                pbucket->pPre=NULL;
            }else{
                pbucket->pListPre=pListTailTemp;
                pbucket->pListNext=NULL;
                pbucket->pPre=NULL;
                pbucket->pNext=NULL;
                pListTailTemp->pListNext=pbucket;
                pListTailTemp=pbucket;
            }
        }else{
            if(strcmp(pbucket->arKey,pbucketindex->arKey)==0){
                //cout<<"key "<<pbucket->arKey<<" is existed"<<endl;
                return false;
            }else{
                while (pbucketindex->pNext!=NULL)
                {
                    pbucketindex=pbucketindex->pNext;
                }
                pbucketindex->pNext=pbucket;
                pbucket->pPre=pbucketindex;
                pbucket->pNext=NULL;
                pbucket->pListPre=pListTailTemp;
                pbucket->pListNext=NULL;
                pListTailTemp->pListNext=pbucket;
                pListTailTemp=pbucket;
                /*//cout<<"key "<<pbucketindex->arKey<<" next key is "<<pbucketindex->pNext->arKey<<endl;*/
                ++nNumOfElementsTemp;
            }
        }
        
    }
    delete [] arBuckets;
    arBuckets=arPBucketTemp;
    pListTail=pListTailTemp;
    pListHead=pListHeadTemp;
    nNumOfElements=nNumOfElementsTemp;
    //cout<<"--------------rehash end-----------------"<<endl;
    return false;
}

void* HashTable::getData( const char* arKey )
{
    ulong h=hash_inline(arKey,nTableSize);
    ulong nIndex=h&nTableMask;
    Bucket *pbucket=arBuckets[nIndex];
    if(pbucket==NULL){
        return NULL;
    }else{
        while (pbucket!=NULL)
        {
            if(strcmp(pbucket->arKey,arKey)==0){
                return pbucket->pData;
            }else{
                pbucket=pbucket->pNext;
            }
        }
        return NULL;
    }
}

bool HashTable::remove( const char* arKey )
{
    ulong h=hash_inline(arKey,nTableSize);
    ulong nIndex=h&nTableMask;
    Bucket *pbucket=arBuckets[nIndex];
    if(pbucket==NULL){
        return false;
    }else{
        while (pbucket!=NULL)
        {
            if(strcmp(pbucket->arKey,arKey)==0){
                if(pbucket==pListHead){
                    pListHead=pbucket->pListNext;
                    if(pListHead!=NULL){
                        pbucket->pListNext->pListPre=NULL;
                    }
                }
                if(pbucket==pListTail){
                    pListTail=pbucket->pListPre;
                    if(pListTail!=NULL){
                        pListTail->pListNext=NULL;
                    }
                }
                if(pbucket->pListPre!=NULL){
                    pbucket->pListPre->pListNext=pbucket->pListNext;
                }
                if(pbucket->pListNext!=NULL){
                    pbucket->pListNext->pListPre=pbucket->pListPre;
                }
                if(pbucket->pPre!=NULL){
                    pbucket->pPre->pNext=pbucket->pNext;
                }else{
                    arBuckets[nIndex]=pbucket->pNext;
                }
                if(pbucket->pNext!=NULL){
                    pbucket->pNext->pPre=pbucket->pPre;
                }
                --nNumOfElements;
                delete pbucket;
                return true;
            }else{
                pbucket=pbucket->pNext;
            }
        }
        return false;
    }
}

#pragma once
class Bucket
{
public:
    Bucket(const char* arKey,void *value,unsigned long h);
    ~Bucket(void);
    unsigned long h;
    unsigned int nKeyLength;
    void *pData;
    const char *arKey;
    Bucket *pNext;
    Bucket *pPre;
    Bucket *pListNext;
    Bucket *pListPre;
};
#include "stdafx.h"
#include "Bucket.h"


Bucket::Bucket(const char* _arKey,void *value,unsigned long h):arKey(_arKey)
{
    this->pData=value;
    this->h=h;
    this->pNext=NULL;
    this->pPre=NULL;
    this->pListNext=NULL;
    this->pListPre=NULL;
}


Bucket::~Bucket(void)
{
}

// hashtables.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
#include "HashTable.h"
using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
    HashTable ht;
    ht.add("name","max");
    ht.add("name","max");
    ht.add("name2","max2");
    ht.add("name3","max3");
    ht.add("name4","max4");
    ht.add("name5","max5");
    ht.add("name6","max6");
    ht.add("name7","max7");
    ht.add("name8","max8");
    ht.add("name9","max9");
    ht.add("name10","max10");
    ht.add("name11","max11");
    ht.add("name12","max12");
    ht.add("name13","max13");
    ht.add("name14","max14");
    ht.add("name15","max15");
    ht.add("name16","max16");
    ht.add("name17","max17");
    ht.add("name18","max18");
    ht.add("name19","max19");
    ht.add("name20","max20");
    ht.add("name21","max21");
    ht.add("name22","max22");
    ht.add("name23","max23");
    ht.add("name24","max24");
    ht.add("name25","max25");
    ht.add("name26","max26");
    ht.add("name27","max27");
    ht.add("name28","max28");
    ht.add("name29","max29");
    cout<<"------------------------------"<<endl;
    Bucket *bucket=ht.pListHead;
    while(bucket!=NULL)
    {
        cout<<"bucket key:"<<bucket->arKey<<";bucket value:"<<(char*)bucket->pData<<";"<<endl;
        bucket=bucket->pListNext;
    }
    cout<<"------------------------------"<<endl;
    bucket=ht.pListTail;
    while(bucket!=NULL)
    {
        cout<<"bucket key:"<<bucket->arKey<<";bucket value:"<<(char*)bucket->pData<<";"<<endl;
        bucket=bucket->pListPre;
    }
    
    cout<<"------------------------------"<<endl;
    for(int i=0;i!=32;++i){
        Bucket *pbucket=ht.arBuckets[i];
        while(pbucket!=NULL){
            cout<<"bucket key:"<<pbucket->arKey<<";index:"<<i<<endl;
            pbucket=pbucket->pNext;
        }
    }
    cout<<"------------------------------"<<endl;
    cout<<"bucket key "<<"name getData:"<<(char*)ht.getData("name")<<endl;
    cout<<"bucket key "<<"name1 getData:"<<ht.getData("name1")<<endl;
    cout<<"bucket key "<<"name5 getData:"<<(char*)ht.getData("name5")<<endl;
    cout<<"bucket key "<<"name10 getData:"<<(char*)ht.getData("name10")<<endl;
    cout<<"bucket key "<<"name15 getData:"<<(char*)ht.getData("name15")<<endl;
    cout<<"bucket key "<<"name20 getData:"<<(char*)ht.getData("name20")<<endl;
    cout<<"bucket key "<<"name29 getData:"<<(char*)ht.getData("name29")<<endl;
    cout<<"------------------------------"<<endl;
    cout<<"bucket key "<<"name delete:"<<ht.remove("name")<<endl;
    cout<<"bucket key "<<"name1 delete:"<<ht.remove("name1")<<endl;
    cout<<"bucket key "<<"name15 delete:"<<ht.remove("name15")<<endl;
    cout<<"bucket key "<<"name20 delete:"<<ht.remove("name20")<<endl;
    cout<<"bucket key "<<"name10 delete:"<<ht.remove("name10")<<endl;
    cout<<"bucket key "<<"name5 delete:"<<ht.remove("name5")<<endl;
    cout<<"bucket key "<<"name29 delete:"<<ht.remove("name29")<<endl;
    cout<<"------------------------------"<<endl;
    bucket=ht.pListHead;
    while(bucket!=NULL)
    {
        cout<<"bucket key:"<<bucket->arKey<<";bucket value:"<<(char*)bucket->pData<<";"<<endl;
        bucket=bucket->pListNext;
    }
    cout<<"------------------------------"<<endl;
    for(int i=0;i!=32;++i){
        Bucket *pbucket=ht.arBuckets[i];
        while(pbucket!=NULL){
            cout<<"bucket key:"<<pbucket->arKey<<";index:"<<i<<endl;
            pbucket=pbucket->pNext;
        }
    }
    cout<<"elemetes num "<<ht.nNumOfElements<<endl;
    cout<<"------------------------------"<<endl;
    int num=10000500;
    for(int i=0;i!=num;++i){
        char *key=new char[10]();
        for(int j=0;j!=9;++j){
            int c=rand()%26+97;
            key[j]=c;
        }
        key[9]=0;
        ht.add(key,key);
    }
    cout<<"------------------------------"<<endl;
//     ht.add("name30","max30");
//     ht.add("name31","max31");
//     ht.add("name32","max32");
//     ht.add("name33","max33");
//     ht.add("name34","max34");
//     ht.add("name35","max35");
//     ht.add("name36","max3");
//     for(int i=0;i!=32;++i){
//         Bucket *pbucket=ht.arBuckets[i];
//         while(pbucket!=NULL){
//             cout<<"bucket key:"<<pbucket->arKey<<";index:"<<i<<endl;
//             pbucket=pbucket->pNext;
//         }
//     }
//     cout<<"elemetes num "<<ht.nNumOfElements<<endl;
//     cout<<"------------------------------"<<endl;
//     num=5000;
//     for(int i=0;i!=num;++i){
//         char *key=new char[10]();
//         for(int j=0;j!=9;++j){
//             int c=rand()%26+97;
//             key[j]=c;
//         }
//         key[9]=0;
//         cout<<"main key:"<<key<<endl;
//         ht.add(key,key);
//         cout<<"main end key:"<<key<<endl;
//     }
//     cout<<"elemetes num "<<ht.nNumOfElements<<endl;
//     cout<<"------------------------------"<<endl;
//     return 0;
}