B-树Java实现

最新推荐文章于 2023-11-23 21:51:46 发布
最新推荐文章于 2023-11-23 21:51:46 发布
阅读量750 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lizhe10177/article/details/19489279
版权 
package BTree;

import java.util.Queue;
import java.util.LinkedList;

/*
 * 存储节点数据的Node类，关键字存储在key[1]key至[keynum]，子节点指针存储在child[0]至child[keynum]
 * */
class Node {
	public static final int M = 3;

	public Node parent;

	public int keynum;
	int[] key;
	Node[] child;

	public Node() {
		parent = null;
		keynum = 0;
		key = new int[M + 1];
		child = new Node[M + 1];
	}
}
/*
 * 该类存储查询结果，tag为true时表示找到关键字，node为所在节点，pos为所在位置，1，2，，，keynum
 * tag为false时表示未找到关键字，node为应该插入的叶节点，pos为插入位置
 * */
class Result {
	boolean tag;
	Node node;
	int pos;

	public Result() {
	}

	public Result(Node node, int pos, boolean tag) {
		this.node = node;
		this.pos = pos;
		this.tag = tag;
	}
}

/*
 * 该类在删除关键字的方法中用到，用以保存关键字个数大于【m/2】-1的左兄弟或者右兄弟,node为空时表示
 * 没有符合要求的左兄弟或者右兄弟，不为空时tag指示左兄弟或者又兄弟，0左1右。
 * */
class Brother {
	Node node;
	int tag;

	public Brother(Node brother, int tag) {
		node = brother;
		this.tag = tag;
	}
}

/*
 * 存储合并两个节点后的结果。tag为true表示有分裂，key为中间关键字，否则合并无分裂。
 * */
class CombineResult {
	boolean tag;
	int key;

	public CombineResult(boolean b, int n) {
		tag = b;
		key = n;
	}
}

public class BTree {
	public Node bTree = new Node();
	/*
	 * 左中右顺序遍历
	 * */
	private void scanTree(Node bTree) {
		if (bTree != null) {
			for (int i = 1; i <= bTree.keynum; i++) {
				scanTree(bTree.child[i - 1]);
				System.out.println(bTree.key[i]);
			}
			scanTree(bTree.child[bTree.keynum]);
		}
	}
	/*
	 * 层次遍历
	 * */
	private void broadScan(Node bTree) {
		Queue<Node> tree = new LinkedList<Node>();
		tree.offer(bTree);
		Node node;
		while ((node = tree.poll()) != null) {
			for (int i = 1; i <= node.keynum; i++) {
				tree.offer(node.child[i - 1]);
				System.out.print(node.key[i] + " ");
			}
			tree.offer(node.child[node.keynum]);
			System.out.print(":");
			System.out.println(node.keynum);
		}
	}

	public void scan() {
		scanTree(bTree);
		broadScan(bTree);
	}
	/*
	 * 返回查询结果
	 * */
	public Result search(Node bTree, int key) {
		int i;
		for (i = 1; i <= bTree.keynum; i++) {
			if (bTree.key[i] == key) {
				break;
			}
		}
		if (i != bTree.keynum + 1) {
			return (new Result(bTree, i, true));
		} else {
			int j = 1;
			while (key > bTree.key[j] && j <= bTree.keynum) {
				j++;
			}
			if (j == bTree.keynum + 1) {
				if (bTree.child[bTree.keynum] != null) {
					return (search(bTree.child[bTree.keynum], key));
				} else {
					return (new Result(bTree, bTree.keynum + 1, false));
				}
			} else {
				if (bTree.child[j - 1] != null) {
					return (search(bTree.child[j - 1], key));
				} else {
					return (new Result(bTree, j, false));
				}
			}
		}
	}

	public boolean insertKey(int key) {
		Result res = search(this.bTree, key);
		if (res.tag) {
			return false;
		}
		return insert(this, res.node, key, null, res.pos);
	}
	
