Implementato HashCode Dictionary via LinearProbing (Open Adress) e Chaining.

2014-05-11 22:47:12 +02:00
parent 597626b34c
commit 53d6129052
19 changed files with 961 additions and 18 deletions
--- a/dictionary/HashDictionaryChaining.java
+++ b/dictionary/HashDictionaryChaining.java
@@ -0,0 +1,192 @@
+package dictionary;
+
+import arraylist.ArrayIndexList;
+import arraylist.IndexList;
+import exceptions.HashExceptionKey;
+import exceptions.InvalidEntryException;
+import position.NodePositionList;
+import position.PositionList;
+import priorityqueue.Entry;
+import priorityqueue.MyEntry;
+import sun.rmi.log.ReliableLog;
+
+import java.security.InvalidKeyException;
+import java.util.Iterator;
+
+/**
+ * Created with MONSTER.
+ * User: xgiovio
+ * Date: 11/05/2014
+ * Time: 19:28
+ */
+public class HashDictionaryChaining <K,V> implements Dictionary<K,V> {
+
+        IndexList<Logfile<K,V>> table = null;
+        Logfile<K,V> AVAIBLE = null;
+        int avaible_slots = 0;
+        int elements = 0;
+
+    public HashDictionaryChaining ( Logfile<K,V> IN_AVAIBLE, int in_size){
+        table = new ArrayIndexList<Logfile<K, V>>(in_size);
+        AVAIBLE = IN_AVAIBLE;
+
+        for (int i= 0 ; i< in_size ;i++){
+            table.add(i,AVAIBLE);
+            avaible_slots ++;
+        }
+    }
+
+    public   float load_factor () throws InvalidKeyException{
+        float ret =  (size() / (float)raw_size());
+        if ( ret >= 0.9 ) {
+            reformat();
+            return load_factor();
+        }
+        return ret;
+    }
+
+    public  int raw_size (){
+        return table.size();
+    }
+
+    @Override
+    public int size() {
+        return elements;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return (size() == 0);
+    }
+
+    protected int hash ( K key, int size){
+
+        if (  (key instanceof String) )
+            return com.xgiovio.hash.functions.hash_horner( (String)key ,size );
+        throw new HashExceptionKey();
+    }
+
+
+    @Override
+    public Entry<K, V> find(K key) throws InvalidKeyException {
+
+            checkKey(key);
+            int h = hash(key, raw_size());
+            if (table.get(h) == AVAIBLE)
+                return null;
+            Logfile<K, V> n = table.get(h);
+            return n.find(key);
+    }
+
+    @Override
+    public Iterable<Entry<K, V>> findAll(K key) throws InvalidKeyException {
+        checkKey(key);
+        int h = hash(key,raw_size());
+        if (table.get(h) == AVAIBLE)
+            return null;
+        Logfile<K, V> n = table.get(h);
+        return n.entries();
+    }
+
+    @Override
+    public Entry<K, V> insert(K key, V value) throws InvalidKeyException {
+             checkKey(key);
+             if (load_factor() >= 0.9 )
+                 reformat();
+             int h = hash(key,raw_size());
+             if (table.get(h) == AVAIBLE) {
+                 Logfile<K, V> n = new Logfile<K, V>();
+                 table.set(h,n);
+                 avaible_slots--;
+                 elements++;
+                 return n.insert(key,value);
+             } else {
+                 Logfile<K, V> n = table.get(h);
+                 elements++;
+                 return n.insert(key,value);
+             }
+    }
+
+    @Override
+    public Entry<K, V> remove(Entry<K, V> e) throws InvalidEntryException {
+        if (e == null)
+            throw new InvalidEntryException();
+        int h = hash(e.getKey(),raw_size());
+        if (table.get(h) == AVAIBLE)
+            throw new InvalidEntryException();
+        Logfile<K, V> n = table.get(h);
+        Entry<K,V> t =  n.remove(e);
+        elements--;
+        if (n.size() == 0){
+            table.set(h,AVAIBLE);
+            avaible_slots++;
+        }
+       return t;
+    }
+
+    @Override
+    public Iterable<Entry<K, V>> entries() {
+
+        NodePositionList<Entry<K,V>> ret = new NodePositionList<Entry<K, V>>();
+
+        for (int i = 0 ; i< raw_size() ;i++){
+            if (table.get(i) != AVAIBLE){
+                Iterator<Entry<K,V>> local_it = table.get(i).entries().iterator();
+                for (;local_it.hasNext();){
+                    ret.addLast(local_it.next());
+                }
+            }
+
+        }
+        return ret;
+    }
+
+
+    protected void checkKey(K key) throws InvalidKeyException {
+        if (key == null )
+            throw new InvalidKeyException("Invalid key");
+    }
+
+
+    void reformat () throws InvalidKeyException{
+
+        Iterable<Entry<K,V>> ite = entries();
+        int new_size = raw_size() * 2;
+        IndexList<Logfile<K,V>>  table2 = new ArrayIndexList<Logfile<K, V>>(new_size);
+        avaible_slots = 0;
+        elements = 0;
+
+        for (int i= 0 ; i< (new_size) ;i++){
+            table2.add(i,AVAIBLE);
+        }
+        table = table2;
+
+        for (Entry<K,V> e : ite){
+            insert(e.getKey(),e.getValue());
+
+        }
+    }
+
+
+    public String toString() {
+
+        Iterator<Entry<K,V>> it = entries().iterator();
+
+        String to_return = "";
+        to_return = to_return + "[";
+
+        for (;it.hasNext();){
+            Entry<K,V>  t = it.next();
+
+            if (it.hasNext())  {
+
+                to_return+=(t.toString() + " , ");
+            }    else {
+
+                to_return+=(t.toString());
+            }
+        }
+
+        return to_return+= "]";
+    }
+}