算法的备胎Hash和找靠山的队列
备胎Hash
Hash，不管是算法，还是在工程中都会大量使用。很多复杂的算法问题都用Hash能够轻松解决，也正是如此，在算法例就显得没什么思维含量，所以Hash是应用里的扛把子，但在算法里就是备胎的角色，只要有其他方式，一般就不会考虑队列了。这也是面试算法和应用算法的一个区别。
Hash的重要性
Hash在技术面试中也频繁出现，常见问题有三个：
1.对象比较为什么要计算hashCode
2.HashMap的实现原理；ConcurrentHashMap的实现原理，特别是并发和扩容方面的问题。
3.ThreadLocal里的Map工作原理
找靠山的队列
直接考察队列的算法题几乎没有，大部分场景是作为高级算法的一个工具。经典问题是树里的层次遍历相关问题和图 等高级主题中 与 广度优先相关的问题。所以说队列需要找一个靠山才行。
队列的重要性
对于Java程序员来说，队列真正的大热门是作为技术面试，考察JUC里的阻塞队列、AQS等的实现原理等。这个一般在多线程相关的课程里讲解。
Hash基础
Hash的概念和基本特征
概念
哈希（Hash）也称为散列，就是把任意长度的输入，通过散列算法，变换成固定长度的输出，这个输出值就是散列值。
基本特征
映射：
假设数组array存放的是1到15这些数，现在要存在一个大小是7的Hash表中，该如何存储呢？
存储（如下图所示）：
存储位置计算公式
index = number % 7
读取：
index = number % 7
存储案例
将1至6存入的时候，图示如下：
将7至13存入的时候，图示如下：
最后存14 和 15
读取案例
假如我们要测试13在不在这个结构中，同样使用上面的公式进行计算。通过计算，
13 % 7 = 6。则可以直接访问array[6]这个位置，很明显是存在的，所以返回true。
假如我们要测试20在不在这个结构中，同样使用上面的公式进行计算。通过计算，
20 % 7 = 6。则可以直接访问array[6]这个位置，但这个位置上只有6和13，没有20，所以返回false。
碰撞处理方法
碰撞
在上面例子中，有些在Hash中的位置可能要存储两个甚至多个元素，很明显单纯的数组是不行的（会出现元素覆盖）。这种由 两个不同的输入值，根据同一散列函数计算出的散列值相同的现象 就叫做 碰撞。
碰撞解决方法
- 开放地址法（Java里的ThreadLocal）
- 链地址法（Java里的ConcurrentHashMap）
- 哈希法（布隆过滤器）
- 建立公共溢出区
开放定址法
开放定址法就是一旦发生了冲突，就去寻找下一个空的散列地址，只要散列表足够大，空的散列地址总能找到，并将数据存入其中。
图例
例如上面要继续存7，8，9的时候，7没问题，可以直接存到索引为0位置。8本来应该存到索引为1的位置，但是已经满了，所以继续向后找，索引3的位置是空的，所以8存到3位置。同理9存到索引6位置。
疑惑解释
疑惑：
这样鸠占鹊巢的方法会不会引起混乱? 比如再存3 和6的话，本来自己的位置好好的，但是被外来户占领了，该如何处理呢?
解释：
这个问题学习Java里的ThreadLocal后能解开。其基本思想如下：
ThreadLocal有一个专门存储元素的TheadLocalMap，每次在get 和set元素的时候，会先将目标位置前后的空间搜索一下，将标记为null的位置回收掉，这样大部分不用的位置就收回来了。
这就像假期后你到公司，每个人都将自己的位子附近打扫干净，结果整个工作区就很干净了。当然Hash处理该问题的整个过程非常复杂，涉及弱引用等等，这些都是Java技术面试里的高频考点。
链地址法
将哈希表的每个单元作为链表的头节点，所有哈希地址为 i 的元素构成一个同义词链表。即发生Hash冲突时，就把该关键字链在以该单位为头节点的链表的尾部，如下图所示：
这种处理方法的问题是处理起来代价还是比较高的。要落地还要进行很多优化
例如在Java里的ConcurrentHashMap中就使用了这种方式，其中涉及元素尽量均匀、访问和操作速度要快、线程安全、扩容等很多问题
错误的Hash结构
看一下下面这个Hash结构，下面的图有两处非常明显的错误
错误解释
首先是数组的长度必须是2的n次幂，这里长度是9，明显有错，然后是entry 的个数不能大于数组长度的75%，如果大于就会触发扩容机制进行扩容，这里明显是大于75%
原因
总：
在许多哈希表的实现中，选择2的n次幂作为哈希表的大小，可以提高散列函数的计算速度、解决哈希冲突的效率，并可以更好地利用内存。这些因素都有助于提高哈希表的性能。
分：
散列函数计算索引：哈希表使用散列函数将键（key）映射到索引，然后将值（value）存储在该索引处。对于2的n次幂大小的哈希表，散列函数可以使用位操作，而不需要执行较慢的模运算。例如，可以使用按位与运算（bitwise AND）操作，通过掩码来获取索引。这样可以提高散列函数的计算速度。
哈希冲突的解决：在哈希表中，不同的键可能会被散列到相同的索引位置，这称为哈希冲突。为了解决冲突，通常使用开放定址法、链表法或者其他方法。当哈希表的大小为2的n次幂时，使用位移操作（bitwise shift）可以快速计算出下一个索引位置，这样可以加快解决哈希冲突的速度。
内存分配的优化：许多现代计算机体系结构中，内存是以块（block）的形式进行分配的，其中每个块的大小通常是2的n次幂。如果哈希表的大小与内存块的大小匹配，可以更好地利用内存，减少内存分配的碎片化。
正确的Hash结构
解释
数组的长度即是2的n次幂，而他的size又不大于数组长度的75%。 HashMap的实现原理是先要找到要存放数组的下标，如果是空的就存进去，如果不是空的就判断key值是否一样，如果一样就替换，如果不一样就以链表的形式存在链表中(从JDK8开始，根据元素数量选择使用链表还是红黑树存储)。
队列基础
队列的概念和基本特征
概念
队列（Queue）是一种常见的数据结构，它是一种先进先出（First-In-First-Out，FIFO）的线性数据结构。
基本特征
先进先出：节点的排排队次序和出队次序按入队时间先后确定
实现方式
- 数组
队列使用一个固定大小的数组来存储元素，并使用两个指针来标记队列的头部和尾部
- 链表
对于基于链表，因为链表的长度是随时都可以变的，实现起来比较简单。
实现队列
链表实现
package org.example.queue;
public class LinkQueue {
/**
* 构建节点
*/
static class Node{
public int data;
public Node next;
public Node(int data) {
this.data = data;
}
}
/*
创建队列头和尾
*/
private Node front;
private Node rear;
private int size;
// 初始化节点
public LinkQueue() {
this.front = new Node(0);
this.rear = new Node(0);
}
/**
* 入队
* @param value 入队数据
*/
public void push(int value){
Node newNode = new Node(value);
Node temp = front;
while (temp.next != null){
temp = temp.next;
}
temp.next = newNode;
rear = newNode;
size++;
}
/**
* 出队
* @return 出队的值
*/
public int pull(){
if (front.next == null){
System.out.println("队列已空，无法出队");
}
Node firstNode = front.next;
front.next = firstNode.next;
size--;
return firstNode.data;
}
/**
* 遍历队列
*/
public void traverse(){
Node temp = front.next;
while (temp != null){
System.out.println(temp.data + "\t");
temp = temp.next;
}
}
public static void main(String[] args) {
LinkQueue linkQueue = new LinkQueue();
linkQueue.push(1);
linkQueue.push(2);
linkQueue.push(3);
System.out.println("The first Node = " + linkQueue.pull());
System.out.println("队列遍历结果为");
linkQueue.traverse();
}
}
