哈希表的原理和使用(C++代码)

最新推荐文章于 2024-08-04 21:48:35 发布
最新推荐文章于 2024-08-04 21:48:35 发布
阅读量5.2w 收藏 445
点赞数 78
分类专栏： 算法与数据结构 文章标签： 数据结构 算法基础 哈希表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38169413/article/details/81612307
版权

文章目录

一、概念

散列技术是在记录的存储位置和他的关键字之间建立一个确定的对应关系f，是的每个关键字key对应一个存储位置f(key)。查找时，根据这个对应的关系找到给定值key的映射f(key)，若查找集合中存在这个记录，则必定在f(key)的位置上。我们把这种对应关系f成为散列函数，又称为哈希(Hash)函数。采用散列技术将记录存储在一块连续的存储空间中，这块连续空间称为散列表或哈希表(Hash-Table)。

二、散列表的构造方法

2.1 直接定址法

直接定址法使用下面的公式
f ( k e y ) = a × k e y + b , b 为 常 数 f(key) = a×key+b,b为常数 f(key)=a×key+b,b为常数
比如统计出生年份，那么就可以使用 f ( k e y ) = k e y − 1990 f(key) = key-1990 f(key)=key−1990来计算散列地址。
在这里插入图片描述

2.2 除留取余法

这种方法是最常用的散列函数构造方法，对于表长为m的散列公式为
f ( k e y ) = k e y m o d    p ( p ≤ m ) f(key)=key \mod p (p \leq m) f(key)=keymodp(p≤m)
在这里插入图片描述

2.3 数字分析法

分析数字关键字在各位上的变化情况，取比较随机的位作为散列地址这里使用一个手机号码作为例子，手机号码是一个字符串，一般的说，后面4位是真正的用户号。
![在这里插入图片描述](https://img-blog.csdnimg.cn/20190310214023289.png)

2.4 折叠法

把关键词分割成位数相同的几个部分，然后叠加。
在这里插入图片描述

2.5 平方取中法

在这里插入图片描述

三、冲突解决方法

常用处理冲突的思路：

  • 换个位置: 开放地址法
  • 同一位置的冲突对象组织在一起: 链地址法

3.1 开放地址法

一旦产生了冲突（该地址已有其它元素），就按某种规则去寻找另一空地址.若发生了第 i 次冲突，试探的下一个地址将增加 d i d_i di​， 基本公式是：
h i ( k e y ) = ( h ( k e y ) + d i ) m o d    T a b l e S i z e ( 1 ≤ i < T a b l e S i z e ) h_i(key) = (h(key)+d_i) \mod TableSize ( 1≤ i < TableSize ) hi​(key)=(h(key)+di​)modTableSize(1≤i<TableSize)
这里面 d i d_i di​ 决定了不同的解决冲突方案： **线性探测、平方探测、双散列。**下面依次介绍各中方法。

3.1.1 线性探测法

线性探测法以增量序列 1 ， 2 ， … … ， （ T a b l e S i z e − 1 ) 1， 2， ……，（TableSize -1) 1，2，……，（TableSize−1)循环试探下一个存储地址。
【例1】 设关键词序列为 47 ， 7 ， 29 ， 11 ， 9 ， 84 ， 54 ， 20 ， 30 {47， 7， 29， 11， 9， 84， 54， 20， 30} 47，7，29，11，9，84，54，20，30,散列表表长 T a b l e S i z e = 11 TableSize =11 TableSize=11 （装填因子 α = 9 / 13 ≈ 0.69 α= 9/13 ≈ 0.69 α=9/13≈0.69）,散列函数为： h ( k e y ) = k e y m o d    11 h(key) = key \mod 11 h(key)=keymod11。 用线性探测法处理冲突，列出依次插入后的散列表，并估算查找性能。

【解】 初步的散列地址如下表所示。

关键词 ( k e y ) (key) (key)4772911984542030
散列地址 h ( k e y ) h(key) h(key)3770971098

可以看出，有多个关键词的散列地址发生了冲突，具体见下表。

关键词 ( k e y ) (key) (key)4772911984542030
散列地址 h ( k e y ) h(key) h(key)3770971098
冲突次数001003136

具体的哈希表构建过程可以用下面的图表来表示
在这里插入图片描述

这里引出一下散列表的的查找性能分析，散列表的查找性能，一般有两种方法

  • 成功平均查找长度(ASLs)
  • 不成功平均查找长度 (ASLu)

