13、B-树 Balance Tree
特点
B树（B-树）用于解决磁盘上的数据管理问题， 前面学的AVL树和红黑树用于解决内存上的数据管理问题
度 degree 指树中节点孩子树
阶 order 指所有节点孩子数的最大值
B-树是一种自平衡的多路搜索树（就是不一定是二叉树），主要用于存储数据并保证较低的查找、插入和删除时间复杂度。B-树中的每个节点最多有m个子节点，m称为B-树的阶。每个节点（除了根节点和叶子节点）至少有⌈m/2-1⌉个子节点，其中⌈x⌉表示不小于x的最小整数。
B-树具有以下特点：
- 所有叶子节点都在同一层。
- 非叶子节点可以有多个子节点，节点中子节点的个数与节点的度数相同。
- 每个节点包含n-1个关键字和n个子节点指针，其中a ≤ n ≤ b。a和b是预先设定的最小度数和最大度数。
- 除根节点外，所有节点的关键字数量都在预定范围内。
- 所有关键字在节点内按升序排列，左子树的所有关键字小于该节点的关键字，右子树的所有关键字都大于该节点的关键字。
B-树主要用于数据库和文件系统中。它们提供了高效的查找、插入和删除操作，特别是在处理大量数据时。
B树（B-树）是一种自平衡的多路搜索树，主要用于磁盘上的数据管理，特别是数据库和文件系统中。由于磁盘的读写速度较慢，B树的设计能够有效地减少磁盘访问次数，从而提高数据管理的效率。
而AVL树和红黑树则是用于解决内存上的数据管理问题。它们是两种自平衡的二叉搜索树，主要用于内存中的数据结构，如查找、插入和删除操作。与B树不同，AVL树和红黑树在内存中的操作相对较快，因为内存的访问速度远高于磁盘。
总结来说，B树主要用于磁盘上的数据管理，而AVL树和红黑树主要用于内存上的数据管理。
代码示例
新增
- 首先查找本节点中的插入位置i，如果没有空位(key被找到)，应该走更新的逻辑，目前什么没做
- 接下来分两种情况
- 如果节点是叶子节点，可以直接插入了
- 如果节点是非叶子节点，需要继续在children[i]处继续递归插入
- 无论那种情况，插入完成后都可能超过节点keys数目限制，此时应当执行节点分裂
节点分裂
- 如果 parent == null 表示要分裂的是根节点，此时需要创建新根，原来根节点作为新根的0孩子
- 否则
- 创建right节点（分裂后大于当前left节点的），把t以后的key和child都拷贝过去
- t-1处的key插入到parent的index, index指left作为孩子时的索引
- right 节点作为parent的孩子插入到index + 1处
删除
-
case 1：当前节点是叶子节点，没找到
-
case 2：当前节点是叶子节点，找到了
-
case 3：当前节点是非叶子结点，没找到
-
case 4：当前节点是非叶子节点，找到了
-
case 5：删除后key数目 < 下限 （不平衡)
-
case 6：根节点
package com.zky;
import java.util.Arrays;
public class BTree {
static class Node {
int[] keys; // 关键字
Node[] children; // 孩子
int keyNumber; // 有效关键字的个数
boolean leaf = true; // 是否是叶子节点
int t; // 最小度数（最小孩子数）
public Node(int t) { // t >= 2
this.t = t;
this.children = new Node[2 * t];
this.keys = new int[2 * t - 1];
}
@Override
public String toString() {
return Arrays.toString(Arrays.copyOfRange(keys, 0, keyNumber));
}
// 多路查找
Node get(int key) {
int i = 0;
while (i < keyNumber) {
if (keys[i] == key) {
return this;
}
if (keys[i] > key) {
break;
}
i++;
}
// 执行到此时keys[i] > key 或 i == keyNumber
if (leaf) {
return null;
}
// 非叶子情况
return children[i].get(key);
}
// 向指定索引处插入 key
void insertKey(int key, int index) {
System.arraycopy(keys, index, keys, index + 1, keyNumber - index);
keys[index] = key;
keyNumber++;
}
// 向指定索引处插入 child
void insertChild(Node child, int index) {
System.arraycopy(children, index, children, index + 1, keyNumber - index);
children[index] = child;
}
// 移除指定 index 处的 key
int removeKey(int index) {
int t = keys[index];
System.arraycopy(keys, index + 1, keys, index, --keyNumber - index);
return t;
}
// 移除最左边的 key
int removeLeftmostKey() {
return removeKey(0);
}
// 移除最右边的key
int removeRightmostKey() {
return removeKey(keyNumber - 1);
}
// 提出指定 index 处的 child
Node removeChild(int index) {
Node t = children[index];
System.arraycopy(children, index + 1, children, index, children.length - 1 - index);
return t;
}
// 移除最左边的 key
Node removeLeftmostChild() {
return removeChild(0);
}
// 移除最右边的key
Node removeRightmostChild() {
return removeChild(keyNumber);
}
// index 孩子处左边的兄弟
Node childLeftSibling(int index) {
return index > 0 ? children[index - 1] : null;
}
// index 处右边的兄弟
Node childRightSibling(int index) {
return index == keyNumber ? null : children[index + 1];
}
// 复制当前节点的所有的 key 和 child 到 target
void moveToTarget(Node target) {
int start = target.keyNumber;
if (!leaf) {
for (int i = 0; i <= keyNumber; i++) {
target.children[start + i] = children[i];
}
}
for (int i = 0; i <= keyNumber; i++) {
target.keys[target.keyNumber++] = keys[i];
}
}
}
Node root;
int t; // 树中节点最小度数
final int MIN_KEY_NUMBER; // 最小 key 数目
final int MAX_KEY_NUMBER; // 最大 key 数目
public BTree() {
this(2);
}
public BTree(int t) {
this.t = t;
root = new Node(t);
MAX_KEY_NUMBER = 2 * t - 1;
MIN_KEY_NUMBER = t - 1;
}
// 1. 是否存在
public boolean contains(int key) {
return root.get(key) != null;
}
// 2. 新增
public void put(int key) {
doPut(root, key, null, 0);
}
private void doPut(Node node, int key, Node parent, int index) {
int i = 0;
while (i < node.keyNumber) {
if (node.keys[i] == key) {
return; // 更新
}
if (node.keys[i] > key) {
break; // 找到了出入位置，即为此时的i
}
i++; // 插入位置
}
if (node.leaf) {
node.insertKey(key, i);
} else {
// 递归寻找插入的位置
doPut(node.children[i], key, node, i);
}
// 无论是递归查找还是直接出入了都要 检查是否达到上限
if (node.keyNumber == MAX_KEY_NUMBER) {
split(node, parent, index);
}
}
// 节点分裂
private void split(Node left, Node parent, int index) {
// 特殊情况：分裂的是根节点
if (parent == null) {
Node newRoot = new Node(t);
newRoot.leaf = false;
newRoot.insertChild(left, 0);
this.root = newRoot;
parent = newRoot;
}
// 1. 创建right节点，把left中t之后的kye和child移动过去
Node right = new Node(t);
right.leaf = left.leaf;
System.arraycopy(left.keys, t, right.keys, 0, t - 1);
// 不是叶子节点把孩子也带上
if (!left.leaf) {
System.arraycopy(left.children, t, right.children, 0, t);
}
right.keyNumber = t - 1;
left.keyNumber = t - 1;
// 2. 中间的key （t-1处）插入到父节点
int mid = left.keys[t - 1];
parent.insertKey(mid, index);
// 3. right 节点作为父节点的孩子
parent.insertChild(right, index + 1);
}
// 3. 删除 这里有6种情况
public void remove(int key) {
doRemove(null, root, 0, key);
}
private void doRemove(Node parent, Node node, int index, int key) {
int i = 0;
while (i < node.keyNumber) {
if (node.keys[i] >= key) {
break;
}
i++;
}
// i 找到：代表带删除key的索引
// i 没找到：代表到第i个孩子继续查找
if (node.leaf) {
if (!found(node, key, i)) { // case 1 当前节点是叶子节点，没找到
return;
} else { // case 2 当前节点是叶子节点，找到了
node.removeKey(i);
}
} else {
if (!found(node, key, i)) { // case 3 当前节点是非叶子结点，没找到
doRemove(node, node.children[i], i, key);
} else { // case 4 当前节点是非叶子节点，找到了
// 1. 找到后继 key
Node s = node.children[i + 1];
while (!s.leaf) {
s = s.children[0];
}
int skey = s.keys[0];
// 2. 替换待删除 key
node.keys[i] = skey;
// 3. 删除后续 key
doRemove(node, node.children[i + 1], i + 1, skey);
}
}
if (node.keyNumber < MIN_KEY_NUMBER) {
// 重新调整平衡 case 5 删除后key数目 < 下限 （不平衡) case 6 根节点
balance(parent, node, index);
}
}
private void balance(Node parent, Node x, int i) {
// case 6 根节点
if (x == root) {
if (root.keyNumber == 0 && root.children[0] != null) {
root = root.children[0];
}
return;
}
Node left = parent.childLeftSibling(i);
Node right = parent.childRightSibling(i);
if (left != null && left.keyNumber > MIN_KEY_NUMBER) {
// case 5-1 左边富裕，右旋
// a） 把父节点中前驱key旋转下来
x.insertKey(parent.keys[i - 1], 0);
if (!left.leaf) {
// b）left中最大的孩子换爹
x.insertChild(left.removeRightmostChild(), 0);
}
// c） left中最大的key旋转上去
parent.keys[i - 1] = left.removeLeftmostKey();
return;
}
if (right != null && right.keyNumber > MIN_KEY_NUMBER) {
// case 5-2 右边富裕，左旋
// a） 把父节点中前驱key旋转下来
x.insertKey(parent.keys[i], x.keyNumber);
// b） right中最大的孩子换爹
if (!right.leaf) {
x.insertChild(right.removeLeftmostChild(), x.keyNumber + 1);
}
// c） right中最大的key旋转上去
x.removeLeftmostKey();
parent.keys[i] = x.removeLeftmostKey();
return;
}
// case 5-3 两边都不够借，向左合并
if (left != null) {
// 向左兄弟合并
parent.removeChild(i);
left.insertKey(parent.removeKey(i - 1), left.keyNumber);
x.moveToTarget(left);
} else {
// 向自己合并
parent.removeChild(i + 1);
x.insertKey(parent.removeKey(i), x.keyNumber);
right.moveToTarget(x);
}
}
private boolean found(Node node, int key, int i) {
return i < node.keyNumber && node.keys[i] == key;
}
}
14、哈希表 HashTable
特点
给每份数据分配一个编号，放入表格（数组）
建立编号与表格索引的关系，将来就可以通过编号快速查找数据
- 理想情况编号唯一，数组能容纳所有数据
- 现实是不能说为了容纳所有数据造一个超大的数组，编号也有可能重复
解决
- 有限长度的数组，以【拉链】方式存储数据
- 允许编号适当重复，通过数据自身来进行区分
哈希算法
jdk中
-
自带的object算法
-
字符串算法1
哈希算法(Hash Function) - 知乎 (zhihu.com)
第二代哈希算法
MurmurHash
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>30.1-jre</version>
</dependency>
一篇让你熟练掌握Google Guava包(全网最全) - 掘金 (juejin.cn)
MurmurHash算法初探 - 知乎 (zhihu.com)
思考
或者说优化？
- 我们代码里使用了尾插法，如果改成头插法呢？
- JDK的HashMap中采用了将对象hashCode高低位相互抑或的方式减少冲突，怎么理解？
- 我们的HashTable中表格容量是2的n次方，很多优化都是基于这个前提，能否不同2的n次方作为表格容量？
- JDK的HashMap在链表长度过长会转换成红黑树，对此你怎么看？
代码示例
忘了创建maven工程，这个没有使用MurmurHash 算法
package com.zky;
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Map;
import java.util.stream.Collectors;
public class HashTable {
// 摘要算法
// 散列算法
// 节点类
static class Entry {
int hash; // 哈希码
Object key; // 键
Object value; // 值
Entry next;
public Entry(int hash, Object key, Object value) {
this.hash = hash;
this.key = key;
this.value = value;
}
}
Entry[] table = new Entry[16];
int size = 0; // 元素个数
float loadFactor = 0.75f; // 12 阈值
int threshold = (int) (loadFactor * table.length);
/* 求模运算替换为位运算
- 前提：数组长度是 2 的 n 次方
- hash % 数组长度 等价于 hash & （数组长度 - 1）
*/
// 根据hash 码获取 value
Object get(int hash, Object key) {
int idx = hash & (table.length - 1);
if (table[idx] == null) {
return null;
}
Entry p = table[idx];
while (p != null) {
if (key.equals(p.key)) {
return p.value;
}
p = p.next;
}
return null;
}
// 向 hash 表中存入新 key value 如果key 重复 更新 value
void put(int hash, Object key, Object value) {
int idx = hash & (table.length - 1);
// 1、idx 处有空位，直接新增
if (table[idx] == null) {
table[idx] = new Entry(hash, key, value);
} else {
// 2、idx 处无空位，沿链表找，有重复key更新，否则新增
Entry p = table[idx];
while (true) {
if (key.equals(p.key)) {
p.value = value; // 2.1、更新
return;
}
if (p.next == null) {
break;
}
p = p.next;
}
p.next = new Entry(hash, key, value); // 2.2、新增
}
size++;
if (size > threshold) {
resize();
}
}
// 扩容方法
private void resize() {
Entry[] newTable = new Entry[table.length << 1];
for (int i = 0; i < table.length; i++) {
Entry p = table[i]; // 拿到每个链表头
if (p != null) {
// 拆分链表，移动到新数组
/*
一个链表最多拆分成两个
hash & table.length == 0 的一组
hash & table.length != 0 的一组
*/
Entry a = null;
Entry b = null;
Entry aHead = null;
Entry bHead = null;
while (p != null) {
if ((p.hash & table.length) == 0) {
if (a != null) {
a.next = p;
} else {
aHead = p;
}
a = p; // 分配到a
} else {
if (b != null) {
b.next = p;
} else {
bHead = p;
}
b = p; // 分配到b
}
p = p.next;
}
if (a != null) {
a.next = null;
newTable[i] = aHead;
}
if (b != null) {
b.next = null;
newTable[i + table.length] = bHead;
}
}
}
table = newTable;
threshold = (int) (loadFactor * table.length);
}
// 根据hash码删除，返回删除的value
Object remove(int hash, Object key) {
int idx = hash & (table.length - 1);
if (table[idx] == null) {
return null;
}
Entry p = table[idx];
Entry prev = null;
while (p != null) {
if (key.equals(p.key)) {
// 找到了删除
if (prev == null) {
table[idx] = p.next;
} else {
prev.next = p.next;
}
size--;
return p.value;
}
prev = p;
p = p.next;
}
return null;
}
public Object get(Object key) {
int hash = getHash(key);
return get(hash, key);
}
public void put(Object key, Object value) {
int hash = getHash(key);
put(hash, key, value);
}
public Object remove(Object key) {
int hash = getHash(key);
return remove(hash, key);
}
private int getHash(Object key) {
// 原则：值相同的字符串生成相同的 hash 码，尽量让值不同的字符串生成不同的 hash 吗
return key.hashCode();
}
public void print() {
int[] sums = new int[table.length];
for (int i = 0; i < table.length; i++) {
Entry p = table[i];
while (p != null) {
sums[i]++;
p = p.next;
}
}
Map<Integer, Long> collect = Arrays.stream(sums).boxed().collect(Collectors.groupingBy(e -> e, Collectors.counting()));
System.out.println(collect);
}
public static void main(String[] args) {
HashTable table = new HashTable();
for (int i = 0; i < 200000; i++) {
Object o = new Object();
table.put(o, o);
}
table.print();
}
/*
为什么计算索引位置同式子：hash & （数组长度 - 1）
为什么旧链表会拆分成两条，一条hash & 就数组长度 == 0 另一条 != 0
为什么拆分后的两条链表，一个原索引不变，另一个是原索引 + 旧数组长度
他们都有个共同的前提：数组长度是 2 的 n 次方
*/
}
846
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