	/*
	 * 合并两个节点，若合并后无分裂，则lchild保存合并后的节点，否则lchild和rchild分别保存分裂后的
	 * 两个节点，返回值中的key属性保存中间的关键字，此方法包含递归
	 * */
	private CombineResult combine(Node lchild, Node rchild) {
		if (lchild.child[lchild.keynum] == null && rchild.child[0] == null) {
			int lnum = lchild.keynum, rnum = rchild.keynum;
			int total = lnum + rnum;
			if (total < Node.M) {
				for (int i = lnum + 1; i <= total; i++) {
					lchild.key[i] = rchild.key[i - lnum];
				}
				lchild.keynum = total;
				CombineResult cres = new CombineResult(false, 0);
				return cres;
			} else {
				int mid = total % 2 == 1 ? total / 2 + 1 : total / 2;
				int[] temp = new int[total + 1];
				for (int i = 1; i <= lnum; i++) {
					temp[i] = lchild.key[i];
				}
				for (int i = 1; i <= rnum; i++) {
					temp[i + lnum] = rchild.key[i];
				}
				for (int i = 1; i <= mid - 1; i++) {
					lchild.key[i] = temp[i];
				}
				for (int i = mid + 1; i <= total; i++) {
					rchild.key[i - mid] = temp[i];
				}
				lchild.keynum = mid - 1;
				rchild.keynum = total - mid;
				CombineResult cres = new CombineResult(true, temp[mid]);
				return cres;
			}
		} else if (lchild.child[lchild.keynum] != null
				&& rchild.child[0] != null) {
			CombineResult result = combine(lchild.child[lchild.keynum],
					rchild.child[0]);

			if (result.tag) {
				int lnum = lchild.keynum, rnum = rchild.keynum;
				int total = lnum + 1 + rnum;
				int mid = total % 2 == 1 ? total / 2 + 1 : total / 2;
				if (lnum + 1 + rnum < Node.M) {
					lchild.key[lnum + 1] = result.key;
					for (int i = 1; i <= rnum; i++) {
						lchild.key[lnum + 1 + i] = rchild.key[i];
					}
					for (int i = 0; i <= rnum; i++) {
						lchild.child[lnum + i] = rchild.child[i];
						if(lchild.child[lnum+i]!=null){
							lchild.child[lnum+i].parent=lchild;
						}
					}
					lchild.keynum = lnum + 1 + rnum;
					CombineResult cres = new CombineResult(false, 0);
					return cres;
				} else {
					int[] temp = new int[total + 1];
					Node[] ntemp = new Node[total + 1];
					for (int i = 1; i <= lnum; i++) {
						temp[i] = lchild.key[i];
					}
					temp[lnum + 1] = result.key;
					for (int i = 1; i <= rnum; i++) {
						temp[i + lnum + 1] = rchild.key[i];
					}
					for (int i = 0; i <= lnum; i++) {
						ntemp[i] = lchild.child[i];
					}
					for (int i = 0; i <= rnum; i++) {
						ntemp[i + 1 + lnum] = rchild.child[i];
					}
					for (int i = 1; i <= mid - 1; i++) {
						lchild.key[i] = temp[i];
					}
					for (int i = mid + 1; i <= total; i++) {
						rchild.key[i - mid] = temp[i];
					}
					for (int i = 0; i <= mid - 1; i++) {
						lchild.child[i] = ntemp[i];
						if(lchild.child[i]!=null){
							lchild.child[i].parent=lchild;
						}
					}
					for (int i = mid; i <= total + 1; i++) {
						rchild.child[i - mid] = ntemp[i];
						if(rchild.child[i-mid]!=null){
							rchild.child[i-mid].parent=rchild;
						}
					}
					lchild.keynum = mid - 1;
					rchild.keynum = total - mid;
					CombineResult cres = new CombineResult(true, temp[mid]);
					return cres;
				}
			} else {
				int lnum = lchild.keynum, rnum = rchild.keynum;
				int total = lnum + rnum;
				if (total < Node.M) {
					for (int i = lnum + 1; i <= total; i++) {
						lchild.key[i] = rchild.key[i - lnum];
						lchild.child[i] = rchild.child[i - lnum];
						if(lchild.child[i]!=null){
							lchild.child[i].parent=lchild;
						}
					}
					lchild.keynum = total;
					CombineResult cres = new CombineResult(false, 0);
					return cres;
				} else {
					int mid = total % 2 == 1 ? total / 2 + 1 : total / 2;
					int[] temp = new int[total + 1];
					Node[] ntemp = new Node[total + 1];
					for (int i = 1; i <= lnum; i++) {
						temp[i] = lchild.key[i];
					}
					for (int i = 0; i <= lnum; i++) {
						ntemp[i] = lchild.child[i];
					}
					for (int i = 1; i <= rnum; i++) {
						temp[i + lnum] = rchild.key[i];
						ntemp[i + lnum] = rchild.child[i];
					}
					for (int i = 1; i <= mid - 1; i++) {
						lchild.key[i] = temp[i];
					}
					for (int i = 0; i <= mid - 1; i++) {
						lchild.child[i] = ntemp[i];
						if(lchild.child[i]!=null){
							lchild.child[i].parent=lchild;
						}
					}
					for (int i = mid; i <= total; i++) {
						rchild.child[i - mid] = ntemp[i];
						if(rchild.child[i-mid]!=null){
							rchild.child[i-mid].parent=rchild;
						}
					}
					for (int i = mid + 1; i <= total; i++) {
						rchild.key[i - mid] = temp[i];
					}
					lchild.keynum = mid - 1;
					rchild.keynum = total - mid;
					CombineResult cres = new CombineResult(true, temp[mid]);
					return cres;
				}
			}
		} else if (lchild.child[lchild.keynum] != null
				&& rchild.child[0] == null) {
			int lnum = lchild.keynum, rnum = rchild.keynum;
			int total = lnum + rnum;
			if (total < Node.M) {
				for (int i = lnum + 1; i <= total; i++) {
					lchild.key[i] = rchild.key[i - lnum];
					lchild.child[i] = rchild.child[i - lnum];
					if(lchild.child[i]!=null){
						lchild.child[i].parent=lchild;
					}
				}
				lchild.keynum = total;
				CombineResult cres = new CombineResult(false, 0);
				return cres;
			} else {
				int mid = total % 2 == 1 ? total / 2 + 1 : total / 2;
				int[] temp = new int[total + 1];
				Node[] ntemp = new Node[total + 1];
				for (int i = 1; i <= lnum; i++) {
					temp[i] = lchild.key[i];
				}
				for (int i = 0; i <= lnum; i++) {
					ntemp[i] = lchild.child[i];
				}
				for (int i = 1; i <= rnum; i++) {
					temp[i + lnum] = rchild.key[i];
					ntemp[i + lnum] = rchild.child[i];
				}
				for (int i = 1; i <= mid - 1; i++) {
					lchild.key[i] = temp[i];
				}
				for (int i = 0; i <= mid - 1; i++) {
					lchild.child[i] = ntemp[i];
					if(lchild.child[i]!=null){
						lchild.child[i].parent=lchild;
					}
				}
				for (int i = mid; i <= total; i++) {
					rchild.child[i - mid] = ntemp[i];
					if(rchild.child[i-mid]!=null){
						rchild.child[i-mid].parent=rchild;
					}
				}
				for (int i = mid + 1; i <= total; i++) {
					rchild.key[i - mid] = temp[i];
				}
				lchild.keynum = mid - 1;
				rchild.keynum = total - mid;
				CombineResult cres = new CombineResult(true, temp[mid]);
				return cres;
			}
		} else if (lchild.child[lchild.keynum] == null
				&& rchild.child[0] != null){
			lchild.child[lchild.keynum] = rchild.child[0];
			if(lchild.child[lchild.keynum]!=null){
				lchild.child[lchild.keynum].parent=lchild;
			}
			int lnum = lchild.keynum, rnum = rchild.keynum;
			int total = lnum + rnum;
			if (total < Node.M) {
				for (int i = lnum + 1; i <= total; i++) {
					lchild.key[i] = rchild.key[i - lnum];
					lchild.child[i] = rchild.child[i - lnum];
					if(lchild.child[i]!=null){
						lchild.child[i].parent=lchild;
					}
				}
				lchild.keynum = total;
				CombineResult cres = new CombineResult(false, 0);
				return cres;
			} else {
				int mid = total % 2 == 1 ? total / 2 + 1 : total / 2;
				int[] temp = new int[total + 1];
				Node[] ntemp = new Node[total + 1];
				for (int i = 1; i <= lnum; i++) {
					temp[i] = lchild.key[i];
				}
				for (int i = 0; i <= lnum; i++) {
					ntemp[i] = lchild.child[i];
				}
				for (int i = 1; i <= rnum; i++) {
					temp[i + lnum] = rchild.key[i];
					ntemp[i + lnum] = rchild.child[i];
				}
				for (int i = 1; i <= mid - 1; i++) {
					lchild.key[i] = temp[i];
				}
				for (int i = 0; i <= mid - 1; i++) {
					lchild.child[i] = ntemp[i];
					if(lchild.child[i]!=null){
						lchild.child[i].parent=lchild;
					}
				}
				for (int i = mid; i <= total; i++) {
					rchild.child[i - mid] = ntemp[i];
					if(rchild.child[i-mid]!=null){
						rchild.child[i-mid].parent=rchild;
					}
				}
				for (int i = mid + 1; i <= total; i++) {
					rchild.key[i - mid] = temp[i];
				}
				lchild.keynum = mid - 1;
				rchild.keynum = total - mid;
				CombineResult cres = new CombineResult(true, temp[mid]);
				return cres;
			}
		} else {
			return null;
		}
	}

