【数据结构】：哈希表（hashtable）

最新推荐文章于 2024-08-12 16:54:46 发布
最新推荐文章于 2024-08-12 16:54:46 发布
阅读量688 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ChaseRaod/article/details/78541327
版权

hashtable—-哈希表，也称散列表，是根据关键字直接访问在内存存储位置的数据结构。它通过一个关键值得函数将所需的数据映射到所需的位置来访问数据，这个映射函数叫散列函数，存放记录的数组叫做散列表。

构造哈希表的几种方法。
1，直接定址法—-取关键字的某个线性函数为散列地址，Hash(key)=key或Hash（key）=key%p.
2，除留余数法—-取关键值被某个不大于散列表m的数p除后的所得的余数为散列地址。Hash（key）=key%p.
3，平方取中法
4，折叠法
5，随机数法
6，数学分析法
我们今天主要介绍直接定制法（也称开放定址法、闭散列方法）和除留余数法（也称开链法、拉链法、哈希桶）

不同的key值经过哈希函数Hash（key）后可能产生相同的值，我们将这称为哈希冲突或哈希碰撞。
哈希冲突与在载荷因子有关 a = 填入表中的元素个数/散列表的长度
负载因子越小 效率越高 但浪费空间越多
负载因子越大 产生的冲突可能性越大
载荷因子应严格控制在0.7-0.8以下，超过限制的值就要进行resize

一、闭散列方法-开放定址法
1，线性探测
（1）直接定址：当hash函数就是Hash(key)=key，直接将元素定位在数组中所对应的位置上，这种方法准确但实在太浪费空间，当元素少但范围大时浪费的空间太多。
（2）线性探测：当给出的空间最大是p时，hash函数时Hash（key） = key%p,当产生冲突时，将数据放在其后第一个没有存数据的位置。这种方法解决了空间问题，但容易造成冲突,使hash拥堵。
（3）二次探测：hash函数是Hash(key)+0,Hash(key)+1^2,Hash(key)+2^2,……Hash(key)+i^2.二次探测是对线性表探测的改进。

这里写图片描述

#pragma once

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

//线性探测
enum State
{
    EMPTY,//NULL
    EXIST,//存在
    DELETE,//删除
};

template<class K>
struct __HashFunc
{
    size_t operator()(const K& key)
    {
        return (size_t)key;
    }
};

//字符串哈希算法
struct _HashFuncString
{
    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;
    }

    size_t operator()(const string& s)
    {
        return BKDRHash(s.c_str());
    }
};

template<class K,class V>
struct HashNode
{
    State _state;
    K _key;
    V _value;
};


template<class K,class V,class _HashFunc = __HashFunc<K>>
class HashTable
{
    typedef HashNode<K, V> Node;
public:
    HashTable()
        :_size(0)
    {}


    bool InSert(const K& key, const V& value)
    {
        CheckCapacity();
        size_t index = HashFunc(key);
        size_t first = index;
        size_t i = 1;

        while (_tables[index]._state == EXIST)
        {
            if (_tables[index]._key == key)
            {
                if (_tables[index]._state == EXIST)
                {
                    return  false;
                }
            }
            //index += (first + i * i)%_tables.size();
            //++i;
            ++index;
            if (index == _tables.size())
            {
                index = 0;
            }
        }
        _tables[index]._key = key;
        _tables[index]._value = value;
        _tables[index]._state = EXIST;
        ++_size;
        return true;
    }

    Node* Find(const K& key)
    {
        size_t index = HashFunc(key);
        while (_tables[index]._state != EMPTY)
        {
            if (_tables[index]._key == key)
            {
                return &_tables[index];
            }
            ++index;
            if (index == _tables.size())
            {
                index = 0;
            }
        }
        return NULL;
    }

    bool Erase(const K& key)
    {
        HashNode* ret = Find(key);
        if (ret)
        {
            //伪删除法
            --_size;
            ret->_state = DELETE;
        }
        else
            return false;
    }

//素数表
    size_t GetNextPrime(size_t value)
    {
        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
        };
        for (size_t i = 0; i < _PrimeList; ++i)
        {
            if (_PrimeList[i] > value)
                return _PrimeList[i];
        }
        return _PrimeList[_PrimeSize - 1];
    }

    void CheckCapacity()
    {
        if (_tables.size() == 0 || _size*10 / _tables.size() >= 7)
        {
            /*vector<Node> newTables;
            newTables.resize(newSize);*/
            HashTable<K, V,_HashFunc> newTable;
            newTable._tables.resize(GetNextPrime(_tables.size());
            for (size_t i = 0; i < _tables.size(); ++i)
            {
                    newTable.InSert(_tables[i]._key, _tables[i]._value);
            }
            //vector中的swap只交换指针
            _tables.swap(newTable._tables);
        }
    }

    size_t HashFunc(const K& key)
    {
        _HashFunc hashfunc;
        return hashfunc(key) % _tables.size();
    }
protected:
    vector<Node> _tables;//size是表的大小
    size_t _size;//表有效数据的个数
};



