散列

以下为学习笔记

散列的插入、删除、查找时间为O(1)，因为其不是像树一样通过比较来进行上面的操作，而是直接进行。

 

理想的散列表结构：一个包含有关键字的具有固定大小的数组。

　　表的大小记为TableSize，index从0到TableSize-1。

 

散列函数

（1）散列函数：每个关键字通过散列函数映射到0~TableSize-1这个范围的某个数，并且关键字被放到散列表适当的单元中。

（2）理想散列函数的要求：两个不同的关键字被映射到不同的单元；在TableSize大小的散列表里均匀地分配关键字。

（3）如果输入的关键字为整数，则一般合理的方法是返回“key mod TableSize”的结果；

　　  通常，关键字是字符串，一种方法是把字符串中字符的ASCII码值加起来，再对TableSize求余。

 

冲突

（1）冲突：当一个元素插入散列表时，其插入的单元已经存在另一个元素时，就产生冲突，冲突需要消除。

（2）解决冲突的常用方法：分离链接法和开放定址法

分离链接法

 

其做法是将散列到同一个单元的所有元素保留到一个表中（即建立个链表保存这些冲突的元素），为了方便，这些表都有表头。

代码如下：

 

#include <iostream>
using namespace std;

struct ListNode//链表结点
{
    int data;//数据
    struct ListNode* next;//next指针
};
typedef struct ListNode* list;
typedef struct ListNode* position;
struct HashTable
{
    int TableSize;//散列表大小
    list TheLists;//定义一个指针指向散列表数组
};
typedef struct HashTable* Hash;

//散列函数,返回该关键字在散列表的位置
unsigned int hash_fun(unsigned int key, int tablesize)
{
    return key%tablesize;
}
//初始化散列表
Hash initialize_table(int tablesize)
{
    Hash H;
    H = (Hash)malloc(sizeof(HashTable));
    H->TableSize = tablesize;
    H->TheLists = (list)malloc(sizeof(ListNode)*tablesize);//new ListNode[tablesize];
    for (int i = 0; i < tablesize; i++)
        (H->TheLists+i)->next = NULL;
    return H;
}
//释放散列表
void destroy_table(Hash H)
{
    position p, tmp,p1=H->TheLists;
    for (int i = 0; i < H->TableSize; i++)
    {
        p = H->TheLists->next;
        while (p != NULL)
        {
            tmp = p->next;
            free(p);
            p = tmp;
        }
        H->TheLists++;
    }
    free(p1);
}
//找数据
position find(Hash H, int data)
{
    position p;
    list L;
    L = H->TheLists + hash_fun(data, H->TableSize);//先找到所属的哪个链表
    p = L->next;
    while (p != NULL && p->data != data)//然后在所属链表里找
        p = p->next;
    return p;//返回指针,没有找到则为NULL
}
//放数据
void insert_data(Hash H,int data[],int n)
{
    position pos,p,tmp; list L;
    for (int i = 0; i < n; i++)
    {
        pos = find(H, data[i]);
        if (pos == NULL)//散列表里没有这个数据
        {
            L = H->TheLists + hash_fun(data[i], H->TableSize);//先找到所属的那个链表
            p = (position)malloc(sizeof(ListNode));
            tmp = L->next;
            L->next = p;
            p->data = data[i];
            p->next = tmp;
        }
        //若已经有这个数据则什么也不干
    }
}
//扫描散列表
void scan(Hash H)
{
    position p; list L;
    for (int i = 0; i < H->TableSize; i++)
    {
        L = H->TheLists + i;
        p = L->next;
        while (p != NULL)
        {
            cout << p->data << " ";
            p = p->next;
        }
    }
}
int main()
{
    Hash H;
    int tablesize = 10;
    int data[] = { 0,1,4,9,16,25,36,49,64,81 };
    H = initialize_table(tablesize);
    insert_data(H, data, 10);
    scan(H);
    destroy_table(H);
    system("pause");
    return 0;
}

 

运行结果：

 

 

 

