用C++模拟实现哈希表

最新推荐文章于 2024-07-01 22:14:39 发布
最新推荐文章于 2024-07-01 22:14:39 发布
阅读量393 收藏
点赞数
分类专栏： 数据结构 文章标签： 哈希 开散列 闭散列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/L_listen/article/details/79937834
版权

哈希相关概念

//comm.hpp
#pragma once



const int _PrimeSize = 28;  //素数表
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 GetCapacity(const int capacity)
{
    int i = 0;
    while (_PrimeList[i] < capacity && i < _PrimeSize)
    {
        i++;
    }
    return _PrimeList[i];
}
template <class K>
class KeyToInt
{
public:
    int operator()(const int& n)
    {
        return n;
    }
};

template <>
class KeyToInt<string>
{
public:
    int operator()(string st)
    {

        return BKDRHash(st.c_str());
    }
private:
    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);
    }
};

闭散列


#include <iostream>
using namespace std;
#include "comm.hpp"

enum STATAUS   //表示每个位置状态
{
     EMPTY, EXIST, DELETE
};
template <class K>
struct Element
{
    Element()
        :key(0)
        ,s(EMPTY)   
    {}
    K key;
    STATAUS s;
};


template <class K>
class Hash
{
public:
    Hash(size_t capacity = 7)
        :_size(0)
        , _capacity(capacity)
    {
        _hash = new Element<K>[capacity];
    }
    bool Insert(const K& key)
    {
        CapacityCheck();
        int addr = FunHash(key);
        return  LineCheck(addr, key);
    }
    bool  Find(const K& key)  //查找
    {
        int addr = FunHash(key);
        int oldaddr = addr;
        while (_hash[addr].key != key)
        {
            addr++;
            if (addr == _capacity)
            {
                addr = 0;
            }
            if (addr == oldaddr)
            {
                return false;
            }
        }
        return true;
    }
    bool Emase()  //删除
    {
        int addr = FunHash(key);
        int oldaddr = addr;
        while (_hash[addr].key != key)
        {
            addr++;
            if (addr == _capacity)
            {
                addr = 0;
            }
            if (addr == oldaddr)
            {
                return false;
            }
        }
        _hash[addr].s = DELETE;
        size--;
        return true;
    }
    ~Hash()
    {
        if (_hash)
        {
            delete[] _hash;
            _hash = NULL;
            _size = 0;
            _capacity = 0;
        }
    }
private:
    void CapacityCheck()
    {
        if (_size * 10 / _capacity > 7)
        {
            int newcapacity = GetCapacity(_capacity);
            Hash temp(newcapacity);
            Swap(temp); 
            _capacity = newcapacity;
        }
    }
    int FunHash(const K&  key)
    {
        return key%_capacity;
    }
    void Swap(Hash& s)
    {
        for (int i = 0; i < _size; ++i)
        {
            s.Insert(_hash[i].key);
        }
        swap(_hash, s._hash);
        s._size = _size;
    }
    bool LineCheck(int addr, const K& key)  //只有为空才插入
    {
        int oldaddr = addr;
        while (_hash[addr].s != EMPTY)  
        {
            addr++;
            if (addr == _capacity)
            {
                addr = 0;
            }
            if (addr == oldaddr)
            {
                return false;
            }
        }
        _hash[addr].key = key;
        _hash[addr].s = EXIST;
        _size++;
        return true;
    }
    bool Secondcheck()
    {
        int oldaddr = addr;
        int i = 1;
        while (_hash[addr].s != EMPTY)
        {
            addr += i*i;
            i++;
            if (addr == _capacity)
            {
                addr = 0;
            }
            if (addr == oldaddr)
            {
                return false;
            }
        }
        _hash[addr].key = key;
        _hash[addr].s = EXIST;
        _size++;
        return true;

    }
    Element<K>* _hash;
    size_t _size;
    size_t _capacity;
};

void Funtest()
{
    int arr[] = { 37, 25, 14, 36, 49, 68, 57, 11 };
    Hash<int> h;
    for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i)
    {
        h.Insert(arr[i]);
    }
}

开散列

