【数据结构】C++实现哈希表

于 2023-09-24 22:44:59 发布
阅读量370 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ikun66666/article/details/133254958
版权

闭散列哈希表

哈希表的结构

在闭散列的哈希表中，哈希表每个位置除了存储所给数据之外，还应该存储该位置当前的状态，哈希表中每个位置的可能状态如下：

  1. EMPTY（无数据的空位置）。
  2. EXIST（已存储数据）。
  3. DELETE（原本有数据，但现在被删除了）。

我们可以用枚举定义这三个状态。

// 闭散列哈希表
enum State {
    EMPTY,// 哈希表位置为NULL
    EXITS,// 哈希表位置有值了
    DELETE// 哈希表位置为删除标志
};

为什么需要标识哈希表中每个位置的状态？

若是不设置哈希表中每个位置的状态，那么在哈希表中查找数据的时候可能是这样的。以除留余数法的线性探测为例，我们若是要判断下面这个哈希表是否存在元素40，步骤如下：

  1. 通过除留余数法求得元素40在该哈希表中的哈希地址是0。
  2. 从0下标开始向后进行查找，若找到了40则说明存在。

但是我们在寻找元素40时，不可能从0下标开始将整个哈希表全部遍历一次，这样就失去了哈希的意义。我们只需要从0下标开始往后查找，直到找到元素40判定为存在，或是找到一个空位置判定为不存在即可。

在这里插入图片描述

因为线性探测在为冲突元素寻找下一个位置时是依次往后寻找的，既然我们已经找到了一个空位置，那就说明这个空位置的后面不会再有从下标0位置开始冲突的元素了。比如我们要判断该哈希表中是否存在元素90，步骤如下：

  1. 通过除留余数法求得元素90在该哈希表中的哈希地址是0。
  2. 从0下标开始向后进行查找，直到找到下标为5的空位置，停止查找，判定元素90不存在。

但这种方式是不可行的，原因如下：

  1. 如何标识一个空位置？用数字0吗？那如果我们要存储的元素就是0怎么办？因此我们必须要单独给每个位置设置一个状态字段。
  2. 如果只给哈希表中的每个位置设置存在和不存在两种状态，那么当遇到下面这种情况时就会出现错误。

我们先将上述哈希表当中的元素1000找到，并将其删除，此时我们要判断当前哈希表当中是否存在元素40，当我们从0下标开始往后找到2下标（空位置）时，我们就应该停下来，此时并没有找到元素40，但是元素40却在哈希表中存在。

在这里插入图片描述

因此我们必须为哈希表中的每一个位置设置一个状态，并且每个位置的状态应该有三种可能，当哈希表中的一个元素被删除后，我们不应该简单的将该位置的状态设置为EMPTY，而是应该将该位置的状态设置为DELETE。

这样一来，当我们在哈希表中查找元素的过程中，若当前位置的元素与待查找的元素不匹配，但是当前位置的状态是EXIST或是DELETE，那么我们都应该继续往后进行查找，而当我们插入元素的时候，可以将元素插入到状态为EMPTY或是DELETE的位置。

因此，闭散列的哈希表中的每个位置存储的结构，应该包括所给数据和该位置的当前状态。

template<class K, class V>
struct HashData {
    pair<K, V> _kv;
    State _state = EMPTY;//状态初始化为空
};

而为了在插入元素时好计算当前哈希表的负载因子，我们还应该时刻存储整个哈希表中的有效元素个数，当负载因子过大时就应该进行哈希表的增容。

//哈希表
template<class K, class V>
class HashTable{
public:
	//...
private:
    vector<HashData<K, V>> _tables;// 将Hash值存放在vector中
    size_t _n = 0;                 // 存储的数据个数
};

哈希表的查找

在哈希表中查找数据的步骤如下：

  1. 先判断哈希表的大小是否为0，若为0则查找失败。
  2. 通过哈希函数计算出对应的哈希地址。
  3. 从哈希地址处开始，采用线性探测向后向后进行数据的查找，直到找到待查找的元素判定为查找成功，或找到一个状态为EMPTY的位置判定为查找失败。

注意： 在查找过程中，必须找到位置状态为EXIST，并且key值匹配的元素，才算查找成功。若仅仅是key值匹配，但该位置当前状态为DELETE，则还需继续进行查找，因为该位置的元素已经被删除了。

