Hash Table 哈希表 C++ 例子

最新推荐文章于 2024-02-26 08:37:50 发布
最新推荐文章于 2024-02-26 08:37:50 发布
阅读量5.4k 收藏 4
点赞数
分类专栏： C++&C

What's a Hash Table? Why we need a Hash Table?


By Using a Hash Table we can find element very quickly. For example, There are 20 random number in an array below.



It's not a sorted array, So We can not use Binary Search to finding a number, When we need to find  118, We need 12 comparisons! Finding number like 270, 198, we need even more comparison.


We change the way the 20 number store. We store them in 10 linked lists. There is a rule, If the number's last digit is 0, so we insert it in a  linked list which  index is 0. Look at  the Figure 1 for more detail. like number 118, it's last digit is 8, so we  insert it in ninth linked list.



So in this way, We find 118 only need 1 comparison in the ninth linked list! Finding number like 270 or 198, we need just 2 comparisons.


Hash Function


Note that the basic hash table which we explained above used a modulo function. There are many way to hash data, but modulo is the most common. What's more, the modulo function often use a prime number. That was because you get fewer collisions when you modulo a key  by a prime number. Having fewer collisions makes your table easier to work and more efficient. There is a completed mathmatical reasoning behind this, but it is okay for us to assume that this is true for us.


A Hash Table Class Example


You need have some STD knowledge, We will use "list" in STD instead of using customied linked list. And we also use  "find" and "erase" function.


[cpp] view plain copy print ?
  1. #ifndef _HASHTABLE_   
  2. #define _HASHTABLE_   
  3.   
  4. #include <list>   
  5. #include <algorithm>   
  6.   
  7. using namespace std;  
  8.   
  9. class HashTable{  
  10.   
  11. private:  
  12.     list<int> containers[10];  
  13.     int HashFunction(const int& v) const;  
  14.     int count;  
  15.   
  16. public:  
  17.     HashTable();  
  18.     ~HashTable();  
  19.     void Insert(const int& e);  
  20.     bool Find(const int& e) const;  
  21.     bool Delete(const int& e);  
  22.     int Count() const;  
  23. };  
  24.   
  25. int HashTable::HashFunction(const int& v) const{  
  26.     return v%10;  
  27. }  
  28.   
  29. HashTable::HashTable(){  
  30.     count = 0;  
  31. }  
  32.   
  33. HashTable::~HashTable(){  
  34.     count = 0;  
  35.     for(int i = 0; i< 10; ++i){  
  36.         containers[i].clear();  
  37.     }  
  38. }  
  39.   
  40. void HashTable::Insert(const int& e){  
  41.     const int hashResult = HashFunction(e);  
  42.     containers[hashResult].push_back(e);  
  43.     ++count;  
  44. }  
  45.   
  46. bool HashTable::Find(const int& e) const{  
  47.     const int hashResult = HashFunction(e);  
  48.     list<int>::const_iterator itr = find(containers[hashResult].begin(),  
  49.         containers[hashResult].end(), e);  
  50.     if(itr != containers[hashResult].end()){  
  51.         return true;  
  52.     }else{  
  53.         return  false ;  
  54.     }  
  55. }  
  56.   
  57. bool HashTable::Delete(const int& e){  
  58.     const int hashResult = HashFunction(e);  
  59.     list<int>::iterator itr = find(containers[hashResult].begin(),  
  60.         containers[hashResult].end(), e);  
  61.     if(itr != containers[hashResult].end()){  
  62.         containers[hashResult].erase(itr);  
  63.         --count;  
  64.         return true;  
  65.     }else{  
  66.         return false;  
  67.     }  
  68.   
  69. }  
  70.   
  71. int HashTable::Count()const{  
  72.     return count;  
  73. }  
  74.   
  75. #endif  
#ifndef _HASHTABLE_
#define _HASHTABLE_

#include <list>
#include <algorithm>

using namespace std;

class HashTable{

private:
	list<int> containers[10];
	int HashFunction(const int& v) const;
	int count;

public:
	HashTable();
	~HashTable();
	void Insert(const int& e);
	bool Find(const int& e) const;
	bool Delete(const int& e);
	int Count() const;
};

