数据结构简介:哈希表

最新推荐文章于 2023-06-01 00:57:54 发布
最新推荐文章于 2023-06-01 00:57:54 发布
阅读量370 收藏 1
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangdamingll/article/details/104198484
版权

数据结构简介

数据结构简介

哈希表(散列表)

参考网址

  1. https://blog.csdn.net/stpeace/article/details/81274233
  2. https://blog.csdn.net/qq_36221862/article/details/73488162
  3. https://blog.csdn.net/xyzbaihaiping/article/details/51607770

1. 定义

  • 散列表的实现常常叫作散列(hashing),散列是一种用于以常数平均时间执行插入,删除和查找的技术.但是,那些需要元素间任何序信息的树操作在这里将不会得到有效的支持.
  • 注意:表的大小(tablesize)一般是素数,这样产生冲突的时候会有更多的备选空间,更好的散列分布

2. 散列表解决冲突的方法

  • 拉链法
  1. hash(x)=x mod tablesize
  2. 装填因子a约等于1(tablesize应该为素数)
  3. 产生冲突时,元素应插入对应链表的前端,因为不仅方便,而且这个元素最有可能不久又被访问
  • 开放地址法(线性探测法、平方探测法)
  1. 线性探测法
    (1)hi(x) = ( hash(x) + f(i) ) mod tablesize,且f(0)=0;f(i)=i;
    (2)装填因子a必须要小于等于0.5
    (3)惰性删除
  2. 平方探测法
    (1)hi(x) = ( hash(x) + f(i) ) mod tablesize,且f(0)=0;f(i)=i^2;
    (2)装填因子a必须要小于等于0.5,并且tablesize必须为素数.因为这样的话,表至少有一半为空时,产生冲突时,平方探测法总能够插入成功
    (3)惰性删除
  • 双散列
    f(i)=i * hash2(x)
    hash2(x) = R -(x mod R),R为小于tablesize的素数
    hi(x) = (hash(x) + f(i)) mod tablesize = (hash(x) + i * hash2(x)) mod tablesize

3. 以最坏情形O(1)访问的散列表

  • 完美散列
  • 杜鹃散列(布谷鸟散列)
  1. 常用较小的填装因子(小于0.5不包括0.5)且多于两个散列函数实现
  2. 示例代码
  • 跳房子散列
  1. 尝试改进线性探测算法
  2. 定义:通过预先确定的、在计算机结构体系的基础上优化的常数,来为探测序列的最大长度定界.

示例代码

基于哈希表简单实现HashMap(拉链法)

代码仅供参考:github地址

#ifndef __HASH_MAP1_HPP__
#define __HASH_MAP1_HPP__

#include <iostream>
#include <string>
#include <memory>
#include <functional>
using namespace std;

namespace hashmap1{

//hash table 内部节点
template <typename T,typename U>
class Node{
public:
    Node(const T& key,const T& value){
        m_key = key;
        m_value = value;
    }
    ~Node(){
        std::cout<<"~Node()"<<std::endl;
    }
public:
    T m_key;
    U m_value;
    std::unique_ptr<Node<T,U>> pNode = nullptr;
};

//基于hash table 实现的HashMap 冲突解决使用拉链法
template <typename T,typename U>
class HashMap{
public:
    explicit HashMap(const unsigned int size){
        this->m_size = size;
        m_ppNode = std::make_unique<unique_ptr<Node<T,U>>[]>(m_size);
        for(unsigned int index=0;index<m_size;index++){
            m_ppNode[index].reset(nullptr);
        }
    }
public:
    void Insert(const T& key,const U& value){
        int index = std::hash<T>{}(key)%m_size; //std::hash C++ 17
        std::unique_ptr<Node<T,U>> newNode = std::make_unique<Node<T,U>>(key,value);
        if(m_ppNode[index] == nullptr){
            m_ppNode[index] = std::move(newNode);//内存是否被正确回收？待验证
            return ;
        }
        //map容器考虑去重
        Node<T,U>* node = m_ppNode[index].get();
        while(node->pNode!= nullptr){
            if(node->m_key == key){
                node->m_value = value;
                return;
            }
            node = node->pNode.get();
        }
        if(node->m_key == key){ //判断循环最后一个元素
            node->m_value = value;
            return ;
        }
        //没有重复的元素 采用尾插法
        node->pNode = std::move(newNode);
    }

