具体算法思想及应用介绍的文章网上有很多，这篇推荐给大家http://blog.csdn.net/hbhhww/article/details/8206846。
我就直接上自己的Java代码，之前写的时候也参考了一些其它语言的实现 。
/**
* <code>B-Tree</code> : <p />
* 假设B树的度为 m（m>=2），则B树满足如下要求：(参考算法导论)
* <br />
* (1)每个非根节点至少包含m-1个关键字,m个指向子节点的指针;至多包含2m-1个关键字,2m个指向子女的指针（叶子节点的子女为空）
* <br />
* (2)节点的所有key按非降序存放,假设节点的关键字分别为K[1], K[2] … K[n], 指向子女的指针分别为P[1], P[2]…P[n+1],
* 其中n为节点关键字的个数。则有：P[1] <= K[1] <= P[2] <= K[2] …..<= K[n] <= P[n+1] // 这里P[n]也指其指向的关键字
* <br />
* (3)若根节点非空，则根节点至少包含两个子女;
* <br />
* (4)所有的叶子节点都在同一层
* <p/>
*
*
* 查询:<br />
* 从<code>root</code>出发,对每个节点,找到大于或等于target关键字中最小的K[i]
* <br />
* (1)如果K[i]与target相等,则查找成功,返回一个标识true,和target下标i
* <br />
* (2)否则查找失败, 返回一个标识false,和一个下标指向其子节点位置,递归search新的子节点,如果是叶节点则表示不存在该关键字
*
* <p/>
* 插入:
* <br />
* B树的插入需要沿着搜索的路径从<code>root</code>一直到叶节点,根据B树的规则,每个节点的关键字个数在[m-1, 2m-1]之间,
* 当target要加入到某个叶子时,如果该叶子节点已经有2m-1个关键字,则再加入target就违反了B树的定义,
* 这时就需要对该叶子节点进行分裂,将叶子以中间节点为界,分成两个包含m-1个关键字的子节点,
* 同时把中间节点提升到该叶子的父节点中,如果这样使得父节点的关键字个数超过2m-1,
* 则要继续向上分裂,直到根节点,根节点的分裂会使得树加高一层
* <br />
* 关键:在下降的过程中,一旦遇到已满的节点(关键字个数为2m-1),就就对该节点进行分裂,这样就保证在叶子节点需要分裂时,
* 其父节点一定是非满的,从而不需要再向上回溯
*
* <p/>
* 删除:
* <br />
* B树的删除同样需要沿着搜索的路径从<code>root</code>一直到叶节点
* 1,根节点只有一个实例,且起子节点都只包含<code>minEntrySize</code>个实例时,树降高(树降高的唯一情形)
* <br />
* 2,如果在内部节点node中找到关键字key下标i,观察该节点的第i与i+i个子节点,在它俩中找到实例数大于<code>minEntrySize</code>的
* 记为tmpNode,中转tmpKey到当前node,在tmpNode中递归删除tmpKey,如果上述两个子节点实例数均不大于<code>minEntrySize</code>
* 则借当前key合并节点
* <br />
* 3,与插入时避免回溯的思想一样,保证(2)中合并节点时,借走父节点的 一个实例,而不须继续向上回溯
*/
public class BTree<K extends Comparable<K>, V> {
private static final int M = 4;
private int minEntrySize;
private int maxEntrySize;
private Node root;
private int size;
private int depth;
public BTree() {
this(M);
}
public BTree(int m) {
this.minEntrySize = m - 1;
this.maxEntrySize = (m * 2) - 1;
this.root = new Node(true);
}
/**
* @return 树中不存在当前key时返回null, 否则返回上次key保存的值
*/
public V put(K key, V value) {
if (root.isFull()) {// 创建新root
Node newRoot = new Node(false);
newRoot.children.add(root);
splitFullNode(root, newRoot, 0);
root = newRoot;
depth++;
}
return insert(root, key, value);
}
public V get(K key) {
return serach(root, key);
}
private V serach(Node current, K key) {
SerachResult sr = current.serach(key);
if (sr.serached) {
return current.entrys.get(sr.wudindex).value;
} else {
if (!current.isLeaf) {
return serach(current.children.get(sr.wudindex), key);
}
//递归到叶节点中仍没有查询到
return null;
}
}
public int size() {
return size;
}
public boolean isEmpty() {
return size == 0;
}
public int depth() {
return depth;
}
private V insert(Node current, K key, V value) {
if (current.isFull()) {
throw new UnsupportedOperationException("只能为非满节点插入实例...");
}
SerachResult sr = current.serach(key);
if (sr.serached) {
V oldValue = current.entrys.get(sr.wudindex).value;
current.entrys.get(sr.wudindex).value = value;
return oldValue;
}
if (!current.isLeaf) {
Node wudNode = current.children.get(sr.wudindex);
if (wudNode.isFull()) {
// 回溯过程中每遇到一个满实例节点就立刻分裂
// 保证在叶节点需要分裂时,其父节点一定是非满的,从而不需要再向上回溯
splitFullNode(wudNode, current, sr.wudindex);
if (key.compareTo(current.entrys.get(sr.wudindex).key) > 0) {//需要插入到分裂出的兄弟节点中
wudNode = current.children.get(sr.wudindex + 1);
}
}
return insert(wudNode, key, value);
} else {//所有节点都在叶节点加入
current.entrys.add(sr.wudindex, new Entry(key, value));
size++;
}
return null;
}
/**
* 将一个满实例节点分割, 中间实例提取至父节点中, 分隔出的部分((m - 1)个)实例放入新生成的兄弟节点中
* @param parent 父节点
* @param child 满实例节点
* @param i 满实例节点在父节点中的位置(提取出中间实例应在父节点中插入的位置)
*/
private void splitFullNode(Node fullNode, Node parent, int index) {
if (!fullNode.isFull()) {
throw new UnsupportedOperationException("不能对非满节点经行分裂!");
}
int middleIndex = (fullNode.entrys.size() - 1) / 2;
Entry middleEntry = fullNode.entrys.get(middleIndex);
//此处已保证parent加入新节点后仍满足B-tree特性
parent.entrys.add(index, middleEntry);
Node sibling = new Node(fullNode.isLeaf);
//采用向右分割
for (int i = maxEntrySize - 1; i > middleIndex; i--) {
sibling.entrys.add(0, fullNode.entrys.get(i));
fullNode.entrys.remove(i);
}
fullNode.entrys.remove(middleIndex);
parent.children.add(index + 1, sibling);
//如果分割的不是叶节点, 则fullNode的后半部分(m个)子节点将成为sibling的子节点
if (!fullNode.isLeaf) {
int cs = fullNode.children.size();
for (int i = cs - 1; i >= (cs / 2); i--) {
sibling.children.add(0, fullNode.children.get(i));
fullNode.children.remove(i);
}
}
}
private class Node {
List<Entry> entrys;
List<Node> children;
boolean isLeaf;
Node(boolean isLeaf) {
this.entrys = new ArrayList<Entry>();
this.children = new ArrayList<Node>();
this.isLeaf = isLeaf;
}
/**
* 在当前节点中查询
* @param key 搜索关键字
* @return {@link SerachResult}
*/
SerachResult serach(K key) {
int left = 0;
int right = entrys.size() - 1;
int middle = 0;
while (left <= right) {
middle = (left + right) / 2;
K ck = entrys.get(middle).key;
if (key.compareTo(ck) < 0) {
right = middle - 1;
} else if(key.compareTo(ck) > 0) {
left = middle + 1;
} else {
break;
}
}
boolean flag = true;
if (left > right) {//未找到
flag = false;
}
return new SerachResult(flag, left);
}
boolean isFull() {
return entrys.size() == maxEntrySize;
}
}
private class Entry {
K key;
V value;
Entry(K key, V value) {
this.key = key;
this.value = value;
}
@Override
public String toString() {
return "{key:" + key + ", value:" + value + "}";
}
}
/**
* 在节点中单次查询结果
*/
private class SerachResult {
/**
* 是否查询到
*/
boolean serached;
/**
* 查到时为在node实例集中的位置
* 未查到时表示在node子节点集对应节点中
*/
int wudindex;
SerachResult(boolean serached, int wudindex) {
this.serached = serached;
this.wudindex = wudindex;
}
}
}我的实现里主要加入了泛型，提供了put(key, value); get(key); 两个操作。 大体上看就是一个HashMap的功能。
删除节点那部分的代码我这里没贴，因为实在太复杂也太长，我的代码也未必能让大家看的明白， 如果有兴趣的，自己动手实现一遍更好。
