哈希表
散列表,它是基于快速存取的角度设计的,也是一种典型的 “空间换时间” 的做法;
键(key) : 组员的编号, 如: 1,2,3…;
值(value): 组员的其他信息 (包含: 性别, 年龄, 战斗力等);
索引: 数组的下标 (0,1,2…), 用以快速定位和检索数据;
哈希桶: 保存索引的数组 (链表或数组), 数组成员为每一个索引值相同的多个元素
哈希函数: 将组员编号映射到索引上, 采用求余法(方法可以有很多种);
算法代码实现:(使用的是链表实现)
#include <iostream>
#include <string>
using namespace std;
#define DEFAULT_SIZE 32
//哈希表元素定义
typedef struct _listNode {
struct _listNode* next;//指像下一个位置的指针
int key;//索引编号
void* data;//保存的数据
}listNode;
typedef listNode* list;
typedef listNode* elem;
//哈希表结构定义
typedef struct _HashTable {
int TableSize;//哈希桶的总个数
list* Thelists;//保存在链表的位置
}HashTable;
//哈希函数: 根据key 计算索引,定位Hash桶的位置
int Hash(int key, int TableSize) {
return (key % TableSize);
}
//初始化哈希表
HashTable* initHash(int TableSize) {
if (TableSize <= 0) {
TableSize = DEFAULT_SIZE;
}
HashTable* htable = NULL;
htable = new HashTable;
if (htable == NULL) {
cout << "htable new error!" << endl;
return NULL;
}
htable->TableSize = TableSize;
//为hash桶分配内存空间,其为一个指针数组
htable->Thelists = new list[htable->TableSize];//这里需要分配一个指针数组
if (htable->Thelists == NULL) {
cout << "list new error!" << endl;
delete htable;
return NULL;
}
//为hash桶对应的指针数组初始化链表节点
for (int i = 0; i < TableSize; i++) {
htable->Thelists[i] = (list)(new listNode);//需要把分配的节点进行类型转换
if ((list)htable->Thelists[i]==NULL) {
cout << "listNode new error!" << endl;
delete htable->Thelists;
delete htable;
return NULL;
}
else {
//初始化hash桶里的所有元素为0
memset(htable->Thelists[i], 0, sizeof(listNode));
}
}
return htable;
}
//从哈希表中根据键值查找元素
elem Find(HashTable* table, int key) {
list L = NULL;
elem e = NULL;
int i = 0;
i = Hash(key, table->TableSize);
L = table->Thelists[i];
e = L->next;
while (e != NULL && e->key != key) {
e = e->next;
}
return e;
}
//哈希表链表插入元素,元素为键值对
void insertHash(HashTable* table, int key, void* value) {
elem e = NULL;
elem tmp = NULL;
list L = NULL;
e = Find(table, key);
if (e == NULL) {
tmp = new listNode;
if (tmp == NULL) {
cout << "tmp new error!" << endl;
return;
}
//使用前插法
L = table->Thelists[Hash(key,table->TableSize)];
tmp->data = value;
tmp->key = key;
tmp->next = L->next;
L->next = tmp;
}
else {
cout << "key already exist!" << endl;
}
}
//哈希表链表删除元素
void deleteHash(HashTable* table, int key) {
elem e = NULL;
elem last = NULL;
list L = NULL;
int i = Hash(key, table->TableSize);
L = table->Thelists[i];
last = L;
e = L->next;
while (e != NULL && e->key != key) {
e = e->next;
last = e;
}
if (e != NULL) {
//如果键值对存在
last->next = e->next;
delete e;
}
}
//提取哈希表中的数据
void *retrieveHash(elem e) {
return e ? e->data : NULL;
}
//销毁哈希表
void destoryHash(HashTable* hash) {
list L = NULL;
elem cur = NULL;
elem next = NULL;
for (int i = 0; i < hash->TableSize; i++) {
L = hash->Thelists[i];
cur = L->next;
while (cur != NULL) {
next = cur->next;
delete cur;
cur = next;
}
delete L;
}
delete hash->Thelists;
delete hash;
}
//测试代码
int main(void) {
const char* elems[] = { "小王","老王","老宋"};
HashTable* hash;
hash = initHash(16);
insertHash(hash, 1, (char*)elems[0]);
insertHash(hash, 2, (char*)elems[1]);
insertHash(hash, 3, (char*)elems[2]);
deleteHash(hash, 1);
for (int i = 1; i < 4; i++) {
elem e = Find(hash, i);
if (e != NULL) {
cout << "NO."<<i<<" is:"<<(const char*)retrieveHash(e) << endl;
}
else {
cout << "not seek out:"<<elems[i-1] << endl;
}
}
system("pause");
return 0;
}
小练习:
DNA 检测字串匹配
测试色盲的基因组包含 8 位基因，编号 1 至 8。每一位基因都可以用一个字符来表示，这个字符 是’A’、‘B’、‘C’、'D’四个字符;
解答思路：
- 可以直接把待测试基因的 2,3,4,5 位直接与基因库里的记录逐一对比，但如果色盲基因库很庞 大，程序执行效率很低
- 可以使用哈希表来存储色盲基因库数据，通过哈希函数把 4 位色盲基因映射到哈希表中，大大提高检索的效 率.
#pragma once
#ifndef DNA_HASH_H
#define DNA_HASH_H
#include <iostream>
#include <string>
using namespace std;
#define DEFAULT_SIZE 32
#define H_int32 int
//定义哈希表的元素结构
typedef struct _listNode {
struct _listNode* next;
void* key;
void* data;
}listNode;
typedef listNode* list;
typedef listNode* Elem;
typedef struct _HashTable {
int TableSize;
list* Thelists;
}Hash;
//哈希函数
H_int32 Hash_Func(void* key, H_int32 TableSize);
//初始化哈希表
Hash* initHash(H_int32 TableSize);
//哈希表插入元素和键值对
void insertHash(Hash* hash, void* key, void* value);
//哈希表删除元素,元素为键值对
void deleteHash(Hash* hash, void* key);
//哈希表查找
Elem FindHash(Hash* hash, void* key);
//哈希表销毁
void destotyHash(Hash* hash);
//哈希表元素中提取数据
void* retrieveHash(Elem elem);
#endif // !DNA_HASH_H
#include "DNA_hash.h"
#define BUCKET_SIZE 1024
#define compare(a,b) strcmp((const char*)a,(const char*)b)
#define hash_func SDDMhash
unsigned int SDDMhash(void* key)
{
unsigned int hash = 0;
char* str = (char*)key;
while (*str) {
hash = (*str++) + (hash << 6) + (hash << 16) - hash;
}
return (hash & 0x7FFFFFFF);
}
H_int32 Hash_Func(void* key, H_int32 TableSize)
{
return hash_func(key)%TableSize;
}
Hash* initHash(H_int32 TableSize)
{
Hash* hash = NULL;
hash = new Hash;
if (TableSize <= 0) {
TableSize = DEFAULT_SIZE;
}
if (hash == NULL) {
cout << "初始化内存分配失败!" << endl;
return NULL;
}
hash->TableSize = TableSize;
//为hash桶分配内存空间,其为一个指针数组
//hash->Thelists = (list*)malloc(sizeof(list) * TableSize);
hash->Thelists = new list[hash->TableSize];
if (hash->Thelists == NULL) {
cout << "数组指针内存分配失败!" << endl;
delete hash;
return NULL;
}
//为hash 桶对应的指针数组初始化链表节点
for (int i = 0; i < TableSize; i++) {
hash->Thelists[i] = (list) (new listNode);
if ((list)hash->Thelists[i]==NULL) {
cout << "指针数组内存分配失败!" << endl;
delete hash;
return NULL;
}
else{
memset(hash->Thelists[i], 0, sizeof(list));
}
}
return hash;
}
void insertHash(Hash* hash, void* key, void* value)
{
Elem elem = NULL;
Elem tmp = NULL;
list L = NULL;
elem = FindHash(hash, key);
if (elem == NULL) {
tmp = new listNode;
if (tmp == NULL) {
cout << "插入元素内存分配失败!" << endl;
return;
}
H_int32 code = Hash_Func(key, hash->TableSize);
L = hash->Thelists[code];//前插法
tmp->data = value;
tmp->key = key;
tmp->next = L->next;
L->next = tmp;
}
else {
cout << "已存在的索引!" << endl;
}
}
void deleteHash(Hash* hash, void* key)
{
Elem elem = NULL;
Elem last = NULL;
list L = NULL;
int i = Hash_Func(key, hash->TableSize);
L = hash->Thelists[i];
last = L;
elem = L->next;
while (elem != NULL && elem->key != key) {
last = elem;
elem = elem->next;
}
if (elem) {
last->next = elem->next;
delete elem;
}
}
Elem FindHash(Hash* hash, void* key)
{
list L = NULL;
Elem elem = NULL;
int i = 0;
i = Hash_Func(key, hash->TableSize);
L = hash->Thelists[i];
elem = L->next;
while (elem != NULL && compare(elem->key, key) != 0) {
elem = elem->next;
}
return elem;
}
void destotyHash(Hash* hash)
{
list L = NULL;
Elem cur = NULL;
Elem next = NULL;
for (int i = 0; i < hash->TableSize; i++) {
L = hash->Thelists[i];
cur = L->next;
while (cur != NULL) {
next = cur->next;
delete cur;
cur = next;
}
delete L;
}
delete hash->Thelists;
delete hash;
}
void* retrieveHash(Elem elem)
{
return elem?elem->data:NULL;
}
int main(void) {
const char* elems[] = { "ADBB","BDDC","CDBC","BDBB" };
const char* tester = "ABDABACD";
char cur[5] = { '\0' };
Hash* hash = NULL;
hash = initHash(BUCKET_SIZE);
insertHash(hash, (int*)elems[0], (char*)elems[0]);
insertHash(hash, (int*)elems[1], (char*)elems[1]);
insertHash(hash, (int*)elems[2], (char*)elems[2]);
insertHash(hash, (int*)elems[3], (char*)elems[3]);
deleteHash(hash, (int*)elems[0]);
strncpy_s(cur, tester + 1, 4);
Elem elem = FindHash(hash, (char*)cur);
if (elem) {
cout <<"匹配到基因:"<< (char*)retrieveHash(elem) << endl;
}
else {
cout << "没有找到匹配的基因!" << endl;
}
system("pause");
return 0;
}
C++实现
#include<iostream>
#include<list>
#include<utility>//pair<>函数的头文件
using namespace std;
//为了兼容更多的数据使用泛型编程
template<class T>
class Hash_tab
{
public:
Hash_tab(int length);//构造函数
Hash_tab(const Hash_tab* h_t);//拷贝构造函数
~Hash_tab();//析构函数
T insert(int key, T val);//数据插入
T remove_key(int key);//根据索引删除数据
T remove_val(T val);//根据数据删除数据
T find_key(int key);//根据索引查找数据
int find_val(T val);//根据数据查找索引
void print();//打印哈希表
private:
//哈希函数,计算哈希桶的位置
int hash_fun(int key) { return key % len; }
int get_lenght() { return len; }
private:
using ht = list<pair<int, T>>;//组合两个数据的链表节点
int len;//哈希表的长度;
ht* elem = NULL;
};
template<class T>
Hash_tab<T>::Hash_tab(int length):len(length)
{
if (this->len <= 0) {
this->len = 1;
}
//分配一个组合了两个数据的指针数组
this->elem = new ht[len];
}
template<class T>
Hash_tab<T>::Hash_tab(const Hash_tab* h_t)
{
this->elem = new ht[len];
for (int i = 0; i < len; i++) {
h_t->elem[i] = this->elem[i];
}
}
template<class T>
Hash_tab<T>::~Hash_tab()
{
if (elem != nullptr) {
delete[]elem;
elem = NULL;
}
}
template<class T>
T Hash_tab<T>::insert(int key, T val)
{
int place = this->hash_fun(key);
for (auto& s : this->elem[place]) {//找到place在elem数组中的位置
if (s.first == key) {//如果key这个索引已经存在有三种情况
//1.返回原有的数据
return s.second;
//2.替换掉原有的数据
//s.first = key;
//s.second = val;
//return val;
//3.在后面继续插入
//elem[place].push_back({key,val});
//return val;
}
}
elem[place].push_back({ key,val });
return val;
}
template<class T>
T Hash_tab<T>::remove_key(int key)
{
int place = this->hash_fun(key);
for (auto& s : elem[place]) {
if (s.first == key) {
return s.second;
elem[place].remove(s);
}
}
return 0;
}
template<class T>
T Hash_tab<T>::remove_val(T val)
{
for (int i = 0; i < len; i++) {
for (auto& s : elem[i]) {
if (s.second == val) {
return s.second;
elem[i].remove(s);
}
}
}
return NULL;
}
template<class T>
T Hash_tab<T>::find_key(int key)
{
int base = this->hash_fun(key);
for (auto& s : elem[base]) {
if (s.first == key) {
return s.second;
}
}
return NULL;
}
template<class T>
int Hash_tab<T>::find_val(T val)
{
for (int i = 0; i < len; i++) {
for (auto& s : elem[i]) {
if (s.second == val) {
return s.first;
}
}
}
return 0;
}
template<class T>
void Hash_tab<T>::print()
{
for (int i = 0; i < len; i++) {
cout << "(" << i << ")->";
for (auto& s : elem[i]) {
cout << "[" << s.first << "," << s.second << "]->";
}
cout << "NULL" << endl;
}
}
int main() {
Hash_tab<string> s(0);
s.insert(0, "张飞");
s.insert(4, "刘备");
s.insert(11,"鲁班");
cout << s.find_key(0) << endl;
cout << s.find_val("刘备") << endl;
s.print();
system("pause");
}
4141
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