    pair<U,bool> Find(const T&key){
        int index = std::hash<T>{}(key)%m_size;
        auto p = m_ppNode[index].get();
        while(p!= nullptr){
            if(p->m_key == key){
                return make_pair(p->m_value, true);
            }
            p = p->pNode.get();
        }
        return make_pair(U(), false);
    }
private:
    std::unique_ptr<unique_ptr<Node<T,U>>[]> m_ppNode = nullptr;//unique_ptr对象数组
    unsigned int m_size=0;
};

void TestHashMap1(){
    {
        HashMap<string,string> map(100);
        map.Insert("a","aaa");
        map.Insert("b","bbb");

        pair<string,bool> ret1 = map.Find("a");
        if(ret1.second){
            std::cout<<"find:value="<<ret1.first<<std::endl;
        } else{
            std::cout<<"not find"<<std::endl;
        }

        pair<string,bool> ret2 = map.Find("b");
        if(ret2.second){
            std::cout<<"find:value="<<ret2.first<<std::endl;
        } else{
            std::cout<<"not find"<<std::endl;
        }

        pair<string,bool> ret3 = map.Find("c");
        if(ret3.second){
            std::cout<<"find:value="<<ret3.first<<std::endl;
        } else{
            std::cout<<"not find"<<std::endl;
        }
    }
}

}
#endif
基于哈希表简单实现HashMap(线性探查法、二次探查法)

代码仅供参考:github地址

#ifndef __HASH_MAP2_HPP__
#define __HASH_MAP2_HPP__

#include <iostream>
#include <string>
#include <vector>
#include <cmath>

using namespace std;

namespace hashmap2{
enum State{
    EMPTY,
    DELETE,
    EXIST
};

//hash table 内部节点
template <typename K,typename V>
class HashNode{
public:
    HashNode():m_state(EMPTY){}
public:
    std::pair<K,V> m_kv;
    State m_state;
};

//基于hash table 实现的HashMap 冲突解决使用开放地址法
template <typename K,typename V,bool isLine = true> //模板偏特化
class HashMap{
public:
    explicit HashMap(const unsigned int size = 10):m_size(0){
        m_table.resize(GetNextPrime(size));
    }
public:
    bool Insert(const K& key,const V& value){
        CheckSize();
        unsigned int hashAddr = std::hash<K>{}(key)%m_table.size();//C++ 17
        unsigned int index = hashAddr;
        int offset = 1;
        while(m_table[index].m_state == EXIST){
            if(m_table[index].m_kv.first == key){
                return false;
            }
            if(isLine){
                index = DetectedLine(index);
            }else{
                index = DetectedSquare(index,offset);
            }
        }
        m_table[index].m_kv = std::make_pair(key,value);
        m_table[index].m_state = EXIST;
        m_size++;
        return true;
    }

    std::pair<HashNode<K,V>*,bool> Find(const K&key){
        unsigned int hashAddr = std::hash<K>{}(key)%m_table.size();//C++ 17
        unsigned int index = hashAddr;
        HashNode<K, V>& elem = m_table[index];
        if(elem.m_kv.first!=key){ //产生冲突了 继续寻找
            if(isLine){//线性查找
                while(true){
                    index = DetectedLine(index);
                    if(index == hashAddr){
                        return std::make_pair(&elem,false);
                    }
                    if(m_table[index].m_kv.first == key && m_table[index].m_state == EXIST){
                        return std::make_pair(&m_table[index], true);
                    }
                }
            }else{//平方查找
                int offset =1;
                while(m_table[index].m_state != EMPTY){ //EXIST和DELETE都是要查找的目标
                    index = DetectedSquare(index,offset);
                    if(m_table[index].m_kv.first == key && m_table[index].m_state == EXIST){
                        return std::make_pair(&m_table[index], true);
                    }
                }
            }
        }else{
            if(m_table[index].m_state == EXIST){
                return make_pair(&elem, true);
            }
        }

        return make_pair(&elem, false);
    }