int HashTable::HashFunction(const int& v) const{
	return v%10;
}

HashTable::HashTable(){
	count = 0;
}

HashTable::~HashTable(){
	count = 0;
	for(int i = 0; i< 10; ++i){
		containers[i].clear();
	}
}

void HashTable::Insert(const int& e){
	const int hashResult = HashFunction(e);
	containers[hashResult].push_back(e);
	++count;
}

bool HashTable::Find(const int& e) const{
	const int hashResult = HashFunction(e);
	list<int>::const_iterator itr = find(containers[hashResult].begin(),
		containers[hashResult].end(), e);
	if(itr != containers[hashResult].end()){
		return true;
	}else{
		return  false ;
	}
}

bool HashTable::Delete(const int& e){
	const int hashResult = HashFunction(e);
	list<int>::iterator itr = find(containers[hashResult].begin(),
		containers[hashResult].end(), e);
	if(itr != containers[hashResult].end()){
		containers[hashResult].erase(itr);
		--count;
		return true;
	}else{
		return false;
	}

}

int HashTable::Count()const{
	return count;
}

#endif

Test the simple hash table class


[cpp] view plain copy print ?
  1. // SimpleHashTable.cpp : Defines the entry point for the console application.   
  2. //   
  3.   
  4. #include "stdafx.h"   
  5. #include "HashTable.h"   
  6. #include <iostream>   
  7.   
  8. using namespace std;  
  9.   
  10. int _tmain(int argc, _TCHAR* argv[])  
  11. {  
  12.     HashTable h;  
  13.     h.Insert(234);  
  14.     h.Insert(567);  
  15.     h.Insert(987);  
  16.     h.Insert(222);  
  17.     h.Insert(564);  
  18.     h.Insert(111);  
  19.   
  20.     h.Delete(234);  
  21.   
  22.     cout << boolalpha;  
  23.     cout << "Is 234 exist? " << h.Find(234)  << endl;  
  24.     cout << "Is 111 exist? " << h.Find(111) << endl;  
  25.     cout << "Total count:" << h.Count() << endl;  
  26.   
  27.     int i;  
  28.     cin >> i;  
  29.     return 0;  
  30. }  
// SimpleHashTable.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "HashTable.h"
#include <iostream>

using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
	HashTable h;
	h.Insert(234);
	h.Insert(567);
	h.Insert(987);
	h.Insert(222);
	h.Insert(564);
	h.Insert(111);

	h.Delete(234);

	cout << boolalpha;
	cout << "Is 234 exist? " << h.Find(234)  << endl;
	cout << "Is 111 exist? " << h.Find(111) << endl;
	cout << "Total count:" << h.Count() << endl;

	int i;
	cin >> i;
	return 0;
}



A more completed Hash Table class


