Ordered List e BinarySearchTree

dictionary/BinarySearchTree.java

@@ -0,0 +1,180 @@
+package dictionary;
+import exceptions.InvalidEntryException;
+import position.NodePositionList;
+import position.Position;
+import position.PositionList;
+import priorityqueue.Entry;
+import tree.binarytree.BTPosition;
+import tree.binarytree.LinkedBinaryTree;
+import utility.DefaultComparator;
+
+import java.security.InvalidKeyException;
+import java.util.Comparator;
+
+
+
+
+public class BinarySearchTree<K,V>   extends LinkedBinaryTree<Entry<K,V>> implements Dictionary<K,V> {
+
+  protected Comparator<K> C;	// comparator
+  protected Position<Entry<K,V>>  actionPos; // insert node or removed node's parent
+  protected int numEntries = 0;	// number of entries
+
+  public BinarySearchTree()  { 
+    C = new DefaultComparator<K>();
+    addRoot(null);
+  }
+
+  public BinarySearchTree(Comparator<K> c)  { 
+    C = c; 
+    addRoot(null);
+  }
+
+  /** Nested class for location-aware binary search tree entries */
+  protected static class BSTEntry<K,V> implements Entry<K,V> {
+    protected K key;
+    protected V value;
+    protected Position<Entry<K,V>> pos;
+    BSTEntry(K k, V v, Position<Entry<K,V>> p) { 
+      key = k; value = v; pos = p;
+    }
+    public K getKey() { return key; }
+    public V getValue() { return value; }
+    public Position<Entry<K,V>> position() { return pos; }
+  }
+
+  /** Extracts the key of the entry at a given node of the tree. */
+  protected K key(Position<Entry<K,V>> position)  {
+    return position.element().getKey();
+  }
+
+  /** Extracts the value of the entry at a given node of the tree. */  
+  protected V value(Position<Entry<K,V>> position)  { 
+    return position.element().getValue(); 
+  }
+
+  /** Extracts the entry at a given node of the tree. */  
+  protected Entry<K,V> entry(Position<Entry<K,V>> position)  { 
+    return position.element();
+  }
+
+  /** Replaces an entry with a new entry (and reset the entry's location) */
+  protected void replaceEntry(Position <Entry<K,V>> pos, Entry<K,V> ent) {
+    ((BSTEntry<K,V>) ent).pos = pos;
+    replace(pos, ent);
+  }
+
+
+protected void checkKey(K key) throws InvalidKeyException {
+  if(key == null)
+    throw new InvalidKeyException("null key");
+}
+
+protected void checkEntry(Entry<K,V> ent) throws InvalidEntryException {
+  if(ent == null || !(ent instanceof BSTEntry))
+    throw new InvalidEntryException("invalid entry");
+}
+
+protected Entry<K,V> insertAtExternal(Position<Entry<K,V>> v, Entry<K,V> e) {
+  expandExternal(v,null,null);
+  replace(v, e);
+  numEntries++;
+  return e;
+}
+/** Auxiliary method for removing an external node and its parent */
+protected void removeExternal(Position<Entry<K,V>> v) {
+  removeAboveExternal(v);
+  numEntries--;
+}
+/** Auxiliary method used by find, insert, and remove. */
+protected Position<Entry<K,V>> treeSearch(K key, Position<Entry<K,V>> pos) {
+  if (isExternal(pos)) return pos; // key not found; return external node
+  else {
+    K curKey = key(pos);
+    int comp = C.compare(key, curKey);
+    if (comp < 0) 
+      return treeSearch(key, left(pos));	// search left subtree
+    else if (comp > 0)
+      return treeSearch(key, right(pos));	// search right subtree
+    return pos;		// return internal node where key is found
+  }
+}
+
+
+// Adds to L all entries in the subtree rooted at v having keys equal to k
+protected void addAll(PositionList<Entry<K,V>> L, Position<Entry<K,V>> v, K k) {
+  if (isExternal(v)) return;
+  Position<Entry<K,V>> pos = treeSearch(k, v);
+  if (!isExternal(pos))  {  // we found an entry with key equal to k 
+    addAll(L, left(pos), k);
+    L.addLast(pos.element()); 	// add entries in inorder
+    addAll(L, right(pos), k);
+  } // this recursive algorithm is simple, but it's not the fastest
+}
+
+  /** Returns the number of entries in the tree. */
+  public int size() { return numEntries; }
+
+  /** Returns whether the tree is empty. */
+  public boolean isEmpty() { return size() == 0; }
+
+  /** Returns an entry containing the given key.  Returns null if no such entry exists. */
+  public Entry<K,V> find(K key) throws InvalidKeyException {
+    checkKey(key);		// may throw an InvalidKeyException
+    Position<Entry<K,V>> curPos = treeSearch(key, root());
+    actionPos = curPos;		// node where the search ended
+    if (isInternal(curPos)) return entry(curPos);
+    return null;
+  }
+
+  /** Returns an iterable collection of all the entries containing the  given key. */
+  public Iterable<Entry<K,V>> findAll(K key) throws InvalidKeyException {
+    checkKey(key);		// may throw an InvalidKeyException
+    PositionList<Entry<K,V>> L = new NodePositionList<Entry<K,V>>();
+    addAll(L, root(), key);
+    return L;
+  }
+
+  /** Inserts an entry into the tree and returns the newly created entry. */
+  public Entry<K,V> insert(K k, V x) throws InvalidKeyException {
+    checkKey(k);	// may throw an InvalidKeyException
+    Position<Entry<K,V>> insPos = treeSearch(k, root());
+    while (!isExternal(insPos))  // iterative search for insertion position
+      insPos = treeSearch(k, left(insPos));
+    actionPos = insPos;	// node where the new entry is being inserted
+    return insertAtExternal(insPos, new BSTEntry<K,V>(k, x, insPos));
+  }
+
+  /** Removes and returns a given entry. */
+  public Entry<K,V> remove(Entry<K,V> ent) throws InvalidEntryException  {
+    checkEntry(ent);            // may throw an InvalidEntryException
+    Position<Entry<K,V>> remPos = ((BSTEntry<K,V>) ent).position(); 
+    Entry<K,V> toReturn = entry(remPos);	// entry to be returned
+    if (isExternal(left(remPos))) remPos = left(remPos);  // left easy case
+    else if (isExternal(right(remPos))) remPos = right(remPos); // right easy case
+    else {			//  entry is at a node with internal children
+      Position<Entry<K,V>> swapPos = remPos;	// find node for moving entry
+      remPos = right(swapPos);
+      do
+	    remPos = left(remPos);
+      while (isInternal(remPos));
+      replaceEntry(swapPos, (Entry<K,V>) parent(remPos).element());
+    }
+    actionPos = sibling(remPos);	// sibling of the leaf to be removed
+    removeExternal(remPos);
+    return toReturn;
+  }
+
+  /** Returns an iterator containing all entries in the tree. */
+  public Iterable<Entry<K,V>> entries() {
+    PositionList<Entry<K,V>> entries = new NodePositionList<Entry<K,V>>();
+    Iterable<Position<Entry<K,V>>> positer = positions();
+    for (Position<Entry<K,V>> cur: positer)
+      if (isInternal(cur))
+	entries.addLast(cur.element());
+    return entries;
+  }
+
+
+}
+