	public boolean deleteKey(int key) {
		return delete(this, bTree, key);
	}
	/*
	 * 删除算法：1，先合并所删除关键字的左右节点，若合并后两关键分裂，则直接用分裂处的中间关键字填补所删除关键，删除完成
	 * 2，若左右节点合并后无分裂，则判断所删除关键字所在节点的剩余关键字个数，若大于等于【m/2】-1，则删除完成
	 * 3，若剩余关键字个数小于【m/2】-1，则首先找左右兄弟借节点，通过简单调整自己，父节点和兄弟节点的关系完成删除
	 * 4，若没有兄弟可借节点，则将父节点的关键字拉下一个，删除父节点中的该关键字，用到递归
	 * */
	private boolean delete(BTree tree,Node bTree, int key) {
		Result result = search(bTree, key);
		if (!result.tag) {
			return false;
		} else {
			CombineResult cr = combine(result.node.child[result.pos - 1],
					result.node.child[result.pos]);
			if (cr.tag) {//子节点合并后分裂为两个节点加一个关键字，用此关键字填补删除的关键字
				result.node.key[result.pos] = cr.key;
				return true;
			} else {
				for (int i = result.pos; i < result.node.keynum; i++) {
					result.node.key[i] = result.node.key[i + 1];
					result.node.child[i] = result.node.child[i + 1];
				}
				result.node.keynum--;

				// 关键字个数大于M/2-1
				int min = Node.M % 2 == 0 ? Node.M / 2 : Node.M / 2 + 1;
				if (result.node.keynum >= min - 1) {// 大于最小关键字个数，直接删除关键字
					return true;
				} else {
					if (result.node.parent == null) {//根节点的处理
						if(result.node.keynum>=1){
							return true;
						}else{
							tree.bTree=bTree.child[0];
							return true;
						}
					}
					int posInParent = posAtParent(result.node);
					Brother bro = getWealthyBrother(result.node);// 获取可以支援自己的兄弟节点
					if (bro.node != null) {
						if (bro.tag == 0) {// 左边的兄弟
							for (int k = result.node.keynum; k >= 1; k--) {
								result.node.key[k + 1] = result.node.key[k];
							}
							for (int k = result.node.keynum; k >= 0; k--) {
								result.node.key[k + 1] = result.node.key[k];
							}
							result.node.child[0] = bro.node.child[bro.node.keynum];
							if(result.node.child[0]!=null){
								result.node.child[0].parent=result.node;
							}
							result.node.key[1] = result.node.parent.key[posInParent];
							result.node.parent.key[posInParent] = bro.node.key[bro.node.keynum];
							result.node.keynum++;
							bro.node.keynum--;
							return true;
						} else {// 右边的兄弟
							result.node.key[result.node.keynum + 1] = result.node.parent.key[posInParent + 1];
							result.node.child[result.node.keynum + 1] = bro.node.child[0];
							if(result.node.child[result.node.keynum+1]!=null){
								result.node.child[result.node.keynum+1].parent=result.node;
							}
							result.node.parent.key[posInParent + 1] = bro.node.key[1];
							result.node.keynum++;
							for (int k = 1; k < bro.node.keynum; k++) {
								bro.node.key[k] = bro.node.key[k + 1];
							}
							for (int k = 0; k < bro.node.keynum; k++) {
								bro.node.child[k] = bro.node.child[k + 1];
							}
							bro.node.keynum--;
							return true;
						}
					} else {
						if (posInParent == result.node.parent.keynum) {
							for (int k = result.node.keynum; k >= 1; k--) {
								result.node.key[k + 1] = result.node.key[k];
							}
							result.node.key[1] = result.node.parent.key[result.node.parent.keynum];
							for (int k = result.node.keynum; k >= 0; k--) {
								result.node.child[k + 1] = result.node.child[k];
							}
							result.node.child[0] = null;
							result.node.keynum++;
							delete(tree,bTree, result.node.parent.key[posInParent]);
							return true;
						} else {
							result.node.key[result.node.keynum + 1] = result.node.parent.key[posInParent + 1];
							result.node.child[result.node.keynum + 1] = null;
							result.node.keynum++;
							delete(tree,bTree, result.node.parent.key[posInParent+1]);
							return true;
						}
					}
				}
			}
		}
	}
	/*
	 * 查找在父节点中的位置，即由父节点的child[?]所指向
	 * */
	public int posAtParent(Node node) {
		int mark = node.key[1];
		int j;
		for (j = 1; j <= node.parent.keynum; j++) {
			if (mark < node.parent.key[j]) {
				break;
			}
		}
		return j - 1;
	}
	/*
	 * 寻找能给自己借关键字的兄弟
	 * */
	public Brother getWealthyBrother(Node node) {
		Node brother = null;
		int tag;
		int min = Node.M % 2 == 0 ? Node.M / 2 : Node.M / 2 + 1;
		// 找出它在父亲节点中的位置
		int pos = posAtParent(node);
		if (pos == 0 && node.parent.child[1].keynum > min - 1) {
			brother = node.parent.child[1];
			tag = 1;
		} else if (pos == node.parent.keynum
				&& node.parent.child[node.parent.keynum - 1].keynum > min - 1) {
			brother = node.parent.child[node.parent.keynum - 1];
			tag = 0;
		} else if (node.parent.child[pos - 1].keynum > min - 1) {
			brother = node.parent.child[pos - 1];
			tag = 0;
		} else if (node.parent.child[pos + 1].keynum > min - 1) {
			brother = node.parent.child[pos + 1];
			tag = 1;
		} else {
			tag = -1;
		}
		return new Brother(brother, tag);
	}

