搜索结构--哈希表

哈希概念

• 顺序搜索以及二叉树搜索树中，元素存储位置和元素各关键码之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。搜索的效率取决于搜索过程中元素的比较次数。
• 理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。

• 如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。

• 当向该结构中：

• 插入元素时：根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放
• 搜索元素时：对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键
  码相等，则搜索成功
• 该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表(Hash Table)(或者
  称散列表)

哈希冲突

• 对于两个数据元素的关键字 和 （i != j），有 ！= ，但有：
  HashFun(Ki) == HashFun(Kj) 即不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。

处理哈希冲突

处理哈希冲突两种常见的方法：闭散列和开散列
- 闭散列
也叫开放地址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把key存放到表中“下一个” 空位中去 。寻找“下一个”空位有两种常见的方法：1.线性探测 2.二次探测(Hi+1 = Hi + 2*i +1)；

1.线性探测的缺点：一旦发生哈希冲突，所有的冲突连在一起，容易产生数据“堆积”，即：不同关键码占据了可利用的空位置，使得寻找某关键码的位置需要许多次比较，导致搜索效率降低–解决办法（负载因子–用空间换时间）

• 开散列
  开散列法又叫链地址法(开链法)。
  开散列法：首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。

• 开散列表与闭散列表对比
  开散列表：运用单链表存储方式，不产生堆积现象，应用链地址法处理溢出，需要增设链接指针，似乎增加了存储开销。事实上： 由于开地址法必须保持大量的空闲空间以确保搜索效率，如二次探测法要求负载因子a <= 0.7，而表项所占空间又比指针大的多，所以使用链地址法比使用开地址法更加节省空间。
  闭散列表：运用顺序表存储，存储效率较高，但容易产生堆积，查找不易实现，需要用到二次再查找。

下面为开散列表的代码实现：

HashTable.h

#ifndef __HASHTABLE_H__
#define __HASHTABLE_H__


#include <stdio.h>
#include <assert.h>
#include <malloc.h>

//哈希表中每个位置的状态
typedef enum Stat
{
    EM,  //空
    EX,  //存在
    DE   //被删除
}Stat;

typedef int DataType;
typedef size_t(*PDTInt)(DataType str);

typedef enum
{
    _IsLine,          //线性探测
    _IsNotLine        //二次探测
}IsLine;

//哈希表每个位置包含数据和这个位置的状态
typedef struct Elem
{
    DataType _data;
    Stat stat;
}Elem;

typedef struct HashTable
{
    Elem* _table;
    int _capacity;    //容量
    int _size;        //有效元素个数
    int _total;      //有效元素和被删除的元素之和
    IsLine DetecWay;    //发生哈希冲突的探测方法
    PDTInt pDTInt;      //将数据转化为整型，函数指针
}HTable;


//处理哈希冲突的方法--线性探测
int IsLineDetec(HTable* ht, int addr);

//二次探测
int NotIsLineDetec(HTable* ht, int addr, int i);

//初始化
void HashTableInit(HTable* ht, int capacity, IsLine DetecWay, PDTInt pDtInt);
//插入元素
void HashTableInsert(HTable* ht, DataType data);

//查找元素,找到返回地址
int HashTableFind(HTable* ht, DataType data);

//删除元素
void HashTableDelete(HTable* ht, DataType data);

int HashTableSize(HTable* ht);

int HashTableEmpty(HTable* ht);

//销毁哈希表
void HashTableDestory(HTable* ht);


#endif

HashTable.c

include “HashTable.h”

include “comm.h”

//哈希函数
static int HashFunc(HTable* ht, int data)
{
    assert(ht);

    return ht->pDTInt(data) % (ht->_capacity);
}


//处理哈希冲突的方法--线性探测
int IsLineDetec(HTable* ht, int addr)
{

    addr = addr + 1;
    if (addr == ht->_capacity)//如果越界
        addr = 0;

    return addr;
}

//二次探测
int NotIsLineDetec(HTable* ht, int addr, int i)
{
    addr = addr + 2 * i + 1;

    //如果越界不能直接置零，因为有可能i的值经过不断累加本身已经大于容量
    if (addr >= ht->_capacity)
        addr %= ht->_capacity;
    return addr;
}
//初始化
void HashTableInit(HTable* ht, int capacity, IsLine DetecWay, PDTInt pDtInt)
{
    int i = 0;
    assert(ht);

    //capacity = GetCapacity(capacity);
    ht->_table = (Elem*)malloc(sizeof(Elem)*capacity);

    if (NULL == ht->_table)
        return;

    for (; i < capacity; i++)
        ht->_table[i].stat = EM;

    ht->_capacity = capacity;
    ht->_size = 0;
    ht->_total = 0;
    ht->DetecWay = DetecWay;
    ht->pDTInt = pDtInt;
}

void _Swap(int* left, int* right)
{
    assert(left);
    assert(right);

    int tmp = 0;
    tmp = *left;
    *left = *right;
    *right = tmp;
}

void Swap(HTable* lht, HTable* rht)
{
    assert(lht);
    assert(rht);

    _Swap(&(lht->_capacity), &(rht->_capacity));
    _Swap(&(lht->_size), &(rht->_size));
    _Swap((int*)&(lht->_table), (int*)&(rht->_table));
    _Swap(&(lht->_total), &(rht->_total));
}

