数据结构_哈希

最新推荐文章于 2023-03-28 09:49:35 发布
最新推荐文章于 2023-03-28 09:49:35 发布
阅读量176 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cute_shuai/article/details/79425274
版权

哈希

关键：不比较关键码，直接搜索得到需要的数。
特点：与搜索树不一样，哈希结构元素的储存位置与关键码直接对应，可以不用进行比较遍历。
哈希001
如图，创建一个数组，把a[4]中的数据按特定的规则保存到相应的位置，比如a[i]%n，到时候搜索数据的时候可以按照同样的规律直接找到这个位置，如果这个位置有数，则存在。

哈希冲突

比如按照特定方式处理数据，不同数据处理得到的结果可能相同，这样就都指向同一个储存位置。
闭散列解决
存储时，如果该位置有数据，则往下一个位置保存，如果后面还有冲突，则一直往后面找，直到找到空处，保存下来。读取时，如果处理得到的位置有数据，但是不是想要的数，则一直往后面找，直到找到为止，如果遇到了空处还没找到，则没有保存过该数。
具体代码接口实现

#pragma once

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>


typedef int KeyType;
typedef int ValueType;


enum Status
{
    EMPTY,    //空 
    EXITS,    //存在
    DELETE,   //被删除
};

typedef struct HashNode
{
    KeyType _key;
    ValueType _value;
    enum Status _status;
}HashNode;

typedef struct HashTable
{
    HashNode* table;
    size_t _size;
    size_t N;
}HashTable;

size_t HashFunc(KeyType key, size_t N)    //算位置
{
    return key%N;
}

void HashTableInit(HashTable* ht)   //初始化
{
    assert(ht);

    ht->table = NULL;
    ht->_size = 0;
    ht->N = 0;
}

int HashTableInsert(HashTable* ht, KeyType key, ValueType value)    //插入
{
    assert(ht);

    size_t N = 53;
    size_t i = 1;
    int index = 0;
    int tail = 0;

    const int _PrimeSize = 28;

    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
    };


    if (ht->table == NULL)
    {
        ht->table = (HashNode*)malloc(sizeof(HashNode)*N);
        assert(ht->table);
        memset(ht->table, 0, N);
        index = HashFunc(key, N);
        ht->table[index]._key = key;
        ht->table[index]._value = value;
        ht->table[index]._status = EXITS;
        ht->_size = 1;
        ht->N = N;

        return 0;
    }

    tail = ((ht->_size) * 10 )/ (ht->N);
    if (tail >= 7)
    {
        while (tail >= 7 && i < _PrimeSize)
        {
            i = 1;
            N = _PrimeList[i];
            i++;
            tail = (ht->_size) * 10 % N;
        }
        HashNode* NewTable = (HashNode*)malloc(sizeof(HashNode)*N);
        assert(NewTable);
        memset(NewTable, 0, N);

        for (i = 0; i < ht->N; i++)
        {
            if (ht->table[i]._status != EMPTY)   //需复制位置不为空
            {
                index = HashFunc(ht->table[i]._key, N);
                while (NewTable[index]._status != EMPTY)  //复制到的位置不为空
                {
                    index++;
                    if (index == N)
                        index = 0;
                }
                NewTable[index]._key = ht->table[i]._key;
                NewTable[index]._value = ht->table[i]._value;
                NewTable[index]._status = ht->table[i]._status;
            }
        }
        free(ht->table);
        ht->table = NewTable;
        ht->N = N;
    }

    index = HashFunc(key, ht->N);
    while (ht->table[index]._status == EXITS)
    {
        if (ht->table[index]._key == key)
            return -1;
        index++;
        if (index == N)
            index = 0;
    }
    ht->table[index]._key = key;
    ht->table[index]._value = value;
    ht->table[index]._status = EXITS;
    ht->_size++;

    return 0;
}

HashNode* HashTableFind(HashTable* ht, KeyType key)   //寻找
{
    assert(ht);

    int index = HashFunc(key, ht->N);
    while (ht->table[index]._status != EMPTY)  //不为空
    {
        if (ht->table[index]._key == key)
            return &(ht->table[index]);
        index++;
    }
    return NULL;
}

int HashTableRemove(HashTable* ht, KeyType key)
{
    assert(ht);

    HashNode* node = HashTableFind(ht, key);
    if (node != NULL)
    {
        node->_status = DELETE;
        ht->_size--;
        return 0;
    }
    else
        return -1;
}

//static size_t BKDRHash(const char* str);