HashData<K, V> *Find(const K &key) {
    //哈希表大小为0，表示哈希表为空，返回nullptr
    if (this->_tables.size() == 0) {
        return nullptr;
    }

    //哈希函数
    size_t hashi = key % this->_tables.size();
    size_t i = 1;
    size_t index = hashi;// index是插入的位置
    // 当哈希状态为EXITS，说明表中位置已经有值，那么就继续查找
    while (this->_tables[index]._state != EMPTY) {
        // 当表中值跟key相等，并且状态为存在时才返回，因为可能值的状态被改为了delete说明刚刚被删除，不可以返回
        if (this->_tables[index]._kv.first == key && this->_tables[index]._state == EXITS) {
            return &this->_tables[index];
        }
        index = hashi + i;  //线性探测
        //index = hashi + i * i;  //二次探测
        index %= this->_tables.size();// 防止index越界，绕回去
        i++;

        // 这里的_state可能都是存在或者删除，那么程序就可能陷入死循环，所以需要给定条件退出
        // 如果已经查找一圈，那么说明全是存在+删除
        if (index == hashi) {
            break;
        }
    }

    return nullptr;
}

哈希表的插入

向哈希表中插入数据的步骤如下：

  1. 查看哈希表中是否存在该键值的键值对，若已存在则插入失败。
  2. 判断是否需要调整哈希表的大小，若哈希表的大小为0，或负载因子过大都需要对哈希表的大小进行调整。
  3. 将键值对插入哈希表。
  4. 哈希表中的有效元素个数加一。

其中，哈希表的调整方式如下：

  • 若哈希表的大小为0，则将哈希表的初始大小设置为10。
  • 若哈希表的负载因子大于0.7，则先创建一个新的哈希表，该哈希表的大小为原哈希表的两倍，之后遍历原哈希表，将原哈希表中的数据插入到新哈希表，最后将原哈希表与新哈希表交换即可。

注意： 在将原哈希表的数据插入到新哈希表的过程中，不能只是简单的将原哈希表中的数据对应的挪到新哈希表中，而是需要根据新哈希表的大小重新计算每个数据在新哈希表中的位置，然后再进行插入。

将键值对插入哈希表的具体步骤如下：

  1. 通过哈希函数计算出对应的哈希地址。
  2. 若产生哈希冲突，则从哈希地址处开始，采用线性探测向后寻找一个状态为EMPTY或DELETE的位置。
  3. 将键值对插入到该位置，并将该位置的状态设置为EXIST。

注意： 产生哈希冲突向后进行探测时，一定会找到一个合适位置进行插入，因为哈希表的负载因子是控制在0.7以下的，也就是说哈希表永远都不会被装满。

bool Insert(const pair<K, V> &kv) {
    //1.查找值
    if (Find(kv.first)) {
        return false;
    }

    // 当我们的哈希表是空或者负载因子大于0.7的时候，我们需要给将哈希表增容
    // 负载因子 = 表中有效数据个数 / 空间的大小
    if (_tables.size() == 0 || _n * 10 / _tables.size() >= 7) {
        //为空的时候，给初始10，负载因子大于0.7就扩容两倍
        size_t newsize = this->_tables.size() == 0 ? 10 : this->_tables.size() * 2;
        HashTable<K, V> newHashTable;// 重新创建一个HashTable类
        newHashTable._tables.resize(newsize);

        // 遍历旧表，重新映射到新表
        for (auto &data: this->_tables) {// data是_table中的类型，对应的HashData
            if (data._state == EXITS) {
                newHashTable.Insert(data._kv);// 将旧的kv插入到新的类对象中
            }
        }

        //交换
        this->_tables.swap(newHashTable._tables);
    }

    //哈希函数
    size_t hashi = kv.first % this->_tables.size();

    // 线形探测
    size_t i = 1;
    size_t index = hashi;// index是最后要插入的位置
    // 当哈希状态为EXITS，说明表中位置已经有值，那么就继续查找
    while (this->_tables[index]._state == EXITS) {
        index = hashi + i;
        //index = hashi + i * i;  //二次线性探测
        index %= this->_tables.size();// 防止index越界，绕回去
        i++;
    }

    this->_tables[index]._kv = kv;
    this->_tables[index]._state = EXITS;
    this->_n++;// 存储的数据个数+1

    return true;
}

