哈希之开散列-哈希桶

最新推荐文章于 2024-08-17 21:30:00 发布
原创 最新推荐文章于 2024-08-17 21:30:00 发布 · 228 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#哈希桶 #哈希 #开散列

本文详细解析了哈希桶与开散列的概念，通过头文件HashBucket.h和common.h，以及源文件HashBucket.c和common.c，阐述了这两种数据结构在哈希表实现中的应用和优势。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

头文件

  • HashBucket.h
#pragma once
#ifndef _HASHBUCKET_H_
#define _HASHBUCKET_H_

#define size_t unsigned long

typedef int K;

//typedef char* K;
typedef char* V;




typedef size_t(*PHF)(K key);

typedef struct Pair
{
    K _key;
    V _value;
}Pair;

typedef struct Node
{
    struct Node* _pNext;
    Pair _data;
}Node, *PNode;


typedef struct HashTable
{
    PNode* _table;
    unsigned long _capacity;
    unsigned long _size;
    PHF _DateToInt;
}HT;


void InitHashBucket(HT* ht, int capacity, PHF dataToInt);
int InsertHashBucketUnique(HT* ht, K key, V v);
int DeleteHashBucketUnique(HT* ht, K key);

void InsertHashBucketEqual(HT* ht, K key, V v);
int DeleteHashBucketEqual(HT* ht, K key);
PNode FindHashBucket(HT* ht, K key);
int ChechCapacity(HT* ht);
void DestroyHashBucket(HT* ht);
void ExtendCapacity(HT* ht);

int HashFunc(HT* ht, K key);
PNode BuyNode(K key, V value);
void PrintHashBucket(HT* ht);

#endif // !_HASHBUCKET_H_
  • common.h 
#pragma once

#ifndef _COMMON_H_
#define _COMMON_H_

#include"HashBucket.h"

#pragma once


#define _PrimeSize  28
#define size_t unsigned long

static const unsigned long _PrimeList[_PrimeSize] =
{
    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
};


unsigned long GetPrimeNumber(int Capacity);
static size_t BKDRHash(const char * str);

size_t IntToInt(K key);
size_t StrToInt(K key);

#endif // !_COMMON_H_

源文件

  • HashBucket.c
#include<stdio.h>
#include<assert.h>
#include"HashBucket.h"
#include"common.h"

#pragma warning(disable:4996); 

//初始化
void InitHashBucket(HT* ht, int capacity, PHF dataToInt)
{

    assert(ht);

    ht->_capacity = capacity;

    ht->_DateToInt = dataToInt;

    ht->_size = 0;

    ht->_table = (PNode*)malloc(sizeof(PNode) * ht->_capacity);

    for (int i = 0; i < ht->_capacity; i++)
    {
        ht->_table[i] = NULL;
    }
}

//插入唯一
int InsertHashBucketUnique(HT* ht, K key, V v)
{
    assert(ht);

    if (ChechCapacity(ht))
    {
        ExtendCapacity(ht);
    }

    size_t BucketNo = HashFunc(ht, key);

    PNode pCur = ht->_table[BucketNo];

    while (pCur)
    {
        if (pCur->_data._key == key)
            return 0;
        else
            pCur = pCur->_pNext;
    }

    pCur = BuyNode(key, v);

    pCur->_pNext = ht->_table[BucketNo];
    ht->_table[BucketNo] = pCur;
    ht->_size++;
    return 1;
}

//删除唯一
int DeleteHashBucketUnique(HT* ht, K key)
{
    assert(ht);

    size_t BucketNo = HashFunc(ht, key);

    PNode pCur = ht->_table[BucketNo];
    PNode pPre = ht->_table[BucketNo];

    if (ht->_table[BucketNo] && ht->_table[BucketNo]->_data._key == key)
    {
        ht->_table[BucketNo]= pCur->_pNext;
        ht->_size--;
        free(pCur);
        return 1;
    }

    pCur = ht->_table[BucketNo]->_pNext;
    pPre = ht->_table[BucketNo];

    while (pCur)
    {
        if (pCur->_data._key == key)
            break;
        else
        {
            pPre = pCur;
            pCur = pCur->_pNext;
        }

    }
    if (NULL == pCur)
        return 0;

    pPre->_pNext = pCur->_pNext;
    free(pCur);
    ht->_size--;
    return 1;


}

