// recursive support method for above
private BSTNode delete(T item, BSTNode current) {
// if current is null, nothing new to return
if (current != null) {
// if item is smaller, go left
if (item.compareTo(current.element) < 0) {
current.left = delete(item, current.left);
}
// if item is larger, go right
else if (item.compareTo(current.element) > 0) {
current.right = delete(item, current.right);
} else {
// get smallest of right subtree, then delete this node
if (current.left != null && current.right != null) {
current.element = findMinimum(current.right);
current.right = delete(current.element, current.right);
}
// if only left child, replace with this
else if (current.left != null && current.right == null) {
current = current.left;
}
// if only right child, replace with this
else if (current.left == null && current.right != null) {
current = current.right;
} else {
// if no children, delete node by setting to null
current = null;
}
}
}
return current;
}
/*
* formacion del arbol
*/
private void continueRotation(BSTNode gr, BSTNode par, BSTNode ch, BSTNode desc) {
if (gr != null) { // if par has a grandparent;
if (gr.right == ((SplayTreeNode) ch).parent) gr.right = ch;
else gr.left = ch;
} else root = ch;
if (desc != null) ((SplayTreeNode) desc).parent = par;
((SplayTreeNode) par).parent = ch;
((SplayTreeNode) ch).parent = gr;
}
public BSTNode minBST(int[] array, int start, int end) {
if (start > end) {
return null;
}
int mid = (start + end) / 2;
BSTNode n = new BSTNode(array[mid]);
size++;
n.left = minBST(array, start, mid - 1);
n.right = minBST(array, mid + 1, end);
return n;
}
public boolean remove(int x) {
BSTNode current = root;
BSTNode parent = null;
boolean branch = true; // true =left, false =right
while (current != null) {
if (current.value == x) {
BSTNode bigson = current;
while (bigson.left != null || bigson.right != null) {
parent = bigson;
if (bigson.right != null) {
bigson = bigson.right;
branch = false;
} else {
bigson = bigson.left;
branch = true;
}
}
// System.out.println("Remove: current "+current.value+" parent "+parent.value+" bigson
// "+bigson.value);
if (parent != null) {
if (branch) {
parent.left = null;
} else {
parent.right = null;
}
}
if (bigson != current) {
current.value = bigson.value;
} else {;
}
return true;
}
parent = current;
// if (current.value <x ) { // THERE WAS ERROR
if (current.value > x) {
current = current.left;
branch = true;
} else {
current = current.right;
branch = false;
}
}
return false;
}
// recusive support method for above
private BSTNode insert(T item, BSTNode current) {
// if current node does not exist, make new node for item
if (current == null) {
current = new BSTNode(item, null, null);
}
// if new item is smaller, go to the left
else if (item.compareTo(current.element) < 0) {
current.left = insert(item, current.left);
}
// if new item is larger, go to the right
else if (item.compareTo(current.element) > 0) {
current.right = insert(item, current.right);
}
// otherwise we have duplicate and throw exception
else {
throw new MyException("Duplicate item");
}
return current;
}
public void add(int x) {
BSTNode current = root;
if (root == null) {
root = new BSTNode(x);
return;
}
while (current.value != x) {
if (x < current.value) {
if (current.left == null) {
current.left = new BSTNode(x);
} else {
current = current.left;
}
} else {
if (current.right == null) {
current.right = new BSTNode(x);
} else {
current = current.right;
}
}
}
}