    bool Remove(const K& key){
        auto ret = Find(key);
        if(ret.second){
            ret.first->m_state = DELETE;
            m_size--;
            return true;
        }
        return false;
    }

    inline unsigned int Size(){
        return m_size;
    }

private:
    unsigned int DetectedLine(unsigned int hashAddr){ //线性探查法
        hashAddr++;
        if(hashAddr == m_table.size()){
            hashAddr = 0;
        }
        return hashAddr;
    }

    unsigned int DetectedSquare(unsigned int hashAddr,int& offset){//平方探查法
        /* 平方消解函数: H(i) = H(i-1) + 2i-1
         *
         * H(i) = H0 + i^2
         * H(i-1) = H0 + (i-1)^2
         * H(i) = H(i-1) + 2*i - 1 = H(i-1) + i<<1 - 1
         * */
        hashAddr += offset;
        offset+=2;
        hashAddr = hashAddr % m_table.size() ;
        return hashAddr;
    }

    void CheckSize(){
        if((m_size/m_table.size())>0.5){ //当装载因子a大于0.5时，需要将vector扩容处理
            m_table.resize(GetNextPrime(m_size));

            HashMap<K,V,isLine> hm;
            for(auto it : m_table){
                if(it.m_state == EXIST){
                    hm.Insert(it.m_kv.first,it.m_kv.second);
                }
            }
            this->Swap(hm);
        }
    }

    void Swap(HashMap<K,V,isLine> hm){
        std::swap(m_size,hm.m_size);
        m_table.swap(hm.m_table);
    }

    unsigned int GetNextPrime(const unsigned int size){//使用素数表对齐做哈希表的容量，降低哈希冲突
        const int _PrimeSize = 28;
        static const unsigned long _PrimeList[_PrimeSize] ={
                52ul, 97ul, 193ul, 389ul, 769ul,
                1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
                49157ul, 98317ul, 196613ul, 393241ul, 786433ul,
                1572869ul, 3145739ul, 6291469ul, 12582917ul, 24165843ul,
                50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul,
                1610612741ul, 3221225473ul, 4294967291ul
        };

        for(unsigned i = 0; i < _PrimeSize; ++i){
            if (_PrimeList[i] > size){
                return _PrimeList[i];
            }
        }
        return _PrimeList[_PrimeSize-1];
    }

private:
    std::vector<HashNode<K,V>> m_table; //hash table
    unsigned int m_size=0;//hash table store element number
};

void TestHashMap2(){
    {
        HashMap<int,int,false> map;
        map.Insert(25, 1);
        map.Insert(25, 2);
        map.Insert(14, 2);
        map.Insert(36, 3);
        map.Insert(49, 4);
        map.Insert(68, 5);
        map.Insert(57, 6);
        map.Insert(11, 7);
        map.Insert(37, 8);

        cout<<map.Size()<<endl;

        auto ret = map.Find(25);
        if(ret.second){
            std::cout<<"Find:key="<<ret.first->m_kv.first<<" value="<<ret.first->m_kv.second<<std::endl;
        }else{
            std::cout<<"not find"<<std::endl;
        }

        ret = map.Find(11);
        if(ret.second){
            std::cout<<"Find:key="<<ret.first->m_kv.first<<" value="<<ret.first->m_kv.second<<std::endl;
        }else{
            std::cout<<"not find"<<std::endl;
        }

        ret = map.Find(12);
        if(ret.second){
            std::cout<<"Find:key="<<ret.first->m_kv.first<<" value="<<ret.first->m_kv.second<<std::endl;
        }else{
            std::cout<<"not find:12"<<std::endl;
        }

        map.Remove(25);
        ret = map.Find(25);
        if(ret.second){
            std::cout<<"Find:key="<<ret.first->m_kv.first<<" value="<<ret.first->m_kv.second<<std::endl;
        }else{
            std::cout<<"not find:25"<<std::endl;
        }

        map.Remove(14);
        cout<<map.Size()<<endl;
    }
}

}

