From 84f50389965c5eca797ee185d4e0378ad01d86fb Mon Sep 17 00:00:00 2001 From: Ray Date: Sat, 1 Aug 2020 18:00:27 -0400 Subject: [PATCH 1/2] Add HashMapLinearProbing.java and MainLinearProbing.java --- .../HashMap/Hashing/HashMapLinearProbing.java | 163 ++++++++++++++++++ .../HashMap/Hashing/MainLinearProbing.java | 54 ++++++ 2 files changed, 217 insertions(+) create mode 100644 DataStructures/HashMap/Hashing/HashMapLinearProbing.java create mode 100644 DataStructures/HashMap/Hashing/MainLinearProbing.java diff --git a/DataStructures/HashMap/Hashing/HashMapLinearProbing.java b/DataStructures/HashMap/Hashing/HashMapLinearProbing.java new file mode 100644 index 00000000..e0132335 --- /dev/null +++ b/DataStructures/HashMap/Hashing/HashMapLinearProbing.java @@ -0,0 +1,163 @@ +package DataStructures.HashMap.Hashing; + +/** + * This class is an implementation of a hash table using linear probing + * + */ +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; + } +} \ No newline at end of file diff --git a/DataStructures/HashMap/Hashing/MainLinearProbing.java b/DataStructures/HashMap/Hashing/MainLinearProbing.java new file mode 100644 index 00000000..594ca41f --- /dev/null +++ b/DataStructures/HashMap/Hashing/MainLinearProbing.java @@ -0,0 +1,54 @@ +package DataStructures.HashMap.Hashing; + +import java.util.Scanner; + +public class MainLinearProbing { + public static void main(String[] args) { + + int choice, key; + + HashMapLinearProbing h = new HashMapLinearProbing(7); + Scanner In = new Scanner(System.in); + + while (true) { + System.out.println("Enter your Choice :"); + System.out.println("1. Add Key"); + System.out.println("2. Delete Key"); + System.out.println("3. Print Table"); + System.out.println("4. Exit"); + System.out.println("5. Search and print key index"); + + choice = In.nextInt(); + + switch (choice) { + case 1: { + System.out.println("Enter the Key: "); + key = In.nextInt(); + h.insertHash(key); + break; + } + case 2: { + System.out.println("Enter the Key delete: "); + key = In.nextInt(); + h.deleteHash(key); + break; + } + case 3: { + System.out.println("Print table"); + h.displayHashtable(); + break; + } + case 4: { + In.close(); + return; + } + case 5: { + System.out.println("Enter the Key to find and print: "); + key = In.nextInt(); + System.out.println("Key: "+ key + " is at index: "+ h.findHash(key)); + } + } + + } + } +} \ No newline at end of file From f729092e8a86f973fdbda35707b7a81cd31e56f6 Mon Sep 17 00:00:00 2001 From: Ray S <68674276+rbshealy@users.noreply.github.com> Date: Sun, 2 Aug 2020 09:17:16 -0400 Subject: [PATCH 2/2] Use public class HashMapLinearProbing --- DataStructures/HashMap/Hashing/HashMapLinearProbing.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/DataStructures/HashMap/Hashing/HashMapLinearProbing.java b/DataStructures/HashMap/Hashing/HashMapLinearProbing.java index e0132335..5c376718 100644 --- a/DataStructures/HashMap/Hashing/HashMapLinearProbing.java +++ b/DataStructures/HashMap/Hashing/HashMapLinearProbing.java @@ -4,7 +4,7 @@ package DataStructures.HashMap.Hashing; * This class is an implementation of a hash table using linear probing * */ -class HashMapLinearProbing { +public class HashMapLinearProbing { private int hsize; private Integer[] buckets; private Integer AVAILABLE; @@ -160,4 +160,4 @@ class HashMapLinearProbing { } return response; } -} \ No newline at end of file +}