void TestHashTable()
{
    HashTable<int, int> ht1;
    ht1.InSert(89,0);
    ht1.InSert(18, 0);
    ht1.InSert(49, 0);
    ht1.InSert(58, 0);
    ht1.InSert(9, 0);

    //返回当前时间的时间戳
    srand(time(0));
    for (size_t i = 0; i < 53; ++i)
    {
        ht1.InSert(rand(), 0);
    }

    HashTable<string, string,_HashFuncString> dict;
    dict.InSert("left", "左边");
    dict.InSert("right", "右边");
}

代码中，用到了素数表，是为了减少哈希冲突。字符串哈希算法是将字符串转化成整型从而进行HashFunc的算法。
字符串哈希算法

二，开链法/拉链法（哈希桶）
哈希桶是利用一个数组来存放节点的指针，里面并不存放任何数据，而这个数组下面所挂的单链表用来存放经过HashFunc（key）后映射位置相同的元素。
这里写图片描述

我们将开链法的hash表实现为加了迭代器版的，因为它只是底层的实现，C++库中的unordered_map和unordered_set是对它的一层封装。

#pragma once

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

template<class ValueType>
struct HashNode
{
    /*K _key;
    V _value;*/

    /*HashNode(const K& key, const V& value)
        :_key(key)
        , _value(value)
        , _next(NULL)
    {}*/

    ValueType _valueField;
    HashNode<ValueType>* _next;
    HashNode(const ValueType& v)
        :_valueField(v)
        ,_next(NULL)
    {}
};

//默认是整型
template<class K>
struct __HashFunc
{
    size_t operator()(const K& key)
    {
        return (size_t)key;
    }
};

struct _HashFuncString
{
    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;
    }

    size_t operator()(const string& s)
    {
        return BKDRHash(s.c_str());
    }
};

//迭代器
//前置声明
template<class K, class ValueType, class KeyOfValue, class _HashFunc = __HashFunc<K>>
class HashTable;

template <class K, class ValueType, class KeyOfValue, class _HashFunc = __HashFunc<K>>
struct __HashTableIterator
{
    typedef HashNode<ValueType> Node;
    typedef __HashTableIterator<K, ValueType, KeyOfValue, _HashFunc> Self;
    Node* _node;
    HashTable<K, ValueType, KeyOfValue, _HashFunc>* _hashtable;
    __HashTableIterator(Node* node, HashTable<K, ValueType, KeyOfValue, _HashFunc>* hashtable)
        :_node(node)
        ,_hashtable(hashtable)
    {}

    ValueType& operator*()
    {
        return _node->_valueField;
    }

    ValueType* operator->()
    {
        return &(operator*());
    }

    bool operator == (const Self& s)const 
    {
        return _node == s._node;
    }

    bool operator != (const Self& s)const 
    {
        return _node != s._node;
    }

    Self& operator++()
    {
        if (_node->_next != NULL)
        {
            _node = _node->_next;
        }
        else
        {
            KeyOfValue keyofvalue;
            size_t index = _hashtable->HashFunc(keyofvalue(_node->_valueField),
                _hashtable->_tables.size());
            Node* cur = NULL;
            //为什么是index+1?因为考虑到可能是hashtable最后一个节点,则不需要再++
            for (size_t i = index+1; i < _hashtable->_tables.size(); ++i)
            {//如果不为NULL
                if (_hashtable->_tables[i])
                {
                    cur = _hashtable->_tables[i];
                    break;
                }
            }
            _node = cur;
        }
        return *this;
    }

    Self operator++(int)
    {
        Self tmp(*this);
        ++tmp;
        return *this;
    }
};

//set
template<class K>
struct __KeyOfK
{
    const K& operator()(const K& key)
    {
        return key;
    }
};
//map
template<class K,class V>
struct __KeyOfKV
{
    const K& operator()(const pair<K, V>& kv)
    {
        return kv.first;
    }
};
//UnOrderedMap<K,V> -> HashTable<K,pair<K,V>,__KeyOfKV<K,V>>
//UnOrderedSet<K>   -> HashTable<K,K,__KeyOfK<K>>