对于上面一题的散列地址冲突次数为

散列地址 h ( k e y ) h(key) h(key)0123456789101112
关键词 ( k e y ) (key) (key)1130477299845420
冲突次数060010313

ASLs： 查找表中关键词的平均查找比较次数（其冲突次数加1）
A S L s = （ 1 + 7 + 1 + 1 + 2 + 1 + 4 + 2 + 4 ） / 9 = 23 / 9 ≈ 2.56 ASLs = （1+7+1+1+2+1+4+2+4） / 9 = 23/9 ≈ 2.56 ASLs=（1+7+1+1+2+1+4+2+4）/9=23/9≈2.56

ASLu：不在散列表中的关键词的平均查找次数（不成功）
一般方法：将不在散列表中的关键词分若干类。
如：根据H(key)值分类
A S L u = （ 3 + 2 + 1 + 2 + 1 + 1 + 1 + 9 + 8 + 7 + 6 ） / 11 = 41 / 11 ≈ 3.73 ASL u= （3+2+1+2+1+1+1+9+8+7+6） / 11 = 41/11 ≈ 3.73 ASLu=（3+2+1+2+1+1+1+9+8+7+6）/11=41/11≈3.73

  • 参考代码
#include<iostream>
#include <stdlib.h>
using namespace std;


#define SUCCESS 1
#define UNSUCCESS 0
#define HASHSIZE 12
#define NULLKEY -32768
typedef bool Status ;
typedef struct 
{
	int *elem;
	int count;
}HashTable;

int m = 0;   //the length of HashTable


//Initialize  of HashTable
Status InitHashTable(HashTable* H)
{
	int i;
	m = HASHSIZE;
	H->count = m;
	H->elem = (int*)malloc(m*sizeof(int));
	for(i = 0;i < m; i++)
	{
		H->elem[i] = NULLKEY;
	}
	return true;
}

//hash function
int Hash(int key)
{
	return key % m; 
}

//Insert the elem to the Hahtable
void InsertHash(HashTable* H,int key)
{
	int addr = Hash(key);  //get the address of hash
	while(H->elem[addr] != NULLKEY)     //Conflict
		addr = (addr+1) % m;
	H->elem[addr] = key;
}


//search the key
Status searchHash(HashTable H,int key,int *addr)
{
	*addr = Hash(key);
	while(H.elem[*addr] != key)
	{
		*addr = (*addr+1) % m;
		if(H.elem[*addr] == NULLKEY || *addr == Hash(key))
			//return the origin
			return UNSUCCESS;
	}
	return SUCCESS;
}

int main()
{
	return 0;
}

3.1.2 平方探测法

平方探测法以增量序列 1 2 , − 1 2 , 2 2 , − 2 2 , . . . , q 2 1^2 ,-1^2 ,2^2 ,-2^2 ,...,q^2 12,−12,22,−22,...,q2，且 q ≤ ⌊ T a b l e S i z e / 2 ⌋ q ≤ \lfloor TableSize/2 \rfloor q≤⌊TableSize/2⌋ 循环试探下一个存储地址。还是使用[例1]，得到的冲突如下表

关键词 key4772911984542030
散列地址h(key)3770971098
冲突次数001002033

A S L s = ( 1 + 1 + 2 + 1 + 1 + 3 + 1 + 4 + 4 ) / 9 = 18 / 9 = 2 ASLs =(1+1+2+1+1+3+1+4+4)/ 9 = 18/9 = 2 ASLs=(1+1+2+1+1+3+1+4+4)/9=18/9=2
在这里插入图片描述

  • 参考代码
/*******************************************************************************
功    能：哈希表——平方探测法(+/- 1^2,2^2,3^2...)
创建时间： 2018-07-24
作    者：Elvan
修改时间：
作    者：
********************************************************************************/

#include <iostream>
#include <string>
#include <vector>
#include <cmath>
#include <malloc.h>
using namespace std;

#define MAXTABLESIZE 10000 //允许开辟的最大散列表长度
typedef int ElementType;
typedef enum
{
    Legitimate,
    Empty,
    Deleted
} EntryType; //散列单元的状态类型

struct HashEntry
{
    ElementType data; //存放的元素
    EntryType state;  //单元状态
};

typedef struct HashEntry Cell;

struct TblNode
{
    int tablesize; //表的最大长度
    Cell *cells;   //存放散列单元数据的数组
};
typedef struct TblNode *HashTable;

