散列表

散列表的思想就是把关键值送给一个散列函数，产生出一个散列值，这个值平均分布在一个整数区域中

 

=>散列表的实现的细节

1 当数组足够大时可以直接寻址不需要散列函数，常数操作时间O(1)

   但数据规模远大于散列表大小时，考虑到空间的局限性，需要散列函数使关键值均匀的分开

2 散列表的装载因子，也就是实际决定散列表运算时间的参数， 数据规模n 除与  散列表数组大小m 即 α = n/m

3 散列函数核心是采取一些措施尽可能地使关键字均地分开，

   确保关键字的独立性 => 构造一个良好的散列函数

4 当关键值均匀地存储在散列链表里，花费常数操作时间+链表长度（数据规模n 除与 散列表数组大小m ）=  O(1)+n/m

    如果散列函数弱爆了，几乎所有值都在一个链表里，那么花费线性时间（根据数据规模n）O(n)

5 散列表的大小为1001（选取素数，有助于更加均匀的分开关键值）

6 散列函数通过一系列相乘相加(基数为31）,获取散列值（获取方式请看代码），最终值根据数组大小求模返回

7 通过链表解决碰撞（散列值相同情况），即散列表相当于一个数组，每个元素有一个链表

8 通过键 获取值的 一种散列表（键值对，使用动态分配内存）

#include <iostream>
#include <crtdbg.h>
using namespace std;

typedef int DataType;

struct Node
{
    DataType data;
    char *str;
    Node * next;
};
//可以直接使用一个结构体Node实现
//之所以分开是为了增加灵活性
struct hashNode
{
    Node *node;
    //hashNode *next;
};

class Hash
{
private:
    enum 
    {
        MULTIPLIER = 31,  //乘法散列基数（根据书里的经验 37 也可）
        SIZE = 1001   //使用素数确定散列表大小，尽可能把关键吗均匀地分开
    };
    hashNode *hashTable[SIZE];//散列表
    int hashFn(const char* key);//散列函数
public:
    Hash()
    {
        Init();
    }
    ~Hash()
    {
        Delete();
    }
    void Init();
    void Delete();
    bool Insert(const char* key, const DataType &data);
    bool ExtractData(const char* key);//通过键删除该值
    bool Find(const char* key, DataType &outData);
    void Print()const;

};
int Hash::hashFn(const char* key)
{
    int hashVal = 0;
    for (const char *p = key; *p != '\0'; ++p)
    {
        hashVal = MULTIPLIER*hashVal+ *p;
    }
    return hashVal%SIZE;
}
void Hash::Init()
{
    for (int i=0; i<SIZE; ++i )
    {
        hashTable[i] = NULL;  
    }
}
//释放内存 str、碰撞的node以及hashTable表头
void Hash::Delete()
{
    for (int i=0; i<SIZE; ++i)
    {
        if (hashTable[i] !=NULL)
        {
            for (Node *p = hashTable[i]->node; p != NULL;)
            {
                Node *pTemp = p->next;
                delete [] p->str;  
                delete p;
                p = pTemp;
            }
            hashTable[i]->node = NULL;
            delete hashTable[i];
            hashTable[i] = NULL;
        }
    }
}
//添加元素
bool Hash::Insert(const char* key, const DataType &data)
{
    int index = hashFn(key);
    if (hashTable[index] == NULL)
    {
        hashTable[index] = new hashNode;
        hashTable[index]->node = new Node;
        hashTable[index]->node->data = data;
        hashTable[index]->node->str = new char[sizeof(key)+1];
        strcpy(hashTable[index]->node->str, key);
        hashTable[index]->node->next = NULL;
    }
    else
    {
        Node* p = new Node;
        p->data = data;
        p->str = new char[sizeof(key)+1];
        strcpy(p->str, key);
        p->next = hashTable[index]->node->next;
        hashTable[index]->node->next = p;
    }
    return true;
}
//删除元素
bool Hash::ExtractData(const char* key)
{
    int index = hashFn(key);
    if (hashTable[index] == NULL)
    {
        return false;
    }
    else
    {  //考虑两种情况，hashTable表头 与 链表
        if (strcmp(hashTable[index]->node->str, key) == 0)
        {
            Node *p = hashTable[index]->node->next;
            Node *pTemp = hashTable[index]->node;
            delete [] pTemp->str;
            delete pTemp;
            hashTable[index]->node = p;

            return true;
        }
        else
        {
            Node *pPreNode = hashTable[index]->node;
            for (Node *p=pPreNode->next; p !=NULL; )
            {    
                if (strcmp(p->str, key) == 0)
                {
                     pPreNode->next = p->next;
                     delete [] p->str;
                     delete p;
                     p = NULL;

                     return true;
                }
                pPreNode = p;
                p=p->next;
            }
        }
        return false;
    }
}
//通过键查找值，如果找到通过outData返回
bool Hash::Find(const char* key, DataType &outData)
{
    int index = hashFn(key);
    if (hashTable[index] == NULL)
    {
        return false;
    }
    else
    {
        for(Node *p = hashTable[index]->node;p !=NULL; p = p->next )
        {
            if (strcmp(p->str, key) == 0)
            {
                outData = p->data;
                return true;
            }
        }
    }
    return false;
}
void Hash::Print()const
{
    for (int i=0; i<SIZE; ++i)
    {
        if (hashTable[i] != NULL)
        {
            for (Node *p = hashTable[i]->node; p!=NULL; p = p->next)
            {
                cout << p->str << "\t" << p->data << endl;
            }
        }
    }
}
void main()
{
    _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);

    Hash hash;
    hash.Insert("tom", 15);
    hash.Insert("bart", 17);
    hash.Insert("shan", 17);
    hash.Insert("eve", 16);
    hash.Insert("jack", 21);
    hash.Print();
    hash.ExtractData("jack");
    cout << endl;
    hash.Print();

    cout << endl;
    DataType data=0;
    if (hash.Find("shan",data))
    {
        cout << "shan:   " << data << endl; 
    }

    system("pause");
}