#endif
A鱼翔浅底A
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
哈希表的数据结构
06-29
哈希表的数据结构哈希表的数据结构哈希表的数据结构哈希表的数据结构
HashTable:哈希表数据结构
05-17
哈希表，也被称为散列表，是计算机科学中一种高效的数据结构，用于存储和检索数据。它基于“键-值”对（key-value pairs）的概念，通过哈希函数将键映射到数组的特定位置，从而实现快速访问。在Java编程语言中，哈希...
数据结构之哈希表
lilisalo
10-24 78
wikipedia上的解释 http://zh.wikipedia.org/wiki/%E5%93%88%E5%B8%8C%E8%A1%A8 下图示意了哈希表（Hash Table）这种数据结构。 哈希表 如上图所示，首先分配一个指针数组，数组的每个元素是一个链表的头指针，每个链表称为一个槽（Slot）。哪个数据应该放入哪个槽中由哈希函数决定，在这个...
数据结构-哈希表
Shawn Jeon`s blog
10-29 177
Hash table哈希表(Hash table) 哈希表(Hash table) 又称散列表, 它是键值对数据结构, 也就是 key& value的映射集, 其中键是通过散列计算后, 将映射到表中某一个位置, 以此加快查找的速度. 此映射函数叫做散列函数, 存放值的数组叫做散列表 public class HashtableApp { public static void main(String[] args) { HashTab hashTab = new Hash
数据结构：哈希表
zjx624bjh的博客
04-21 337
哈希概念： 构造一种存储结构，通过某种函数使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。当向该结构中插入元素时，根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放。 当先结构中搜索元素时，对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功。 该方...
数据结构哈希表
有点騒的程序员
07-26 299
开发工具与关键技术：MyEclipse 10；Java基础语法 撰写时间：2019-07-26 哈希表（Hash表）是通过哈希函数来确定数据元素存放位置的一种特殊表结构，简单来说就是存储哈希值的结构。而哈希函数是数据元素的关键字和该数据元素的存放位置之间映射函数 哈希表的原理： 对对象元素中的关键字 (对象中的特有数据) ，进行哈希算法的运算，并得出一个具体的算法值，这个值称为哈希值。而哈...
数据结构实验五哈希表设计c语言
04-25
哈希表是一种常用的数据结构，它可以快速地存储和检索数据。在本实验中，我们设计了一种哈希表，以学生姓名为关键字，存储学生信息，并实现了查找学生信息的功能。 哈希表的构造方法 在本实验中，我们使用了链地址...
哈希表数据结构ADT实现代码
12-02
哈希表（Hash Table）是一种高效的数据结构，用于存储和检索键值对。它通过将键（Key）映射到数组的索引位置来实现快速访问。哈希表的实现通常涉及两个主要部分：哈希函数和冲突解决策略。在这个项目中，我们将深入...
数据结构课程设计哈希表设计问题.doc
12-19
哈希表是一种常用的数据结构，它可以快速地存储和检索数据。在本课程设计中，我们将设计一个哈希表，解决人名查找问题，使得平均查找长度不超过 2。 一、哈希表的基本概念 哈希表是一种数据结构，它使用哈希函数将...
数据结构试验哈希表优质资料.doc
12-02
数据结构试验哈希表优质资料 本资源是一个关于数据结构试验哈希表优质资料的文档，主要包括考试日程安排、考试成绩统计和排序、查找学生成绩等功能。下面是该资源的详细知识点： 一、考试日程安排 * 问题描述：...
HashMap Hashtable区别
热门推荐
shohokuf的专栏
02-24 11万+
http://blog.csdn.net/java2000_net/archive/2008/06/05/2512510.aspx  我们先看2个类的定义public class Hashtable extends Dictionary implements Map, Cloneable, java.io.Serializable public class Ha
数据结构 哈希表
最新发布
qq_74115825的博客
06-01 137
（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做，存放记录的叫做。给定表M，存在函数f(key)，对任意给定的关键字值key，代入函数后若能得到包含该关键字的记录在表中的地址，则称表M为哈希（Hash）表，函数f(key)为哈希(Hash) 函数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值