13.哈希表（Hashtable）的实现

已于 2023-11-15 13:31:18 修改
阅读量436 收藏
点赞数 9
分类专栏： c++ 文章标签： 散列表 哈希算法 算法 c++
于 2023-11-14 10:50:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62318955/article/details/134394053
版权

哈希表（Hashtable）的实现

实现要求：

​ 我们这里主要想实现一个可以处理多种不同的字符串哈希函数的通用哈希表，处理哈希冲突使用的是拉链法：

/*************************************************************************
        > File Name: 15.cpp
        > Author:Xiao Yuheng
        > Mail:3312638794@qq.com
        > Created Time: Wed Nov  8 22:38:19 2023
 ************************************************************************/

#include <iostream>
#include <vector>
#include <functional>

using namespace std;

class Node {
public:
    Node() = default;
    Node(string, int, Node *);
    string key();
    int value;
    Node *next();
    void set_next(Node *);
    void insert(Node *);
    void erase_next();

private:
    string __key;
    Node *__next;
};



class HashTable {
public:
    typedef function<int(string)> HASH_FUNC_T;
    HashTable (HASH_FUNC_T hash_func, int size);
    bool insert(string, int);
    bool erase(string);
    bool find(string);
    int capacity();
    int &operator[](string);
    ~HashTable();

private:
    Node *__insert(string, int);
    Node *__find(string);
    void __expand();
    int __size, data_cnt;
    vector<Node> data;
    HASH_FUNC_T hash_func;
};



int BKDRHash(string s) {
    int seed = 31;
    int h = 0;
    for (int i = 0; s[i]; i++) {
        h = h * seed + s[i];
    }
    return h & 0x7fffffff;
}

class APHash_Class {
public:
    int operator() (string s) {
        int h = 0;
        for (int i = 0; s[i]; i++) {
            if (i % 2) {
                h = (h << 3) ^ s[i] ^ (h >> 5);
            } else {
                h = ~((h << 7) ^ s[i] ^ (h >> 11));
            }
        }
        return h & 0x7fffffff;
    }
};

int main() {
    APHash_Class APHash;
    HashTable h1(BKDRHash);
    HashTable h2(APHash);
    int op;
    string s;
    cout << h1.capacity() << endl;
    cout << h2.capacity() << endl;
    h1["hello"] = 123;
    h1["world"] = 456;
    h1["haizei"] = 789;
    cout << h1.capacity() << endl;
    cout << h2.capacity() << endl;
    cout << h1["hello"] << " " << h1["world"] << " " << h1["hahaha"] << endl;
    while (cin >> op >> s) {
        switch(op) {
            case 0: {
                cout << "insert " << s << " to hash table 1 = ";
                cout << h1.insert(s) << endl;
                cout << "insert " << s << " to hash table 2 = ";
                cout << h2.insert(s) << endl;
            } break;
            case 1: {
                cout << "erase " << s << " from hash table 1 = ";
                cout << h1.erase(s) << endl;
                cout << "erase " << s << " from hash table 2 = ";
                cout << h2.erase(s) << endl;
            } break;
            case 2: {
                cout << "find " << s << " at hash table 1 = ";
                cout << h1.find(s) << endl;
                cout << "find " << s << " at hash table 2 = ";
                cout << h2.find(s) << endl;
            } break;
        }
    }
    return 0;
}

​ 我们需要实现可以满足主函数的所有功能，简单解释一下需要实现哪些类及其功能：

​ Node 类

class Node {
public:
    Node() = default;
    Node(string, int, Node *);
    string key();
    int value;
    Node *next();
    void set_next(Node *);
    void insert(Node *);
    void erase_next();

private:
    string __key;
    Node *__next;
};
  • Node 类表示哈希表中的节点。
  • 每个节点包含一个键（__key）、一个值（value），以及指向下一个节点的指针（__next）。
  • insert 函数用于在当前节点后插入一个节点，erase_next 函数用于删除下一个节点。