	public boolean insert(BTree tree, Node base, int key, Node node, int pos) {
		// 插入
		int i;
		for (i = base.keynum; i >= pos; i--) {
			base.key[i + 1] = base.key[i];
			base.child[i + 1] = base.child[i];
		}
		base.key[i + 1] = key;
		base.child[i + 1] = node;
		if(node!=null){
			node.parent=base;
		}
		base.keynum++;
		// 判断分裂
		if (base.keynum == Node.M) {
			int mid = Node.M / 2;
			int splitPos = (Node.M % 2 == 1) ? mid + 1 : mid;
			// 创建新节点
			Node rNode = new Node();
			rNode.parent = base.parent;
			for (int j = splitPos + 1; j <= Node.M; j++) {
				rNode.key[j - splitPos] = base.key[j];
				rNode.child[j - splitPos] = base.child[j];
				if(rNode.child[j-splitPos]!=null){
					rNode.child[j-splitPos].parent=rNode;
				}
				
			}
			rNode.child[0] = base.child[splitPos];
			if(rNode.child[0]!=null){
				rNode.child[0].parent=rNode;
			}
			
			
			rNode.keynum = Node.M - splitPos;
			// 改造旧节点
			base.keynum = splitPos - 1;
			// 插入到上级节点
			if (base.parent == null) {
				base.parent = new Node();
				tree.bTree = base.parent;
				tree.bTree.key[1] = base.key[splitPos];
				tree.bTree.child[0] = base;
				tree.bTree.child[1] = rNode;
				rNode.parent = tree.bTree;
				tree.bTree.keynum = 1;
			} else {
				// Result sResult = search(tree.bTree, base.key[splitPos]);
				int posAtParent=posAtParent(base)+1;
				insert(tree, base.parent, base.key[splitPos], rNode,
						posAtParent);
			}
		}
		return true;

	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BTree tree = new BTree();
		String[] dataList = args[0].split(",");
		int[] datas = new int[dataList.length];
		for (int i = 0; i < dataList.length; i++) {
			datas[i] = Integer.parseInt(dataList[i]);
			tree.insertKey(datas[i]);
		}
		tree.scan();
		tree.deleteKey(6);
		tree.scan();
	}

}


 