template<class K, class ValueType, class KeyOfValue, class _HashFunc = __HashFunc<K>>
class HashTable
{
    typedef  HashNode<ValueType> Node;
    friend class __HashTableIterator<K, ValueType, KeyOfValue, _HashFunc>;
public:
    typedef __HashTableIterator<K, ValueType, KeyOfValue, _HashFunc> Iterator;
    HashTable()
        :_size(0)
    {}

    ~HashTable()
    {
        for (size_t i = 0; i < _tables.size(); ++i)
        {
            Node* cur = _tables[i];
            while (cur)
            {
                Node* next = cur->_next;
                delete cur;
                cur = next;
            }
            _tables[i] = NULL;
        }
    }

    //bool InSert(const K& key, const V& value)
    //{
    //  CheckCapacity();
    //  size_t index = HashFunc(key,_tables.size());
    //  Node* cur = _tables[index];
    //  while (cur)
    //  {
    //      if (cur->_key == key)
    //      {
    //          return false;
    //      }
    //      cur = cur->_next;
    //  }
    //  //头插
    //  Node* tmp = new Node(key, value);
    //  tmp->_next = _tables[index];
    //  _tables[index] = tmp;
    //  ++_size;
    //}

    pair<Iterator,bool> InSert(const ValueType& kv)
    {
        CheckCapacity();
        KeyOfValue keyofvalue;
        size_t index = HashFunc(keyofvalue(kv), _tables.size());
        Node* cur = _tables[index];
        while (cur)
        {
            if (keyofvalue(cur->_valueField) == keyofvalue(kv))
            {
                return make_pair(Iterator(cur,this),false);
            }
            cur = cur->_next;
        }
        //头插
        Node* tmp = new Node(kv);
        tmp->_next = _tables[index];
        _tables[index] = tmp;
        ++_size;
        return make_pair(Iterator(tmp,this),true);
    }

    //素数表
    size_t GetNextPrime(size_t value)
    {
        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
        };
        for (size_t i = 0; i < _PrimeSize; ++i)
        {
            if (_PrimeList[i] > value)
                return _PrimeList[i];
        }
        return _PrimeList[_PrimeSize - 1];
    }


    void CheckCapacity()
    {
        if (_size == _tables.size())
        {
            KeyOfValue keyofvalue;
            vector<Node*> newTables;
            newTables.resize(GetNextPrime(_tables.size()));
            for (size_t i = 0; i < _tables.size(); ++i)
            {
                Node* cur = _tables[i];
                while (cur)
                {
                    Node* next = cur->_next;
                    //头插
                    size_t index = HashFunc(keyofvalue(cur->_valueField), newTables.size());
                    cur->_next = newTables[index];
                    newTables[index] = cur;

                    cur = next;
                }
                _tables[i] = NULL;
            }
            _tables.swap(newTables);
        }
    }

    Iterator Find(const K& key)
    {
        KeyOfValue keyofvalue;
        size_t index = HashFunc(key, _tables.size());
        Node* cur = _tables[index];
        while (cur)
        {
            if (keyofvalue(cur->_valueField)== key)
                return Iterator(cur,this);
            cur = cur->_next;
        }
        return End();
    }

    void Erase(Iterator pos)
    {
        KeyOfValue keyofvalue;
        size_t index = HashFunc(keyofvalue(*pos), _tables.size());
        Node* prev = NULL;
        Node* cur = _tables[index];
        while (cur)
        {
            if (keyofvalue(cur->_valueField) == key)
            {
                if (prev == NULL)//cur是头要特殊处理
                {
                    _tables[index] = cur->_next;
                }
                else
                {
                    prev->_next = cur->_next;
                }
                delete cur;
                --_size;
            }
            prev = cur;
            cur = cur->_next;
        }
    }

    size_t Erase(const K& key)
    {
        Iterator pos = Find(key);
        if (pos != End())
        {
            Erase(pos);
            return 1;
        }
        else
            return 0;
    }

    size_t HashFunc(const K& key,size_t size)
    {
        _HashFunc hushfuc;
        return hushfuc(key)%size;
    }

    Iterator Begin()
    {//返回第一个不为NULL的节点
        Node* cur = NULL;
        for (size_t i = 0; i < _tables.size(); ++i)
        {
            if (_tables[i])
            {
                cur = _tables[i];
                break;
            }
        }
        return Iterator(cur, this);//不是单参数的构造函数不能进行隐式类型转换
    }

    Iterator End()
    {
        return Iterator(NULL, this);
    }
