重学数据结构系列之——哈希表

1.定义

哈希表,也叫散列表。根据关键码值(Key value)而直接进行访问的数据结构。

比如你要查a,通过哈希函数f(a) = k就可以得到哈希表b的索引,b[k]即可获取a 对应的value

这个可以用来快速查重吧,就是你给我一个a,a在不在哈希表里呢?大家平时注册的时候,用户大的时候就可以用这个来快速查重了

百度百科:

http://baike.baidu.com/link?url=g4ZucsLSBI2PGnm6i08Lvs2fsgFaeafANq43uFlfaux-B-oykiNKcXXC9ESZpDRU-NASNIxl_QQ6YKK0uIm8xK


什么是冲突呢,就是多对一,比如:f(a) = k,同时f(c) = k,f(d) = k

2.解决冲突的方法(下面是复制的,仅作为笔记之用)

开放地址法。如果发生冲突,那么就使用某种策略寻找下一存储地址,直到找到一个不冲突的地址或者找到关键字,否则一直按这种策略继续寻找。如果冲突次数达到了上限则终止程序,表示关键字不存在哈希表里。一般常见的策略有这么几种:
1. 线性探测法,如果当前的冲突位置为 d,那么接下来几个探测地址为 d + 1,d + 2,d + 3 等,也就是从冲突地址往后面一个一个探测;
2. 线性补偿探测法,它形成的探测地址为 d + m,d + 2 * m,d + 3 * m 等,与线性探测法不同,这里的查找单位不是 1,而是 m,为了能遍历到哈希表里所有位置,我们设置m 和表长 size 互质;
3. 随机探测法,这种方法和前两种方法类似,这里的查找单位不是一个固定值,而是一个随机序列。
4. 二次探测法,它形成的探测地址为 d + 1^2,d + (-1)^2,d + 2^2,d + (-2)^2 等,这种方法在冲突位置左右跳跃着寻找探测地址。
开放地址法计算简单快捷,处理起来方便,但是也存在不少缺点。线性探测法容易形成“堆聚”的情况,即很多记录就连在一块,而且一旦形成“堆聚”,记录会越聚越多。另外,开放地址法都有一个缺点,删除操作显得十分复杂,我们不能直接删除关键字所在的记录,否则在查找删除位置后面的元素时,可能会出现找不到的情况,因为删除位置上已经成了空地址,查找到这里时会终止查找。

链地址法。该方法将所有哈希地址相同的结点构成一个单链表,单链表的头结点存在哈希数组里。链地址法常出现在经常插入和删除的情况下。
相比开放地址法,链地址法有以下优点:不会出现“堆聚”现象,哈希地址不同的关键字不会发生冲突;不需要重建哈希表,在开放地址法中,如果哈希表里存满关键字了就需要扩充哈希表然后重建哈希表,而在链地址法里,因为结点都是动态申请的,所以不会出现哈希表里存满关键字的情况;相比开放地址法,关键字删除更方便,只需要找到指定结点,删除该结点即可。

3.实现

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