哈希表的删除

删除哈希表中的元素非常简单，我们只需要进行伪删除即可，也就是将待删除元素所在位置的状态设置为DELETE。

在哈希表中删除数据的步骤如下：

  1. 查看哈希表中是否存在该键值的键值对，若不存在则删除失败。
  2. 若存在，则将该键值对所在位置的状态改为DELETE即可。
  3. 哈希表中的有效元素个数减一。

注意： 虽然删除元素时没有将该位置的数据清0，只是将该元素所在状态设为了DELETE，但是并不会造成空间的浪费，因为我们在插入数据时是可以将数据插入到状态为DELETE的位置的，此时插入的数据就会把该数据覆盖。

bool Erase(const K &key) {
    HashData<K, V> *ret = Find(key);
    if (ret) {
        ret->_state = DELETE;
        this->_n--;
        return true;
    } else {
        return false;
    }
}

完整代码

#pragma once
#include <iostream>
#include <vector>
using namespace std;
// 闭散列哈希表
enum State {
    EMPTY,// 哈希表位置为NULL
    EXITS,// 哈希表位置有值了
    DELETE// 哈希表位置为删除标志
};

template<class K, class V>
struct HashData {
    pair<K, V> _kv;
    State _state = EMPTY;//状态初始化为空
};

template<class K, class V>
class HashTable {
public:
    HashData<K, V> *Find(const K &key) {
        //哈希表大小为0，表示哈希表为空，返回nullptr
        if (this->_tables.size() == 0) {
            return nullptr;
        }

        //哈希函数
        size_t hashi = key % this->_tables.size();
        size_t i = 1;
        size_t index = hashi;// index是插入的位置
        // 当哈希状态为EXITS，说明表中位置已经有值，那么就继续查找
        while (this->_tables[index]._state != EMPTY) {
            // 当表中值跟key相等，并且状态为存在时才返回，因为可能值的状态被改为了delete说明刚刚被删除，不可以返回
            if (this->_tables[index]._kv.first == key && this->_tables[index]._state == EXITS) {
                return &this->_tables[index];
            }
            index = hashi + i;//线性探测
            //index = hashi + i * i;  //二次探测
            index %= this->_tables.size();// 防止index越界，绕回去
            i++;

            // 这里的_state可能都是存在或者删除，那么程序就可能陷入死循环，所以需要给定条件退出
            // 如果已经查找一圈，那么说明全是存在+删除
            if (index == hashi) {
                break;
            }
        }

        return nullptr;
    }
    bool Insert(const pair<K, V> &kv) {
        //1.查找值
        if (Find(kv.first)) {
            return false;
        }

        // 当我们的哈希表是空或者负载因子大于0.7的时候，我们需要给将哈希表增容
        // 负载因子 = 表中有效数据个数 / 空间的大小
        if (_tables.size() == 0 || _n * 10 / _tables.size() >= 7) {
            //为空的时候，给初始10，负载因子大于0.7就扩容两倍
            size_t newsize = this->_tables.size() == 0 ? 10 : this->_tables.size() * 2;
            HashTable<K, V> newHashTable;// 重新创建一个HashTable类
            newHashTable._tables.resize(newsize);

            // 遍历旧表，重新映射到新表
            for (auto &data: this->_tables) {// data是_table中的类型，对应的HashData
                if (data._state == EXITS) {
                    newHashTable.Insert(data._kv);// 将旧的kv插入到新的类对象中
                }
            }

            //交换
            this->_tables.swap(newHashTable._tables);
        }

        //哈希函数
        size_t hashi = kv.first % this->_tables.size();

        // 线形探测
        size_t i = 1;
        size_t index = hashi;// index是最后要插入的位置
        // 当哈希状态为EXITS，说明表中位置已经有值，那么就继续查找
        while (this->_tables[index]._state == EXITS) {
            index = hashi + i;
            //index = hashi + i * i;  //二次线性探测
            index %= this->_tables.size();// 防止index越界，绕回去
            i++;
        }

        this->_tables[index]._kv = kv;
        this->_tables[index]._state = EXITS;
        this->_n++;// 存储的数据个数+1

        return true;
    }
    bool Erase(const K &key) {
        HashData<K, V> *ret = Find(key);
        if (ret) {
            ret->_state = DELETE;
            this->_n--;
            return true;
        } else {
            return false;
        }
    }

private:
    vector<HashData<K, V>> _tables;// 将Hash值存放在vector中
    size_t _n = 0;                 // 存储的数据个数
};