//插入相同的
void InsertHashBucketEqual(HT* ht, K key, V v)
{
    assert(ht);

    if (ChechCapacity(ht))
    {
        ExtendCapacity(ht);
    }

    size_t BucketNo = HashFunc(ht, key);

    PNode pCur = BuyNode(key, v);

    pCur->_pNext = ht->_table[BucketNo];
    ht->_table[BucketNo] = pCur;

    ht->_size++;

}
//删除相同的
int DeleteHashBucketEqual(HT* ht, K key)
{
    assert(ht);

    int flag = ht->_size;

    size_t BucketNo = HashFunc(ht, key);

    PNode pCur = ht->_table[BucketNo];
    PNode pPre = ht->_table[BucketNo];

    while(ht->_table[BucketNo] && ht->_table[BucketNo]->_data._key == key)
    {
        ht->_table[BucketNo] = pCur->_pNext;
        ht->_size--;
        free(pCur);

        pCur = ht->_table[BucketNo];
    }
    if (pCur)
        pCur = ht->_table[BucketNo]->_pNext;

    while (pCur)
    {

         if (pCur->_data._key == key)
        {
            pPre->_pNext = pCur->_pNext;
            free(pCur);
            pCur = pPre->_pNext;
            ht->_size--;
        }
        else
        {
            pPre = pCur;
            pCur = pCur->_pNext;
        }
    }
    return flag != ht->_size ;
}
//搜索
PNode FindHashBucket(HT* ht, K key)
{
    assert(ht);

    int flag = ht->_size;

    size_t BucketNo = HashFunc(ht, key);

    PNode pCur = ht->_table[BucketNo];

    while (pCur)
    {
        if (pCur->_data._key == key)
        {
            break;
        }
        else
        {
            pCur = pCur->_pNext;
        }
    }
    return pCur;
}

//检查空间
int ChechCapacity(HT* ht)
{
    return ht->_capacity == ht->_size;
}

//销毁哈希桶
void DestroyHashBucket(HT* ht)
{
    assert(ht);

    PNode pDel;

    int BucketInd = 0;
    for (; BucketInd < ht->_capacity; BucketInd++)
    {
        pDel = ht->_table[BucketInd];

        while (pDel)
        {
            ht->_table[BucketInd] = pDel->_pNext;
            free(pDel);
            pDel = ht->_table[BucketInd];
        }
    }
    free(ht->_table);

    ht->_size = 0;

    ht->_capacity = 0;
}

//哈希函数
int HashFunc(HT* ht, K key)
{

    assert(ht);

    return ht->_DateToInt(key) % ht->_capacity;

}
//创建结点
PNode BuyNode(K key, V value)
{
    PNode pNewNode = (PNode)malloc(sizeof(Node));
    pNewNode->_data._key = key;
    pNewNode->_data._value = value;
    pNewNode->_pNext = NULL;
    return pNewNode;
}
//打印
void PrintHashBucket(HT* ht)
{
    assert(ht);

    PNode pCur;

    int BucketInd = 0;
    for (; BucketInd < ht->_capacity; BucketInd++)
    {
        printf("Hash Bucket No.%ld:", BucketInd);
        pCur = ht->_table[BucketInd];
        while (pCur)
        {
            printf("<%s, %s>\t", pCur->_data._key, pCur->_data._value);
            pCur = pCur->_pNext;
        }
        printf("\n");
    }
}

//打印
void PrintHashBucket_int(HT* ht)
{
    assert(ht);

    PNode pCur;

    int BucketInd = 0;
    for (; BucketInd < ht->_capacity; BucketInd++)
    {
        printf("Hash Bucket No.%ld:", BucketInd);
        pCur = ht->_table[BucketInd];
        while (pCur)
        {
            printf("<%d, %s>\t", pCur->_data._key, pCur->_data._value);
            pCur = pCur->_pNext;
        }
        printf("\n");
    }
}
//扩容
void ExtendCapacity(HT* ht)
{
    size_t NewCapacity = ht->_capacity + 5;

    PNode* pNewNode = (PNode*)malloc(sizeof(PNode) * NewCapacity);//申请新的空间

    for (int i = 0; i < NewCapacity; i++)
    {
        pNewNode[i] = NULL;
    }

    PNode pCur;

    size_t BucketInd = 0;

    for (; BucketInd < ht->_capacity; BucketInd++)//开始交换结点
    {
        if (ht->_table[BucketInd])
        {
            size_t BucketNo = 0;
            pCur = ht->_table[BucketInd];
            while (pCur)
            {
                //BucketNo = HashFunc(ht, pCur->_data._key);
                BucketNo = ht->_DateToInt(pCur->_data._key) % NewCapacity;

                ht->_table[BucketInd] = pCur->_pNext;

                pCur->_pNext = pNewNode[BucketNo];
                pNewNode[BucketNo] = pCur;

                pCur = ht->_table[BucketInd];
            }
        }
    }

    free(ht->_table);

    ht->_table = pNewNode;

    ht->_capacity = NewCapacity;
}

