哈希技术

最新推荐文章于 2024-05-28 22:08:12 发布
最新推荐文章于 2024-05-28 22:08:12 发布
阅读量373 收藏 1
点赞数
原文链接：http://www.cnblogs.com/wulei0630/p/9351056.html
版权

1. 哈希的定义

在数据元素的存储位置和它的关键字之间建立一个映射关系f，通过f可以直接得到关键字所代表的数据元素

 

2. 哈希表

哈希技术中用于存储数据元素的数据结构

 

3. 哈希函数

哈希技术中的映射关系f

 

4. 哈希技术的关键点

① 哈希表：哈希技术需要具体的数据结构为基础，如数组、链表、二叉树......

②哈希函数：哈希技术需要映射关键字和数据元素的存储位置，依赖于数学运算，如四则运算、逻辑运算、比较......

 

5. 哈希的操作

① 创建哈希： Hash* Hash_Create();
② 销毁哈希： void Hash_Destroy(Hash* hash);
③ 清空哈希： void Hash_Clear(Hash* hash);
④ 加入键值对： int Hash_Add(Hash* hash, HashKey* key, HashValue* value);
⑤ 删除键值对： HashValue* Hash_Remove (Hash* hash, HashKey* key);
⑥ 根据建获取值： HashValue* Hash_Get(Hash* hash, HashKey* key);
⑦ 获取键值对数目： int Hash_Count(Hash* hash);

 

6. 哈希的实现

哈希表 = 数组 + 链表

① DList.h

#ifndef DLIST_H
#define DLIST_H

typedef enum _Ret
{
    RET_OK,
    RET_OOM,
    RET_STOP,
    RET_PARAMS,
    RET_FAIL
} Ret;

struct _DList;
typedef struct _DList DList;

typedef void (*DListDataDestroyFunc)(void* ctx, void* data);
typedef int (*DListDataCompareFunc)(void* ctx, void* data);
typedef Ret (*DListDataVisitFunc)(void* ctx, void* data);

DList* dlist_create(DListDataDestroyFunc data_destroy, void* data_destroy_ctx);

Ret dlist_insert(DList* thiz, size_t index, void* data);
Ret dlist_prepend(DList* thiz, void* data);
Ret dlist_append(DList* thiz, void* data);
Ret dlist_delete(DList* thiz, size_t index);
Ret dlist_get_by_index(DList* thiz, size_t index, void** data);
Ret dlist_set_by_index(DList* thiz, size_t index, void* data);
size_t   dlist_length(DList* thiz);
int      dlist_find(DList* thiz, DListDataCompareFunc cmp, void* ctx);
Ret dlist_foreach(DList* thiz, DListDataVisitFunc visit, void* ctx);

void dlist_destroy(DList* thiz);

#endif

 

② DList.c

#include <stdlib.h>
#include "DList.h"

typedef struct _DListNode
{
    struct _DListNode* prev;
    struct _DListNode* next;

    void* data;
}DListNode;

struct _DList
{
    DListNode* first;
    DListDataDestroyFunc data_destroy;
    void* data_destroy_ctx;
};

static void dlist_destroy_data(DList* thiz, void* data)
{
    if(thiz->data_destroy != NULL)
    {
        thiz->data_destroy(thiz->data_destroy_ctx, data);
    }

    return;
}

static DListNode* dlist_create_node(DList* thiz, void* data)
{
    DListNode* node = malloc(sizeof(DListNode));

    if(node != NULL)
    {
        node->prev = NULL;
        node->next = NULL;
        node->data = data;
    }

    return node;
}

static void dlist_destroy_node(DList* thiz, DListNode* node)
{
    if(node != NULL)
    {
        node->next = NULL;
        node->prev = NULL;
        dlist_destroy_data(thiz, node->data);
        free(node);
    }

    return;
}

DList* dlist_create(DListDataDestroyFunc data_destroy, void* data_destroy_ctx)
{
    DList* thiz = malloc(sizeof(DList));

    if(thiz != NULL)
    {
        thiz->first = NULL;
        thiz->data_destroy = data_destroy;
        thiz->data_destroy_ctx = data_destroy_ctx;
    }

    return thiz;
}

