哈希表——根据函数和关键字key查找

---

哈希函数就是根据key计算出应该存储地址的位置，而哈希表是基于哈希函数建立的一种查找表。

---

一、哈希函数

1、构造方法

• （1）直接定址法

  • 哈希函数为关键字的线性函数如H (key ) =a.key+b或H(key)=key;
  • 适应情况：事先知道关键码，关键码集合不是很大且连续性较好;
  • 优点：不会产生冲突
  • 缺点：占用连续空间，空间效率低

• （2）数字分析法

  • 假设关键字集合中的每个关键字key都是由s位数字组成，分析key 中的全体数据，并从中提取分布均匀的若干位或他们的组合构成全体。

• （3）平方取中法

  • 如果关键字的每一位都有某些数字重复出现频率很高的现象，可以先求关键字的平方值，通过平方扩大差异，而后取中间数位作为最终存储地址。
  • 适应情况：事先不知道关键码的分布，且关键码的位数不是很大。

• （4）除留余数法

  • H(key）=key MOD p (p<=m，m为表长)
  • 技巧：一般情况下，选p为小于或等于表长（最好接近表长）的素数.
  • 缺点：连续的关键码映射成连续的散列值，虽然能保证连续的关键码不发生冲突，但也意味着要占据连续的数组单元，可能导致散列性能的降低

• （5）折叠法

  • 将关键字分割成位数相同的几部分，然后取叠加和(舍去进位)作为哈希地址
  • 适应情况：事先不知道关键码的分布，且关键码的位数很多；

• （6）随机数法

  • 取关键字的随机函数为哈希地址，即H(key)=random(key)

2、哈希函数设计考虑因素

• 计算散列地址所需要的时间〔即hash函数本身不要太复杂);
• 关键字的长度;
• 表长;
• 关键字分布是否均匀，是否有规律可循;
• 设计的hash函数在满足以上条件的情况下尽量减少冲突。

3、哈希冲突

• 即不同key 值产生相同的地址，H (key1) = H (key2 )。

4、解决哈希冲突

• （1）开放定址法

  • 即当发生H(key1)= H (key2)时，发现key1已经存在时，这时key2无法存放到对应的哈希糟内，那么我们为其寻找新的哈希槽存放它，
    • 寻找的方法有多种
      • 1)线性探测再散列
      • 2)平方探测再散列
      • 3)随机

• （2）链地址法

  • 在哈希槽内用一条链表把发生冲突的数据挂到一起。

5、哈希表/散列表

• 定义

        其实就是一个数组，对这个数组进行访问的下标由哈希函数生成。

        散列既是一种查找技术，也是一种存储技术。散列只是通过记录的关键码定位该记录，没有完整地表达记录之间的逻辑关系，所以，散列主要是面向查找的存储结构。

• 代码实现(待补充)

  • 装填因子α=关键字个数/表长
    • α是已存入元素与散列空间大小的比例
    • 一般取值为0.6-0.9时产生冲突的可能性较小
    • 例如，若有元素600个，则选取表长为667~1000较为合适。

  • #include 
    #include 
    #define H_OK 0
    #define H_NO -1
    #define HASH_SIZE    17777          //哈希表大小（最好是质数）
    
    //数据结点的定义
    typedef struct HashNode
    {
       int data;                        //数据域
        struct HashNode *next;          //指针域 
    }HashNode;
    
    //哈希槽结点定义
    typedef struct HashSlot
    {
        HashNode *head;                 //链表头节点（解决哈希冲突）
    }HashSlot;
    
    //哈希表初始化
    int init_hash_table()
    {
        hash_table = (HashSlot*)malloc(sizeof(HashSlot) * HASH_SIZE);    //给hash_table分配内存
        if(hash_table == NULL)
        {
            return H_NO;
        }
        
        int index = 0;        //        给每个哈希槽内的链表头分配内存
        for(;index < HASH_SIZE;++index)
        {
            hash_table[index].head = (HashSlot*)malloc(sizeof(HashNode));
            if(hash_table[index].head == NULL)
            {
                return H_NO;
            }
            hash_table[index].head->next = NULL;
        }
        return H_OK;
    }
    
    //获取哈希种子（哈希键值）
    int get_hash_key(int data)
    {
        if(data<0)
        {
            return (-data % HASH_SIZE);
        }
        return (data % HASH_SIZE);
    }
    
    //插入一个数据
    int insert_data(int data)
    {
    
        
        int key = get_hash_key(data);	//获取哈希键值
        if(key<0)
        {
         	return H_NO;		//哈希槽为空
        }
       if(hash_table != NULL)	//申请一个空的结点，需要分配内存
        {
    	HashNode *pNode = (HashNode*)malloc(sizeof(HashNode));
    	if(pNode == NULL)
    	{
    	    return H_NO;
    	}
    	pNode->data=data;	//数据域的赋值
    	
    	pNode->next = hash_table[key].head->next;    //头插法插入链表
    	hash_table[key].head->next=pNode;
    
    	return H_OK;
        }
        return H_NO;
    }
    
    //查找一个数据
    int search_data(int data)
    {
        int key = get_hash_key(data);
        if(key<0)
        {
    	return H_NO:
        }
        if(hash_table != NULL)
        {
    	HashNode *pNode = hash_table[key].head->next;
    	while(pNode != NULL)
    	{
    	    if(data==pNode->data)
    	    {
    		printf("seaarch success:%p:%p\n",pNode,hash_table[key]);
    		return H_OK;
    	    }
    	    pNode = pNode->next;
            }
        }
        return H_NO;
    }
    
    //删除一个数据
    
    
    //主函数
    int main()
    {
    
        init_hash_table();
    
        if(1 == get_hash_key(1) && 1==get_hash_key(17778))
        {
            printf("TEST OK!\n");
        }
    
        insert_data(1);
        insert_data(17778);
        insert_data(0);
        insert_data(2);
        insert_data(17779);
    
        search_data(1);
        search_data(17778);
        search_data(0);
        search_data(2);
        search_data(17779);
        return 0;
    }