/////////////////////////////////////////////////-----测试
void test_str()
{
    HT ht;

    InitHashBucket(&ht, 5, StrToInt);

    InsertHashBucketUnique(&ht, "ac", "鹌鹑");
    InsertHashBucketUnique(&ht, "rg", "如果");
    InsertHashBucketUnique(&ht, "lm", "里面");
    InsertHashBucketUnique(&ht, "et", "儿童");
    InsertHashBucketUnique(&ht, "ht", "合同");
    PrintHashBucket(&ht);
    printf("---------------------------------------\n");

    InsertHashBucketUnique(&ht, "pn", "陪你");
    InsertHashBucketUnique(&ht, "yn", "一年");
    InsertHashBucketUnique(&ht, "qn", "去年");
    InsertHashBucketUnique(&ht, "ynddd", "一年d");
    InsertHashBucketUnique(&ht, "qnqqd", "去年qdq");
    PrintHashBucket(&ht);
    printf("---------------------------------------\n");

    InsertHashBucketUnique(&ht, "asdpn", "驴妈陪你");
    InsertHashBucketUnique(&ht, "asdyn", "的一年");
    InsertHashBucketUnique(&ht, "aedsdqn", "大去年");
    InsertHashBucketUnique(&ht, "fegynddd", "就看到一年d");
    InsertHashBucketUnique(&ht, "gefqnqqd", "按时去年qdq");
    PrintHashBucket(&ht);
    printf("---------------------------------------\n");
}

void FindTest(HT* ht, size_t key)
{
    PNode pNew = FindHashBucket(ht, key);
    printf("key = %ld: ", key);
    if (pNew)
    {
        printf("<%ld,%s>\n", pNew->_data._key, pNew->_data._value);
    }
    printf("\n");
}

void test_int()
{
    HT ht;

    InitHashBucket(&ht, 5, IntToInt);

    //插入，扩容测试
    InsertHashBucketUnique(&ht, 1, "鹌鹑");//1
    InsertHashBucketUnique(&ht, 4, "如果");//4
    InsertHashBucketUnique(&ht, 13, "里面");//3
    InsertHashBucketUnique(&ht, 25, "儿童");//0
    InsertHashBucketUnique(&ht, 103, "合同");//3
    PrintHashBucket_int(&ht);
    printf("---------------------------------------\n");

    InsertHashBucketUnique(&ht, 32, "陪你");//2
    InsertHashBucketUnique(&ht, 19, "一年");//9
    InsertHashBucketUnique(&ht, 67, "去年");//7
    InsertHashBucketUnique(&ht, 28, "一年d");//8
    InsertHashBucketUnique(&ht, 97, "去年qdq");//7
    PrintHashBucket_int(&ht);
    printf("---------------------------------------\n");

    InsertHashBucketUnique(&ht, 15, "驴妈陪你");//0
    InsertHashBucketUnique(&ht, 94, "的一年");//4
    InsertHashBucketUnique(&ht, 252, "大去年");//10
    InsertHashBucketUnique(&ht, 29, "就看到一年d");//14
    InsertHashBucketUnique(&ht, 27, "按时去年qdq");//13
    PrintHashBucket_int(&ht);
    printf("---------------------------------------\n");

    InsertHashBucketUnique(&ht, 27, "按时去年qdq");//13
    PrintHashBucket_int(&ht);
    printf("---------------------------------------\n");

    DeleteHashBucketUnique(&ht, 15);
    PrintHashBucket_int(&ht);
    printf("---------------------------------------\n");

    InsertHashBucketEqual(&ht, 27, "aaaaaaaa");
    InsertHashBucketEqual(&ht, 27, "aaaaaaaa");
    InsertHashBucketEqual(&ht, 27, "aaaaaaaa");
    InsertHashBucketEqual(&ht, 27, "aaaaaaaa");
    PrintHashBucket_int(&ht);
    printf("---------------------------------------\n");

    DeleteHashBucketEqual(&ht, 27);
    PrintHashBucket_int(&ht);
    printf("---------------------------------------\n");

    size_t k = 1;
    while (  k)
    {
        scanf("%ld",&k);
        FindTest(&ht, k);
    }

    DestroyHashBucket(&ht);
    PrintHashBucket_int(&ht);
    printf("---------------------------------------\n");
}

int  main()
{
    //test_str();
    test_int();

    system("pause");
    return 0;

}
  • common.c 