void HashTableDestory(HashTable* ht)
{
    assert(ht);

    free(ht->table);
    ht->table = NULL;
    ht->_size = 0;
    ht->N = 0;
}

void HashTablePrintf(HashTable* ht)
{
    assert(ht);

    for (size_t i = 0; i < ht->N; i++)
    {
        if (ht->table[i]._status == EXITS)  //存在
        {
            printf("[%d]%d ",i, ht->table[i]._key);
        }
    }
    printf("\n");
}

开散列解决
给一个指针数组开拓一块空间，每个元素是一个指向结点的指针，每个结点都可以保存数据，有哈希冲突的数据直接挂在这个结点的下面，就像单链表一样。这样比闭散列更节约空间。
哈希002

具体代码接口实现

#pragma once

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

typedef int KeyType;
typedef int ValueType;

typedef struct HashNode
{
    KeyType _key;
    ValueType _value;
    struct HashNode* _next;
}HashNode;

typedef struct HashTable
{
    //HashNode** _tables; 
    HashNode** _tables;
    size_t _size;
    size_t _N;
}HashTable;

HashNode* BuyHashNode(KeyType key, ValueType value)   //创建结点
{
    HashNode* cur = (HashNode*)malloc(sizeof(HashNode));
    cur->_key = key;
    cur->_value = value;
    cur->_next = NULL;

    return cur;
}

size_t HashFunc(KeyType key, size_t N)    //计算位置
{
    return key%N;
}

size_t GetNextPrimeNum(size_t cur);


void HashTableInit(HashTable* ht)
{
    assert(ht);

    ht->_N = 0;
    ht->_size = 0;
    ht->_tables = NULL;
}

int HashTableInsert(HashTable* ht, KeyType key, ValueType value)
{
    assert(ht);

    int tail = 0;
    size_t index = 0;
    size_t i = 0;
    size_t N = 0;
    HashNode** table = ht->_tables;

    const int _PrimeSize = 28;
    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
    };


    if (table == NULL)
    {
        i = 0;
        ht->_tables = (HashNode**)malloc(sizeof(HashNode*)*_PrimeList[i]);
        assert(ht->_tables);
        ht->_N = _PrimeList[i];
        for (i = 0; i < ht->_N; i++)
        {
            ht->_tables[i] = NULL;
        }
        index = HashFunc(key, ht->_N);
        ht->_tables[index] = BuyHashNode(key, value);
        return 0;
    }
    tail = (ht->_size+1)/ (ht->_N);
    if (tail == 1)                 //判满扩容
    {
        i = 0;
        while (tail >= 1)
        {
            i++;
            N = _PrimeList[i];
            tail = (ht->_size + 1) / N;
        }
        HashNode** NewTable = (HashNode**)malloc(sizeof(HashNode*)*N);
        for (i = 0; i < N; i++)
        {
            NewTable[i] = NULL;
        }
        assert(NewTable);

        for (i = 0; i < ht->_N; i++)   //把旧表的数据复制到新表
        {
            while (table[i] != NULL)    //判断表的每个位置是否有数据，有就复制
            {
                HashNode* cur = table[i];
                HashNode* next = cur->_next;
                cur->_next = NULL;
                table[i] = next;

                index = HashFunc(cur->_key, N);
                next = NewTable[index];
                if (next != NULL)
                {
                    while (next->_next != NULL)
                    {
                        next = next->_next;
                    }
                    next->_next = cur;
                }
                else
                    NewTable[index] = cur;
            }
        }   //for循环终止
        free(table);
        table = NULL;
        ht->_tables = NewTable;
        ht->_N = N;
    }       //扩容结束

    index = HashFunc(key, ht->_N);    //开始插入
    if (ht->_tables[index] != NULL)
    {
        HashNode* cur = ht->_tables[index];
        if (cur->_key == key)
            return -1;
        while (cur->_next != NULL)
        {
            cur = cur->_next;
            if (cur->_key == key)
                return -1;
        }
        cur->_next = BuyHashNode(key, value);
    }
    else
        ht->_tables[index] = BuyHashNode(key, value);

    return 0;

}



HashNode* HashTableFind(HashTable* ht, KeyType key)
{
    assert(ht);
    int index = 0;
    HashNode* cur = NULL;
    if (ht->_tables == NULL)
        return NULL;
    index = HashFunc(key, ht->_N);
    cur = ht->_tables[index];
    while (cur != NULL)
    {
        if (cur->_key == key)
            return cur;
        cur = cur->_next;
    }
    return NULL;
}