开散列哈希表(哈希桶)

哈希表的结构

在开散列的哈希表中，哈希表的每个位置存储的实际上是某个单链表的头结点，即每个哈希桶中存储的数据实际上是一个结点类型，该结点类型除了存储所给数据之外，还需要存储一个结点指针用于指向下一个结点。

template<class K, class V>
struct HashNode {
    HashNode<K, V> *_next;
    pair<K, V> _kv;

    HashNode(const pair<K, V> &kv)
        : _kv(kv), _next(nullptr) {}
};

与闭散列的哈希表不同的是，在实现开散列的哈希表时，我们不用为哈希表中的每个位置设置一个状态字段，因为在开散列的哈希表中，我们将哈希地址相同的元素都放到了同一个哈希桶中，并不需要经过探测寻找所谓的“下一个位置”。

哈希表的开散列实现方式，在插入数据时也需要根据负载因子判断是否需要增容，所以我们也应该时刻存储整个哈希表中的有效元素个数，当负载因子过大时就应该进行哈希表的增容。

//哈希表
template<class K, class V>
class HashTable{
public:
	//...
private:
    vector<Node *> _tables;
    size_t n = 0;// 存储有效数据的个数
};

只能存储key为整形的元素，其他类型怎么解决？

使用模板特化编写仿函数

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

// 特化模板，传string的话，就走这个
template<>
struct HashFunc<string> {
    size_t operator()(const string &s) {
        size_t hash = 0;
        for (auto ch: s) {
            hash += ch;
            hash *= 31;
        }
        return hash;
    }
};

这样我们的结构就变成了：

template<class K, class V, class Hash = HashFunc<K>>// Hash用于将key转换成可以取模的类型
class HashTable {
public:
	//
private:
    vector<Node *> _tables;
    size_t n = 0;// 存储有效数据的个数
};

哈希表的查找

在哈希表中查找数据的步骤如下：

  1. 先判断哈希表的大小是否为0，若为0则查找失败。
  2. 通过哈希函数计算出对应的哈希地址。
  3. 通过哈希地址找到对应的哈希桶中的单链表，遍历单链表进行查找即可。
Node *Find(const K &key) {
    if (this->_tables.size() == 0) {
        return nullptr;
    }

    Hash hash;    //用于处理各种类型的仿函数
    size_t hashi = hash(key) % this->_tables.size();
    Node *cur = this->_tables[hashi];
    while (cur) {
        if (cur->_kv.first == key) {
            return cur;
        }
        cur = cur->_next;
    }
    return nullptr;
}

哈希表的插入

向哈希表中插入数据的步骤如下：

  1. 查看哈希表中是否存在该键值的键值对，若已存在则插入失败。
  2. 判断是否需要调整哈希表的大小，若哈希表的大小为0，或负载因子过大都需要对哈希表的大小进行调整。
  3. 将键值对插入哈希表。
  4. 哈希表中的有效元素个数加一。

其中，哈希表的调整方式如下：

  • 若哈希表的大小为0，则将哈希表的初始大小设置为10。
  • 若哈希表的负载因子已经等于1了，则先创建一个新的哈希表，该哈希表的大小为原哈希表的两倍，之后遍历原哈希表，将原哈希表中的数据插入到新哈希表，最后将原哈希表与新哈希表交换即可。

重点： 在将原哈希表的数据插入到新哈希表的过程中，不要通过复用插入函数将原哈希表中的数据插入到新哈希表，因为在这个过程中我们需要创建相同数据的结点插入到新哈希表，在插入完毕后还需要将原哈希表中的结点进行释放，多此一举。

实际上，我们只需要遍历原哈希表的每个哈希桶，通过哈希函数将每个哈希桶中的结点重新找到对应位置插入到新哈希表即可，不用进行结点的创建与释放。

说明一下： 下面代码中为了降低时间复杂度，在增容时取结点都是从单链表的表头开始向后依次取的

将键值对插入哈希表的具体步骤如下：

  1. 通过哈希函数计算出对应的哈希地址。
  2. 若产生哈希冲突，则直接将该结点头插到对应单链表即可。
