队列和Hash的概念特征——算法通关村第五关【青铜】

一、Hash

1.1 基础概念

哈希（Hash）也称为散列，就是把任意长度的输入，通过散列算法，变换成固定长度的 输出，这个输出值就是散列值。
哈希的基本存放方式（以大小为7为例）：
计算公式为：index = number % 7
将1到6存入的时候，图示如下：

继续存7到13

最后再存14和15:

1.2 位置重复问题

有些在Hash中很多位置可能要存两个甚至多个元素，这种两个不同的输入值，根据同一散列函数计算出的散列值相同的 现象叫做碰撞。
常见的方法有：开放定址法(Java里的Threadlocal)、链地址法(Java里 的ConcurrentHashMap)、再哈希法(布隆过滤器)、建立公共溢出区。

1、开放地址法

一旦发生了冲突，就去寻找下一个空的散列地址，只要散列表足够大，空的散列地址总能找到，并将记录存入。

2、链地址法

将哈希表的每个单元作为链表的头结点，所有哈希地址为i的元素构成一个同义词链表。

二、队列

2.1 基本概念

队列的特点是节点的排队次序和出队次序按入队时间先后确定，即先入先出，即我们常说的FIFO(first in first )先进先出。

2.2 代码实现

#include <stdio.h>
#include <stdlib.h>
#define MaxSize 10
//链式队列节点类型定义
typedef struct LinkNode {
	ElemType data;
	struct LinkNode * next;
}LinkNode;
//链式队列定义
typedef struct {
	LinkNode *front, *rear;
}LinkQueue;
//初始化队列(带头节点
void InitQueue(LinkQueue &Q) {
	Q.front = Q.rear = (LinkNode *)malloc(sizeof(LinkNode));
	Q.front->next = NULL;
}
//判断队列是否为空
bool IsEmpty(LinkQueue Q) {
	return Q.front == Q.rear ? true : false;
}
//初始化队列(不带头节点
void InitQueue(LinkQueue &Q) {
	Q.front = Q.rear = NULL;
}
//判断队列是否为空
bool IsEmpty(LinkQueue Q) {
	return Q.front == NULL ? 1; 0;
}
//入队操作 带头节点
void EnQueue(LinkQueue &Q, ElemType x) {
	LinkNode *s = (LinkNode *)malloc(sizeof(LinkNode));
	s->data = x; //将传入的数据赋值给创建的节点
	s->next = NULL; //新插入的节点的next值应为NULL
	Q.rear->next = s; //现节点的尾部指向s
	Q.rear = s;
}
//入队操作 不带头节点
void EnQueue(LinkQueue &Q, ElemType x) {
	LinkNode *s = (LinkNode *)malloc(sizeof(LinkNode));
	s->data = x;
	s->next = NULL;
	if (Q.front == NULL) {
		Q.front = s;
		Q.rear = s;
	}
	else {
		Q.rear->next = s;
		Q.rear = s;
	}
}
//出队  带头节点
bool DeQueue(LinkQueue &Q, ElemType &x) {
	if (Q.front == Q.rear)return false;//判断是不是空队
	LinkNode *p = Q.front->next;
	x = p->data;
	Q.front->next = p->next;
	if (Q.rear == p)Q.rear = Q.front;//证明队列中只有这一个元素，对列空
	free(p);
}
//出队  不带头节点
bool DeQueue(LinkQueue &Q, ElemType &x) {
	if (Q.front == Q.rear)return false;//判断是不是空队
	LinkNode *p = Q.front;
	x = p->data;
	Q.front = p->next;
	if (Q.rear == p)Q.rear = Q.front = NULL;//证明队列中只有这一个元素，对列空
	free(p);
}