int HashTableRemove(HashTable* ht, KeyType key)
{
    assert(ht);

    HashNode* cur = HashTableFind(ht, key);
    HashNode* next = NULL;
    if (cur == NULL)
        return -1;

    next = cur->_next;
    if (next != NULL)
    {
        cur->_key = next->_key;
        cur->_value = next->_value;
        cur->_next = next->_next;
    }
    else
    {
        int index = HashFunc(key,ht->_N);
        HashNode* parent = ht->_tables[index];
        if (parent == cur)
        {
            ht->_tables[index] = NULL;
        }

        else
        {
            while (parent->_next != cur)
            {
                parent = parent->_next;
            }
            parent->_next = NULL;
        }
        free(cur);
    }
    return 0;
}

void HashTableDestory(HashTable* ht)
{
    assert(ht);

    HashNode* cur = NULL;
    size_t i = 0;
    if (ht->_size == 0)
        return;
    for (i; i < ht->_N; i++)
    {
        cur = ht->_tables[i];
        if (cur != NULL)
        {
            while (cur == NULL)
            {
                HashNode* next = cur->_next;
                free(cur);
                cur = next;
            }
        }
    }
    free(ht->_tables);
    ht->_tables = NULL;
    ht->_N = 0;
    ht->_size = 0;
}

