Add HashMapLinearProbing.java and MainLinearProbing.java

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
+ *
+ */
+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;
+    }
+}

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));
+				}	
+			}
+
+		}
+	}
+}