HashTable 类

class HashTable {
public:
    typedef function<int(string)> HASH_FUNC_T;
    HashTable (HASH_FUNC_T hash_func, int size);
    bool insert(string, int);
    bool erase(string);
    bool find(string);
    int capacity();
    int &operator[](string);
    void swap(HashTable &);
    ~HashTable();

private:
    Node *__insert(string, int);
    Node *__find(string);
    void __expand();
    int __size, data_cnt;
    vector<Node> data;
    HASH_FUNC_T hash_func;
};
  • HashTable 类表示哈希表，包含一些基本的哈希表操作。
  • hash_func 是用户提供的哈希函数。
  • insert、erase、find、capacity、operator[] 等函数实现了哈希表的插入、删除、查找、获取容量和重载数组访问操作符等功能。
  • __expand 函数用于在哈希表容量不足时进行扩展。
  • swap 函数用于交换两个哈希表的内部状态。

实现Node类的功能：

Node::Node(string key, int value = 0, Node *node = nullptr) : __key(key), value(value), __next(node) {}
string Node::key() { return __key; }
Node *Node::next() { return __next; }
void Node::set_next(Node *node) { __next = node; }
void Node::insert(Node *node) {
    node->set_next(this->next());
    this->set_next(node);
}
void Node::erase_next() {
    Node *p = this->next();
    if (p == nullptr) return ;
    this->set_next(this->next()->next());
    delete p;
}

这是关于 Node 类成员函数的实现：

Node 类构造函数

Node::Node(string key, int value, Node *node) : __key(key), value(value), __next(node) {}
  • Node 类的构造函数，接受三个参数：key（键值），value（值，默认为0），和 node（下一个节点，默认为nullptr）。
  • 使用初始化列表初始化了 __key、value 和 __next。

key 函数

string Node::key() {
    return __key;
}
  • key 函数用于返回节点的键值。

next 函数

Node *Node::next() {
    return __next;
}
  • next 函数用于返回指向下一个节点的指针。

set_next 函数

void Node::set_next(Node *node) {
    __next = node;
}
  • set_next 函数用于设置下一个节点的指针。

insert 函数

void Node::insert(Node *node) {
    node->set_next(this->next());
    this->set_next(node);
}
  • insert 函数用于在当前节点后插入一个新的节点。
  • 将新节点的下一个节点指针设置为当前节点的下一个节点，然后将当前节点的下一个节点指针设置为新节点。

erase_next 函数

void Node::erase_next() {
    Node *p = this->next();
    if (p == nullptr) return ;
    this->set_next(this->next()->next());
    delete p;
}
  • erase_next 函数用于删除当前节点的下一个节点。
  • 如果下一个节点为空，直接返回。
  • 否则，将当前节点的下一个节点指针设置为下下个节点，然后删除下一个节点。

实现HashTable类的功能：

HashTable::HashTable (HASH_FUNC_T hash_func, int size = 10) :
                    data(size), hash_func(hash_func),
                    __size(size), data_cnt(0) {}