private:
    vector<Node*> _tables;//vector里面存的是节点
    size_t _size;
};

void TestHashTable()
{
    HashTable<int, int,__KeyOfK<int>> ht1;//set
    ht1.InSert(1);
    ht1.InSert(5);
    ht1.InSert(1);
    ht1.InSert(8);
    HashTable<int, int, __KeyOfK<int>>::Iterator it1 = ht1.Begin();
    while (it1 != ht1.End())
    {
        cout << *it1 << " ";
        ++it1;
    }
    cout << endl;
    //返回当前时间的时间戳
    /*srand(time(0));
    for (size_t i = 0; i < 53; ++i)
    {
        ht1.InSert(rand(), 0);
    }*/

    HashTable<string, pair<string, string>, __KeyOfKV<string, string>, _HashFuncString> dict;//map
    dict.InSert(make_pair("left", "左边"));
    dict.InSert(make_pair("right", "右边"));
}

unordered_map类似于map的特性，是KV模型，不允许键值冗余。

#include"HashLink.h"

template<class K, class V, class _HashFunc = __HashFunc<K>>
class UnOrderedMap
{
    typedef HashNode<pair<K,V>> Node;
public:
    typedef typename HashTable<K, pair<K, V>, __KeyOfKV<K, V>, __HashFunc<K>>::Iterator Iterator;
    pair<Iterator,bool> InSert(const pair<K,V>& kv)
    {
        return ht.InSert(kv);
    }

    Iterator Find(const K& key)
    {
        return ht.Find(key);
    }

    void Erase(Iterator pos)
    {
        return ht.Erase(pos);
    }
private:
    HashTable<K, pair<K,V>, __KeyOfKV<K,V>, __HashFunc<K>> ht;
};

unordered_set类似于set的特性，是K模型，同样不允许键值冗余。

#include"HashLink.h"

template<class K,class _HashFunc = __HashFunc<K>>
class UnOrderedSet
{
    typedef HashNode<K> Node;
public:
    typedef typename HashTable<K, K, __KeyOfK<K>, __HashFunc<K>>::Iterator Iterator;
    pair<Iterator,bool> InSert(const K& key)
    {
        return ht.InSert(key);
    }

    size_t Erase(const K& key)
    {
        return ht.Erase(key);
    }

    Iterator Find(const K& key)
    {
        return ht.Find(key);
    }