/*返回大于n且不超过MAXTABLESIZE的最小素数*/
int NextPrime(int n)
{
    int p = (n % 2) ? n + 2 : n + 1; //从大于n的下一个奇数开始
    int i;
    while (p <= MAXTABLESIZE)
    {
        for (i = (int)sqrt(p); i > 2; i--)
        {
            if ((p % i) == 0)
                break;
        }
        if (i == 2)
            break; //说明是素数，结束
        else
            p += 2;
    }
    return p;
}

/*创建新的哈希表*/
HashTable CreateTable(int table_size)
{
    HashTable h = (HashTable)malloc(sizeof(TblNode));
    h->tablesize = NextPrime(table_size);
    h->cells = (Cell *)malloc(h->tablesize * sizeof(Cell));
    //初始化哈希表状态为空单元
    for (int i = 0; i < h->tablesize; i++)
    {
        h->cells[i].state = Empty;
    }
    return h;
}

/*查找数据的初始位置*/
int Hash(ElementType key, int n)
{
    return key % 11; //假设为11
}

/*查找元素位置*/
int Find(HashTable h, ElementType key)
{
    int current_pos, new_pos;
    int collision_num = 0; //记录冲突次数

    new_pos = current_pos = Hash(key, h->tablesize); //初始散列位置

    //当该位置元素为非空并且不是要找的元素的时候，发生冲突
    while (h->cells[new_pos].state != Empty && h->cells[new_pos].data != key)
    {
        collision_num++;
        if (collision_num % 2) //处理奇数冲突
        {
            new_pos = current_pos + (collision_num + 1) * (collision_num + 1) / 4;
            if (new_pos >= h->tablesize)
                new_pos = new_pos % h->tablesize;
        }
        else //处理偶数冲突
        {
            new_pos = current_pos - (collision_num) * (collision_num) / 4;
            while (new_pos < 0)
                new_pos += h->tablesize; //调整到合适大小
        }
    }
    return new_pos;
}


/*插入新的元素*/
bool Insert(HashTable h,ElementType key)
{
    int pos = Find(h,key);  //先查找key是否存在
    if(h->cells[pos].state != Legitimate)
    {
        h->cells[pos].state = Legitimate;
        h->cells[pos].data = key;
        return true;
    }
    else
    {
        cout << "键值已存在！"<<endl;
        return false;
    }
}


int main(int argc, char const *argv[])
{
    int a[] = {47,7,29,11,9,84,54,20,30};
    int n = 9;
    HashTable h = CreateTable(n);
    for(int i = 0;i < n;i++)
    {
        Insert(h,a[i]);  //插入元素
    }
    for(int i = 0;i < h->tablesize;i++)
    {
        cout << h->cells[i].data << " ";  //打印哈希表元素
    }
    cout << endl;
    return 0;
}

3.2 链地址法

链地址法就是将相应位置上冲突的所有关键词存储在同一个单链表中
【例2】 设关键字序列为 47 , 7 , 29 , 11 , 16 , 92 , 22 , 8 , 3 , 50 , 37 , 89 , 94 , 21 47, 7, 29, 11, 16, 92, 22, 8, 3, 50, 37, 89, 94, 21 47,7,29,11,16,92,22,8,3,50,37,89,94,21，散列函数取为 h ( k e y ) = k e y m o d    11 h(key) = key \mod 11 h(key)=keymod11，用分离链接法处理冲突。
在这里插入图片描述
【解】表中有9个结点只需1次查找，5个结点需要2次查找，所以查找成功的平均查找次数为
A S L s = ( 9 + 5 ∗ 2 ) / 14 ≈ 1.36 ASLs=(9+5*2)/ 14 ≈ 1.36 ASLs=(9+5∗2)/14≈1.36

  • 参考代码
/*******************************************************************************
功    能：哈希表——链表法(+/- 1^2,2^2,3^2...)
创建时间： 2018-07-24
作    者：Elvan
修改时间：
作    者：
********************************************************************************/

#include <iostream>
#include <string>
#include <vector>
#include <cmath>
#include <malloc.h>
using namespace std;

#define MAXTABLESIZE 10000 //允许开辟的最大散列表长度
#define KEYLENGTH 100      //关键字的最大长度

