Help with final Graduation Project

Question

I've done with the majority of it, however I need help with the remove method for a B tree. when removing from a non-leaf node, your remove must replace the removed item with the smallest item in the right subtree.
The code:
import java.util.Stack;
public class BTreeG<E extends Comparable< ? super E>> {
    // Each Btree object is a B-tree header.
    // This B-tree is represented as follows: order is the maximum number
    // of children per node, and root is a link to its root node.
    // Each B-tree node is represented as follows: size contains its size; a
    // subarray items[0...size-1] contains its elements; and a subarray
    // childs[0...size] contains links to its child nodes. For each element
    // items, childs[i] is a link to its left child, and childs[i+1] is a
// link to its right child. In a leaf node, all child links are null.
// Moreover, for every element x in the left subtree of element y:
// x.compareTo(y) < 0
// and for every element z in the right subtree of element y:
// z.compareTo(y) > 0.
private final int order;
private Node root;
public BTreeG () {
     // Construct an empty B-tree of order 5.
this(5);
public BTreeG (int k) {
// Construct an empty B-tree of order k.
root = null;
order = k;
public E get(E item){
if (root == null)
return null;
Node node = root;
while (true) {
int pos = node.searchInNode(item);
if (item.equals(node.items[pos]))
return (E)node.items[pos];
else if (node.isLeaf())
return null;
else
node = node.childs[pos];
public void insert (E item) {
// Insert element item into this B-tree.
if (root == null) {
root = new Node( item);
return;
Stack ancestors = new Stack();
Node curr = root;
while (true) {
int currPos = curr.searchInNode(item);
if (item.equals(curr.items[currPos]))
return;
else if (curr.isLeaf()) {
curr.insertInNode(item, null, null, currPos);
if (curr.size == order) // curr has overflowed
splitNode(curr, ancestors);
return;
} else {
ancestors.push(new Integer(currPos));
ancestors.push(curr);
curr = curr.childs[currPos];
private void splitNode (Node node,
Stack ancestors) {
// Split the overflowed node in this B-tree. The stack ancestors contains
// all ancestors of node, together with the known insertion position
// in each of these ancestors.
int medPos = node.size/2;
E med = (E)node.items[medPos];
Node leftSib = new Node(
node.items, node.childs, 0, medPos);
Node rightSib = new Node(
node.items, node.childs, medPos+1, node.size);
if (node == root)
root = new Node( med, leftSib,
rightSib);
else {
Node parent =
(Node) ancestors.pop();
int parentIns = ((Integer)
ancestors.pop()).intValue();
parent.insertInNode(med, leftSib, rightSib,
parentIns);
if (parent.size == order) // parent has overflowed
splitNode(parent, ancestors);
public void remove (E item) {
     // your code goes here
public void print () {
// Print a textual representation of this B-tree.
printSubtree(root, "");
private void printSubtree (Node top, String indent) {
// Print a textual representation of the subtree of this B-tree whose
// topmost node is top, indented by the string of spaces indent.
if (top == null)
System.out.println(indent + "o");
else {
System.out.println(indent + "o-->");
boolean isLeaf = top.isLeaf();
String childIndent = indent + " ";
for (int i = 0; i < top.size; i++) {
if (! isLeaf) printSubtree(top.childs[i], childIndent);
System.out.println(childIndent + top.items[i]);
if (! isLeaf) printSubtree(top.childs[top.size], childIndent);
//////////// Inner class ////////////
private class Node<E extends Comparable< ? super E>>
// Each Node object is a B-tree node.
private int size;
private E[] items;
private Node[] childs;
     private Node (E item) {
     this (item, null, null);
private Node (E item, Node left, Node right) {
// Construct a B-tree node of order k, initially with one element, item,
// and two children, left and right.
items = (E[])new Comparable[order];
childs = new Node[order+1];
// ... Each array has one extra component, to allow for possible
// overflow.
this.size = 1;
this.items[0] = item;
this.childs[0] = left;
this.childs[1] = right;
private Node ( E[] items, Node[] childs, int l, int r) {
// Construct a B-tree node of order k, with its elements taken from the
// subarray items[l...r-1] and its children from the subarray
// childs[l...r].
this.items = (E[])new Comparable[order];
this.childs = new Node[order+1];
this.size = 0;
for (int j = l; j < r; j++) {
this.items[this.size] = items[j];
this.childs[this.size] = childs[j];
this.size++;
this.childs[this.size] = childs[r];
private boolean isLeaf () {
// Return true if and only if this node is a leaf.
return (childs[0] == null);
private int searchInNode (E item) {
// Return the index of the leftmost element in this node that is
// not less than item.
int l = 0, r = size-1;
while (l <= r) {
int m = (l + r)/2;
int comp = item.compareTo((E)items[m]);
if (comp == 0)
return m;
else if (comp < 0)
r = m - 1;
else
l = m + 1;
return l;
private void insertInNode (E item, Node leftChild,
Node<E> rightChild, int ins) {
// Insert element item, with children leftChild and rightChild, at
// position ins in this node.
for (int i = size; i > ins; i--) {
items[i] = items[i-1];
childs[i+1] = childs[i];
size++;
items[ins] = item;
childs[ins] = leftChild;
childs[ins+1] = rightChild;

Answer 1

I've done with the majority of it, however I need
help with the remove method for a B tree. when
removing from a non-leaf node, your remove must
replace the removed item with the smallest item in
the right subtree. It's hard to implement a B tree. That's why you rather use a standard implementation. If not you're basically on your own. Don't expect others to do it for you. Why should they bother? Please tell us when you're finished and where we can download you B-tree implementation -:)