JavaAlgorithms/DataStructures/HashMap/Hashing/HashMapLinearProbing.java
2020-08-02 09:17:16 -04:00

164 lines
4.1 KiB
Java

package DataStructures.HashMap.Hashing;
/**
* This class is an implementation of a hash table using linear probing
*
*/
public class HashMapLinearProbing {
private int hsize;
private Integer[] buckets;
private Integer AVAILABLE;
/**
* Constructor initializes buckets array, hsize, and creates dummy object for AVAILABLE
* @param hsize the desired size of the hash map
*/
public HashMapLinearProbing(int hsize) {
buckets = new Integer[hsize];
this.hsize = hsize;
AVAILABLE = new Integer(Integer.MIN_VALUE);
}
/**
* The Hash Function takes a given key and finds an index based on its data
* @param key the desired key to be converted
* @return int an index corresponding to the key
*/
public int hashing(int key) {
int hash = key % hsize;
if (hash < 0) {
hash += hsize;
}
return hash;
}
/**
* inserts the key into the hash map by wrapping it as an Integer object
* @param key the desired key to be inserted in the hash map
*/
public void insertHash(int key) {
Integer wrappedInt = new Integer(key);
int hash = hashing(key);
if(isFull()) {
System.out.println("Hash table is full");
return;
}
for (int i = 0;i < hsize; i++) {
if(buckets[hash] == null || buckets[hash] == AVAILABLE) {
buckets[hash] = wrappedInt;
return;
}
if(hash + 1 < hsize) {
hash++;
} else {
hash = 0;
}
}
}
/**
* deletes a key from the hash map and adds an available placeholder
* @param key the desired key to be deleted
*/
public void deleteHash(int key) {
Integer wrappedInt = new Integer(key);
int hash = hashing(key);
if(isEmpty()) {
System.out.println("Table is empty");
return;
}
for(int i = 0;i < hsize; i++) {
if(buckets[hash] != null && buckets[hash].equals(wrappedInt)) {
buckets[hash] = AVAILABLE;
return;
}
if(hash + 1 < hsize) {
hash++;
} else {
hash = 0;
}
}
System.out.println("Key " + key + " not found");
}
/**
* Displays the hash table line by line
*/
public void displayHashtable() {
for (int i = 0; i < hsize; i++) {
if(buckets[i] == null || buckets[i] == AVAILABLE) {
System.out.println("Bucket " + i + ": Empty");
} else {
System.out.println("Bucket " + i + ": " + buckets[i].toString());
}
}
}
/**
* Finds the index of location based on an inputed key
* @param key the desired key to be found
* @return int the index where the key is located
*/
public int findHash(int key) {
Integer wrappedInt = new Integer(key);
int hash = hashing(key);
if(isEmpty()) {
System.out.println("Table is empty");
return -1;
}
for(int i = 0;i < hsize; i++) {
if(buckets[hash].equals(wrappedInt)) {
buckets[hash] = AVAILABLE;
return hash;
}
if(hash + 1 < hsize) {
hash++;
} else {
hash = 0;
}
}
System.out.println("Key " + key + " not found");
return -1;
}
/**
* isFull returns true if the hash map is full and false if not full
* @return boolean is Empty
*/
public boolean isFull() {
boolean response = true;
for(int i = 0; i< hsize;i++) {
if(buckets[i] == null || buckets[i] == AVAILABLE) {
response = false;
break;
}
}
return response;
}
/**
* isEmpty returns true if the hash map is empty and false if not empty
* @return boolean is Empty
*/
public boolean isEmpty() {
boolean response = true;
for(int i = 0; i< hsize;i++) {
if(buckets[i] != null) {
response = false;
break;
}
}
return response;
}
}