[cpp] view plain copy print ?
  1. #ifndef _HASHTABLE_   
  2. #define _HASHTABLE_   
  3.   
  4. #include <list>   
  5. #include <string>   
  6. #include <algorithm>   
  7.   
  8. using namespace std;  
  9.   
  10.   
  11. class Entry{  
  12. private:  
  13.     int m_key;  
  14.     string m_data;  
  15. public:  
  16.     friend bool operator == (const Entry& e1,const Entry& e2);  
  17.     Entry(){}  
  18.     Entry(const int& key,const string& data){  
  19.         m_key = key;  
  20.         m_data = data;  
  21.     }  
  22.     void setKey(const int& key){  
  23.         m_key = key;  
  24.     }  
  25.     void setData(const string& data){  
  26.         m_data = data;  
  27.     }  
  28.     int getKey()const{  
  29.         return m_key;  
  30.     }  
  31.     string getData()const{  
  32.         return m_data;  
  33.     }  
  34.       
  35. };  
  36.   
  37. bool operator ==(const Entry& e1,const Entry& e2){  
  38.     return (e1.m_key == e2.m_key);  
  39. }  
  40.   
  41.   
  42. class HashTable{  
  43.   
  44. private:  
  45.     list<Entry> containers[10];  
  46.     int HashFunction(const int& v) const;  
  47.     int count;  
  48.   
  49. public:  
  50.     HashTable();  
  51.     ~HashTable();  
  52.     void Insert(const Entry& entry);  
  53.     bool Find(const int& key,list<Entry>::const_iterator& itr) const;  
  54.     bool Delete(const int& key);  
  55.     int Count() const;  
  56. };  
  57.   
  58. int HashTable::HashFunction(const int& v) const{  
  59.     return v%10;  
  60. }  
  61.   
  62. HashTable::HashTable(){  
  63.     count = 0;  
  64. }  
  65.   
  66. HashTable::~HashTable(){  
  67.     count = 0;  
  68.     for(int i = 0; i< 10; ++i){  
  69.         containers[i].clear();  
  70.     }  
  71. }  
  72.   
  73. void HashTable::Insert(const Entry& entry){  
  74.     const int hashResult = HashFunction(entry.getKey());  
  75.     containers[hashResult].push_back(entry);  
  76.     ++count;  
  77. }  
  78.   
  79. bool HashTable::Find(const int& key,list<Entry>::const_iterator& out) const{  
  80.     const int hashResult = HashFunction(key);  
  81.     Entry entry;  
  82.     entry.setKey(key);  
  83.     list<Entry>::const_iterator itr = find(containers[hashResult].begin(),  
  84.         containers[hashResult].end(), entry);  
  85.     if(itr != containers[hashResult].end()){  
  86.          out = itr;  
  87.          return true;  
  88.     }else{  
  89.         return  false ;  
  90.     }  
  91. }  
  92.   
  93. bool HashTable::Delete(const int& key){  
  94.     const int hashResult = HashFunction(key);  
  95.     Entry entry;  
  96.     entry.setKey(key);  
  97.     list<Entry>::iterator itr = find(containers[hashResult].begin(),  
  98.         containers[hashResult].end(), entry);  
  99.     if(itr != containers[hashResult].end()){  
  100.         containers[hashResult].erase(itr);  
  101.         --count;  
  102.         return true;  
  103.     }else{  
  104.         return false;  
  105.     }  
  106.   
  107. }  
  108.   
  109. int HashTable::Count()const{  
  110.     return count;  
  111. }  
  112.   
  113. #endif  
#ifndef _HASHTABLE_
#define _HASHTABLE_

#include <list>
#include <string>
#include <algorithm>

using namespace std;


class Entry{
private:
	int m_key;
	string m_data;
public:
	friend bool operator == (const Entry& e1,const Entry& e2);
	Entry(){}
	Entry(const int& key,const string& data){
		m_key = key;
		m_data = data;
	}
	void setKey(const int& key){
		m_key = key;
	}
	void setData(const string& data){
		m_data = data;
	}
	int getKey()const{
		return m_key;
	}
	string getData()const{
		return m_data;
	}
	
};

bool operator ==(const Entry& e1,const Entry& e2){
	return (e1.m_key == e2.m_key);
}


class HashTable{

private:
	list<Entry> containers[10];
	int HashFunction(const int& v) const;
	int count;

public:
	HashTable();
	~HashTable();
	void Insert(const Entry& entry);
	bool Find(const int& key,list<Entry>::const_iterator& itr) const;
	bool Delete(const int& key);
	int Count() const;
};

int HashTable::HashFunction(const int& v) const{
	return v%10;
}

HashTable::HashTable(){
	count = 0;
}

HashTable::~HashTable(){
	count = 0;
	for(int i = 0; i< 10; ++i){
		containers[i].clear();
	}
}

void HashTable::Insert(const Entry& entry){
	const int hashResult = HashFunction(entry.getKey());
	containers[hashResult].push_back(entry);
	++count;
}

bool HashTable::Find(const int& key,list<Entry>::const_iterator& out) const{
	const int hashResult = HashFunction(key);
	Entry entry;
	entry.setKey(key);
	list<Entry>::const_iterator itr = find(containers[hashResult].begin(),
		containers[hashResult].end(), entry);
	if(itr != containers[hashResult].end()){
         out = itr;
		 return true;
	}else{
		return  false ;
	}
}