void HashPrint(HashTable* ht)
{
    assert(ht);

    size_t i = 0;
    HashNode* cur = NULL;
    if (ht->_tables == NULL)
        return;
    for (i = 0; i < ht->_N; i++)
    {
        if (ht->_tables[i] != NULL)
        {
            int j = 0;
            cur = ht->_tables[i];
            while (cur != NULL)
            {
                printf("[%d][%d]%d ", i, j, cur->_key);
                cur = cur->_next;
            }
        }
    }
    printf("\n");
}
cute_shuai
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——哈希
Benson的博客
02-03 404
哈希       像C++和Java这种高级语言，都提供了哈希(Hash)的集合库。Hash也是一种数据结构，这种数据结构的特点就是可以储存键值对，每个键都对应着一个值，可以通过键在Hash表中快速查找到这个键所对应的值。Hash表会预先申请一块比较大的内存，当向Hash表中添加键值对时，就直接存入在已经申请的内存中。通常，Hash需要一个Hash函数来确定这个值应该存放在哪里，因为在Hash表
数据结构---哈希
qq_48983250的博客
03-09 337
1.哈希 Hash 哈希函数 == 散列函数 将数据自身的值 和 最终的存储位置 形成一个特定关系，这个关系叫做hash函数 y（存储位置） = f（x（关键值key）） 2.如何构造哈希（6种） （1）直接定址法 （2）数字分析法 （3）平方取中法 （4）折叠法 （5）除留余数法 （6）随机数法 最经常的构造方法：除留余数法 哈希表：hash table 哈希表 哈希函数 哈希是一种存储方法 哈希是一种排序方法 哈希的存储方法是面向排序方法创建的 只要算法中用到了哈希思想，这个算法就可以叫做hash算法
数据结构: 哈希
最新发布
mengqie的博客
03-28 150
哈希算法，哈希表，哈希桶
数据结构_数据结构_
10-03
此外，书中还会涵盖哈希表这一高效的数据结构，它通过散列函数将键映射到一个固定大小的数组，实现快速查找、插入和删除操作。哈希表在数据库、缓存系统等领域有着广泛应用。 排序和查找是数据结构中的重要主题。...
哈希表de 设计.rar_c++ 哈希表_哈希_哈希 VC_哈希表
09-23
哈希表，也被称为散列表，是计算机科学中一种高效的数据结构，用于存储和检索数据。在C++中，哈希表通常通过自定义实现或使用标准库中的`unordered_map`来实现。本文将深入探讨哈希表的设计原理、工作方式以及在C++...
chazhao.rar_哈希表_哈希表 查找
09-21
哈希表是一种高效的数据结构，它通过特定的函数——哈希函数，将数据映射到一个固定大小的数组中，以此实现快速的插入、删除和查找操作。在本压缩包文件"chazhao.rar"中，我们主要探讨的是哈希表在查找操作中的应用...
sanliebiao.rar_hash text find_哈希值_哈希检索_哈希表_文件哈希表
09-19
哈希表，也被称为散列表，是计算机科学中一种高效的数据结构，用于存储和检索数据。它基于哈希函数，可以实现快速的插入、查找和删除操作，平均时间复杂度通常为O(1)。在"sanliebiao.rar_hash text find_哈希值_哈希...
29_哈希冲突和解决方法1
08-03
哈希表是一种高效的数据结构，通过关键字与值的映射关系实现快速查找。哈希函数是实现这种映射的核心，它的目标是使数据能够均匀地分布在整个哈希表中，以降低冲突概率。 哈希函数的构造方法包括数字分析法、平方取...
哈希表的数据结构
06-29
哈希表的数据结构哈希表的数据结构哈希表的数据结构哈希表的数据结构
数据结构---哈希（Hash）
MEANSWER的博客
06-19 4290
哈希1. 哈希概念2. 哈希函数3. 哈希冲突3.1 闭散列3.1.1 闭散列模拟实现3.2 开散列3.2.1 开散列模拟实现4. 基于开散列实现unordered_set5. 基于开散列实现unordered_map6. 闭散列和开散列对比7. 哈希的应用7.1 位图 对于set和map来说底层所使用的是红黑树，其在搜索上面已经很厉害了，为什么还需要在搞一个unordered_set和unordered_map呢？ #include<iostream> #include<vector&g
【数据结构】哈希（Hash）
秋之回忆Alex的博客
09-02 6270
数据结构：哈希函数
数据结构——哈希算法
lianghe77的博客
11-13 1350
哈希算法的定义是将任意长度的二进制值串映射为固定长度的二进制值串。这个映射规则就是哈希算法。通过原始数据映射后得到的二进制值串就是哈希值。设计一个优秀的哈希算法应满足几点要求： 1.从哈希值不能反向推导出原始数据（因此哈希算法也叫单向哈希算法）。 2.对输入数据非常敏感，哪怕原始数据只修改了一个Bit，最后得到的哈希值也大不相同。 3.散列冲突的概率要很小，对于不同的原始数据，哈希值相同的概率非...
数据结构之哈希算法
wang0907的博客
03-04 3338
1：什么是哈希算法? 将一个任意长度的二进制串映射为固定长度的二进制串的算法，我们叫做是哈希算法，其中固定长度的二进制串结果叫做哈希值。 比如md5算法就是一种哈希算法，md5算法将任意长度的二进制串映射为长度128bit的二进制串。 2：一个合格的哈希算法需要满足哪些条件? 1：哈希冲突概率极低 2：差别很小的原始串哈希的结果差别也要很大 3：哈希计算速度快（如md5算法加密4000个字左右的汉字只需要1ms左右） 4：无法反向从哈希值推到出原始值 3：哈希算法都有哪些应用? A:加密（密码存储）
数据结构之哈希详解
说文科技，做有态度的研究。
02-04 513
数据结构之哈希详解【updating…】 1.什么是哈希？ 2.如何设计哈希函数？ 3.哈希冲突？ 怎么解决哈希冲突可以说是哈希结构中最重要的话题了。即使一个哈希函数设计的很好，但是仍然避免不了元素冲突的产生，那么该如何解决哈希冲突呢？ 普通的解决哈希冲突的方法有： 开放地址法 拉链法 下面详细地对解决哈希冲突的方法进行一个介绍。 3.1 开发地址法 ...
高阶数据结构—— 哈希
lyzzs222的博客
11-06 527
哈希数据结构，具体模拟实现哈希表和哈希桶，对哈希冲突的处理方法，哈希的概念，哈希映射？数据可哈希的转换？ 这里都有。
数据结构之哈希（hash）表
yu_kang的博客
04-03 352
数据结构之哈希（hash）表哈希表的定义哈希冲突哈希冲突解决办法开发定址法链地址法关于哈希表的性能 缘起： 最近开始详细看 jdk 源码的集合工具类，其中很多用到哈希表来存储数据，所以先了解下哈希表的原理 注释：本篇引用自数据结构之哈希（hash）表 哈希表的定义 这里先说一下哈希（hash）表的定义：哈希表是一种根据关键码去寻找值的数据映射结构，该结构通过把关键码映射的位置去寻找存放值的地方，说...
初识哈希表【数据结构】
一朵花花
11-05 2002
哈希表概念哈希冲突哈希冲突处理方法： 概念 前言 举例： 给定多干个整数[0，99]，在给定一个数字 n，判断 n 是否出现在刚才的集合中 1.基于顺序表： 可以用一个数组保存若干个整数，拿着 n 在数组中依次遍历，进行比较 — O(N) 2.基于链表： 可以用一个链表保存若干个整数，拿着 n 在链表中依次遍历，进行比较 — O(N) 3.基于二叉搜索树： 可以用一个二叉搜索树来保存这些整数，按照二叉搜索树的方式进行查找比较 — O(N) (比较理想的情况：OlogN) 更高效的办法： 仍然创建一个 bo

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值