开放定址法 

 分离链接法缺点是需要指针，且给新单元分配地址需要时间，这使得算法的速度较慢。开放定址法，在发生冲突时尝试在原来的散列表里选择空的单元（而不是建新的空间），直到找到空的单元。单元的选择依据（Hash(X)+F(i))%TableSize，i=0，1，2，3……（遇到冲突时i才加1，没冲突时则不再加），Hash(X)为散列函数，即开始时映射出的关键字在散列表的位置。根据F(i)的不同可以分为线性探测法、平方探测法、双散列。

1）线性探测法

F(i)=i。

只要表够大，总能找到一个空间，但是如此花费的时间是较多的；即使表较空，元素占据的单元也会形成一些区块，称为一次聚集，这使得散列到区块的关键字要多次选单元才能解决冲突。

代码如下：

#include <iostream>
using namespace std;

enum KindOfEntry { Legitimate, Empty, Deleted };//表示散列表某单元是存在数据、空的还是删除了(懒惰删除)
struct HashNode//散列表单元
{
    int data;
    KindOfEntry info;
};
typedef struct HashNode* position;
struct HashTable//记录散列表的信息
{
    int TableSize;
    HashNode* TheCells;
};
typedef HashTable* Hash;

//散列函数
unsigned int fun_hash(unsigned int key, int tablesize, int i)
{
    return (key % tablesize + i) % tablesize;
}
//散列表初始化
Hash initialize_hash(int tablesize)
{
    Hash H;
    H = (Hash)malloc(sizeof(HashTable));
    H->TableSize = tablesize;//初始化散列表大小
    H->TheCells = (position)malloc(sizeof(HashNode)*tablesize);
    for (int i = 0; i < tablesize; i++)
    {
        (H->TheCells + i)->info = Empty;//散列表的单元全部初始化为空
        (H->TheCells + i)->data = -1;//初始化里面数据为-1，表示没有填进数据
    }
    return H;
}
//查找能插入的位置
position find(Hash H, int data)
{
    unsigned int current_pos,i=0;
    current_pos = data % H->TableSize;
    while ((H->TheCells + current_pos)->data != data && (H->TheCells + current_pos)->info != Empty)
    {
        current_pos++;
        if (current_pos >= H->TableSize)
            current_pos =0;
    }
    return H->TheCells + current_pos;
}
//插入
void insert(Hash H, int data[],int n)
{
    for (int i = 0; i < n; i++)
    {
        position p = find(H, data[i]);
        if (p->info != Legitimate)
        {
            p->data = data[i];
            p->info = Legitimate;
        }
    }
}
//扫描
void scan(Hash H)
{
    for (int i = 0; i < H->TableSize; i++)
    {
        if ((H->TheCells + i)->info != Deleted)
            cout << (H->TheCells + i)->data << " ";
        else
            cout << -1 << " ";
    }    
}
//懒惰删除
void lazy_delete(Hash H, int data)
{
    int i = 0;
    while ((H->TheCells + i)->data != data)
        i++;
    (H->TheCells + i)->info = Deleted;
}
int main()
{
    Hash H;
    int data[] = { 89,18,49,58,69 };
    H = initialize_hash(10);
    insert(H, data, 5);
    scan(H);
    cout << endl;
    lazy_delete(H, 89);
    scan(H);
    system("pause");
    return 0;
}

运行结果：

 

2）平方探测法

F(i)=i^2。

消除线性探测的一次聚集问题

一旦散列表被填了超过一半，当表的大小不是素数时甚至在表被填满一般之前，就不能保证一次找到一个空的单元了。

定理：使用平方探测，且表的大小时素数，那么当表至少有一般是空的时候，总能插入一个新的元素。

3）双散列

F(i)=i*hash2(X)。hash2(X)是新的散列函数，一般hash2(X)=R-(X%R)

 

再散列

当散列表快要填满时，操作的运行时间会变长，且insert操作会失败，此时一种解决方法是建立另外一个大约两倍大的表，扫描整个原始散列表，（使用新的散列函数）映射到到新表中。

可以在以下情况时开始再散列：

 

1）表满一半时即开始再散列

2）插入失败时开始

3）达到装填因子（散列表中元素个数/散列表的大小）时开始