bool HashTable::Delete(const int& key){
	const int hashResult = HashFunction(key);
	Entry entry;
    entry.setKey(key);
	list<Entry>::iterator itr = find(containers[hashResult].begin(),
		containers[hashResult].end(), entry);
	if(itr != containers[hashResult].end()){
		containers[hashResult].erase(itr);
		--count;
		return true;
	}else{
		return false;
	}

}

int HashTable::Count()const{
	return count;
}

#endif

Test the completed hash table class


[cpp] view plain copy print ?
  1. // HashTableApp.cpp : Defines the entry point for the console application.   
  2. //   
  3.   
  4. #include "stdafx.h"   
  5. #include "HashTable.h"   
  6. #include <iostream>   
  7. #include <string>   
  8.   
  9. using namespace std;  
  10.   
  11. int _tmain(int argc, _TCHAR* argv[])  
  12. {  
  13.     HashTable h;  
  14.     h.Insert(Entry(234,"one"));  
  15.     h.Insert(Entry(567,"two"));  
  16.     h.Insert(Entry(987,"three"));  
  17.     h.Insert(Entry(222,"four"));  
  18.     h.Insert(Entry(564,"five"));  
  19.     h.Insert(Entry(111,"six"));  
  20.   
  21.     h.Delete(234);  
  22.   
  23.     list<Entry>::const_iterator itr;  
  24.     if(h.Find(234,itr)){  
  25.         cout <<"The data with key 234: " << itr->getData() << endl;  
  26.     }else{  
  27.         cout << "Can not find the data with key 234 " << endl;  
  28.     }  
  29.     if(h.Find(111,itr)){  
  30.         cout <<"The data with key 111: " << itr->getData() << endl;  
  31.     }else{  
  32.         cout << "Can not find the data with key 111" << endl;  
  33.     }  
  34.     cout << "Total count: " << h.Count() << endl;  
  35.   
  36.     int i;  
  37.     cin >> i;  
  38.     return 0;  
  39. }  
// HashTableApp.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "HashTable.h"
#include <iostream>
#include <string>

using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
	HashTable h;
	h.Insert(Entry(234,"one"));
	h.Insert(Entry(567,"two"));
	h.Insert(Entry(987,"three"));
	h.Insert(Entry(222,"four"));
	h.Insert(Entry(564,"five"));
	h.Insert(Entry(111,"six"));

	h.Delete(234);

	list<Entry>::const_iterator itr;
	if(h.Find(234,itr)){
		cout <<"The data with key 234: " << itr->getData() << endl;
	}else{
		cout << "Can not find the data with key 234 " << endl;
	}
	if(h.Find(111,itr)){
		cout <<"The data with key 111: " << itr->getData() << endl;
	}else{
		cout << "Can not find the data with key 111" << endl;
	}
	cout << "Total count: " << h.Count() << endl;

	int i;
	cin >> i;
	return 0;
}

http://www.waitingfy.com/?p=480