int HashTable::capacity() { return data_cnt; }
bool HashTable::insert(string key, int value = 0) {
    Node *p = __insert(key, value);
    if (data_cnt > __size * 2) __expand();
    return p != nullptr;
}
Node *HashTable::__insert(string key, int value) {
    if (find(key)) return nullptr;
    int ind = hash_func(key) % __size;
    data[ind].insert(new Node(key, value));
    data_cnt += 1;
    return data[ind].next();
}
bool HashTable::erase(string key) {
    if (!find(key)) false;
    int ind = hash_func(key) % __size;
    Node *p = &data[ind];
    while (p->next() && p->next()->key() != key) { p = p->next(); }
    if (p->next() == nullptr) return false;
    p->erase_next();
    data_cnt--;
    return true;
}
bool HashTable::find(string key) {
    Node *p = __find(key);
    if (p == nullptr) return false;
    return true;
}
Node *HashTable::__find(string key) {
    int ind = hash_func(key) % __size;
    Node *p = &data[ind];
    while (p && p->key() != key) { p = p->next(); }
    return p;
}
int &HashTable::operator[](string key) {
    Node *p = __find(key);
    if (p) return p->value;
    insert(key);
    return __find(key)->value;
}
void HashTable::__expand() {
    HashTable h(hash_func, __size * 2);
    for (int i = 0; i < __size; i++) {
        Node *p = data[i].next();
        while(p) {
            h.insert(p->key(), p->value);
            p = p->next();
        }
    }
    swap(h);
}
void HashTable::swap(HashTable &h) {
    std::swap(__size, h.__size);
    std::swap(data_cnt, h.data_cnt);
    std::swap(data, h.data);
    std::swap(hash_func, h.hash_func);
}
HashTable::~HashTable() {
    for (int i = 0; i < __size; i++) {
        while (data[i].next()) { data[i].erase_next(); }
    }
}

这是哈希表 HashTable 类的实现，其中使用了链地址法解决哈希冲突。

构造函数

HashTable::HashTable(HASH_FUNC_T hash_func, int size) :
    data(size), hash_func(hash_func),
    __size(size), data_cnt(0) {}
  • 构造函数接受两个参数：hash_func 为哈希函数，size 为哈希表的初始大小，默认为10。
  • 初始化了 data 向量，存储 Node 节点。
  • 初始化了 hash_func 和哈希表的大小 __size。
  • data_cnt 用于记录哈希表中元素的个数。

capacity 函数

int HashTable::capacity() {
    return data_cnt;
}
  • capacity 函数返回哈希表中元素的个数。

insert 函数

bool HashTable::insert(string key, int value) {
    Node *p = __insert(key, value);
    if (data_cnt > __size * 2) __expand();
    return p != nullptr;
}
  • insert 函数用于向哈希表中插入新元素。
  • 首先调用 __insert 函数，如果返回的节点指针不为空，表示插入成功。
  • 如果哈希表元素个数超过当前大小的两倍，调用 __expand 函数进行扩展。

__insert 函数

Node *HashTable::__insert(string key, int value) {
    if (find(key)) return nullptr;
    int ind = hash_func(key) % __size;
    data[ind].insert(new Node(key, value));
    data_cnt += 1;
    return data[ind].next();
}
  • __insert 函数用于在哈希表中插入新节点。
  • 如果节点已经存在于哈希表中，返回 nullptr。
  • 计算节点应该插入的位置，调用链表节点的 insert 函数插入新节点。
  • 哈希表元素个数加1，返回插入的节点指针。

erase 函数

bool HashTable::erase(string key) {
    if (!find(key)) false;
    int ind = hash_func(key) % __size;
    Node *p = &data[ind];
    while (p->next() && p->next()->key() != key) { p = p->next(); }
    if (p->next() == nullptr) return false;
    p->erase_next();
    data_cnt--;
    return true;
}
  • erase 函数用于从哈希表中删除指定键的节点。
  • 如果节点不存在于哈希表中，返回 false。
  • 计算节点应该在哪个位置，遍历链表找到对应的节点，删除该节点。
  • 哈希表元素个数减1，返回 true 表示删除成功。

find 函数

bool HashTable::find(string key) {
    Node *p = __find(key);
    if (p == nullptr) return false;
    return true;
}
  • find 函数用于判断哈希表中是否存在指定键的节点。
  • 调用 __find 函数，如果返回的节点指针为空，表示不存在，返回 false，否则返回 true。

__find 函数

Node *HashTable::__find(string key) {
    int ind = hash_func(key) % __size;
    Node *p = &data[ind];
    while (p && p->key() != key) { p = p->next(); }
    return p;
}
  • __find 函数用于在哈希表中查找指定键的节点。
  • 计算节点应该在哪个位置，遍历链表找到对应的节点，返回该节点指针。