#include"common.h"

size_t GetPrimeNumber(int Capacity)//得到最接近的质数
{
    for (int i = 0; i < _PrimeSize; i++)
    {
        if (_PrimeList[i] > Capacity)
            return _PrimeList[i];
    }
    return _PrimeList[_PrimeSize];
}

static size_t BKDRHash(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(K key)
{
    return key;
}
size_t StrToInt(K key)
{
    return BKDRHash(key);
}
哈希和哈希桶
TONGtongTONG000的博客
11-02 2185
概念 数据结构中有一类常用于搜索，给定一个元素集合，常见的可用于搜索的算法有 遍历，遍历是十分粗暴简单的手段，对于元素的集合没有特殊要求，时间复杂度是O(N)。效率通常较低。 二分查找，二分查找要求元素集合有序，时间复杂度为O(logN), 二叉搜索树，查找规则简单，但是退化为单支树时间复杂度是O(N), AVL树和红黑树，时间复杂度都是O(logN). 上面的这些常用的方法无一例外都有一个关键步骤就是元素的比较，通过比较待查找元素和集合中的元素，来确定该元素在集合中的位置。真实的效率取决于比较的次数。 如
内核中的hash和bucket
Macross的专栏
10-19 3333
哈希表（Hashtable）又称为“散置”，Hashtable是会根据索引键的哈希程序代码组织成的索引键（Key）和值（Value）配对的集合。Hashtable 对象是由包含集合中元素的哈希桶（Bucket）所组成的。而Bucket是Hashtable内元素的虚拟子群组，可以让大部分集合中的搜寻和获取工作更容易、更快速。 哈希函数（Hash Function）为根据索引键来返回数值哈
散列桶
weixin_34106122的博客
08-09 999
1、桶 就是可以存放数据的结构；在这里我认为桶就是结构体！ 在哈希表的改进之上，哈希表当时自己的做法是：表中存放的是指针，而不能存放数据； 现在用桶存储：哈希表中的每个元素是结构体，有数据域和链域！(根据自己的情况不同而进行规定存放数据的多少和相应的有几个链域)；其后哈希结点也可以这样定义，结点存放数据多少自己都可以定义；表中的结构体和结点的结构体没有什么联系！ 在这...
哈希桶
HiMark
07-24 4377
哈希表的开散列 开散列法又叫链地址法 开散列法：首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一个集合，每一个子集称为一个桶，个桶中元素通过单链表链接起来，各链表的头节点存储在哈希表中。 bucket.h 1 #pragma once 2 3 #include&amp;amp;lt;stdio.h&amp;amp;gt; 4 #include&amp;amp;lt;stdlib.h&amp;amp;gt; ...
【C++哈希桶(开散列)】
m0_72964546的博客
11-17 465
开散列法又叫链地址法(开链法)，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结存储在哈希表中。
哈希表开散列哈希桶实现
01-07
开散列法对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点组成 一个向量，因此，向量的元素个数与可能的...
C++ 哈希表详细讲解（闭散列，开散列）
foodsx的博客
07-12 1436
C++ 哈希表详细讲解（闭散列，开散列）
哈希——开散列
h1091068389的博客
08-06 605
又叫拉链法或者哈希桶。他先将数据按照哈希函数计算得到哈希地址，如果出现相同的哈希地址的数据，那么就用一个单链表把数据连起来，各链表的头节点存储在哈希表中。由于类似于字符串等这些不能直接使用除留余数法进行哈希函数计算哈希地址的情况，这里和闭散列里面情况类似，需要设计一些哈希方法来进行转换，从而能够进行这里的取模运算。这里的扩容是先创建一个新的vector数组，给他设置为新的大小，然后通过遍历原哈希表，将哈希表每个地址的元素，以及每个链表上面所挂的数据，一一重新映射到新的vector数组中，最后进行交换即可。.
哈希函数/散列算法
arnodev
10-28 1957
哈希函数（Hash function），又称散列函数、散列算法，它是一种不可逆的信息摘要算法，具体实现就是把任意长度的输入信息通过哈希算法变成固定长度的输出信息。
线性表(散列) - 哈希表
qq_63353796的博客
06-20 433
散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。
散列文件的存储——‘桶’
Dearye_1的博客
11-09 4456
散列文件的存储单位称为桶（Bucket）。假如一个桶能存放m个记录，当桶中已有m个同义词（散列函数值相同）的记录时，存放第m+1个同义词会发生“溢出”。此时需要将第m+1个同义词存放到另一个称为“溢出桶”的桶中。相对地，称存放前m个同义词的桶为“基桶”。溢出桶和基桶大小相同，用指针链接。查找指定元素记录时，首先在基桶中查找。若找到，则成功返回，否则沿指针到溢出桶中进行查找。
C++数据结构——哈希桶HashBucket
m0_75186846的博客
05-26 1332
哈希桶（Hash Bucket）是哈希表中用来存储哈希冲突的一个位置。当多个键通过哈希函数映射到同一个索引时，这些键值对被存储在同一个桶中。哈希桶通常采用链表或其他数据结构来存储这些冲突的元素。这种方法被称为“链地址法”，它允许多个键值对共享同一个哈希表索引，从而有效解决哈希冲突问题。
哈希拉链法（哈希桶）
Hanani_Jia的博客
05-22 718
  昨天写了哈希的开放定址法的博客，今天我们要说的是拉链法，还有一个名字叫哈希桶。哈希桶要做的就是，之前我们用的开放定址法，通过将数据映射到数组中来实现哈希。这里每个数组的位置只能存放一个数据，如果冲突的话会继续往下找找到空的位置然后放进去，但是其实大家都能感觉出来上一个代码很简单，也很扯，感觉实现起来完全不行，不要说海量数据了， 有点数据感觉就不行了，虽然可以扩容但是也是一件很复杂的事情。这里我...
C++：哈希函数和桶
qq_43441284的博客
08-17 1049
有一个简单的Point类，它有两个int类型的成员变量x和y。Point类定义了一个内部的Hash结构体，它重载了()操作符以提供哈希函数。在std命名空间中特化了std::hash模板，以便unordered_map等容器能够使用它。#include // 包含std::hash// 自定义的Point类public:int x, y;// 为了让Point可以用于unordered_map等容器中，我们需要提供哈希函数。
C++_开散列哈希表（哈希桶）
hello呀！
09-07 1067
开散列概念 开散列法又叫链地址法(开链法)，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码 归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结 点存储在哈希表中。 开散列中每个桶中放的都是发生哈希冲突的元素 哈希桶中元素是用链表串接起来的，因此先给出哈希桶的结构 开散列与比散列比较 应用链地址法处理溢出，需要增设链接指针，似乎增加了存储开销。事...
详解c++---哈希桶
qq_68695298的博客
07-02 991
哈希桶的原理以及哈希桶的模拟实现
桶式散列法解决散列表“重复值”冲突
qq_37342484的博客
06-20 1199
解决冲突 在处理散列表的时候，不可避免会遇到计算出的散列值已经存储了另外一个键，这就造成了冲突。通常在发生这种冲突时我们会用到解决冲突的技术，包括桶式散列法、开放地址法、双重散列法。下面一一实现和介绍三种技术！ 桶式散列法 “桶”是一种存储在散列表元素内的简单数据结构，它可以存储多个数据项，这种数据结构其实就是数组，但我们一般可以用ArrayList，它会运行超出范围，并会自动分配更多的空间...
“哈希表的精髓：深入探索哈希桶数据存储与检索“（附源码+解析）
广西彭于晏的博客
06-05 2625
Insert(const T& data) 函数的复杂度：平均情况下，插入操作的时间复杂度为 O(1)，即常数时间。这是因为哈希桶使用拉链法解决冲突，将数据存储在链表中，插入操作只需在对应的链表头部插入新节点。最坏情况下，插入操作的时间复杂度为 O(n)，其中 n 是哈希桶中元素的个数。当哈希桶的负载因子超过阈值，需要进行扩容，将所有元素重新哈希到新的表中。Find(const K& key) 函数的复杂度：平均情况下，查找操作的时间复杂度为 O(1)，即常数时间。
哈希桶（闭散列开散列）模拟实现
li1829146612的博客
09-12 342
1.哈希概念 2..直接建立映射关系的问题 3.哈希冲突 1.闭散列 2.开散式 4.哈希闭散列实现模拟 1.insert函数 2.find函数实现 3.Erase函数实现 4.数组类型是string的类型的使用 5.闭散列全部代码 5.哈希开散列实现模拟 1.Insert实现模拟 2.find实现模拟 3.erase实现模拟 4.开散列实装string之类的比较，加开散式全部代码有测试案例
哈希碰撞简单散列函数
最新发布
03-17
当散列函数未能充分随机化输入数据时，某些特定模式的数据可能会集中映射到相同的桶中，从而加剧了碰撞的可能性[^2]。此外，如果装载因子过高（即表中已存入的元素数量接近或超过表容量），也会显著增加发生碰撞的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值