2022.3.11 哈希1

1. 哈希

根据设定好的哈希函数和处理发生哈希冲突的解决方法，将一组数据的关键字用过哈希函数可以映射到一组连续有限的地址集(区间)内，可以将映射到的像记录在表中，这个表就是我们所说的哈希表，这个映射过程一般叫做哈希造表或者叫散列，这个映射关系一般叫做哈希函数或者散列函数。

哈希冲突：对不同的关键字可能得到同一哈希地址

2.散列

散列技术是在记录的存储位置和它的关键字之间建立一个确定的对应关系f，使得每个关键字key对应一个存储位置f(key)。查找时，根据这个确定的对应关系找到定值key的映射f(key)，若查到集合中存在这个记录，则必定在f(key)的位置上。这里我们把这种对应关系f称为散列函数，又称哈希函数。按照这个思想，采用散列技术将记录存储在一块连续的存储空间中，这块连续存储空间称为散列表或哈希表，那么关键字对应的记录存储位置我们称为散列地址。

散列==哈希  哈希表===散列表

3. 哈希函数的构造方法：6种

①直接地址法 ②数字分析法 ③折叠法 ④扣留余数法 ⑤ 随机数法 ⑥平方取中法

这六种方法不是独立存在的，可以融合起来一起用。

4. 如何处理哈希冲突(重点)

①开放定址法 ②再散列函数法 ③链地址法 ④公共溢出法

5. 哈希是一种存储方法，也是一种查找方法，算法中只要用到这个哈希思想，就可以叫做哈希算法。

6. 实现链地址法

.h文件

#pragma once

typedef int ELEM_TYPE;
#define MAX_SIZE 12
//链地址法 中 后边连接的单链表的有效节点设计：
typedef struct Node 
{
	ELEM_TYPE data;//一个数据域
	struct Node *next;//一个指针域
}Node, *PNode;

//链地址法的 哈希表头设计
typedef struct Head
{
	struct Node arr[MAX_SIZE];  //数组  12个格子   每一个格子存放一个单链表的表头（用的是有效节点的结构体设计）
}Head, *PHead;



//函数
//初始化
void Init_list_hash(struct Head* hd);

//插入（头插）
bool Insert_head(struct Head *hd, ELEM_TYPE val);

//删除
bool Del_val(PHead hd, ELEM_TYPE val);

//查找
struct Node * Search(PHead hd, ELEM_TYPE val);

//判空
bool IsEmpty(PHead hd);

//获取有效个数
int Get_length(PHead hd);

//清空
void Clear(PHead hd);

//销毁
void Destroy(PHead hd);

//打印
void Show(PHead hd);

.cpp文件

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "list_hash.h"

//初始化//对那数组中的12个单链表头结点进行初始化
void Init_list_hash(struct Head* hd)
{
	for(int i=0; i<MAX_SIZE; i++)
	{
		hd->arr[i].next = NULL; //将每一个头节点的next全部置NULL即可 
	}
}

//插入（头插）
bool Insert_head(struct Head *hd, ELEM_TYPE val)
{
	//assert
	//购买新节点
	struct Node *pnewnode = (struct Node*)malloc(1 * sizeof(struct Node));
	assert(pnewnode != NULL);
	pnewnode->data = val;

	//找到插入位置
	int hash = val % MAX_SIZE;

	//插入
	pnewnode->next = hd->arr[hash].next;//类似单链表头插代码：pnewnode->next =  plist->next;
	hd->arr[hash].next = pnewnode;

	return true;
}

//删除（从前向后遍历一遍，确实存在val这个节点，则删除）//像单链表的按值删除 
bool Del_val(PHead hd, ELEM_TYPE val)
{
	//assert
	int hash = val % MAX_SIZE;

	struct Node *p = &hd->arr[hash];//保存头结点的地址
	for(p; p->next!=NULL; p=p->next)//删除，需要前驱的for循环
	{
		if(p->next->data == val)
		{
			struct Node *q = p->next;
			p->next = q->next;
			free(q);
			q = NULL;

			return true;
		}
	}

	return false;
}

//查找
struct Node * Search(PHead hd, ELEM_TYPE val)
{
	//assert
	int hash = val % MAX_SIZE;

	struct Node *p = hd->arr[hash].next;//保存首元素的地址
	for(p; p!=NULL; p=p->next) //查找，不需要前驱的for循环
	{
		if(p->data == val)
		{
			return p;
		}
	}

	return NULL;
}

//判空
bool IsEmpty(PHead hd)
{
	return Get_length(hd) == 0;
}

//获取有效个数
int Get_length(PHead hd)
{
	int count = 0;
	for(int i=0; i<MAX_SIZE; i++)
	{
		struct Node *p = hd->arr[i].next;//保存首元素的地址
		for(p; p!=NULL; p=p->next) //查找，不需要前驱的for循环
		{
			count++;
		}
	}
	return count;
}

//清空
void Clear(PHead hd)
{
	Destroy(hd);
}

//销毁
void Destroy(PHead hd)
{
	for(int i=0; i<MAX_SIZE; i++)
	{
		while(hd->arr[i].next != NULL)
		{
			struct Node *p = hd->arr[i].next;
			hd->arr[i].next = p->next;
			free(p);
		}
	}
}

//打印
void Show(PHead hd)
{
	for(int i=0; i<MAX_SIZE; i++)
	{
		printf("%d: ", i);
		struct Node *p = hd->arr[i].next;//保存首元素的地址
		for(p; p!=NULL; p=p->next) //查找，不需要前驱的for循环
		{
			printf("%d ", p->data);
		}
		printf("\n");
	}
}