operator[] 函数

int &HashTable::operator[](string key) {
    Node *p = __find(key);
    if (p) return p->value;
    insert(key);
    return __find(key)->value;
}
  • operator[] 函数用于实现对哈希表中元素的数组式访问。
  • 如果键存在，返回对应节点的值的引用。
  • 如果键不存在，调用 insert 函数插入新节点，然后再次调用 __find 函数返回对应节点的值的引用。

__expand 函数

void HashTable::__expand() {
    HashTable h(hash_func, __size * 2);
    for (int i = 0; i < __size; i++) {
        Node *p = data[i].next();
        while(p) {
            h.insert(p->key(), p->value);
            p = p->next();
        }
    }
    swap(h);
}
  • __expand 函数用于扩展哈希表的大小为原来的两倍。
  • 创建一个新的哈希表 h，大小为原来的两倍。
  • 遍历当前哈希表的每个位置，将链表中的节点插入新的哈希表中。
  • 最后调用 swap 函数交换当前哈希表和新哈希表的内部状态。

swap 函数

void HashTable::swap(HashTable &h) {
	std::swap(__size, h.__size);
    std::swap(data_cnt, h.data_cnt);
    std::swap(data, h.data);
    std::swap(hash_func, h.hash_func);
}
  • swap 函数用于交换两个哈希表对象的内部状态。
  • 使用 std::swap 交换当前哈希表和传入哈希表的大小、元素个数、数据、哈希函数。

析构函数

HashTable::~HashTable() {
    for (int i = 0; i < __size; i++) {
        while (data[i].next()) { data[i].erase_next(); }
    }
}
  • 哈希表的析构函数用于释放动态分配的内存。
  • 遍历哈希表的每个位置，依次删除链表中的节点。

完整代码

/*************************************************************************
        > File Name: 15.cpp
        > Author:Xiao Yuheng
        > Mail:3312638794@qq.com
        > Created Time: Wed Nov  8 22:38:19 2023
 ************************************************************************/

#include <iostream>
#include <vector>
#include <functional>

using namespace std;

class Node {
public:
    Node() = default;
    Node(string, int, Node *);
    string key();
    int value;
    Node *next();
    void set_next(Node *);
    void insert(Node *);
    void erase_next();

private:
    string __key;
    Node *__next;
};

Node::Node(string key, int value = 0, Node *node = nullptr) : __key(key), value(value), __next(node) {}
string Node::key() { return __key; }
Node *Node::next() { return __next; }
void Node::set_next(Node *node) { __next = node; }
void Node::insert(Node *node) {
    node->set_next(this->next());
    this->set_next(node);
}
void Node::erase_next() {
    Node *p = this->next();
    if (p == nullptr) return ;
    this->set_next(this->next()->next());
    delete p;
}

class HashTable {
public:
    typedef function<int(string)> HASH_FUNC_T;
    HashTable (HASH_FUNC_T hash_func, int size);
    bool insert(string, int);
    bool erase(string);
    bool find(string);
    int capacity();
    int &operator[](string);
    void swap(HashTable &);
    ~HashTable();

private:
    Node *__insert(string, int);
    Node *__find(string);
    void __expand();
    int __size, data_cnt;
    vector<Node> data;
    HASH_FUNC_T hash_func;
};

HashTable::HashTable (HASH_FUNC_T hash_func, int size = 10) :
                    data(size), hash_func(hash_func),
                    __size(size), data_cnt(0) {}