//使用的链表不带头结点

#include <vector>

template<typename K, typename V>
struct ELEM
{
    ELEM()
       : pnext(NULL)
    {
    }
    ELEM(const K& key, const V& val = V())
        :_val(make_pair(key, val))
        , pnext(NULL)
    {}

    pair<K, V> _val;
    ELEM* pnext;
};
template <class K, class V, class KeyToInt>
class HashTab;

template <class K, class V, class KeyToInt>
class HashIterator
{
    typedef ELEM<K, V>  Node;
    typedef Node* pNode;
    typedef HashIterator<K, V, KeyToInt> Slef;
public:
    HashIterator()
        :_Hash(NULL)
    {}
    HashIterator( HashTab<K, V, KeyToInt>* hb,  const pNode& pcur)
        :_Hash(hb)
        , _pHead(pcur)
    {
    }
    Slef& operator++()
    {
        _Pnext();
        return *this;
    }
    Slef operator++(int)
    {    
        Slef temp(*this);
        _Pnext();
        return temp;
    }
    pair<K, V> operator*()
    {
        return _pHead->_val;
    }
    pNode operator->()
    {
        return _pHead;
    }
    bool operator==(const Slef& s)
    {
        return ((_Hash ==  s._Hash) && (s._pHead == _pHead));
    }
    bool operator!=(const Slef& s)
    {
        return !(operator==(s));
    }
private:
    void _Pnext()
    {   
        size_t index = _Hash->FunHash((*_pHead)._val.first);
        if (_pHead)
        {

            _pHead = _pHead->pnext;
        }

        while ((_pHead == NULL) && (index < (_Hash->_capacity -1)))
        {
            index++;
            _pHead = _Hash->_HashBucket[index];
        }
        if (index >= _Hash->_HashBucket.size() - 1)
        {
                return;
        }
    }
    HashTab<K, V, KeyToInt>*  _Hash;
    pNode _pHead;
};