//检测容量
void CheckCapacity(HTable* ht)
{
    assert(ht);
    if ((ht->_total) * 10 / (ht->_capacity) >= 7)//负载因子
    {
        int i = 0;
        //创建新哈希表
        HTable NewHt;

        //初始化新哈希表
        HashTableInit(&NewHt, ht->_capacity*2, ht->DetecWay, ht->pDTInt);

        //将原哈希表中的有效元素(EX)插到新哈希表的空间
        for (; i < ht->_capacity; i++)
        {
            if (EX == ht->_table[i].stat)
                HashTableInsert(&NewHt, ht->_table[i]._data);
        }

        //交换新旧哈希表
        Swap(&NewHt, ht);

        //销毁新哈希表
        HashTableDestory(&NewHt);
    }

}

//插入元素
void HashTableInsert(HTable* ht, DataType data)
{
    int addr = 0;
    int i = 0;
    assert(ht);

    //检查容量
    CheckCapacity(ht);

    addr = HashFunc(ht, data);

    //如果计算出的地址不是空，就要一直找新地址
    while (EM != ht->_table[addr].stat)
    {
        //设计的哈希表中的数据唯一
        if (ht->_table[addr].stat == EX)
        {
            if (ht->_table[addr]._data == data)
                return;
        }

        //计算出的地址不能使用，发生哈希冲突
        if (ht->DetecWay == _IsLine)
            addr = IsLineDetec(ht, addr);
        else
            addr = NotIsLineDetec(ht, addr, ++i);
    }

    //说明状态为空，可以直接插入
    ht->_table[addr].stat = EX;
    ht->_table[addr]._data = data;
    ht->_size++;
    ht->_total++;
}

//查找元素,找到返回地址
int HashTableFind(HTable* ht, DataType data)
{
    int addr = 0;
    int startaddr = 0;
    int i = 0;
    assert(ht);

    addr = HashFunc(ht, data);
    startaddr = addr;

    //如果计算出的地址不是空，就要一直找新地址
    while (EM != ht->_table[addr].stat)
    {
        //设计的哈希表中的数据唯一
        if (ht->_table[addr].stat == EX)
        {
            if (ht->_table[addr]._data == data)
                return addr;
        }

        //计算出的地址不能使用，发生哈希冲突
        if (ht->DetecWay == _IsLine)

        {
            addr = IsLineDetec(ht, addr);
            //如果转了一圈都没找到，就肯定没有
            if (addr == startaddr)
                return -1;

        }
        else
            addr = NotIsLineDetec(ht, addr, ++i);

    }

    return -1;
}


//删除元素
void HashTableDelete(HTable* ht, DataType data)
{
    int ret = 0;
    assert(ht);

    if (-1 == ret)
        return;

    ht->_table[ret].stat = DE;
    ht->_size--;
}

int HashTableSize(HTable* ht)
{
    return ht->_size;
}

int HashTableEmpty(HTable* ht)
{
    return ht->_size == 0;
}

//销毁哈希表
void HashTableDestory(HTable* ht)
{
    assert(ht);
    free(ht->_table);
    ht->_table = NULL;
    ht->_capacity = 0;
    ht->_size = 0;
    ht->_total = 0;
}

comm.h

#pragma once

typedef unsigned long size_t;
typedef int DataType;

typedef size_t(*PDTInt)(DataType str);

//用来获取容量，使每次都是素数
int GetCapacity(int capacity);

size_t StrToInt(const char * str);

size_t IntToInt(int data);

comm.c

include “comm.h”

int GetCapacity(int capacity)
{
    static const unsigned long _PrimeList[28] =
    {
        53ul, 97ul, 193ul, 389ul, 769ul,
        1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
        49157ul, 98317ul, 196613ul, 393241ul, 786433ul,
        1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul,
        50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul,
        1610612741ul, 3221225473ul, 4294967291ul
    };
    int i = 0;
    for (; i < 28; i++)
    {
        if (capacity < _PrimeList[i])
            return _PrimeList[i];
    }

    return _PrimeList[27];
}

//将字符串转换为整数
size_t StrToInt(const char * str)
{
    unsigned int seed = 131; // 31 131 1313 13131 131313
    unsigned int hash = 0;
    while (*str)
    {
        hash = hash * seed + (*str++);
    }
    return (hash & 0x7FFFFFFF);
}

size_t IntToInt(int data)
{
    return data;
}

test.c

include “comm.h”

include “HashTable.h”

void TestHashTable()
{
HTable ht;
HashTableInit(&ht, 5, _IsLine, IntToInt);//初始化
printf(“%d\n”, HashTableEmpty(&ht));
HashTableInsert(&ht, 20);//插入
HashTableInsert(&ht, 2);
HashTableInsert(&ht, 5);
HashTableInsert(&ht, 100);
HashTableInsert(&ht, 55);
HashTableInsert(&ht, 1);
HashTableInsert(&ht, 10);
printf(“size = %d\n”, HashTableSize(&ht));

printf("Find:%d\n", ht._table[HashTableFind(&ht, 20)]._data);//查找

HashTableDelete(&ht, 55);//删除
printf("size = %d\n", HashTableSize(&ht));
HashTableDestory(&ht);

}

int main()
{
TestHashTable();//动态闭散列哈希表
}