int HashTable::capacity() { return data_cnt; }
bool HashTable::insert(string key, int value = 0) {
    Node *p = __insert(key, value);
    if (data_cnt > __size * 2) __expand();
    return p != nullptr;
}
Node *HashTable::__insert(string key, int value) {
    if (find(key)) return nullptr;
    int ind = hash_func(key) % __size;
    data[ind].insert(new Node(key, value));
    data_cnt += 1;
    return data[ind].next();
}
bool HashTable::erase(string key) {
    if (!find(key)) false;
    int ind = hash_func(key) % __size;
    Node *p = &data[ind];
    while (p->next() && p->next()->key() != key) { p = p->next(); }
    if (p->next() == nullptr) return false;
    p->erase_next();
    data_cnt--;
    return true;
}
bool HashTable::find(string key) {
    Node *p = __find(key);
    if (p == nullptr) return false;
    return true;
}
Node *HashTable::__find(string key) {
    int ind = hash_func(key) % __size;
    Node *p = &data[ind];
    while (p && p->key() != key) { p = p->next(); }
    return p;
}
int &HashTable::operator[](string key) {
    Node *p = __find(key);
    if (p) return p->value;
    insert(key);
    return __find(key)->value;
}
void HashTable::__expand() {
    HashTable h(hash_func, __size * 2);
    for (int i = 0; i < __size; i++) {
        Node *p = data[i].next();
        while(p) {
            h.insert(p->key(), p->value);
            p = p->next();
        }
    }
    swap(h);
}
void HashTable::swap(HashTable &h) {
    std::swap(__size, h.__size);
    std::swap(data_cnt, h.data_cnt);
    std::swap(data, h.data);
    std::swap(hash_func, h.hash_func);
}
HashTable::~HashTable() {
    for (int i = 0; i < __size; i++) {
        while (data[i].next()) { data[i].erase_next(); }
    }
}


int BKDRHash(string s) {
    int seed = 31;
    int h = 0;
    for (int i = 0; s[i]; i++) {
        h = h * seed + s[i];
    }
    return h & 0x7fffffff;
}

class APHash_Class {
public:
    int operator() (string s) {
        int h = 0;
        for (int i = 0; s[i]; i++) {
            if (i % 2) {
                h = (h << 3) ^ s[i] ^ (h >> 5);
            } else {
                h = ~((h << 7) ^ s[i] ^ (h >> 11));
            }
        }
        return h & 0x7fffffff;
    }
};