static DListNode* dlist_get_node(DList* thiz, size_t index, int fail_return_last)
{
    DListNode* iter = thiz->first;

    while(iter != NULL && iter->next != NULL && index > 0)
    {
        iter = iter->next;
        index--;
    }

    if(!fail_return_last)
    {
        iter = index > 0 ? NULL : iter;
    }

    return iter;
}

Ret dlist_insert(DList* thiz, size_t index, void* data)
{
    DListNode* node = NULL;
    DListNode* cursor = NULL;

    if((node = dlist_create_node(thiz, data)) == NULL)
    {
        return RET_OOM; 
    }

    if(thiz->first == NULL)
    {
        thiz->first = node;

        return RET_OK;
    }

    cursor = dlist_get_node(thiz, index, 1);
    
    if(index < dlist_length(thiz))
    {
        if(thiz->first == cursor)
        {
            thiz->first = node;
        }
        else
        {
            cursor->prev->next = node;
            node->prev = cursor->prev;
        }
        node->next = cursor;
        cursor->prev = node;
    }
    else
    {
        cursor->next = node;
        node->prev = cursor;
    }

    return RET_OK;
}

Ret dlist_prepend(DList* thiz, void* data)
{
    return dlist_insert(thiz, 0, data);
}

Ret dlist_append(DList* thiz, void* data)
{
    return dlist_insert(thiz, -1, data);
}

Ret dlist_delete(DList* thiz, size_t index)
{
    DListNode* cursor = dlist_get_node(thiz, index, 0);

    if(cursor != NULL)
    {
        if(cursor == thiz->first)
        {
            thiz->first = cursor->next;
        }

        if(cursor->next != NULL)
        {
            cursor->next->prev = cursor->prev;
        }

        if(cursor->prev != NULL)
        {
            cursor->prev->next = cursor->next;
        }

        dlist_destroy_node(thiz, cursor);
    }

    return RET_OK;
}

Ret dlist_get_by_index(DList* thiz, size_t index, void** data)
{
    DListNode* cursor = dlist_get_node(thiz, index, 0);

    if(cursor != NULL)
    {
        *data = cursor->data;
    }

    return cursor != NULL ? RET_OK : RET_FAIL;
}

Ret dlist_set_by_index(DList* thiz, size_t index, void* data)
{
    DListNode* cursor = dlist_get_node(thiz, index, 0);

    if(cursor != NULL)
    {
        cursor->data = data;
    }

    return cursor != NULL ? RET_OK : RET_FAIL;
}

size_t   dlist_length(DList* thiz)
{
    size_t length = 0;
    DListNode* iter = thiz->first;

    while(iter != NULL)
    {
        length++;
        iter = iter->next;
    }

    return length;
}

Ret dlist_foreach(DList* thiz, DListDataVisitFunc visit, void* ctx)
{
    Ret ret = RET_OK;
    DListNode* iter = thiz->first;

    while(iter != NULL && ret != RET_STOP)
    {
        ret = visit(ctx, iter->data);

        iter = iter->next;
    }

    return ret;
}

int      dlist_find(DList* thiz, DListDataCompareFunc cmp, void* ctx)
{
    int i = 0;
    DListNode* iter = thiz->first;

    while(iter != NULL)
    {
        if(cmp(ctx, iter->data) == 0)
        {
            break;
        }
        i++;
        iter = iter->next;
    }

    return i;
}

void dlist_destroy(DList* thiz)
{
    DListNode* iter = thiz->first;
    DListNode* next = NULL;

    while(iter != NULL)
    {
        next = iter->next;
        dlist_destroy_node(thiz, iter);
        iter = next;
    }

    thiz->first = NULL;
    free(thiz);

    return;
}

 

③ HashTable.h

#ifndef HASHTABLE_H_
#define HASHTABLE_H_

#include "DList.h"

typedef int(*DataHashFunc)(void* data);

typedef DListDataDestroyFunc DataDestroyFunc;

typedef DListDataCompareFunc DataCompareFunc;

typedef DListDataVisitFunc DataVisitFunc;

typedef struct HashTable_
{
    DataHashFunc hashFunc;
    DList** slots;
    int slotNr;
    DataDestroyFunc dataDestroy;
    void* dataDestroyCtx;
} HashTable;

