B树,B+树,红黑树应用场景笔记
一、B树的应用
1、B树大量应用在数据库和文件系统当中。
它的设计思想是,将相关数据尽量集中在一起,以便一次读取多个数据,减少硬盘操作次数。B树算法减少定位记录时所经历的中间过程,从而加快存取速度。
假定一个节点可以容纳100个值,那么3层的B树可以容纳100万个数据,如果换成二叉查找树,则需要20层!假定操作系统一次读取一个节点,并且根节点保留在内存中,那么B树在100万个数据中查找目标值,只需要读取两次硬盘。
如mongoDB数据库使用,单次查询平均快于Mysql(但侧面来看Mysql至少平均查询耗时差不多)
二、B+树的应用
mysql使用B+树作为索引:
B+树相对B树的优点:
①B+树的所有Data域在叶子节点,一般来说都会进行一个优化,就是将所有的叶子节点用指针串联起来,遍历叶子节点就能获取全部数据,这样就能进行区间访问了。
②IO一次读数据是从磁盘上读的,磁盘容量是固定的,取数据量大小是固定的,非叶子节点不存储数据,节点小,磁盘IO次数就少。
1、MYISAM
MyISAM中有两种索引,分别是主索引和辅助索引,在这里面的主索引使用具有唯一性的键值进行创建,而辅助索引中键值可以是相同的。MyISAM分别会存一个索引文件和数据文件。它的主索引是非聚集索引。当我们查询的时候我们找到叶子节点中保存的地址,然后通过地址我们找到所对应的信息。
2、INNODB
InnoDB索引和MyISAM最大的区别是它只有一个数据文件,在InnoDB中,表数据文件本身就是按B+Tree组织的一个索引结构,这棵树的叶节点数据域保存了完整的数据记录。所以我们又把它的主索引叫做聚集索引。而它的辅助索引和MyISAM也会有所不同,它的辅助索引都是将主键作为数据域。所以,这样当我们查找的时候通过辅助索引要先找到主键,然后通过主索引再找到对于的主键,得到信息。
MyISAM表索引在处理文本索引时更具优势,而INNODB表索引在其它类型上更具效率优势,同时MySQL高并发需要事务场景时,只能使用INNODB表
三、红黑树
红黑树往往出现由于树的深度过大而造成磁盘IO读写过于频繁,进而导致效率低下的情况在数据较小,可以完全放到内存中时,红黑树的时间复杂度比B树低。
如linux中进程的调度用的是红黑树。
反之,数据量较大,外存中占主要部分时,B树因其读磁盘次数少,而具有更快的速度。
B+树
学习:第2遍
package com.m.suan_pai;
/**
* B+树的定义:
* <p>
* 1.任意非叶子结点最多有M个子节点;且M>2;M为B+树的阶数
* 2.除根结点以外的非叶子结点至少有 (M+1)/2个子节点;
* 3.根结点至少有2个子节点;
* 4.除根节点外每个结点存放至少(M-1)/2和至多M-1个关键字;(至少1个关键字)
* 5.非叶子结点的子树指针比关键字多1个;
* 6.非叶子节点的所有key按升序存放,假设节点的关键字分别为K[0], K[1] … K[M-2],
* 指向子女的指针分别为P[0], P[1]…P[M-1]。则有:
* P[0] < K[0] <= P[1] < K[1] …..< K[M-2] <= P[M-1]
* 7.所有叶子结点位于同一层;
* 8.为所有叶子结点增加一个链指针;
* 9.所有关键字都在叶子结点出现
*
* @author LeeJay 2014-04-03
*/
/**
* @author LeeJay 2014-04-03
*
*/
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class BplusTree<K extends Comparable<K>, V> {
/** 根节点 */
protected BplusNode<K, V> root;
/** 阶数,M值 */
protected int order;
/** 叶子节点的链表头 */
protected BplusNode<K, V> head;
/** 树高*/
protected int height = 0;
public BplusNode<K, V> getHead() {
return head;
}
public void setHead(BplusNode<K, V> head) {
this.head = head;
}
public BplusNode<K, V> getRoot() {
return root;
}
public void setRoot(BplusNode<K, V> root) {
this.root = root;
}
public int getOrder() {
return order;
}
public void setOrder(int order) {
this.order = order;
}
public void setHeight(int height) {
this.height = height;
}
public int getHeight() {
return height;
}
public V get(K key) {
return root.get(key);
}
public V remove(K key) {
return root.remove(key, this);
}
public void insertOrUpdate(K key, V value) {
root.insertOrUpdate(key, value, this);
}
public BplusTree(int order) {
if (order < 3) {
System.out.print("order must be greater than 2");
System.exit(0);
}
this.order = order;
root = new BplusNode<K, V>(true, true);
head = root;
}
private static void testOrderRemove(int size, int order) {
BplusTree<Integer, Integer> tree = new BplusTree<Integer, Integer>(order);
System.out.println("\nTest order remove " + size + " datas, of order:"
+ order);
System.out.println("Begin order insert...");
for (int i = 0; i < size; i++) {
tree.insertOrUpdate(i, i);
}
System.out.println("Begin order remove...");
long current = System.currentTimeMillis();
for (int j = 0; j < size; j++) {
if (tree.remove(j) == null) {
System.err.println("得不到数据:" + j);
break;
}
}
long duration = System.currentTimeMillis() - current;
System.out.println("time elpsed for duration: " + duration);
System.out.println(tree.getHeight());
}
private static void testRandomRemove(int size, int order) {
BplusTree<Integer, Integer> tree = new BplusTree<Integer, Integer>(order);
System.out.println("\nTest random remove " + size + " datas, of order:"
+ order);
Random random = new Random();
boolean[] a = new boolean[size + 10];
List<Integer> list = new ArrayList<Integer>();
int randomNumber = 0;
System.out.println("Begin random insert...");
for (int i = 0; i < size; i++) {
randomNumber = random.nextInt(size);
a[randomNumber] = true;
list.add(randomNumber);
tree.insertOrUpdate(randomNumber, randomNumber);
}
System.out.println("Begin random remove...");
long current = System.currentTimeMillis();
for (int j = 0; j < size; j++) {
randomNumber = list.get(j);
if (a[randomNumber]) {
if (tree.remove(randomNumber) == null) {
System.err.println("得不到数据:" + randomNumber);
break;
} else {
a[randomNumber] = false;
}
}
}
long duration = System.currentTimeMillis() - current;
System.out.println("time elpsed for duration: " + duration);
System.out.println(tree.getHeight());
}
private static void testOrderSearch(int size, int order) {
BplusTree<Integer, Integer> tree = new BplusTree<Integer, Integer>(order);
System.out.println("\nTest order search " + size + " datas, of order:"
+ order);
System.out.println("Begin order insert...");
for (int i = 0; i < size; i++) {
tree.insertOrUpdate(i, i);
}
System.out.println("Begin order search...");
long current = System.currentTimeMillis();
for (int j = 0; j < size; j++) {
if (tree.get(j) == null) {
System.err.println("得不到数据:" + j);
break;
}
}
long duration = System.currentTimeMillis() - current;
System.out.println("time elpsed for duration: " + duration);
}
private static void testRandomSearch(int size, int order) {
BplusTree<Integer, Integer> tree = new BplusTree<Integer, Integer>(order);
System.out.println("\nTest random search " + size + " datas, of order:"
+ order);
Random random = new Random();
boolean[] a = new boolean[size + 10];
int randomNumber = 0;
System.out.println("Begin random insert...");
for (int i = 0; i < size; i++) {
randomNumber = random.nextInt(size);
a[randomNumber] = true;
tree.insertOrUpdate(randomNumber, randomNumber);
}
System.out.println("Begin random search...");
long current = System.currentTimeMillis();
for (int j = 0; j < size; j++) {
randomNumber = random.nextInt(size);
if (a[randomNumber]) {
if (tree.get(randomNumber) == null) {
System.err.println("得不到数据:" + randomNumber);
break;
}
}
}
long duration = System.currentTimeMillis() - current;
System.out.println("time elpsed for duration: " + duration);
}
private static void testRandomInsert(int size, int order) {
BplusTree<Integer, Integer> tree = new BplusTree<Integer, Integer>(order);
System.out.println("\nTest random insert " + size + " datas, of order:"
+ order);
Random random = new Random();
int randomNumber = 0;
long current = System.currentTimeMillis();
for (int i = 0; i < size; i++) {
randomNumber = random.nextInt(size);
tree.insertOrUpdate(randomNumber, randomNumber);
}
long duration = System.currentTimeMillis() - current;
System.out.println("time elpsed for duration: " + duration);
System.out.println(tree.getHeight());
}
private static void testOrderInsert(int size, int order) {
BplusTree<Integer, Integer> tree = new BplusTree<Integer, Integer>(order);
System.out.println("\nTest order insert " + size + " datas, of order:"
+ order);
long current = System.currentTimeMillis();
for (int i = 0; i < size; i++) {
tree.insertOrUpdate(i, i);
}
long duration = System.currentTimeMillis() - current;
System.out.println("time elpsed for duration: " + duration);
}
// 测试
public static void main(String[] args) {
int size = 1000000;
int order = 100;
//插入的随机和Order比较
testRandomInsert(size, order);
testOrderInsert(size, order);
//查找的随机和Order比较
testRandomSearch(size, order);
testOrderSearch(size, order);
//删除的随机和Order比较
testRandomRemove(size, order);
testOrderRemove(size, order);
}
}
BplusNode.java
package com.m.suan_pai;
import java.util.AbstractMap.SimpleEntry;
import java.util.ArrayList;
import java.util.List;
import java.util.Map.Entry;
public class BplusNode<K extends Comparable<K>, V> {
/**
* 是否为叶子节点
*/
protected boolean isLeaf;
/**
* 是否为根节点
*/
protected boolean isRoot;
/**
* 父节点
*/
protected BplusNode<K, V> parent;
/**
* 叶节点的前节点
*/
protected BplusNode<K, V> previous;
/**
* 叶节点的后节点
*/
protected BplusNode<K, V> next;
/**
* 节点的关键字
*/
protected List<Entry<K, V>> entries;
/**
* 子节点
*/
protected List<BplusNode<K, V>> children;
public BplusNode(boolean isLeaf) {
this.isLeaf = isLeaf;
entries = new ArrayList<Entry<K, V>>();
if (!isLeaf) {
children = new ArrayList<BplusNode<K, V>>();
}
}
public BplusNode(boolean isLeaf, boolean isRoot) {
this(isLeaf);
this.isRoot = isRoot;
}
public V get(K key) {
//如果是叶子节点
if (isLeaf) {
int low = 0, high = entries.size() - 1, mid;
int comp;
while (low <= high) {
mid = (low + high) / 2;
comp = entries.get(mid).getKey().compareTo(key);
if (comp == 0) {
return entries.get(mid).getValue();
} else if (comp < 0) {
low = mid + 1;
} else {
high = mid - 1;
}
}
//未找到所要查询的对象
return null;
}
//如果不是叶子节点
//如果key小于节点最左边的key,沿第一个子节点继续搜索
if (key.compareTo(entries.get(0).getKey()) < 0) {
return children.get(0).get(key);
//如果key大于等于节点最右边的key,沿最后一个子节点继续搜索
} else if (key.compareTo(entries.get(entries.size() - 1).getKey()) >= 0) {
return children.get(children.size() - 1).get(key);
//否则沿比key大的前一个子节点继续搜索
} else {
int low = 0, high = entries.size() - 1, mid = 0;
int comp;
while (low <= high) {
mid = (low + high) / 2;
comp = entries.get(mid).getKey().compareTo(key);
if (comp == 0) {
return children.get(mid + 1).get(key);
} else if (comp < 0) {
low = mid + 1;
} else {
high = mid - 1;
}
}
return children.get(low).get(key);
}
}
public void insertOrUpdate(K key, V value, BplusTree<K, V> tree) {
//如果是叶子节点
if (isLeaf) {
//不需要分裂,直接插入或更新
if (contains(key) != -1 || entries.size() < tree.getOrder()) {
insertOrUpdate(key, value);
if (tree.getHeight() == 0) {
tree.setHeight(1);
}
return;
}
//需要分裂
//分裂成左右两个节点
BplusNode<K, V> left = new BplusNode<K, V>(true);
BplusNode<K, V> right = new BplusNode<K, V>(true);
//设置链接
if (previous != null) {
previous.next = left;
left.previous = previous;
}
if (next != null) {
next.previous = right;
right.next = next;
}
if (previous == null) {
tree.setHead(left);
}
left.next = right;
right.previous = left;
previous = null;
next = null;
//复制原节点关键字到分裂出来的新节点
copy2Nodes(key, value, left, right, tree);
//如果不是根节点
if (parent != null) {
//调整父子节点关系
int index = parent.children.indexOf(this);
parent.children.remove(this);
left.parent = parent;
right.parent = parent;
parent.children.add(index, left);
parent.children.add(index + 1, right);
parent.entries.add(index, right.entries.get(0));
entries = null; //删除当前节点的关键字信息
children = null; //删除当前节点的孩子节点引用
//父节点插入或更新关键字
parent.updateInsert(tree);
parent = null; //删除当前节点的父节点引用
//如果是根节点
} else {
isRoot = false;
BplusNode<K, V> parent = new BplusNode<K, V>(false, true);
tree.setRoot(parent);
left.parent = parent;
right.parent = parent;
parent.children.add(left);
parent.children.add(right);
parent.entries.add(right.entries.get(0));
entries = null;
children = null;
}
return;
}
//如果不是叶子节点
//如果key小于等于节点最左边的key,沿第一个子节点继续搜索
if (key.compareTo(entries.get(0).getKey()) < 0) {
children.get(0).insertOrUpdate(key, value, tree);
//如果key大于节点最右边的key,沿最后一个子节点继续搜索
} else if (key.compareTo(entries.get(entries.size() - 1).getKey()) >= 0) {
children.get(children.size() - 1).insertOrUpdate(key, value, tree);
//否则沿比key大的前一个子节点继续搜索
} else {
int low = 0, high = entries.size() - 1, mid = 0;
int comp;
while (low <= high) {
mid = (low + high) / 2;
comp = entries.get(mid).getKey().compareTo(key);
if (comp == 0) {
children.get(mid + 1).insertOrUpdate(key, value, tree);
break;
} else if (comp < 0) {
low = mid + 1;
} else {
high = mid - 1;
}
}
if (low > high) {
children.get(low).insertOrUpdate(key, value, tree);
}
}
}
private void copy2Nodes(K key, V value, BplusNode<K, V> left,
BplusNode<K, V> right, BplusTree<K, V> tree) {
//左右两个节点关键字长度
int leftSize = (tree.getOrder() + 1) / 2 + (tree.getOrder() + 1) % 2;
boolean b = false;//用于记录新元素是否已经被插入
for (int i = 0; i < entries.size(); i++) {
if (leftSize != 0) {
leftSize--;
if (!b && entries.get(i).getKey().compareTo(key) > 0) {
left.entries.add(new SimpleEntry<K, V>(key, value));
b = true;
i--;
} else {
left.entries.add(entries.get(i));
}
} else {
if (!b && entries.get(i).getKey().compareTo(key) > 0) {
right.entries.add(new SimpleEntry<K, V>(key, value));
b = true;
i--;
} else {
right.entries.add(entries.get(i));
}
}
}
if (!b) {
right.entries.add(new SimpleEntry<K, V>(key, value));
}
}
/**
* 插入节点后中间节点的更新
*/
protected void updateInsert(BplusTree<K, V> tree) {
//如果子节点数超出阶数,则需要分裂该节点
if (children.size() > tree.getOrder()) {
//分裂成左右两个节点
BplusNode<K, V> left = new BplusNode<K, V>(false);
BplusNode<K, V> right = new BplusNode<K, V>(false);
//左右两个节点子节点的长度
int leftSize = (tree.getOrder() + 1) / 2 + (tree.getOrder() + 1) % 2;
int rightSize = (tree.getOrder() + 1) / 2;
//复制子节点到分裂出来的新节点,并更新关键字
for (int i = 0; i < leftSize; i++) {
left.children.add(children.get(i));
children.get(i).parent = left;
}
for (int i = 0; i < rightSize; i++) {
right.children.add(children.get(leftSize + i));
children.get(leftSize + i).parent = right;
}
for (int i = 0; i < leftSize - 1; i++) {
left.entries.add(entries.get(i));
}
for (int i = 0; i < rightSize - 1; i++) {
right.entries.add(entries.get(leftSize + i));
}
//如果不是根节点
if (parent != null) {
//调整父子节点关系
int index = parent.children.indexOf(this);
parent.children.remove(this);
left.parent = parent;
right.parent = parent;
parent.children.add(index, left);
parent.children.add(index + 1, right);
parent.entries.add(index, entries.get(leftSize - 1));
entries = null;
children = null;
//父节点更新关键字
parent.updateInsert(tree);
parent = null;
//如果是根节点
} else {
isRoot = false;
BplusNode<K, V> parent = new BplusNode<K, V>(false, true);
tree.setRoot(parent);
tree.setHeight(tree.getHeight() + 1);
left.parent = parent;
right.parent = parent;
parent.children.add(left);
parent.children.add(right);
parent.entries.add(entries.get(leftSize - 1));
entries = null;
children = null;
}
}
}
/**
* 删除节点后中间节点的更新
*/
protected void updateRemove(BplusTree<K, V> tree) {
// 如果子节点数小于M / 2或者小于2,则需要合并节点
if (children.size() < tree.getOrder() / 2 || children.size() < 2) {
if (isRoot) {
// 如果是根节点并且子节点数大于等于2,OK
if (children.size() >= 2) return;
// 否则与子节点合并
BplusNode<K, V> root = children.get(0);
tree.setRoot(root);
tree.setHeight(tree.getHeight() - 1);
root.parent = null;
root.isRoot = true;
entries = null;
children = null;
return;
}
//计算前后节点
int currIdx = parent.children.indexOf(this);
int prevIdx = currIdx - 1;
int nextIdx = currIdx + 1;
BplusNode<K, V> previous = null, next = null;
if (prevIdx >= 0) {
previous = parent.children.get(prevIdx);
}
if (nextIdx < parent.children.size()) {
next = parent.children.get(nextIdx);
}
// 如果前节点子节点数大于M / 2并且大于2,则从其处借补
if (previous != null
&& previous.children.size() > tree.getOrder() / 2
&& previous.children.size() > 2) {
//前叶子节点末尾节点添加到首位
int idx = previous.children.size() - 1;
BplusNode<K, V> borrow = previous.children.get(idx);
previous.children.remove(idx);
borrow.parent = this;
children.add(0, borrow);
int preIndex = parent.children.indexOf(previous);
entries.add(0, parent.entries.get(preIndex));
parent.entries.set(preIndex, previous.entries.remove(idx - 1));
return;
}
// 如果后节点子节点数大于M / 2并且大于2,则从其处借补
if (next != null
&& next.children.size() > tree.getOrder() / 2
&& next.children.size() > 2) {
//后叶子节点首位添加到末尾
BplusNode<K, V> borrow = next.children.get(0);
next.children.remove(0);
borrow.parent = this;
children.add(borrow);
int preIndex = parent.children.indexOf(this);
entries.add(parent.entries.get(preIndex));
parent.entries.set(preIndex, next.entries.remove(0));
return;
}
// 同前面节点合并
if (previous != null
&& (previous.children.size() <= tree.getOrder() / 2
|| previous.children.size() <= 2)) {
for (int i = 0; i < children.size(); i++) {
previous.children.add(children.get(i));
}
for (int i = 0; i < previous.children.size(); i++) {
previous.children.get(i).parent = this;
}
int indexPre = parent.children.indexOf(previous);
previous.entries.add(parent.entries.get(indexPre));
for (int i = 0; i < entries.size(); i++) {
previous.entries.add(entries.get(i));
}
children = previous.children;
entries = previous.entries;
//更新父节点的关键字列表
parent.children.remove(previous);
previous.parent = null;
previous.children = null;
previous.entries = null;
parent.entries.remove(parent.children.indexOf(this));
if ((!parent.isRoot
&& (parent.children.size() >= tree.getOrder() / 2
&& parent.children.size() >= 2))
|| parent.isRoot && parent.children.size() >= 2) {
return;
}
parent.updateRemove(tree);
return;
}
// 同后面节点合并
if (next != null
&& (next.children.size() <= tree.getOrder() / 2
|| next.children.size() <= 2)) {
for (int i = 0; i < next.children.size(); i++) {
BplusNode<K, V> child = next.children.get(i);
children.add(child);
child.parent = this;
}
int index = parent.children.indexOf(this);
entries.add(parent.entries.get(index));
for (int i = 0; i < next.entries.size(); i++) {
entries.add(next.entries.get(i));
}
parent.children.remove(next);
next.parent = null;
next.children = null;
next.entries = null;
parent.entries.remove(parent.children.indexOf(this));
if ((!parent.isRoot && (parent.children.size() >= tree.getOrder() / 2
&& parent.children.size() >= 2))
|| parent.isRoot && parent.children.size() >= 2) {
return;
}
parent.updateRemove(tree);
return;
}
}
}
public V remove(K key, BplusTree<K, V> tree) {
//如果是叶子节点
if (isLeaf) {
//如果不包含该关键字,则直接返回
if (contains(key) == -1) {
return null;
}
//如果既是叶子节点又是根节点,直接删除
if (isRoot) {
if (entries.size() == 1) {
tree.setHeight(0);
}
return remove(key);
}
//如果关键字数大于M / 2,直接删除
if (entries.size() > tree.getOrder() / 2 && entries.size() > 2) {
return remove(key);
}
//如果自身关键字数小于M / 2,并且前节点关键字数大于M / 2,则从其处借补
if (previous != null &&
previous.parent == parent
&& previous.entries.size() > tree.getOrder() / 2
&& previous.entries.size() > 2) {
//添加到首位
int size = previous.entries.size();
entries.add(0, previous.entries.remove(size - 1));
int index = parent.children.indexOf(previous);
parent.entries.set(index, entries.get(0));
return remove(key);
}
//如果自身关键字数小于M / 2,并且后节点关键字数大于M / 2,则从其处借补
if (next != null
&& next.parent == parent
&& next.entries.size() > tree.getOrder() / 2
&& next.entries.size() > 2) {
entries.add(next.entries.remove(0));
int index = parent.children.indexOf(this);
parent.entries.set(index, next.entries.get(0));
return remove(key);
}
//同前面节点合并
if (previous != null
&& previous.parent == parent
&& (previous.entries.size() <= tree.getOrder() / 2
|| previous.entries.size() <= 2)) {
V returnValue = remove(key);
for (int i = 0; i < entries.size(); i++) {
//将当前节点的关键字添加到前节点的末尾
previous.entries.add(entries.get(i));
}
entries = previous.entries;
parent.children.remove(previous);
previous.parent = null;
previous.entries = null;
//更新链表
if (previous.previous != null) {
BplusNode<K, V> temp = previous;
temp.previous.next = this;
previous = temp.previous;
temp.previous = null;
temp.next = null;
} else {
tree.setHead(this);
previous.next = null;
previous = null;
}
parent.entries.remove(parent.children.indexOf(this));
if ((!parent.isRoot && (parent.children.size() >= tree.getOrder() / 2
&& parent.children.size() >= 2))
|| parent.isRoot && parent.children.size() >= 2) {
return returnValue;
}
parent.updateRemove(tree);
return returnValue;
}
//同后面节点合并
if (next != null
&& next.parent == parent
&& (next.entries.size() <= tree.getOrder() / 2
|| next.entries.size() <= 2)) {
V returnValue = remove(key);
for (int i = 0; i < next.entries.size(); i++) {
//从首位开始添加到末尾
entries.add(next.entries.get(i));
}
next.parent = null;
next.entries = null;
parent.children.remove(next);
//更新链表
if (next.next != null) {
BplusNode<K, V> temp = next;
temp.next.previous = this;
next = temp.next;
temp.previous = null;
temp.next = null;
} else {
next.previous = null;
next = null;
}
//更新父节点的关键字列表
parent.entries.remove(parent.children.indexOf(this));
if ((!parent.isRoot && (parent.children.size() >= tree.getOrder() / 2
&& parent.children.size() >= 2))
|| parent.isRoot && parent.children.size() >= 2) {
return returnValue;
}
parent.updateRemove(tree);
return returnValue;
}
}
/*如果不是叶子节点*/
//如果key小于等于节点最左边的key,沿第一个子节点继续搜索
if (key.compareTo(entries.get(0).getKey()) < 0) {
return children.get(0).remove(key, tree);
//如果key大于节点最右边的key,沿最后一个子节点继续搜索
} else if (key.compareTo(entries.get(entries.size() - 1).getKey()) >= 0) {
return children.get(children.size() - 1).remove(key, tree);
//否则沿比key大的前一个子节点继续搜索
} else {
int low = 0, high = entries.size() - 1, mid = 0;
int comp;
while (low <= high) {
mid = (low + high) / 2;
comp = entries.get(mid).getKey().compareTo(key);
if (comp == 0) {
return children.get(mid + 1).remove(key, tree);
} else if (comp < 0) {
low = mid + 1;
} else {
high = mid - 1;
}
}
return children.get(low).remove(key, tree);
}
}
/**
* 判断当前节点是否包含该关键字
*/
protected int contains(K key) {
int low = 0, high = entries.size() - 1, mid;
int comp;
while (low <= high) {
mid = (low + high) / 2;
comp = entries.get(mid).getKey().compareTo(key);
if (comp == 0) {
return mid;
} else if (comp < 0) {
low = mid + 1;
} else {
high = mid - 1;
}
}
return -1;
}
/**
* 插入到当前节点的关键字中
*/
protected void insertOrUpdate(K key, V value) {
//二叉查找,插入
int low = 0, high = entries.size() - 1, mid;
int comp;
while (low <= high) {
mid = (low + high) / 2;
comp = entries.get(mid).getKey().compareTo(key);
if (comp == 0) {
entries.get(mid).setValue(value);
break;
} else if (comp < 0) {
low = mid + 1;
} else {
high = mid - 1;
}
}
if (low > high) {
entries.add(low, new SimpleEntry<K, V>(key, value));
}
}
/**
* 删除节点
*/
protected V remove(K key) {
int low = 0, high = entries.size() - 1, mid;
int comp;
while (low <= high) {
mid = (low + high) / 2;
comp = entries.get(mid).getKey().compareTo(key);
if (comp == 0) {
return entries.remove(mid).getValue();
} else if (comp < 0) {
low = mid + 1;
} else {
high = mid - 1;
}
}
return null;
}
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("isRoot: ");
sb.append(isRoot);
sb.append(", ");
sb.append("isLeaf: ");
sb.append(isLeaf);
sb.append(", ");
sb.append("keys: ");
for (Entry<K, V> entry : entries) {
sb.append(entry.getKey());
sb.append(", ");
}
sb.append(", ");
return sb.toString();
}
}
转载链接:https://blog.csdn.net/qq_36183935/article/details/81095212
转载链接:https://adbycool.blog.csdn.net/article/details/108505987