int main() {
    APHash_Class APHash;
    HashTable h1(BKDRHash);
    HashTable h2(APHash);
    int op;
    string s;
    cout << h1.capacity() << endl;
    cout << h2.capacity() << endl;
    h1["hello"] = 123;
    h1["world"] = 456;
    h1["haizei"] = 789;
    cout << h1.capacity() << endl;
    cout << h2.capacity() << endl;
    cout << h1["hello"] << " " << h1["world"] << " " << h1["hahaha"] << endl;
    while (cin >> op >> s) {
        switch(op) {
            case 0: {
                cout << "insert " << s << " to hash table 1 = ";
                cout << h1.insert(s) << endl;
                cout << "insert " << s << " to hash table 2 = ";
                cout << h2.insert(s) << endl;
            } break;
            case 1: {
                cout << "erase " << s << " from hash table 1 = ";
                cout << h1.erase(s) << endl;
                cout << "erase " << s << " from hash table 2 = ";
                cout << h2.erase(s) << endl;
            } break;
            case 2: {
                cout << "find " << s << " at hash table 1 = ";
                cout << h1.find(s) << endl;
                cout << "find " << s << " at hash table 2 = ";
                cout << h2.find(s) << endl;
            } break;
        }
    }
    return 0;
}
拾雪藏于春
关注
专栏目录
【PTA刷题】甲级 哈希散列
abyss_miracle的博客
11-19 124
之前概念理解有偏差。 哈希散列是根据pos = (x + j * j) % TableSize来算位置的。（这里就不写错误的方法了，免得记错）。注意是原始大小，加上平方探测，对表大小(一般是个Prime)取余。 那么，如果一直有占用，啥时候停止呢？ 在j < TableSize范围内一直进行。 查询的时候则略有不同，如果一直有占用，就在j <= TableSize的时候都运行。(比插入的时候多查询一次) 【甲级】1145 Hashing – Average Search Time (25)
NodeJS实现哈希查找算法
最新发布
adendean的博客
03-15 508
在这个示例中，我们使用了Map来实现哈希查找算法。首先，我们遍历数组，将数组元素作为键，元素在数组中的索引作为值，存储在Map中。然后，我们可以通过目标值在Map中查找其索引，如果存在则返回索引，否则返回-1表示未找到。NodeJS实现哈希查找算法。
PTA 整型关键字的散列映射(hash)
[空白]
04-22 3906
整型关键字的散列映射 题目要求如下： 7-1 整型关键字的散列映射（25 分） 给定一系列整型关键字和素数P，用除留余数法定义的散列函数将关键字映射到长度为P的散列表中。用线性探测法解决冲突。 输入格式: 输入第一行首先给出两个正整数N（≤1000）和P（≥N的最小素数），分别为待插入的关键字总数、以及散列表的长度。第二行给出N个整型关键字。数字间以空格分隔。 ...
【PTA】hashing(hard version)
weixin_43719720的博客
07-28 264
题意：给出一个散列表，哈希函数是H（x）=x%N，冲突处理方法是线性探测，按照散列表打印出输入的顺序，如果有多种选择先输出小的那个。 解题思路（看了姥姥的慕课和别人的代码）：有冲突的元素有先后顺序，可用有向图（邻接矩阵）来存储，然后拓扑排序。 代码如下 #include<stdio.h> #include<stdlib.h> #include<queue&gt...
pta--1050 String Subtraction（20 分）（Hash）
来啦(#^.^#)
09-04 252
题目链接：https://pintia.cn/problem-sets/994805342720868352/problems/994805429018673152 【分析】 题意：两个字符串s1,s2，s2中出现的字符若在s1中也出现就删除，操作结束后输出s1. 思路：Hash散列，存储每个字符出现的个数。如果某个字符未出现过就输出，否则不输出。 【代码】 #include&lt;b...
哈希表-使用C++实现的哈希表-HashTable.zip
03-04
在"哈希表_使用C++实现的哈希表_HashTable"这个压缩包中，很可能包含了用C++实现的哈希表源代码，可以作为学习和参考。源代码通常会包括哈希函数的定义、插入、查找和删除操作的实现，以及处理哈希冲突的策略。 ...
哈希表-使用Java开发的哈希表-HashTable.zip
03-04
在Java中，`HashTable`是早期版本（Java 1.0）提供的一种线程安全的哈希表实现。尽管现在已经被`HashMap`所替代，但理解`HashTable`的工作原理和特性仍然对深入理解Java集合框架以及数据结构有重要意义。 哈希表的...
哈希表-使用C语言实现哈希表数据结构-HashTable.zip
03-04
"哈希表_使用C语言实现哈希表数据结构_HashTable"这个压缩包很可能包含了具体的C语言代码示例，通过阅读和理解这些代码，你可以深入学习哈希表的实现细节，包括如何定义结构体、如何定义和应用哈希函数、如何处理...
javascript 哈希表(hashtable)的简单实现
10-29
JavaScript中的哈希表（HashTable）是一种数据结构，用于存储键值对，通过键来快速查找对应的值。在JavaScript中，虽然没有内置的哈希表类型，但可以通过对象（Object）来实现类似的功能，因为对象的属性本质上就是...
哈希表（HashTable）C++实现.docx
03-01
### 哈希表（HashTable）C++实现详解 #### 一、引言 哈希表是一种非常重要的数据结构，在实际应用中极为广泛。它通过将键映射到表的一个位置来加速查找记录的速度，这一映射过程称为哈希化。在C++中，标准模板库...
PTA 电话聊天姐妹圈 (25分)（并查集+Hash）
不导翁的博客
07-19 307
新冠疫情期间，大家不能聚会，于是姐妹们就开始煲电话。姐妹们互相煲电话，自然就成了一个一个的圈子，为了区分哪些是真闺蜜，哪些是塑料姐妹情，我们对电话记录进行了跟踪，通过分析通话时间来确定亲密程度。我们这样设定，两个人之间所有的电话时间长度之和作为两个人亲密度的度量，一个姐妹圈是由三个或三个以上的女生组成，且所有成员的通话时间之和超过某个阈值K，姐妹圈中通话时间最长的那个就是该圈的核心。现在给一些通话清单，请找出姐妹圈的个数和姐妹圈里的核心。 输入格式: 第一行两个不超过1000的正整数N和K，分别表示电话的通
PTA数据结构题目
热门推荐
qq_43400374的博客
05-06 3万+
程序填空题 5-1 打印“Hello World!”，占一行。 #include <iostream> using namespace std; int main() { cout<<"Hello World!"<<endl; return 0; } 5-2 下列代码的功能是返回带头结点的单链表L的逆转链表。 List Reverse( Lis...
PTA写BUG日志——哈希篇（算法笔记上机实战）
糕糕的博客
07-16 206
2021年7月16日 哈希第一弹 题目传送门–B1033旧键盘打字 没错没错，这是2/5通过率版本，第一版3/5，改了之后不仅还是超时，结果正确率又降了，嘤嘤嘤~~ //1033 #include<bits/stdc++.h> using namespace std; char test[200000]; char bad[100]; bool flag=false; map<char,int>mp; int main(){ scanf("%s%s",bad,test); for
哈希表【Hash Table】原理、特点及实现方式！一文彻底搞定哈希表！
KIDfengKID的博客
07-01 2241
详细易懂hash table
PTAL1-005 考试座位号 测试点全过 暴力&哈希表算法，以及unordered_map的语法
yudui666的博客
04-01 209
unordered_map 的内部实现可以使用 hash table。Hash table 是一种基于哈希函数实现的数据结构，可以在常数时间复杂度 O(1) 内完成元素的插入、删除和查找等操作，因此被广泛用于实现关联数组和字典等数据结构。unordered_map 的底层实现中，会将键（key）和值（value）存储在一个桶（bucket）中。当一个键被插入时，首先会通过哈希函数计算其哈希值（hash value），然后再将键值对存储在哈希值对应的桶中。
测试了一下node支持的各种哈希函数的性能
Emu的专栏 —— 关注前端技术，关注网络优化
12-10 823
把nodejs里面支持的hash函数都拉出来遛一遛
HashTable的代码实现
qq_44065088的博客
10-27 362
#include <iostream> #include <string> #include <assert.h> #include <Windows.h> using namespace std; #include <cstdlib> //* #include <crtdbg.h> //* #ifdef _D...
nodejs对字符串hash
戎码江湖
10-21 4391
将字符串进行hash const sha256 = require(“sha256”); sha256(需要传入的字符串); 参考网址：https://www.npmjs.com/package/sha256
哈希的简单实现
qq_37954088的博客
04-12 3247
       在前面的学习中，我们看了静态查找和动态查找，今天我们来看哈希查找。线性表，二叉搜索树，AVL树，红黑树和B树，元素在存储结构中的位置与元素的关键码之间不存在直接的对应关系。在这些数据结构中，查找一个元素需要进行一系列的关键码的比较。查找的效率取决于查找过程中比较的次数。 1. 哈希查找的定义          在插入或者查找时，根据元素的关键码，以哈希函数计算出该元素的存储位置并...
C语言实现哈希表：hashtable.txt解析
"本文档提供了一个C语言实现的哈希表，主要包含了哈希表的结构定义、哈希函数以及插入元素的函数。哈希表的大小被限制为128，每个元素由键（key）和值（value）组成，并且支持释放值的回调函数。" 在计算机科学中，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值