shirley
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++语言实现hash表详解及实例代码
01-20
C++语言实现hash表详解 概要：  hash表，有时候也被称为散列表。个人认为，hash表是介于链表和二叉树之间的一种中间结构。链表使用十分方便，但是数据查找十分麻烦；二叉树中的数据严格有序，但是这是以多一个指针...
C++代码中使用哈希表
树欲静静风不止止的博客
08-30 3146
C++代码中如何使用哈希表
【C++】哈希表
BebopPrimer的博客
07-12 4177
【C++】哈希表
『数据结构』哈希表
叄拾叄画生
08-05 6858
什么是哈希？哈希冲突。哈希函数。哈希冲突解决方法。闭散列（线性探测、二次探测）。开散列（哈希桶）、开散列模拟实现（C++和Java）。
C++：【数据结构】哈希表
qq_73176808的博客
05-30 2100
哈希表（hash table）又叫散列表，是一种很实用的数据结构。首先来看一下百度给出的定义：散列表，是。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。通俗一点来说，就是我们有一堆值，他们的范围很大，但是又很分散，直接存储本身的话会非常占地方，所以我们就把它，这样不但节省了空间，而且还方便查找。
【数据结构篇C++实现】- 哈希表
陈七的博客，学习知识分享，期待与大家的交流
03-28 3791
有关散列表（哈希表）数据结构的知识点总结
C++ 实现哈希表的实例
08-29
C++ 实现哈希表的实例详解 哈希表是一种常用的数据结构，它可以快速地存储和检索数据。在 C++ 中，实现哈希表的实例可以帮助我们更好地理解哈希表的原理和实现机制。下面我们将详细介绍 C++ 实现哈希表的实例的相关...
open_addressing_hash_table:在 C++ 上打开寻址哈希表
06-30
在 C++ 上打开寻址哈希表 希望在这里看到功能齐全的 C++ 容器在 C++ 上实现快速和紧凑的开放寻址哈希表。 概念证明（参见 benchmark.cpp）表明，这种映射可以比std::unordered_map快 3 倍。 API 应该很像std::...
Hash_Table.rar_C语言 哈希表_Table_数据结构代码
07-15
哈希表，数据结构，完整代码，值得学习。C++语言
C++ 哈希表
最新发布
Han同学
02-26 2850
C++哈希表
C++ 数据结构与算法（五）（哈希表）
chenyfan_blog
02-25 6012
哈希表 LeetCode 代码随想录
【C++进阶】哈希表详解
m0_67077469的博客
03-21 2575
哈希表详解
【C++进阶】九、哈希表
枫叶先生的博客
03-19 1808
哈希概念|哈希冲突|哈希函数|哈希冲突解决|哈希表的闭散列实现|哈希表的开散列实现（哈希桶）详解
C++实现哈希表。
TPON的博客
11-17 6476
C++模拟实现哈希表
C++ 哈希表基本用法
热门推荐
m0_52318340的博客
07-29 1万+
如果现在做哈希表的题目，是因为按专题刷的哈希表的题目，所以会直接用哈希表。但是遇到一道新的题目，没有标签，怎么想到使用哈希表呢？在unordered_set跟unordered_map中删除元素，都用。如果是unordered_map，遍历的时候，可以访键值。在unordered_set中插入元素，可以用。在unordered_map中插入元素，可以使用。，如果之前已经将key存入到hash中，然后通过。注意，在unordered_map中，即使。，hash中还会存在key，也就是说此时。......
哈希表c++
06-02
哈希表（Hash Table）是一种根据关键码值（Key-Value）直接进行访问的数据结构，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。在哈希表中，关键码值通过哈希函数映射到表中的位置，这个映射函数称为哈希函数。 C++ STL 中提供了哈希表的实现，具体的类为 `unordered_map`，它是一个关联容器，提供了类似于 map 的接口，但是底层用哈希表实现，因此查找速度比 map 快。使用 `unordered_map` 的方式很简单，只需要包含头文件 `<unordered_map>`，然后使用 `unordered_map<Key, Value>` 类定义一个哈希表即可。 例如，下面的代码定义了一个 `unordered_map`，其中 Key 的类型为字符串，Value 的类型为整数： ```c++ #include <unordered_map> #include <iostream> int main() { std::unordered_map<std::string, int> myMap = { {"apple", 1}, {"banana", 2}, {"orange", 3} }; std::cout << "apple: " << myMap["apple"] << std::endl; std::cout << "banana: " << myMap["banana"] << std::endl; std::cout << "orange: " << myMap["orange"] << std::endl; return 0; } ``` 输出结果为： ``` apple: 1 banana: 2 orange: 3 ``` 这个例子中，我们使用了一个初始化列表来初始化了一个 `unordered_map`，然后通过 `[]` 运算符访问其中的元素。如果要在哈希表中插入新的元素，可以使用 `insert` 函数，例如： ```c++ myMap.insert({"pear", 4}); ``` 这会在 `myMap` 中插入一个新的键值对 `("pear", 4)`。 需要注意的是，哈希表中的元素是无序的，因此不能使用下标来访问某个位置的元素。另外，由于哈希表的实现需要使用哈希函数，因此要保证所有的 Key 类型能够正确地计算哈希值。如果需要使用自定义类型作为 Key，需要提供一个自定义的哈希函数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值