知乎哲也
关注
专栏目录
JAVA B+树的实现
10-03
JAVA B+树的实现
java实现B-树
小溪科技
04-05 632
package edu.princeton.cs.algs4; /** * The BTree class represents an ordered symbol table of generic * key-value pairs. * It supports the put, get, contains, * size, and is-empty methods. *
B-树完整项目代码 Java版实现
m0_37683327的博客
10-14 810
B-树完整项目代码 Java版实现 B-树结点定义 public class BTreeNode { public int keyNum; // 结点中关键字的个数 public int[] data; // 存储关键字的数组 public BTreeNode parent; // 双亲结点 public BTreeNode[] childNodes; //指向孩子结点 s...
Java-B树
weixin_45203607的博客
02-08 1482
B树介绍 为啥要有b树,我们想想,我们之前学过或者使用过的二叉树红黑树…这些数据结构,发现一个问题就是在数据量很大的时候那么我们树的高度是非常高的,在我们日常生活中存储数据最常见的外存就是磁盘。 而磁盘是快设备，也就是说磁盘的读写单位是以块为单位，一般地块大小从0.5k到4k。 即使你只读取一个字节，磁盘也是将包含该字节的所有数据读取到硬盘中。而在磁盘读取过程中，最占用时间的是磁盘的寻道，也就是磁头在盘片上找到需要读取的块所在位置的时间，而在盘片上顺序读取数据的所花的时间是占比比较小的。而要减少外存上花的时
Java——B-树
m0_60867520的博客
12-20 1034
B-树的概念和应用场景，B-树的插入流程，自己通过java实现一个B-树，附带详细代码和图解
B.rar_B-树索引_B树_b tree_b tree java_java B-Tree
09-19
标题中的"B.rar_B-树索引_B树_b tree_b tree java_java B-Tree"表明这是一个关于B-树实现的压缩文件，其中包含了用Java语言编写的B-树索引代码，并且含有详细的注释。这为学习和理解B-树提供了实践示例。 首先，...
B-tree 树的 Java实现
04-11
通过理解B树的数据结构原理，并结合Java编程语言特性，我们可以构建一个高效且功能完备的B树实现。这样的实现对于学习数据结构、开发数据库系统或是优化磁盘上的数据访问都非常有价值。在实际项目中，B树常用于文件...
java数组-基于java实现的双数组Trie树.zip
最新发布
03-14
本项目聚焦于利用Java实现的双数组Trie树，这是一种在字符串处理和搜索中广泛使用的数据结构。 Trie树，又称“前缀树”或“字典树”，是一种用于存储键值对的数据结构，特别适用于字符串。它的主要特点是能以O(1)的...
B-树及其基本操作（插入和删除）详解1
08-03
B-树是一种自平衡的树数据结构，主要用于数据库和文件系统中，以高效地存储和检索大量数据。在B-树中，每个节点可以拥有多个子节点，最多可...在实际应用中，Java等编程语言可以通过实现B-树的数据结构来提供这些功能。
山东大学数据结构实验B-树（java实现）
03-07
Java实现B-树时，首先需要定义一个BTreeNode类来表示树的节点。这个类通常包含键的数组、子节点的数组以及一些辅助方法，如查找键的位置、分裂节点等。节点中的键和子节点的数量应该满足B-树的性质：每个节点最多...
B树(B-树) [数据结构与算法][Java]
m0_57001006的博客
12-24 699
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BMEpUByG-1671859765528)(E:\非凡英才\数据结构(java)]\数据结构图解\B树中每个结点的结构.png)[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xmYTtv51-1671859765527)(E:\非凡英才\数据结构(java)]\数据结构图解\三阶B树举例.png)没有B-树, 所谓的B-树就是B树, 只有B树, B+(加)树, B*(星)树。
B-树的java实现
coding and writing
12-10 1964
B-树的java实现
java b树_Java数据结构与算法11——B树
weixin_36316102的博客
02-19 486
1.B树是什么B树(即是B-tree，B是Balanced，平衡的意思)，是一种平衡的多路搜索树，主要用于磁盘等外部存储的一种数据结构，例如用于文件索引。2.回忆磁盘存取数据的知识1.磁盘存取数据的基本过程(1)根据柱面号使磁头移动到所需要的柱面上，这一过程被称为定位或查找。(2)根据盘面号来确定指定盘面上的磁道(3)盘面确定以后，盘片开始旋转，将指定块号的磁道段移动至磁头下2.磁盘读取数据是以块...
b 树 java_B+树java实现
weixin_35739967的博客
02-15 313
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{p...
数据结构 JAVA描述（十六） 动态查找 B-树 B+树 红黑树
此生尽兴
01-15 2411
B-树前面介绍的查找算法都在内存中进行的，它们适合用于较小的文件，而对于较大的、存放在外存的文件就不合适，对于此类较大规模的文件，即使是采用了平衡二叉树，在查找效率上仍然较低。例如若将存放在外存的10亿条记录组织为平衡二叉树，则每次访问记录需要进行约30次外存访问；而若采用256阶的B-树数据结构，则每次访问记录需要进行的外存访问次数为4到5次。B-树的定义B-树是一种平衡的多路查找树，在文件系统中
数据结构与算法【B树】的Java实现+图解
zmbwcx的博客
11-23 1546
B树的节点属性，与其他树不太相同，首先是key可以有多个，因此要设置为数组，孩子节点也未知，因此也要设置为数组。特性3：除根结点与叶子节点外，每个节点至少有ceil(m/2)个孩子，根节点不是叶子节点时，最少有两个孩子。当经过合并之后，根结点可能会存在为null的情况，此时让根节点中的 0 号孩子替代掉根节点就好。父结点 3 移动到左侧孩子节点中，右侧孩子节点中的第一个key 5 移动到父结点中，左旋结束。于是将右侧节点移除，同时将父结点的值与被移除节点的值都放在最初的左孩子节点中。
【算法】B+树的研读及实现（2）---java版核心代码
一名普通码农的菜地
09-06 7388
【前言】 假如大家已经弄懂了b树及b+树那么恭喜你们了，因为我觉得，b树及b+树是文件系统尤其是数据库优化的关键。 这里预告一下，下一篇课题（也不能说课题，只能用“业余研究题目”这种称呼）是R树，R树似乎是多维的B+树，各位假如也希望弄懂R树的话，请先好好看看b+树。 【代码】 package BPlusTree; import java.util.ArrayLi
Java 代码 实现B-树
m0_37683327的博客
10-14 798
Java代码实现B-树 B-树的定义在前面已经介绍过了，在这里就跳过这一部分，直接看代码的实现！ 在学习B-树的过程中，基本的理论都已经了解了！用人的大脑来插入，寻找，删除是很简单的，一目了然，但是真正实现起来却一点也不简单！ 为了实现这个数据结构，我百度搜索了一下，但是大多数都是介绍理论，很少有人真正用Java代码实现的，在这里我按照自己的思路实现了一下，大家觉得有神问题的，欢迎留言评论！！ B...
B-Tree、B+Tree、B*tree
weixin_30363817的博客
03-12 209
（一）什么是B-Tree、B+Tree、B*Tree？what？ （1）B-Tree 1.0是一种多路搜索树（并不是二叉的） ①任意非叶子节点最多有M个儿子；且M>2; ②根结点的儿子数为[2,M]； ③除根结点以外的非叶子结点的儿子数为[M/2, M]； ④每个结点存放至少M/2-1（取上整）和至多M-1个关键字；（至少2个关键字） ⑤非叶子结点的关键字个数=...
Java实现B-TREE数据结构详析
B-树的Java实现可以应用于需要高效的数据存取操作的场景，尤其是当数据量很大且经常需要读写操作时，例如数据库索引、文件系统索引、外部存储设备等。 以上知识点对Java开发者了解和实现B-树数据结构有着重要的作用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值