    void Erase(Iterator pos)
    {
        ht.Erase(pos);
    }

private:
    HashTable<K, K, __KeyOfK<K>,__HashFunc<K>> ht;
};
ChaseRaod
关注
专栏目录
Python数据结构：哈希表
Python宋宋的专栏
06-01 4112
哈希散列（哈希）是电脑科学中一种对资料的处理方法，通过某种特定的函数/算法（称为散列函数/算法）将要检索的项与用来检索的索引（称为散列，或者散列值）关联起来，生成一种便于搜索的数据结构（称为散列表）。哈希表是什么哈希表（散列表）是根据键（Key）直接访问内存存储位置的数据结构。根据键（Key）值将数据映射到内存中一个位置的函数称为哈希函数，根据哈希函数建立的记录数据的表称为哈希表。哈希表的特点若关键字为 ，则其值存放在的存储位置上。由此，不需比较便可直接取得所查记录。称这个对应关系 为散列函数，按这个思想
底层实现数据结构：哈希表
ChanYipFan的博客
04-18 2941
建哈希表时要解决两个问题，索引如何设计以及解决哈希冲突（即由键转换的索引与之前的相同）
哈希表 HashTable 数据结构
06-03
数据结构（C语言版）实习，哈希表，取余，二次散列法解决冲突
哈希表（Hash Table）
最新发布
宋发元
08-12 607
数组是固定长度的、有序的数据集合，存储相同类型的元素。数组的长度在定义时就固定了，不能改变。var arr [5]int // 定义一个长度为5的整数数组arr := [3]string{"apple", "banana", "cherry"} // 定义并初始化一个字符串数组切片是动态长度的、可变的数组视图，它的底层指向一个数组，可以动态调整长度。切片的容量会随着元素的增加而自动扩展。var s []int // 定义一个整数切片。
数据结构之hashtable
小木木的博客
05-23 3105
1、基本概念   hashtable是一种存储成对的键值和实值元素的字典结构。不同于红黑树的对数级的平均时间消耗，hashtable提供常数级的时间消耗。 2、散列函数   为了达到常数级的时间消耗，底层必须使用array这种连续空间的内存结构。想要存储元素，就需要将元素的键值映射成对应的索引值，实现这种功能的映射函数就称为散列函数（hash function）。散列函数的实现是很重要的
数据结构——HashTable
木易三水良
01-20 1392
基本介绍 散列表(hash table,也叫哈希表)，是根据关键码值(Key value)而直接进行访问的数据结构，也就是说，它通过关键码值映射到表中的一个位置来访问记录，以加快查找的速度。这个映射函数叫散列函数，存放记录的数组叫散列表。 哈希表管理学生信息概图 示例代码 学生信息类 @Data public class Student { private int id; ...
java hashtable 数据结构_java数据结构——哈希表（HashTable）
weixin_35068573的博客
02-16 549
哈希表提供了快速的插入操作和查找操作，每一个元素是一个key-value对，其基于数组来实现。一、Java中HashMap与Hashtable的区别：HashMap可以接受null键值和值，而Hashtable则不能。Hashtable是线程安全的，通过synchronized实现线程同步。而HashMap是非线程安全的，但是速度比Hashtable快。这两个类有许多不同的地方，下面列出了一部分：...
基于C语言的数据结构-哈希表hashTable
06-25
哈希表，又称散列表，是一种非常重要的数据结构，它以高效的方式实现了数据的存储和检索。在C语言中，由于没有内置的哈希表实现，程序员需要自定义数据结构来构建哈希表。本教程将深入探讨如何利用C语言构建和操作...
哈希表-使用C语言实现哈希表数据结构-HashTable.zip
03-04
"哈希表_使用C语言实现哈希表数据结构_HashTable"这个压缩包很可能包含了具体的C语言代码示例，通过阅读和理解这些代码，你可以深入学习哈希表的实现细节，包括如何定义结构体、如何定义和应用哈希函数、如何处理...
JS数据结构:哈希表
Preshine
09-18 8235
哈希表也被称为散列表，Hash表是一种特殊的数据结构，它同数组、栈、链表等相比较有很明显的区别，它能够快速定位到想要查找的记录，而不是与表中存在的记录的关键字进行比较来进行查找。
数据结构-HashTable(哈希表/散列表)
hello，world！
09-22 335
哈希函数其实就是我们常说的哈希算法，主要应用在以下这几个方面：文件校验、数字签名、鉴权协议。常用的哈希算法有以下这些。MD5：MD5即Message-Digest Algorithm 5(信息-摘要算法5)，用于确保信息传输完整一致。MD5是输入不定长度信息，输出固定长度128bits的算法。SHA-1：常用于HTTPS传输和软件签名。SHA-2:SHA-224/SHA-256/SHA-384/SHA-512并成为SHA-2。
数据结构-HashTable的简单
yaoyaoli1的专栏
07-20 385
最近复习数据结构相关的知识，自己实现一个简单的散列表
Hashtable的数据结构简记
qq_45841239的博客
07-31 574
与红黑树或者二叉平衡树相比这些树之类的数据结构都是从根节点开始寻找我们需要的值，而哈希表则是通过一种特殊的函数查找关键字key直接确定我们想要的寻找的值的具体位置也就是相对应的地址，不需要一个个得去比较从而提高效率。 index=H（key）(H代表得是哈希函数) 构造： 通常来说一共有五种方法来构造哈希表： 直接定址法 数字分析法 平方取中法 折叠法 除留余数法 其中通常使用除留取余法，在这里只介绍除留取余法： H（key）=key MOD p （p<=m m为表长） 很明显，如何选取p是个关键
终于有人把HashTable这种数据结构讲清楚了！
大数据技术派
12-02 2004
概论HashTable是遗留类，很多映射的常用功能与HashMap类似，不同的是它承自Dictionary类，并且是线程安全的，并发性不如ConcurrentHashMap，因为Conc...
数据结构——哈希表
u014374826的博客
07-05 4349
hash table
【数据结构】哈希表（Hash Table）
suiyishiguang的博客
03-12 1698
【数据结构】哈希表（Hash Table）
数据结构-----哈希表（Hash Table）
Stephen GS的博客
09-05 690
数据结构-----哈希表（Hash Table）
数据结构hashtable C++实现 非链式
a363344923的专栏
12-07 402
#include #include using namespace std; bool isPrime(int x) { for(int i = 2; i * i <= x; ++i) { if(x % i == 0) return false; } return true; } int nextprime(int x)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值