bool Insert(const pair<K, V> &kv) {
    Hash hash;// 仿函数用于不能取模的值
    // 已经有这个数，就不用插入了
    if (Find(kv.first)) {
        return false;
    }

    // 负载因子 == 1时扩容
    if (this->n == this->_tables.size()) {
        // size_t newsize = _tables.size() == 0 ? 10 : _tables.size() * 2;
        size_t newsize = this->GetNextPrime(_tables.size());
        vector<Node *> newtables(newsize, nullptr);
        for (auto &cur: this->_tables) {// cur是Node*
            while (cur) {
                // 保存下一个
                Node *next = cur->_next;
                // 头插到新表
                size_t hashi = hash(cur->_kv.first) % newtables.size();
                cur->_next = newtables[hashi];
                newtables[hashi] = cur;

                cur = next;
            }
        }
        _tables.swap(newtables);
    }

    size_t hashi = hash(kv.first) % this->_tables.size();
    // 头插
    Node *newnode = new Node(kv);
    newnode->_next = _tables[hashi];
    _tables[hashi] = newnode;
    this->n++;

    return true;
}

哈希表的删除

在哈希表中删除数据的步骤如下：

  1. 通过哈希函数计算出对应的哈希桶编号。
  2. 遍历对应的哈希桶，寻找待删除结点。
  3. 若找到了待删除结点，则将该结点从单链表中移除并释放。
  4. 删除结点后，将哈希表中的有效元素个数减一。

注意： 不要先调用查找函数判断待删除结点是否存在，这样做如果待删除不在哈希表中那还好，但如果待删除结点在哈希表，那我们还需要重新在哈希表中找到该结点并删除，还不如一开始就直接在哈希表中找，找到了就删除。

bool Erase(const K &key) {
    Hash hash;
    size_t hashi = hash(key) % this->_tables.size();
    //删除的时候需要找到前一个节点和后一个节点进行链接
    Node *prev = nullptr;
    Node *cur = this->_tables[hashi];//cur初始为头结点
    //遍历单链表
    while (cur) {
        if (cur->_kv.first == key) {
            if (prev == nullptr) {
                //要找的结点就是头结点则直接更新头
                this->_tables[hashi] = cur->_next;
            } else {
                //链接
                prev->_next = cur->_next;
            }
            delete cur;
            return true;
        } else {
            //更新prev和cur
            prev = cur;
            cur = cur->_next;
        }
    }
    return false;
}

扩容优化

在哈希表中，使用素数作为表的大小可以有效地减少哈希冲突。这主要基于以下两点：

  1. 哈希函数的设计：哈希函数的目的是将键均匀地散列在哈希表中，以尽可能减少哈希冲突。许多哈希函数都会利用取模操作来计算元素在表中的位置，例如hash(key) = key % table_size。在这种情况下，如果table_size是素数，那么哈希函数就能够更好地将不同的键散列在表的不同位置，从而减少哈希冲突。
  2. 避免周期性模式：如果我们使用的哈希表大小不是一个素数，特别是如果它有多个不同的因子，那么可能会产生周期性的模式，同样的键可能会被映射到同一个位置。这是因为两个数字如果它们的差是哈希表大小的因子，那么它们的哈希值将会相同。使用素数作为表的大小可以避免这种情况，因为素数只有两个因子，1和它自己。

因此，当哈希表需要扩容时，通常选择下一个较大的素数作为新的表的大小，以优化哈希表的性能。

// 扩容优化，使用素数扩容
size_t GetNextPrime(size_t prime) {
    // SGI
    static const int __stl_num_primes = 28;
    static const unsigned long __stl_prime_list[__stl_num_primes] = {
            53, 97, 193, 389, 769, 1543,
            3079, 6151, 12289, 24593, 49157, 98317,
            196613, 393241, 786433, 1572869, 3145739, 6291469,
            12582917, 25165843, 50331653, 100663319, 201326611, 402653189,
            805306457, 1610612741, 3221225473, 4294967291};

    size_t i = 0;
    for (; i < __stl_num_primes; ++i) {
        if (__stl_prime_list[i] > prime)
            return __stl_prime_list[i];
    }

    return __stl_prime_list[i];
}

完整代码

#pragma once
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <vector>
using namespace std;

