using the code below create a method called getCollisionCount that w.pdf

using the code below create a method called getCollisionCount that will return the
number of collisions that occurred when reading a file
Write an application WordFrequency that will be using the Dictionary ADT to study the number
of collisions that occur with different hash table length.
import java.util.Iterator;
import java.util.NoSuchElementException;
public class HashedDictionary implements DictionaryInterface
{
// The dictionary:
private int numberOfEntries;
private static final int DEFAULT_CAPACITY = 5; // Must be prime
private static final int MAX_CAPACITY = 10000;
// The hash table:
private Entry[] hashTable;
private int tableSize; // Must be prime
private static final int MAX_SIZE = 2 * MAX_CAPACITY;
private boolean integrityOK = false;
private static final double MAX_LOAD_FACTOR = 0.5; // Fraction of
// hash table that can be filled
protected final Entry AVAILABLE = new Entry<>(null, null);
public HashedDictionary()
{
this(DEFAULT_CAPACITY); // Call next constructor
} // end default constructor
public HashedDictionary(int initialCapacity)
{
initialCapacity = checkCapacity(initialCapacity);
numberOfEntries = 0; // Dictionary is empty
// Set up hash table:
// Initial size of hash table is same as initialCapacity if it is prime;

// otherwise increase it until it is prime size
tableSize = getNextPrime(initialCapacity);
checkSize(tableSize); // Check that size is not too large
// The cast is safe because the new array contains null entries
@SuppressWarnings("unchecked")
Entry[] temp = (Entry[])new Entry[tableSize];
hashTable = temp;
integrityOK = true;
} // end constructor
/* Implementations of methods in DictionaryInterface are here. . . .*/
public boolean isEmpty()
{
return this.numberOfEntries == 0;
}//end isEmpty
public Iterator getValueIterator()
{
throw new NoSuchElementException("Value Iterator Not Implemented");
}//end valueIterator
public void clear()
{
checkIntegrity();
for (int index = 0; index < this.hashTable.length; index++)
{

hashTable[index] = null;
}//end of for
this.numberOfEntries = 0;
}//end clear
public Iterator getKeyIterator()
{
return new KeyIterator();
}//end iterator
public boolean contains(K key)
{
return getValue(key) != null;
}//end contains
public int getSize()
{
return this.numberOfEntries;
}//end getSize
public V remove(K key)
{
throw new NoSuchElementException("Illegal call");
}//end remove
/* END of Implementations of dictionary methods are here^. . . . */
/* Implementations of private methods are here. . . . */

//precondition: checkIntegrity has been called
private void enlargeHashTable()
{
Entry[] oldTable = hashTable;
int oldSize = hashTable.length;
int newSize = getNextPrime(oldSize + oldSize);
checkSize(newSize);
//The cast is safe because the new array contains null entries
@SuppressWarnings("unchecked")
Entry[] temp = (Entry[]) new Entry[newSize];
hashTable = temp;
numberOfEntries = 0;//reset number of dictionary entries, since it will be incremented by add
during rehash
//rehash dictionary entries from old array to the new and bigger array;
//skip elements that contain null or available
for(int index = 0; index < oldSize; index++)
{
if((oldTable[index] != null) && (oldTable[index] != AVAILABLE))
{
add(oldTable[index].getKey(), oldTable[index].getValue());
}
}// end for
}//end enlargeHashTable
private int getHashIndex(K key)
{
int hashIndex = key.hashCode() % hashTable.length;
if(hashIndex < 0)
{
hashIndex = hashIndex + hashTable.length;
}

return hashIndex;
}//end getHashIndex
private void checkIntegrity()
{
if(!integrityOK)
{
throw new SecurityException("objecy is currupt");
}
}//end checkIntegrity
private boolean isHashTableTooFull()
{
if((numberOfEntries / hashTable.length) >= MAX_LOAD_FACTOR)
{
return true;
}
else
{
return false;
}
}//end isHashTableTooFull
private int checkSize(int size)
{
if(size >= MAX_SIZE){throw new IllegalStateException("Dictionary has become too large.");}
else{return size;}
}//end checksize

private int checkCapacity(int cap)
{
if(cap < DEFAULT_CAPACITY)
{
cap = DEFAULT_CAPACITY;
}
else if (cap > MAX_CAPACITY)
{
throw new IllegalStateException("Attempt to create a dictionary " + "whose capacity is larger
than " + MAX_CAPACITY);
}
return cap;
}//end checkcap
private int getNextPrime(int integer)
{
// if even, add 1 to make od
if (integer % 2 == 0)
{
integer++;
} // end if
// test odd integers
while (!isPrime(integer))
{
integer = integer + 2;
} // end while
return integer;
}//end getnextprime

private boolean isPrime(int integer)
{
boolean result;
boolean done = false;
// 1 and even numbers are not prime
if ( (integer == 1) || (integer % 2 == 0) )
{
result = false;
}
// 2 and 3 are prime
else if ( (integer == 2) || (integer == 3) )
{
result = true;
}
else // integer is odd and >= 5
{
assert (integer % 2 != 0) && (integer >= 5);
// a prime is odd and not divisible by every odd integer up to its square root
result = true; // assume prime
for (int divisor = 3; !done && (divisor * divisor <= integer); divisor = divisor + 2)
{
if (integer % divisor == 0)
{
result = false; // divisible; not prime
done = true;
} // end if
} // end for
} // end if
return result;
} // end isPrime
/* END of Implementations of private methods are here^. . . . */

protected final class Entry
{
private K key;
private V value;
private Entry(K searchKey, V dataValue)
{
key = searchKey;
value = dataValue;
}//end contructor
private K getKey()
{
return key;
}//end getKey
private V getValue()
{
return value;
}//end value
private void setValue(V newValue)
{
value = newValue;
}//end setValue
} // end Entry
//Required Methods
private class KeyIterator implements Iterator
{
private int currentIndex; // Current position in hash table
private int numberLeft; // Number of entries left in iteration
private KeyIterator()
{

currentIndex = 0;
numberLeft = numberOfEntries;
} // end default constructor
public boolean hasNext()
{
return numberLeft > 0;
} // end hasNext
public void remove()
{
throw new UnsupportedOperationException();
} // end remove
public K next()
{
K result = null;
if (hasNext())
{
// Skip table locations that do not contain a current entry
while ( (hashTable[currentIndex] == null) ||
(hashTable[currentIndex] == AVAILABLE) )
{
currentIndex++;
} // end while
result = hashTable[currentIndex].getKey();
numberLeft--;
currentIndex++;
}
else
throw new NoSuchElementException();
return result;
} // end next
} // end KeyIterator
public V getValue(K key)

{
checkIntegrity();
V result = null;
int index = getHashIndex(key);
if ((hashTable[index] != null) && (hashTable[index] != AVAILABLE))
result = hashTable[index].getValue(); // Key found; get value
// Else key not found; return null
return result;
} // end getValue
public V add(K key, V value)
{
int index;
V oldValue;
if((key == null) || (value == null))
{
throw new NoSuchElementException();
}
index = getHashIndex(key);
if((hashTable[index] != null) && (hashTable[index] != AVAILABLE))
{
hashTable[index] = new Entry(key,value);
numberOfEntries++;
oldValue = null;
}
else
{
oldValue = hashTable[index].getValue();
hashTable[index].setValue(value);
}
if(isHashTableTooFull())
{
enlargeHashTable();
}
return oldValue;

}
//end of require methods
//getCollisionCount method
public int getCollisionCount()
{
//code implementation
return 1;
}
} // end HashedDictionary

using the code below create a method called getCollisionCount that w.pdf

Recommended

Recommended

More Related Content

Similar to using the code below create a method called getCollisionCount that w.pdf

Similar to using the code below create a method called getCollisionCount that w.pdf (20)

More from amirthagiftsmadurai

More from amirthagiftsmadurai (20)

Recently uploaded

Recently uploaded (20)

using the code below create a method called getCollisionCount that w.pdf