//下面说得哈希表就是elem这个储存字符串的指针变量
class HashTable{
private:
	//储存字符串的指针
	string *elem;
	//哈希表容量
	int size;
public:
	HashTable(int input_size){
		size = input_size;
		elem = new string[size];
		//初始化每个字符串
		for (int i = 0; i < size; i++) {
			elem[i] = "#";
		}
	}
	~HashTable(){
		delete[] elem;
	}
	//哈希函数,就是我在定义里随便说得f()函数
	//简单来说就是计算出你这个字符串要放在我哈希表(数组)的哪个位置
	int hash(string& index){
		int code = 0;
		//这里的变量 i 不能用 int 类型,而应该用 size_t 类型,因为字符串是 string 类型,如果用 int 类型会有警告。
		for (size_t i = 0; i < index.length(); i++) {
			//有符号的字符范围这(ASCII)是从 -128 到 127,也就是一共有 256 种
			//index[i] + 128是将他们都转换成正数
			//code * 256估计是为了让差不多的字符相差更远, 
			//比如字符串转化成ASCII是-128,-127,算出的code=1,即位置为1
			//比如字符串转化成ASCII是-127,-126,算出的code=258,即位置为258
			//为了防止数据过大导致的数据溢出,相加的结果再对哈希表的长度 size 取余
			code = (code * 256 + index[i] + 128) % size;
		}
		return code;
	}
	//哈希表的查找函数
	//index:我们要查找的字符串
	//pos:我们的哈希表中可以插入index这个字符串的位置
	//times:冲突的次数
	bool search(string &index, int &pos, int ×){
		pos = hash(index);
		times = 0;
		
		//因为我们初始化elem每个元素为"#"
		//elem[pos] != "#"		这说明当前hash表pos位置上有元素
		//elem[pos] != index	并且该位置上的值不等于index字符串,说明冲突产生了,(两个以上字符串对应哈希表的同一个位置pos)
		while (elem[pos] != "#" && elem[pos] != index) {
			//找到冲突,冲突次数+1
			times++;
			//发生冲突后,我们需要找下一个存储地址,
			//首先我们要满足冲突次数 times 要小于哈希表的长度 size,否则我们认为哈希表已经填满关键字了,没有空余的地址可以存储。
			if (times < size) {
				//利用开放地址法的线性探测解决冲突
				pos = (pos + 1) % size;
			}else{
				//哈希表已经填满关键字,找不到index这个字符串插入哈希表的位置
				return false;
			}
		}
		//该位置上的值等于index字符串,说明找到了
		if (elem[pos] == index) {
			return true;
		}else{
			//否则找不到
			return false;
		}
	}
	//插入字符串到哈希表中
	int insert(string &index){
		int pos, times;
		//插入前看看是否已经在哈希表中
		if (search(index, pos, times)) {
			return 2;
		}else if (times < size/2) {
		//若冲突次数少于哈希表长度的一半
			//上面的search函数已经找到可以插入的位置pos了,直接赋值就可以了
			elem[pos] = index;
			return 1;
		}else{
			//冲突过多,为了提高查找效率,重建哈希表
			//因为冲突过多,search的while循环的次数会很多咯
			recreate();
			return 0;
		}
	}
	//重建哈希表
	void recreate(){
	//首先将原来的哈希表的值临时储存起来	
		string *temp_elem;
		temp_elem = new string[size];
		for (int i = 0; i < size; i++) {
			temp_elem[i] = elem[i];
		}
	//扩大哈希表
		int copy_size = size;
		//扩大两倍
		size = size * 2;
		//申请前先释放之前的空间
		delete[] elem;
		elem = new string[size];
		//先赋初值 :"#"
		for (i = 0; i < size; i++) {
			elem[i] = "#";
		}
		for ( i = 0; i < copy_size; i++) {
			if (temp_elem[i] != "#") {
				insert(temp_elem[i]);
			}
		}		
		delete[] temp_elem;		
	}
};

int main() {
	HashTable hashtable(2000);
	string buffer;
	//这个是要输入多少个字符串
	int n;
	cin>>n;
	for (int i = 1; i <= n; i++) {
		cin>>buffer;
		int ans = hashtable.insert(buffer);
		if (ans == 0) {
			cout<<"insert failed!"<<endl;
		}else if (ans == 1) {
			cout<<"insert success!"<<endl;
		}else if (ans == 2) {
			cout<<"It already exists!"<<endl;
		}
	}
	//查找字符串
	cout<<"请输入你要查找的字符串";
	int temp_pos,temp_times;
	cin>>buffer;
	if (hashtable.search(buffer, temp_pos, temp_times)) {
		cout<<"search success!"<<endl;
	}else{
		cout<<"search failed!"<<endl;
	}
    return 0;
}

4.运行结果

重学数据结构系列之——哈希表_第1张图片

4.简单应用,筛选重名用户

哈希表用上面的,用户重名不区分大小写
int main() {
	HashTable hashtable(200000);
	string buffer;
	//这个是要输入多少个字符串
	int n;
	cin>>n;
	for (int i = 1; i <= n; i++) {
		cin>>buffer;
		//转换为小写
		for (int j = 0; j < buffer.length(); j++) {
			if (buffer[j] >= 65 && buffer[j] <=90) {
				buffer[j] = char(buffer[j]+32);
			}
		}
		int ans = hashtable.insert(buffer);
		if (ans == 0) {
			cout<<"insert failed!"<<endl;
		}else if (ans == 1) {
			cout<<"此用户名没在我们的数据中"<<endl;
		}else if (ans == 2) {
			cout<<"此用户已存在,请发邮件叫他更改用户名"<<endl;
		}
	}
    return 0;
}
重学数据结构系列之——哈希表_第2张图片


你可能感兴趣的:(数据结构)