rbol Binario de Bsqueda

public class BSTree<K extends Comparable<K>, E>

implements IBSTree<K, E> {

protected BSTNode<K, E> root;

public BSTree() {
root = null;
}

public BSTree(BSTNode<K, E> node) {
root = node;
}

@Override
public BSTNode<K, E> getRoot() {
return root;
}

@Override
public void insert(K key, E elem) {
BSTNode<K, E> newNode = new BSTNode<K, E>(key, elem);
if (root == null) {
root = newNode;
return;
}
BSTNode.insert(newNode, root);
}



@Override
public E getElementByKey(K key) {
return BSTNode.getElementByKey(root, key);
}




@Override
public void remove(K key) {
if (root == null) {
System.out.println("Cannot remove: The tree is empty");
return;
}
root = BSTNode.remove(key, root);
}



@Override
public IList<E> getPreorder() {
IList<E> list = new SList<E>();
BSTNode.getPreorder(root, list);
return list;
}

@Override
public boolean containsKey(K key) {
return BSTNode.containsKey(root, key);
}

@Override
public boolean containsElement(E element) {
return BSTNode.containsElement(root, element);
}

























public class BSTNode<K extends Comparable<K>, E>
implements
IBSTNode<K, E>{
K key;
E element;

protected BSTNode<K, E> parent;
protected BSTNode<K, E> leftChild;
protected BSTNode<K, E> rightChild;

public BSTNode(K key, E element) {
parent = null;
leftChild = null;
rightChild = null;
this.key = key;
this.element = element;
}

@Override
public K getKey() {
return key;
}

@Override
public E getElement() {
return element;
}

@Override
public BSTNode<K, E> getParent() {
return parent;
}

@Override
public BSTNode<K, E> getLeftChild() {
return leftChild;
}

@Override
public BSTNode<K, E> getRightChild() {
return rightChild;
}



@Override
public boolean hasLeftChild() {
if (leftChild != null) {
return true;
}
return false;
}

@Override
public boolean hasRightChild() {
if (rightChild != null) {
return true;
}
return false;
}

@Override
public boolean isInternal() {
if (leftChild == null && rightChild == null) {
return false;
}
return true;
}

@Override
public boolean isExternal() {
if (leftChild == null && rightChild == null) {
return true;
}
return false;
}

@Override
public IBSTNode<K, E> getRoot() {
if (parent == null) {
return this;
} else {
return parent.getRoot();
}
}

@Override
public boolean isRoot() {
if (parent == null) {
return true;
} else {
return false;
}
}

@Override
public int getSize() {
return getSize(this);
}

int getSize(BSTNode<K, E> node) {
if (node==null)
return 0;
else
return 1 + getSize(node.leftChild) +
getSize(node.rightChild);
}

@Override
public int getHeight() {
return getHeight(this);
}

static<K extends Comparable<K>,E> int getHeight(BSTNode<K, E> node) {
if (node==null)
return -1;
else
return 1 + Math.max(getHeight(node.leftChild) ,
getHeight(node.rightChild));
}

@Override
public int getDepth() {
return getDepth(this);
}

static<K extends Comparable<K>,E> int getDepth(BSTNode<K, E> node) {
if (node==null)
return -1;
else
return 1+getDepth(node.parent);
}

@Override
public IList<IBSTNode<K, E>> getChildren() {
IList<IBSTNode<K, E>> children = new SList<IBSTNode<K, E>>();
if (hasLeftChild())
children.addLast(leftChild);
if (hasRightChild())
children.addLast(rightChild);
return children;
}

@Override
public IList<E> getPreorder() {
IList<E> list = new SList<E>();
getPreorder(this,list);
return list;
}

static<K extends Comparable<K>,E> void getPreorder(BSTNode<K, E> node,
IList<E> list) {
if (node == null)
return;
list.addLast(node.element);
getPreorder(node.leftChild, list);
getPreorder(node.rightChild, list);
}

static<K extends Comparable<K>,E> E getElementByKey(BSTNode<K, E>
node, K key) {
if (node==null) {
return null;
} else {
if (key.equals(node.getKey()))
return node.getElement();
if (key.compareTo(node.getKey())<0)
return getElementByKey(node.leftChild, key);
else
return getElementByKey(node.rightChild, key);
}
}

static<K extends Comparable<K>,E> boolean containsKey(BSTNode<K, E>
node, K key) {
if (node==null) {
return false;
} else {
if (key.equals(node.getKey()))
return true;
if (key.compareTo(node.getKey())<0)
return containsKey(node.leftChild, key);
else
return containsKey(node.rightChild, key);
}
}

static<K extends Comparable<K>,E> boolean containsElement(BSTNode<K,
E> node, E element) {
if (node==null) {
return false;
} else {
return element.equals(node.getElement())
|| containsElement(node.leftChild, element)
|| containsElement(node.rightChild, element);
}
}

static<K extends Comparable<K>, E> void insert(BSTNode<K, E> newNode,


BSTNode<K, E> node) {
K key = newNode.key;
if (key.compareTo(node.key) == 0) {
System.out.println("Cannot insert, the key already exists");
return;
}
if (key.compareTo(node.key) < 0) {
if (node.leftChild == null) {
node.leftChild = newNode;
newNode.parent = node;
return;
} else {
insert(newNode, node.leftChild);
}
} else {
if (node.rightChild == null) {
node.rightChild = newNode;
newNode.parent = node;
return;
} else {
insert(newNode, node.rightChild);
}
}

}

static<K extends Comparable<K>, E> BSTNode<K,E> remove(K key,
BSTNode<K, E> node) {
if (node == null) {
System.out.println("Cannot remove: The key doesn't
exist");
return null;
}

if (key.compareTo(node.key) < 0) {
node.leftChild = remove(key, node.leftChild);
return node;
} else if (key.compareTo(node.key) > 0) {
node.rightChild = remove(key, node.rightChild);
return node;

} else { //if (key.equals(node.key))
if (!node.hasLeftChild() && !node.hasRightChild()) {
return null;
}
if (!node.hasLeftChild()) {
node.rightChild.parent = node.parent;
return node.rightChild;
}
if (!node.hasRightChild()) {
node.leftChild.parent = node.parent;
return node.leftChild;
}
// Get the predecessor
BSTNode<K, E> predecessorNode = node.leftChild;
while (predecessorNode.hasRightChild()) {
predecessorNode = predecessorNode.rightChild;
}
// Remove the predecessor from the subtree
BSTNode<K, E> leftNode = remove(predecessorNode.key,
node.leftChild);
BSTNode<K, E> rightNode = node.rightChild;
// The predecessor is the new root, set its parent and
subtrees
predecessorNode.parent = node.parent;
predecessorNode.leftChild = leftNode;
if (leftNode != null)
leftNode.parent = predecessorNode;
predecessorNode.rightChild = rightNode;
if (rightNode != null)
rightNode.parent = predecessorNode;
// Return the predecessor
return predecessorNode;
}
}


}