typedef int ElementType;
struct LNode
{
    ElementType data;
    LNode *next;
};
typedef LNode *PtrToNode;
typedef PtrToNode LinkList;
struct TblNode
{
    int tablesize;  //表的最大长度
    LinkList heads; //存放散列单元数据的数组
};
typedef struct TblNode *HashTable;

/*返回大于n且不超过MAXTABLESIZE的最小素数*/
int NextPrime(int n)
{
    int p = (n % 2) ? n + 2 : n + 1; //从大于n的下一个奇数开始
    int i;
    while (p <= MAXTABLESIZE)
    {
        for (i = (int)sqrt(p); i > 2; i--)
        {
            if ((p % i) == 0)
                break;
        }
        if (i == 2)
            break; //说明是素数，结束
        else
            p += 2;
    }
    return p;
}

/*创建新的哈希表*/
HashTable CreateTable(int table_size)
{
    HashTable h = (HashTable)malloc(sizeof(TblNode));
    h->tablesize = NextPrime(table_size);
    h->heads = (LinkList)malloc(h->tablesize * sizeof(LNode));
    //初始化表头结点
    for (int i = 0; i < h->tablesize; i++)
    {
        h->heads[i].next = NULL;
    }
    return h;
}

/*查找数据的初始位置*/
int Hash(ElementType key, int n)
{
    //这里只针对大小写
    return key % 11;
}

/*查找元素位置*/
LinkList Find(HashTable h, ElementType key)
{
    int pos;

    pos = Hash(key, h->tablesize); //初始散列位置

    LinkList p = h->heads[pos].next; //从链表的第一个节点开始
    while (p && key != p->data)
    {
        p = p->next;
    }

    return p;
}

/*插入新的元素*/
bool Insert(HashTable h, ElementType key)
{
    LinkList p = Find(h, key); //先查找key是否存在
    if (!p)
    {
        //关键词未找到，可以插入
        LinkList new_cell = (LinkList)malloc(sizeof(LNode));
        new_cell->data = key;
        int pos = Hash(key, h->tablesize);
        new_cell->next = h->heads[pos].next;
        h->heads[pos].next = new_cell;
        return true;
    }
    else
    {
        cout << "键值已存在！" << endl;
        return false;
    }
}

/*销毁链表*/
void DestroyTable(HashTable h)
{
    int i;
    LinkList p, tmp;
    //释放每个节点
    for (i = 0; i < h->tablesize; i++)
    {
        p = h->heads[i].next;
        while (p)
        {
            tmp = p->next;
            free(p);
            p = tmp;
        }
    }
    free(h->heads);
    free(h);
}