template<class K, class V>
struct HashNode {
    HashNode<K, V> *_next;
    pair<K, V> _kv;

    HashNode(const pair<K, V> &kv)
        : _kv(kv), _next(nullptr) {}
};

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

// 特化模板，传string的话，就走这个
template<>
struct HashFunc<string> {
    size_t operator()(const string &s) {
        size_t hash = 0;
        for (auto ch: s) {
            hash += ch;
            hash *= 31;
        }
        return hash;
    }
};

template<class K, class V, class Hash = HashFunc<K>>// Hash用于将key转换成可以取模的类型
class HashTable {
    typedef HashNode<K, V> Node;

public:
    ~HashTable() {
        for (auto &cur: this->_tables) {
            while (cur) {
                Node *next = cur->_next;
                delete cur;
                cur = next;
            }
            cur = nullptr;
        }
    }

    Node *Find(const K &key) {
        if (this->_tables.size() == 0) {
            return nullptr;
        }

        Hash hash;
        size_t hashi = hash(key) % this->_tables.size();
        Node *cur = this->_tables[hashi];
        while (cur) {
            if (cur->_kv.first == key) {
                return cur;
            }
            cur = cur->_next;
        }
        return nullptr;
    }

    bool Erase(const K &key) {
        Hash hash;
        size_t hashi = hash(key) % this->_tables.size();
        //删除的时候需要找到前一个节点和后一个节点进行链接
        Node *prev = nullptr;
        Node *cur = this->_tables[hashi];//cur初始为头结点
        //遍历单链表
        while (cur) {
            if (cur->_kv.first == key) {
                if (prev == nullptr) {
                    //要找的结点就是头结点则直接更新头
                    this->_tables[hashi] = cur->_next;
                } else {
                    //链接
                    prev->_next = cur->_next;
                }
                delete cur;
                return true;
            } else {
                //更新prev和cur
                prev = cur;
                cur = cur->_next;
            }
        }
        return false;
    }

    // 扩容优化，使用素数扩容
    size_t GetNextPrime(size_t prime) {
        // SGI
        static const int __stl_num_primes = 28;
        static const unsigned long __stl_prime_list[__stl_num_primes] = {
                53, 97, 193, 389, 769, 1543,
                3079, 6151, 12289, 24593, 49157, 98317,
                196613, 393241, 786433, 1572869, 3145739, 6291469,
                12582917, 25165843, 50331653, 100663319, 201326611, 402653189,
                805306457, 1610612741, 3221225473, 4294967291};

        size_t i = 0;
        for (; i < __stl_num_primes; ++i) {
            if (__stl_prime_list[i] > prime)
                return __stl_prime_list[i];
        }

        return __stl_prime_list[i];
    }

    bool Insert(const pair<K, V> &kv) {
        Hash hash;// 仿函数用于不能取模的值
        // 已经有这个数，就不用插入了
        if (Find(kv.first)) {
            return false;
        }

        // 负载因子 == 1时扩容
        if (this->n == this->_tables.size()) {
            // size_t newsize = _tables.size() == 0 ? 10 : _tables.size() * 2;
            size_t newsize = this->GetNextPrime(_tables.size());
            vector<Node *> newtables(newsize, nullptr);
            for (auto &cur: this->_tables) {// cur是Node*
                while (cur) {
                    // 保存下一个
                    Node *next = cur->_next;
                    // 头插到新表
                    size_t hashi = hash(cur->_kv.first) % newtables.size();
                    cur->_next = newtables[hashi];
                    newtables[hashi] = cur;

                    cur = next;
                }
            }
            _tables.swap(newtables);
        }

        size_t hashi = hash(kv.first) % this->_tables.size();
        // 头插
        Node *newnode = new Node(kv);
        newnode->_next = _tables[hashi];
        _tables[hashi] = newnode;
        this->n++;

        return true;
    }