template <typename K, typename V, typename KeyToInt = KeyToInt<K>>
class HashTab
{
    friend class HashIterator<K, V, KeyToInt>;
    typedef ELEM<K, V>  Node;
    typedef Node*  pNode;
public: typedef HashIterator<K, V, KeyToInt> Iterator;
public:
    HashTab(const int& capacity = 2)
        : _size(0)
        , _capacity(capacity)
    {   
        _HashBucket.resize(_capacity);
        for (size_t i = 0; i < _capacity; i++)
        {
            _HashBucket[i] = NULL;
        }
    }
    bool InsertUnique(const K& key, const V& value)
    {
        Cheakcapacity();
        int addr = FunHash(key);
        pNode pcur = _HashBucket[addr];
        if (pcur == NULL)
        {
            pNode temp = new Node(key, value);
            _HashBucket[addr] = temp;
        }
        else
        {
            pNode pre = NULL;
            while (pcur)
            {
                if (pcur->_val.first == key)
                {
                    return false;
                }
                pre = pcur;
                pcur = pcur->pnext;
            }
            pNode temp = new Node(key, value);
            if (pre)
                pre->pnext = temp;
        }
        _size++;
        return true;
    }
    bool InsertEqual(const K& key, const V& value)
    {
        Cheakcapacity();
        int addr = FunHash(key);
        pNode pcur = _HashBucket[addr];
        pNode temp = new Node(key, value);
        if (pcur == NULL)
        {
            _HashBucket[addr] = temp;
        }
        else
        {
            temp->pnext = pcur->pnext;
            pcur->pnext = temp;
        }
        _size++;
        return true;
    }
    bool EraseUnique(const K& key)
    {
        int addr = FunHash(key);
        pNode pcur = _HashBucket[addr];
        pNode pre = NULL;
        if (pcur && pcur->_val.first == key)
        {
            _HashBucket[addr] = pcur->pnext;
            delete pcur;
            pcur = NULL;
            _size--;
            return true;
        }
        else
        {

            while (pcur)
            {
                pre = pcur;
                pcur = pcur->pnext;
                if (pcur->_val.first == key)
                {
                    pre->pnext = pcur->pnext;
                    delete pcur;
                    pcur = NULL;
                    _size--;
                    return true;
                }
            }
            return false;
        }
    }
    bool EraseEqual(const K& key)
    {
        int addr = FunHash(key);
        bool flag = false;
        pNode pcur = _HashBucket[addr];
        pNode pre = NULL;
        while (pcur && pcur->_val.first == key)
        {
            _HashBucket[addr] = pcur->pnext;
            delete pcur;
            pcur = NULL;
            _size--;
            flag = true;
            pcur = _HashBucket[addr];
        }
        while (pcur)
        {
            pre = pcur;
            pcur = pcur->pnext;
           if (pcur->_val.first == key)
           {
              pre->pnext = pcur->pnext;
              delete pcur;
              pcur = NULL;
              _size--;
              flag = true;
            }
        }
        return flag;
    }
    Iterator Begin()
    {
        size_t index = 0;
        pNode pcur = _HashBucket[index];
        while (pcur == NULL && index < (_capacity-1))
        {
            index++;
            pcur = _HashBucket[index];
        }
        return Iterator(this, pcur);
    }
    Iterator End()
    {
        return Iterator(this, NULL);
    }
    size_t Size()
    {
        return _size;
    }
    pair<bool, Iterator>  Find(const K& key)
    {
        int addr = FunHash(key);
        pNode pcur = _HashBucket[addr];
        pNode pre = NULL;
        while (pcur)
        {
            if (pcur->_val.first == key)
            {
                return pair<bool, Iterator>(true, Iterator(this, pcur));
            }
            pre = pcur;
            pcur = pcur->pnext;
        }
        pNode temp = new Node(key);
        if (pre)
        {
            pre->pnext = temp;
            return pair<bool, Iterator>(false, Iterator(this, temp));
        }
        else
        {
            _HashBucket[addr] = temp;
            return pair<bool, Iterator>(false, Iterator(this, temp));
        }

    }
    bool operator==(const HashTab<K, V, KeyToInt> s)
    { 
        return true;
    }
private:
    bool Cheakcapacity()
    {
        if (_HashBucket.size() == _size)
        {
            int newcapacity = GetCapacity(_size);
            HashTab<K, V, KeyToInt>   temp(newcapacity);
            Swap(temp);
            _capacity = newcapacity;
            return true;
        }
        return false;
    }
    void Swap( HashTab<K, V, KeyToInt>& s)
    {
        vector<pNode> temp;
        for (size_t i = 0; i < _size; ++i)
        {
            //s.InsertUnique((_HashBucket[i]->_val).first, (_HashBucket[i]->_val).second);
            s.InsertEqual((_HashBucket[i]->_val).first, (_HashBucket[i]->_val).second);
        }
        swap(_HashBucket, s._HashBucket);

    }
    int FunHash(const K& key)
    {
        int ret = KeyToInt()(key);
        return ret%_capacity;
    }

    vector<pNode> _HashBucket;
    size_t _size;
    size_t _capacity;
};