HashTable* HashTableCreate(DataDestroyFunc dataDestroy, void* ctx, DataHashFunc hashFunc, int slotNr);

Ret HashTableInsert(HashTable* hashTable, void* data);

Ret HashTableDelete(HashTable* hashTable, DataCompareFunc cmp, void* data);

Ret HashTableFind(HashTable* hashTable, DataCompareFunc cmp, void* data, void** retData);

int HashTableLength(HashTable* hashTable);

Ret HashTableForeach(HashTable* hashTable, DataVisitFunc visit, void* ctx);

void HashTableDestroy(HashTable* hashTable);


#endif

 

 

④ HashTable.c

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "HashTable.h"

HashTable* HashTableCreate(DataDestroyFunc dataDestroy, void* ctx, DataHashFunc hashFunc, int slotNr)
{
    HashTable* pNewHashTable = (HashTable*)malloc(sizeof(HashTable));
    
    if(pNewHashTable != NULL)
    {
        pNewHashTable->hashFunc = hashFunc;
        pNewHashTable->slotNr = slotNr;
        pNewHashTable->dataDestroy = dataDestroy;
        pNewHashTable->dataDestroyCtx = ctx;
        
        pNewHashTable->slots = (DList**)malloc(slotNr * sizeof(DList*));
        if(pNewHashTable->slots != NULL)
        {
            memset(pNewHashTable->slots, 0, (slotNr * sizeof(DList*)));
        }
        else
        {
            free(pNewHashTable);
            pNewHashTable = NULL;
        }
    }
    
    return pNewHashTable;
}

Ret HashTableInsert(HashTable* hashTable, void* data)
{
    Ret ret = RET_FAIL;
    int index = 0;
    
    if(hashTable != NULL)
    {
        index = hashTable->hashFunc(data) % hashTable->slotNr;
        
        if(hashTable->slots[index] == NULL)
        {
            hashTable->slots[index] = dlist_create(hashTable->dataDestroy, hashTable->dataDestroyCtx);
        }
        
        dlist_append(hashTable->slots[index], data);
        
        ret = RET_OK;
    }
    
    return ret;
}

Ret HashTableDelete(HashTable* hashTable, DataCompareFunc cmp, void* data)
{
    Ret ret = RET_FAIL;
    int index = 0;
    DList* dList = NULL;
    
    if(hashTable != NULL)
    {
        index = hashTable->hashFunc(data) % hashTable->slotNr;
        
        dList = hashTable->slots[index];
        
        if(dList != NULL)
        {
            index = dlist_find(dList, cmp, data);
            
            dlist_delete(dList, index);
            
            ret = RET_OK;
        }
    }
    
    return ret;
}

Ret HashTableFind(HashTable* hashTable, DataCompareFunc cmp, void* data, void** retData)
{
    Ret ret = RET_FAIL;
    int index = 0;
    DList* dList = NULL;
    
    if(hashTable != NULL && cmp != NULL && data != NULL && retData != NULL)
    {
        index = hashTable->hashFunc(data) % hashTable->slotNr;
        
        dList = hashTable->slots[index];
        
        if(dList != NULL)
        {
            index = dlist_find(dList, cmp, data);
            
            dlist_get_by_index(dList, index, retData);
            
            ret = RET_OK;
        }
    }
    
    return ret;
    
}

int HashTableLength(HashTable* hashTable)
{
    int sum = 0;
    int index = 0;
    
    if(hashTable != NULL)
    {
        for(index = 0; index < hashTable->slotNr; index++)
        {
            if(hashTable->slots[index] != NULL)
            {
                sum = sum + dlist_length(hashTable->slots[index]);
            }
        }
    }
    
    return sum;
}

Ret HashTableForeach(HashTable* hashTable, DataVisitFunc visit, void* ctx)
{
    int index = 0;
    
    if(hashTable != NULL)
    {
        for(index = 0; index < hashTable->slotNr; index++)
        {
            if(hashTable->slots[index] != NULL)
            {
                dlist_foreach(hashTable->slots[index], visit, ctx);
            }
        }
    }
    
    return RET_OK;
}