int main(int argc, char const *argv[])
{
    int a[] = {47, 7, 29,29, 11, 16, 92, 22, 8, 3, 50, 37, 89, 94, 21};
    int n = 15;
    HashTable h = CreateTable(n);
    for (int i = 0; i < n; i++)
    {
        Insert(h, a[i]); //插入元素
    }
    for (int i = 0; i < h->tablesize; i++)
    {
        LinkList p = h->heads[i].next;
        while (p)
        {
            cout << p->data << " "; //打印哈希表元素
            p = p->next;
        }
        cout << endl;
    }
    return 0;
}
hustanding
关注
专栏目录
通用链表实现哈希表
Orange_pa的博客
08-17 265
通用链表实现哈希表.hashTest.c调用hashtable.h里面提供的接口，完成哈希链表的构建和增删改查等。hashtable.c 是hashtable.h的实现。
哈希表C++简单实现
weixin_43606861的博客
02-28 8112
1.什么是哈希表 哈希表（Hash table，也叫散列表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。 1.1 哈希函数 也叫散列函数，即：根据key,计算出key对应记录的储存位置 position = f(key) 散列函数满足以下的条件： 1、对输入值运算，得到一个固定长度的摘要(Hash val...
数据结构中常见的哈希表，到底是什么？
热门推荐
Edison's 小宇宙
04-09 8万+
散列表（Hash table），根据关键码值而直接进行访问的数据结构。它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。
C++&&数据结构——哈希表
aaqq800520的博客
01-23 1600
在C++98中，STL提供了以红黑树为底层的一系列关联式容器，查询时效率可达到logN，但是当树中节点非常多时，查询效率也不理想，所以在C++11中，STL提供了unordered系列的几个容器，使用哈希表作为底层，大大增加了查询效率。对于删除，采用闭散列处理哈希冲突时，不能直接删除表中的数据否则会影响其他数据的搜索，所以采用标记的伪删除法来删除，给要删除的位置打上delete的标记，具体实现请看后面的模拟实现部分。最好的情况是，每个桶中刚好有一个节点，再插入数据时，都会发生哈希冲突，
数据结构 - 哈希表
最新发布
2302_79539362的博客
08-04 1217
数据结构 - 散列表
哈希链表的实现C++
Worthwhile_DUT的博客
12-03 1939
哈希链表的实现
C++数据结构与算法——哈希表实现（链式法）
柯九思kk的博客
11-24 1145
解决散列冲突文件结构字典类概念代码哈希类概念代码有序链表概念代码哈希表实现概念代码测试主函数代码输出 文件结构 字典类 概念 代码 //dictionary.h template<class K,class E> class dictionary { public: virtual ~dictionary(){}//虚析构函数 //纯虚函数 virtual bool empty() const = 0; virtual int size() const = 0;
哈希代码C++
05-04
哈希 C++
哈希表-使用C++实现的哈希表-HashTable.zip
03-04
在"哈希表_使用C++实现的哈希表_HashTable"这个压缩包中，很可能包含了用C++实现的哈希表源代码，可以作为学习和参考。源代码通常会包括哈希函数的定义、插入、查找和删除操作的实现，以及处理哈希冲突的策略。 ...
哈希表-使用C++实现的分布式哈希表.zip
03-04
在本压缩包中，我们关注的是使用C++实现的分布式哈希表，这是一种在多台计算机上分散存储数据的哈希表，它具有高可用性和可扩展性。 首先，让我们深入理解哈希表的基本原理。哈希函数是关键，它的任务是将任意长度...
C++ 实现哈希表的实例
08-29
C++ 实现哈希表的实例详解 哈希表是一种常用的数据结构，它可以快速地...通过了解哈希表的基本概念、C++ 实现哈希表的实例代码实现、哈希表的实现机制和哈希表的应用场景，我们可以更好地应用哈希表来解决实际问题。
哈希表------链表
10-29
哈希表--链表 哈希表--链表 哈希表--链表 哈希表--链表哈希表--链表 哈希表--链表哈希表--链表 哈希表--链表哈希表--链表 哈希表--链表哈希表--链表 哈希表--链表
哈希算法的实现c++
05-10
哈希算法的实现c++
哈希表de 设计.rar_c++ 哈希表_哈希_哈希 VC_哈希表
09-23
哈希表，也被称为散列表...在C++中，通过理解和利用`unordered_map`，开发者可以轻松地实现和使用哈希表，提高程序的运行效率。不断优化哈希函数、控制装载因子以及选择合适的冲突解决策略，都是提升哈希表性能的关键。
哈希表(理论剖析+代码实现)
修行的凡人的博客
10-16 4085
基于著名书籍和自我研究得出的哈希表理论剖析与代码实现
链表实现哈希表以及哈希表的应用
weixin_45642150的博客
04-01 708
''' 哈希表 字典和集合 一个通过哈希函数来计算数据存储位置的数据结构，通常支持如下操作： insert:插入键值对 get ：如果存在键为key的键值对则返回其value，否则返回空值 delete:删除键为key的键值对 直接寻址表 关键字的全域U比较小时，一种简单而又有效的方法 缺点： 当域U很大，需要消耗大量内存 当域U很大，实际出现的key很少， 无法处理关键字不是数字的情况 直接寻址表：key为k的元素放在k位置上 哈希： 构建大小为m的寻址表T key为k的元
数组、链表、哈希表
taotaoahui
10-08 7994
http://bbs.csdn.net/topics/390669143 上体育课的时候，老师说：你们站一队，每个人记住自己是第几个，我喊到几，那个人就举手，这就是数组。 老是说，你们每个人记住自己前面的人和后面的人，然后老师只知道第一人是谁。 然后你们各自由活动，老是要找某一个人，是不是每次都是从第一个开始往自己身后的人开始传达？这就是链表。 老师说： 大家1，2，3，4报
【C++】哈希表模拟实现
m0_69442905的博客
10-10 1099
了解哈希表的几种实现方式，初步了解哈希函数，初步构建简单的封闭哈希表，实现插入，查找，删除等。然后对封闭哈希表基础上进行更新，引出介绍链式哈希表，实现最简单的插入查找，删除
C++ 哈希表
Han同学
02-26 3313
C++哈希表
评论 19
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值