b 树 java_B+树java实现

package com.source;

import java.util.ArrayDeque;

import java.util.ArrayList;

import java.util.Deque;

import java.util.List;

import java.util.Random;

//定义B树结构

@SuppressWarnings("hiding")

public class MyBTree{

private static final int DEFAULT_T = 2;

// B树根节点

private BTNoderoot;

// 度数

private int t;

// 非根节点的最少关键字个数

private int minKeyNum;

// 非根节点的最大关键字个数

private int maxKeyNum;

// 定义树节点

private class BTNode{

// 关键字个数

public int n = 0;

// 存放关键字

public Listkeys = new

ArrayList(maxKeyNum);

// 存放孩子节点的指针

public List> children = new ArrayList>(

maxKeyNum + 1);

// 是否为叶子节点，初始化是叶子节点

public boolean isLeaf = true;

// 向树节点中插入元素

public void insertKey(int index, Object key) {

keys.add(index, key);

n++;

if (keys.size() > maxKeyNum) {

keys.remove(maxKeyNum);

}

}

// 在树节点中移除元素

public Object removeKey(int index) {

Object key = keys.remove(index);

n--;

return key;

}

// 添加孩子节点指针

public void insertChild(int index, BTNodechild)

{

children.add(index, child);

if (children.size() > maxKeyNum + 1) {

children.remove(maxKeyNum + 1);

}

}

// 移除孩子节点指针

public BTNoderemoveChild(int index) {

BTNodechild = children.remove(index);

return child;

}

}

public MyBTree() {

this(DEFAULT_T);

}

public MyBTree(int degree) {

if (degree < 2) {

t = DEFAULT_T;

}

this.t = degree;

this.minKeyNum = degree - 1;

this.maxKeyNum = 2 * degree - 1;

BTNodenode = new

BTNode();

this.root = node;

}

// 添加元素

public void insert(Object key) {

BTNoder = root;

// 若节点元素已满

if (root.n == maxKeyNum) {

BTNodenewRoot = new

BTNode();

root = newRoot;

newRoot.isLeaf = false;

// 添加原节点为孩子节点

newRoot.insertChild(0, r);

// 分裂孩子节点

sliptChild(newRoot, 0);

insertNoFull(newRoot, key);

} else

insertNoFull(r, key);

}

// 分裂节点

private void sliptChild(BTNodex, int index)

{

// 新增结点

BTNodenewNode = new

BTNode();

// 获取原父节点

BTNodey = x.children.get(index);

// 标记是否为叶子节点

newNode.isLeaf = y.isLeaf;

// 向新节点添加元素

for (int j = 0; j < minKeyNum; j++) {

// 从最小元素个数处开始添加

newNode.insertKey(j, y.keys.get(j + t));

}

// 如果原父节点不是叶子节点

if (!y.isLeaf) {

for (int j = 0; j < t; j++) {

newNode.insertChild(j, y.children.get(j + t));

}

}

// 修改节点元素个数

newNode.n = minKeyNum;

y.n = minKeyNum;

// 链接新节点

x.insertChild(index + 1, newNode);

// 添加新元素

x.insertKey(index, y.keys.get(minKeyNum));

}

// 将元素添加至未满的树节点中

private void insertNoFull(BTNodex, Object key)

{

int i = x.n - 1;

// 是叶子节点

if (x.isLeaf) {

while (i >= 0 && key.hashCode() <

x.keys.get(i).hashCode())

i--;

x.insertKey(i + 1, key);

} else {

// 非叶子节点，寻找添加位置

while (i >= 0 && key.hashCode() <

x.keys.get(i).hashCode())

i--;

i = i + 1;

// 若添加位置处元素已满，则分裂节点

if (x.children.get(i).n == maxKeyNum) {

sliptChild(x, i);

// 关键值大于分裂的一个节点

if (key.hashCode() > x.keys.get(i).hashCode())

i = i + 1;

}

insertNoFull(x.children.get(i), key);

}

}

// 删除元素

public boolean delete(Object key) {

return delete(root, key) != null ? true : false;

}

//从某个节点开始删除元素

private Object delete(BTNodex, Object key)

{

// 该过程需要保证，对非根节点执行删除操作时，其关键字个数至少为t。

// 获取节点的元素个数

int n = x.n;

// 断言机制，判断是否正确执行

assert n >= t || x == root;

int i = 0;

while (i < n && key.hashCode() >

x.keys.get(i).hashCode())

i++;

// 当前节点等于要删除的节点

if (i < n && key.equals(x.keys.get(i))) {

// 当前节点是叶子节点

if (x.isLeaf) {

// 直接删除关键字

x.removeKey(i);

}

else {

//获取两边子树根节点

BTNodelittle = x.children.get(i);

BTNodebigger = x.children.get(i + 1);

//左边节点个数满足度数要求

if (little.n >= t) {

// 小于关键值最大值

Object preKey = deleteMaxKey(little);

x.keys.set(i, preKey);

}

else if (bigger.n >= t) {

// 大于关键字最小值

Object nextKey = deleteMinKey(bigger);

x.keys.set(i, nextKey);

}

else {

// 合并节点

int ySize = little.n;

int zSize = bigger.n;

// little.insertKey(ySize, key);

// ySize++;

boolean isChildLeaf = little.isLeaf;

for (int j = 0; j < zSize; j++) {

// 大于关键字子树。添加到小于关键字的子树

little.insertKey(ySize, bigger.keys.get(j));

// 若不是叶节点，则添加孩子节点

if (!isChildLeaf) {

little.insertChild(ySize, bigger.children.get(j));

}

ySize++;

}

//若不是叶节点，添加最后一个指向孩子的指针

if (!isChildLeaf) {

little.insertChild(ySize, bigger.children.get(zSize -

1));

}

//删除节点以及对应的子节点

x.removeKey(i);

x.removeChild(i + 1);

if (x.n == 0) {

root = little;

}

// delete(little, key);

}

}

//删除节点成功

return key;

}

else if (x.isLeaf) {

// 没有找到该关键字，直接返回

return null;

}

// 当前节点不等于要删除的节点

else {

return delete(x.children.get(i), key);

}

}

//删除一个节点中最大的元素

private Object deleteMaxKey(BTNodex) {

int keyNum = x.n;

if (x.isLeaf) {

return x.removeKey(keyNum - 1);

}

else {

return delete(x,x.keys.get(x.n-1));

}

}

//删除一个节点中最小的元素

private Object deleteMinKey(BTNodex) {

//节点为叶节点

if (x.isLeaf) {

return x.removeKey(0);

}

else {

return delete(x,x.keys.get(0));

}

}

//是否包含某个元素

public boolean contains(Object object){

return contains(root, object);

}

// 从某节点开始是否包含某个元素

private boolean contains(BTNodebtnode,Object

object){

int index = findPosition(btnode, object, 0, btnode.n-1);

// 找到节点

if(btnode.keys.get(index).hashCode() ==

object.hashCode()){

System.out.println("Find \""+object+"\" at index -> "+

(index+1));

return true;

}

// 叶子节点,遍历结束

else if(btnode.isLeaf){

System.out.println("The BTree has no member values

\""+object+"\"!" );

return false;

}

// 非叶子节点

else if(btnode.keys.get(index).hashCode() <

object.hashCode()){

return contains(btnode.children.get(index+1),object);

}

else {

return contains(btnode.children.get(index),object);

}

}

//二分查找树节点

private int findPosition(BTNodebtnode,Object

object,int start,int end){

if(start >= end)

return start;

int middle = start+(end-start)/2;

if(btnode.keys.get(middle).hashCode() ==

object.hashCode())

return middle;

else if (btnode.keys.get(middle).hashCode() >

object.hashCode()) {

return findPosition(btnode, object, start, middle-1);

}

else {

return findPosition(btnode, object, middle+1, end);

}

}

// 返回B树中元素的个数

public int size(){

return count(root);

}

//统计某个节点下孩子个数

private int count(BTNodenode){

if(node.isLeaf)

return node.n;

int sum = node.n;

for(int index = 0;index <= node.n;++index){

sum += count( node.children.get(index) );

}

return sum;

}

//是否为空

public boolean isEmpty() {

if(root.n == 0)

return true;

return false;

}

//打印B树

public void print() {

int level = 0;

Deque> queue1 = new

ArrayDeque.BTNode>();

Deque> queue2 = new

ArrayDeque.BTNode>();

// 添加子节点

queue1.add(root);

while (!queue1.isEmpty() || !queue2.isEmpty()) {

//转移元素

if(queue1.isEmpty()){

level++;

while (!queue2.isEmpty()) {

queue1.add(queue2.poll());

}

}

System.out.format("Level_%d : ", level);

BTNodenode = queue1.poll();

for (int i = 0; i < node.n; i++) {

System.out.format("M",node.keys.get(i));

}

System.out.println();

//添加至下一层

if (!node.isLeaf) {

for (int i = 0; i < node.n + 1; i++) {

queue2.add(node.children.get(i));

}

}

}

}

public static void main(String[] args) {

MyBTree bTree = new MyBTree(20);

Random random = new Random();

for(int index = 0;index < 200;++index){

int temp = random.nextInt(128)+1;

bTree.insert(temp);

}

bTree.print();

System.out.println(bTree.size());

System.out.println(bTree.contains(77));

}

}