void HashTableDestroy(HashTable* hashTable)
{
    int index = 0;
    if(hashTable != NULL)
    {
        if(hashTable->slots != NULL)
        {
            for(index = 0; index < hashTable->slotNr; index++)
            {
                if(hashTable->slots[index] != NULL)
                {
                    dlist_destroy(hashTable->slots[index]);
                    hashTable->slots[index] = NULL;
                }
            }
            
            free(hashTable->slots);
            hashTable->slots = NULL;    
        }
        
        free(hashTable);
        hashTable = NULL;
    }    
}

 

注：数组是最简单的哈希实现

 

转载于:https://www.cnblogs.com/wulei0630/p/9351056.html

weixin_30887919
关注
容器（十三）：到底什么是哈希
japson的专栏
02-11 868
容器（十三）：到底什么是哈希标签： Java编程思想容器十三到底什么是哈希 什么是哈希 为什么要使用哈希 简单的小例子 简单的小总结 提出的俩问题 构造哈希函数 直接定址法 除留余数法 数字分析法 平方取中法 随机数法 如何选择 哈希冲突的解决 开放定址法 线性探查法 平方探查法 双散列函数探查法 链地址法拉链法 hashCode还记得当初学数据结构时学到哈希表，当时比较懵啊。现在要好好理解一下什么
基于哈希技术与MapReduce的大数据集K-近邻算法实现代码
05-06
在大数据处理领域，哈希技术和MapReduce是两种重要的工具，它们在处理大规模数据集时有着显著的优势。本项目聚焦于如何结合这两种技术实现K-近邻（K-Nearest Neighbor, KNN）算法，这是一种非参数机器学习算法，广泛...
哈希（Hash）的详细介绍
m0_71417856的博客
05-08 4854
Hash，一般翻译做散列、杂凑，或音译为哈希，是把任意长度的 输入 （又叫做预映射pre-image）通过散列算法变换成固定长度的 输出 ，该输出就是散列值。这种转换是一种压缩映射,也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，所以不可能从散列值来确定唯一的输入值。（逆推是不行的啦就是说）
哈希技术杂烩
dm_ustc的博客
05-08 4027
普通的哈希算法暂且不讲了，我们探讨下哈希技术的各种应用。 1、一致性哈希。在分布式系统用途广泛。 2、局部敏感哈希LSH：simhash和minhash。可以用于相似度检测等。谷歌有篇文章利用LSH进行网页去重。 3、布隆过滤器。判断一个元素是否在一个集合中。 4、在数据流算法中哈希算法应用更是广泛。比如数据流中独立元素计数等。 5、特征哈希。近几年在nips等机器学习会议上，将特征使用
Hash技术的总结归纳
weixin_30518397的博客
08-05 951
在看哈希之前还是来看看“散列函数（哈希函数）”吧，后面会用到的。 解决冲突的方法。 开放定址法。如果h(k)已经被占用，按如下序列探查： (h(k)+p(1))%TSize, (h(k)+p(2))%TSize, …,(h(k)+p(i))%TSize,…　 　　其中，h(k)为哈希函数，TSize为哈希表长，p(i)为探查函数。 在 h(k)+...
哈希算法讲解
EmotionComputer
10-26 2055
哈希是密码学的基础，理解哈希是理解数字签名和加密通信等技术的必要前提。 一. 基本含义： 哈希，英文是 hash ，本来意思是”切碎并搅拌“，有一种食物就叫 Hash ，就是把食材切碎并搅拌一下做成的。哈希函数的运算结果就是哈希值，通常简称为哈希。哈希函数有时候也翻译做散列函数。 根据维基百科的定义，哈希函数要做的事情是给一个任意大小的数据生成出一个固定长度的数据，作为它的映射。所谓映射就是......
安全鲁棒的图像感知哈希技术 (2007年)
05-25
为了对经过图像处理操作的图像内容进行准确认证，利用图像DCT低频系数的感知不变性生成了安全的哈希序列索引。用标准化后的DCT低频系数矩阵和基于密钥种子的随机数矩阵为数字图像生成哈希序列，研究分析了提出算法...
基于抽样技术与哈希技术结合的长流识别算法的研究 (2006年)
06-12
长流识别对于网络操作和网络管理有着重要的意义。...重点对使用抽样技术和哈希技术相结合的长流识别算法做了研 究,并分析了两种技术的长处和不足,提出使用两种技术的结合可以减少资源开销,提高算法的测量精度。
English_Bangla_Dictionary:用完善的哈希技术开发的字典
04-29
用完善的哈希技术开发的字典。 在此字典数据集中，使用了超过16K个单词，并且该数据集为JSON格式。 使用辅助哈希表后，剩余冲突小于7％。 在这个项目中，后端和前端是分开的。 后端是使用node.js开发的，而前端是...
揭秘区块链的核心技术之「哈希与加密算法 」
weixin_30758821的博客
08-14 2538
大家都知道，区块链的关键技术组成主要为：P2P网络协议、共识机制、密码学技术、账户与存储模型。而这些技术中，又以 密码学与共识机制 这两点为最核心。那么今天我们来详细的聊一聊密码学，看一看密码学技术是如何在区块链中应用的。 首先，我们需知道区块链中用到的密码学算法有哪些？其实就两大类： 哈希算法 非对称加密算法 一、区块链中的哈希算法 哈希算法是区块链中用的最多的...
什么是哈希算法
Flytiger
05-06 777
用动画的形式写了一篇科普性的介绍哈希表的文章，希望对题主有帮助，觉得有用麻烦双击一下~散列表 散列表（Hash table，也叫哈希表），是根据键（Key）而直接访问在内存存储位置的数据结构。也就是说，它通过计算一个关于键值的函数，将所需查询的数据映射到表中一个位置来访问记录，这加快了查找速度。这个映射函数称做散列函数，存放记录的数组称做散列表。散列函数 散列函数，顾名思义，它是一个函数。如果把它定义成 hash(key) ，其中 key 表示元素的键值，则 hash(key) 的值表示经过散列函数计算得到
7.哈希
weixin_34365417的博客
06-28 155
　　哈希（Hash）又称散列，它是一个很常见的算法。在Java的HashMap数据结构中主要就利用了哈希。哈希算法包括了哈希函数和哈希表两部分。我们数组的特性可以知道，可以通过下标快速（O(1)）的定位元素，同理在哈希表中我们可以通过键（哈希值）快速的定位某个值，这个哈希值的计算就是通过哈希函数(hash(key) = address )计算得出的。通过哈希值即能定位元素[address] = v...
哈希算法教程（个人总结版）
最新发布
年糕的博客
05-28 2878
哈希算法（Hash Algorithm）是一种将任意长度的输入（也称为消息）转换为固定长度的输出（也称为哈希值、散列值、摘要）的算法。SHA-256（Secure Hash Algorithm 256-bit）是SHA-2（Secure Hash Algorithm 2）家族中的一种，广泛应用于安全性要求较高的场景，如区块链、数字签名等。散列函数用于哈希表（Hash Table）等数据结构中，将数据映射到固定大小的数组上，以实现高效的数据存储和检索。哈希算法可以用于数据库的索引，提高数据检索的效率。
深入理解Hash算法
weixin_34007886的博客
08-03 121
2019独角兽企业重金招聘Python工程师标准>>> ...
hashmap相关的技术小结
爱越野的程序源
04-27 654
下面附一个我写的代码 void createEntry(int hash, K key, V value, int bucketIndex) { Entry<K,V> e = table[bucketIndex]; //将该节点作为头节点 table[bucketIndex] = new Entry<>(hash, key, value, e...
哈希表
ertcmmy的博客
05-31 384
#define MAX_HASH_SIZE 10 // 按需调整 struct Node{ int data; Node *next; }; struct HashTable{ Node *head[MAX_HASH_SIZE]; }; void init_hash_table(HashTable &ht){ memset(&ht, 0, sizeof(ht)); ...
哈希详解与实现1（哈希是什么以及解决哈希冲突）
qq_44423388的博客
09-09 690
【代码】哈希详解与实现1（哈希是什么以及解决哈希冲突）
哈希技术详解：局部敏感与学习哈希
"这篇文档是关于哈希技术的全面总结，特别关注于在相似性搜索中的应用。文档详细介绍了局部敏感哈希（LSH）和学习哈希，并探讨了哈希在近似最近邻搜索中的作用。" 哈希技术是信息技术中的一个重要概念，尤其在大...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值