void  HashTabTest()
{
    /*HashTab<string, string>   HAT;
    HAT.InsertUnique("zhangsan", "zzzz");
    HAT.InsertUnique("lisi", "llll");
    HAT.InsertUnique("wangwu", "wwww");
    HAT.EraseUnique("lisi");
    HAT.EraseUnique("zhangsan");*/

    /*HashTab<string, string>   HAT;
    HAT.InsertEqual("zhangsan", "zzzz");
    HAT.InsertEqual("lisi", "llll");
    HAT.InsertEqual("zhangsan", "zzzz");
    HAT.InsertEqual("zhangsan", "zzzz");
    HAT.InsertEqual ("wangwu", "wwww");
    HAT.InsertEqual("lisi", "llll");
    HAT.EraseEqual ("lisi");
    HAT.EraseEqual("zhangsan");*/

    HashTab<int, int>   HAT;
    HAT.InsertEqual(11, 11);
    HAT.InsertEqual(12, 12);
    HAT.InsertEqual(11, 11);
    HAT.InsertEqual(11, 11);
    HAT.InsertEqual(13, 13);
    HAT.InsertEqual(12, 12);
    cout << (*(HAT.Find(11)).second).first<< endl;
    cout << (*(HAT.Find(14)).second).first << endl;;
    HashTab<int, int>::Iterator It = HAT.Begin();
    while (It != HAT.End())
    {
        cout << (*It).second << "  ";
        It++;
    }
    cout << endl;
    HAT.EraseEqual(12);
    HAT.EraseEqual(11);

    /*HashTab<int, int>::Iterator Its = HAT.Begin();
    while (Its != HAT.End())
    {
        cout << (*Its).second << "  ";
        Its++;
    }*/
}
L_listen
关注
专栏目录
模拟实现哈希表超详解（C++）
m0_67430750的博客
05-15 7332
模拟实现哈希表两万字详解，包括哈希表的闭散列实现和开散列实现，以及迭代器的实现。
C++实现哈希表。
TPON的博客
11-17 6631
C++模拟实现哈希表
一个c++实现的哈希表类
06-27
在程序中我们对关键字key应用散列函数H(key)来判断关键字key是否在散列表中，即计算H(key)的值，H(key)值确定所存数据在散列表中的位置。这样一个数据元素的地址是通过函数来计算的，所以数据元素并不需要按照特定的顺序来存放。但是散列函数H(key)将关键字映射为一个整数时，有可能两个关键字的地址相同，所以构造散列函数时要考虑尽量减少冲突的发生。构造散列函数有多种方法，如：平方取中法、除留余数随机数法。本程序采用除留余数法。程序的具体实现如下：本程序是用模板类myhash来实现，包括protected和public属性成员。其中protected成员有*ht（自定义散列表指针）、*empty(bool类型指针，功能是将元素值空、m(散列表容量)、p(除留余数法的除数)以及辅助函数H(key)(散列函数)和collision(处理冲突的函数)；public成员包括构造函数、析构函数和复制构造函数以及=重载函数，其它成员函数主要有：traver(遍历散列表)、show()(打印出哈希表所存的元素)返回值为bool类型的函数search\insert\Delete。search函数（查询关键字为key的元素的位值）、insert函数(插入元素e到哈希表中)、Delete函数（删除关键字为key的元素）。本程序的main函数同样采用两种类型的数据来进行测试，int型和char型，主要测试元素的插入、删除和搜索。
哈希表的C++实现
klliu_control的博客
03-19 405
哈希表的几个概念： 映像：由哈希函数得到的哈希表是一个映像。 冲突：如果两个关键字的哈希函数值相等，这种现象称为冲突。 处理冲突的几个方法： 1、开放地址法：用开放地址处理冲突就是当冲突发生时，形成一个地址序列，沿着这个序列逐个深测，直到找到一个“空”的开放地址，将发生冲突的关键字值存放到该地址中去。 例如：hash(i)=(hash(key)+d(i)) MOD m
哈希表的设计与实现
02-29
问题描述：针对某个单位电话号码簿，设计一个哈希表，并完成相应的建表和查表程序。 基本要求：设每个记录有下列数据项：电话号码、用户名、住址。从键盘输入各记录，以用户名为关键字建立哈希表，哈希函数用除留取余数法构造，采用线性探测法解决冲突。可以插入、查找、删除并显示给定用户名的记录，并计算查找长度, 哈希表保存到文件中，并能从文件中读取数据。 测试数据：取某个单位电话号码簿中的30个记录。 提高要求： (1)将电话号码薄以文件形式保存到盘上，能够按用户名和电话号码两种形式建立哈希表并实现插入、查找、删除表中元素的功能。 (2)对于相同的哈希函数，采用两种或两种以上的处理冲突的方法，如线性探测法和拉链法，比较不同的处理冲突的方法平均查找长度的变化。测试时，采用同一组测试数据，分别用不同的方法处理冲突，记录并输出各自的平均查找长度。 (3)设计图形用户界面
C++代码中使用哈希表
树欲静静风不止止的博客
08-30 3679
C++代码中如何使用哈希表
C++之哈希表的应用(位图，布隆过滤器，海量数据处理，哈希切割)
weixin_56054625的博客
10-11 661
比如：在布隆过滤器中查找"alibaba"时，假设3个哈希函数计算的哈希值为：1、3、7，刚好和其他元素的比特位重叠，此时布隆过滤器告诉该元素存在，但是该元素是不存在的，所以判断元素在库中是不准确的，但是如果布隆过滤器告诉该元素不存在，那么一定不存在，因为相同字符串经过哈希函数过后算出来的整数都是一样的，所以判断元素不在库中是非常准确的.比如：删除上图中"tencent"元素，如果直接将该元素所对应的二进制比特位置0，“baidu”元素也被删除了，因为这两个元素在多个哈希函数计算出的比特位上刚好有重叠。
C++ 使用哈希表封装模拟实现unordered_map unordered_set
TPON的博客
11-17 889
C++实现哈希表封装unordered_map unordered_set
C++ 哈希
m0_61548909的博客
08-27 2887
在 C++98 中， STL 提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到 $log_2N$，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到，因此在C++11 中， STL 又提供了 4 个unordered系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是其底层结构不同，本文中只对unordered_map 和 unordered_set 进行介绍，unordered_multimap和
基于C++实现扩展哈希的持久化【100010521】
01-28
在本课程设计中，我们将探讨如何使用C++编程语言实现扩展哈希的持久化机制，这一主题对于理解和应用分布式数据库、键值存储系统以及数据结构优化具有重要意义。扩展哈希是一种能够有效处理动态数据集增长的哈希算法...
哈希表应用C++_STL_hash
12-14
哈希表应用C++_STL_hash 哈希表应用C++_STL_hash 哈希表应用C++_STL_hash
C++实现的一个哈希表类
kellymalan的专栏
11-17 755
*----------------------------------------------------------------// Copyright (C) 2005 一缕阳光版权所有// 版权所有。 //// 文件名：Hash.h// 文件功能描述：此类简单实现了一个hash表的功能//// 作者:Sundy// 创建标识：2005-06-27////-----------------
C++实现数据结构哈希表
weixin_45632016的博客
12-12 504
#include<iostream> #include<string> #include <iomanip> using namespace std; #define HMax 8 typedef struct node { double key; string name; string address; node *next; }*list; li...
模拟实现hashTable（哈希表）
兰先生的博客
02-18 708
哈希表
c++实现哈希表算法(算法基础)
qq_63763951的博客
07-20 3942
本章主要讲解了两种常见的哈希.学完本章,相信你会对一般的哈希算法有一定的了解。
C++哈希应用
h'm'y
01-11 1014
所谓位图，就是用每一位来存放某种状态，适用于海量数据，数据无重复的场景。通常是用来判断某个数据存不存在的。
【干货】C++哈希桶（开链法解决哈希冲突）类的实现
weixin_34206899的博客
05-13 262
开链法（哈希桶）是解决哈希冲突的常用手法，结构如下：数据结构的设计思路是这样的，定义一个K—V的链式节点（Node），以数组方式存储节点指针实现代码如下：#include<vector> #include"HashTable.h" size_tGetSize() { staticsize_tindex=0; constint...
自己动手用c++实现哈希表
一只懒虫的博客
09-27 4221
哈希表 查找效率约等于1 实现思想介绍 一般的hash思想 未采用模板，简单的实现 key是int，value是string 把输入的key值经过hash函数计算，算出它要放入的桶的编号 采用一个指针数组记录各个桶 每个桶里都有50个key_value对象，这里未采用链表，只是用数组简单那模拟 缺点 batch类设计的有问题，没采用链表，不能动态增加 insert方法，不能改变已有的ke...
哈希表(C++实现)
最新发布
m0_50655389的博客
07-01 1715
可以不经过任何比较，一次直接从表中得到要搜索的元素
C++实现哈希算法与查找示例
代码中使用了一个动态数组`aa`来模拟哈希表。`find`函数用于查找给定的`key`，通过同样的哈希计算方法找到对应的桶（数组下标）。如果该桶为空（`aa[m].empty()`），表示该键不存在，输出提示信息；反之，输出已...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值