    // 获取哈希表索引最大长度(哈希桶长度)
    size_t MaxBucketSize() {
        size_t max = 0;
        for (int i = 0; i < _tables.size(); ++i) {
            auto cur = _tables[i];
            size_t size = 0;
            while (cur) {
                ++size;
                cur = cur->_next;
            }

            printf("[%d]->%d\n", i, size);

            if (size > max) {
                max = size;
            }
            if (max == 5121) {
                printf("%d", i);
                break;
            }
        }

        return max;
    }

private:
    vector<Node *> _tables;
    size_t n = 0;// 存储有效数据的个数
};
ikun66666
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
模拟实现哈希表超详解（C++）
m0_67430750的博客
05-15 7187
模拟实现哈希表两万字详解，包括哈希表的闭散列实现和开散列实现，以及迭代器的实现。
数据结构基础(18) --哈希表的设计与实现
weixin_30667649的博客
01-13 1406
哈希表 根据设定的哈希函数H(key)和所选中的处理冲突的方法，将一组关键字映射到一个有限的、地址连续的地址集(区间)上，并以关键字在地址集中的“映像”作为相应记录在表中的存储位置，如此构造所得的查找表称之为“哈希表”。构造哈希函数的方法1.直接定址法(数组) 哈希函数为关键字的线性函数H(key)=key或者H(key)=a*key+b 此法仅适合于：地址...
哈希表
傻子编程
03-19 771
概念 顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键 码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O( )，搜索的效率取决于搜索过程中 元素的比较次数。 除了情况4之外，其他情况可以直接删除 情况4不能直接删除，需要在其子树中找一个替代节点进行删除 */ // 请同学们根据上课掌握内容，完成删除的关键部分代码 return true; } } 101 102 103 104 105 106 107 理想的搜索方法：可以不经过任何比较
查找--理解哈希算法并实现哈希表
Paranoid
06-01 3284
我们喜欢使用数组进行数据的查找，就是因为数组是一种“随机存取”的数据结构，我们根据数组的起始地址和数组元素的下标值就可以直接计算出每一个数组元素的存储位置，所以它的查找时间是O(1)，而与数组的个数无关。 我们在这个思想的基础上，可以联想到，如果有一种数据结构，让我们在进行关键字查找的时候，也可以像数组一样，进行随机存储，使其时间复杂度从O(n)降到O(1)，那就可以大大提高查找的效率。我们的前...
哈希表的设计
qq_65390271的博客
04-29 221
哈希函数，哈希冲突，哈希表
数据结构C++语言运用哈希表判断程序代码的相似性
最新发布
06-22
对于两个C++语言的源程序代码，用哈希表的方法分别统计两个程序中使用C++语言关键字的情况，并最终按定量的计算结果，得出两份程序的相似性。 选择若干组编译和运行都无误的C++程序，程序之间有相近的和差别大的，...
C++ 实现哈希表的实例
08-29
C++ 实现哈希表的实例详解 哈希表是一种常用的数据结构，它可以快速地...通过了解哈希表的基本概念、C++ 实现哈希表的实例代码实现、哈希表的实现机制和哈希表的应用场景，我们可以更好地应用哈希表来解决实际问题。
数据结构C++实验报告拉链法哈希表查找算法合工大
01-23
合工大数据结构C++实验报告拉链法哈希表查找算法
C++数据结构哈希表
04-01
总的来说，哈希表是C++中不可或缺的数据结构之一，尤其在处理大量数据时，其高效的性能使得它成为解决许多问题的理想选择。学习和掌握哈希表的设计原理以及在C++中的实现方式，对于提升编程能力有着重要的意义。
数据结构课程设计C++基于哈希表实现的通讯录系统源码+课程设计报告（高分项目）.zip
03-10
数据结构课程设计C++基于哈希表实现的通讯录系统源码+课程设计报告（高分项目）.zip代码完整，报告全面，下载即用。 数据结构课程设计C++基于哈希表实现的通讯录系统源码+课程设计报告（高分项目）.zip代码完整，...
C++——哈希表
m0_48748418的博客
05-25 752
首先将 nums1 的所有元素存入哈希表中，然后遍历 nums2，把在哈希表中出现的元素加入到交集中，同时在哈希表中将该元素删除，避免元素重复计算。unordered_map 是基于哈希表的关联容器，提供了高效的插入、查找和删除操作。哈希表（Hash table），也被称为散列表，是一种常用的数据结构，用于实现键-值对的存储和检索。假设有两个数组 nums1 和 nums2，求出它们的交集并返回，其中返回的交集元素要去重。下面是哈希表在 C++ 中的一个经典例子：求解两个数组的交集。
《数据结构与算法》课程设计——哈希表设计
m0_73070900的博客
06-22 1326
针对某个集体中人名设计一个哈希表，使得平均查找长度不超过R，并完成相应的建表和查表程序。 假设人名为中国人姓名的汉语拼音形式。待填入哈希表的人名共有3000个，取平均查找长度的上限。
数据结构-哈希-哈希表实现
Djsnxbjans的博客
06-22 1501
🚀当插入的某组数据中存在局部集中一些数据时，哈希冲突是很严重的，一个数据占据了另一个数据的位置，另一个位置就要去占据一个其他数据的位置，这样一些数据较为集中的时候，哈希冲突是很严重的导致效率较低。🚀下面实现这开散列的形式是更为优秀的，其哈希冲突的概率于闭散列相比是更低的。🚀应用开散列，对于每个结点要增设链接的指针，似乎增加了空间的开销。
【数据结构实验】哈希表设计
雨林木风的博客
04-21 1692
针对本班同学中的人名设计一个哈希表，使得平均查找长度不超过R，完成相应的建表和查表程序
哈希表概念及简单实现
xd6905的博客
05-30 560
目录 1 什么是哈希表 2 哈希冲突 2.1 冲突解决 2.1.1 重新设计哈希函数 2.1.2 闭散列（开放地址法） 2.1.3 开散列（拉链法） 2.2 哈希表扩容 3 代码实现 3.1闭散列 3.1.1 查找 3.1.2 插入 3.1.3 删除 3.2 开散列 3.2.1 查找 3.2.2 插入 3.2.3 删除 1 什么是哈希表 哈希表的数据结构是一个顺序表，在存储内容时通过数组下标与数据值一一映射的方式记录。这里的一一映射关系可以用函数来表示，这样的函数叫.
Hash 哈希表
m0_52343363的博客
04-23 1263
我们学习了数据结构,其实都在做一件事情那就是 数据的结构 无论是学了啥？目的都是为了1.1 哈希表的定义（Hash table，也叫哈希表），是根据键（Key）而直接访问在内存存储位置的数据结构。也就是说，它通过计算一个关于键值的函数，将所需查询的数据映射到表中一个位置来访问记录，这加快了查找速度。这个映射函数称做散列函数，存放记录的数组称做散列表。remark: 通过某种映射关系 比方将你映射为 阿兰图灵 那么在这个名人散列表查找到图灵时就等于找到了你。
哈希表(hashtable)通过值(value)获取查找键(key)
热门推荐
wyhappy612的专栏
04-21 2万+
哈希表的设计初衷就是通过键key来查找值value的，可以说对哈希表的操作内部机制实质上都是对键的操作。键不能为空且唯一，value值可以。键、值可以为任意数据类型。 通过键key查找值value可通过hstb.hstb.Contains（key）、 hstb.ContainsKey（key）查看是否包含指定的键，　　hstb.ContainsValue（Value）是否包含指定的值，
哈希表的基本概念详解以及具体实现（哈希函数、哈希冲突、负载因子）
LCW0102的博客
01-27 1291
一、哈希表 哈希表是一个典型的用空间换时间的操作，利用数组随机访问的特性，最大化查找效率。哈希过程就是将数组元素与下标建立关系的过程。 二、哈希函数 1、哈希函数的意义： 哈希表是希望将元素与下标建立关系，那么当多个元素之间跨度较大时，我们不可能浪费大量的空间来完成这个存储的过程，就需要通过哈希函数。将下标控制在一定的范围内，就是将我们要存储的键值中的“键”利用特定的哈希函数计算得到一个整型作为数组的索引。 2、哈希函数的设计 （1）当key为整型时 当我们的“键”是一个整型的时候，就利用直接取模的方法，通
哈希表的实现
叫我小秦就好了的博客
03-10 1483
二叉搜索树具有对数时间的表现，但这样的表现建立在一个假设上：输入的数据有足够的随机性。哈希表又名散列表，在插入、删除、搜索等操作上具有「常数平均时间」的表现，而且这种表现是以统计为基础，不需依赖输入元素的随机性。
C++哈希表数据结构
10-05
在C中，可以使用标准库中的哈希表实现，例如使用unordered_set或unordered_map来创建哈希表。unordered_set用于存储唯一的键，而unordered_map用于存储键值对。 下面是使用C++标准库中的unordered_map实现哈希表的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值