algorithm/Java
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/Java.git synced 2025-07-25 13:34:54 +08:00
Code Issues Packages Projects Releases Wiki Activity

Formatted with Google Java Formatter

Browse Source
This commit is contained in:
github-actions
2020-10-24 10:23:28 +00:00
parent a23bac99e8
commit 5d59a2e828
219 changed files with 13758 additions and 14582 deletions
Download Patch File Download Diff File Expand all files Collapse all files

269
DataStructures/HashMap/Hashing/HashMap.java
View File

@ -1,148 +1,145 @@
package DataStructures.HashMap.Hashing;
public class HashMap {
private int hsize;
private LinkedList[] buckets;
private int hsize;
private LinkedList[] buckets;
public HashMap(int hsize) {
buckets = new LinkedList[hsize];
for (int i = 0; i < hsize; i++) {
buckets[i] = new LinkedList();
// Java requires explicit initialisaton of each object
public HashMap(int hsize) {
buckets = new LinkedList[hsize];
for (int i = 0; i < hsize; i++) {
buckets[i] = new LinkedList();
// Java requires explicit initialisaton of each object
}
this.hsize = hsize;
}
public int hashing(int key) {
int hash = key % hsize;
if (hash < 0) hash += hsize;
return hash;
}
public void insertHash(int key) {
int hash = hashing(key);
buckets[hash].insert(key);
}
public void deleteHash(int key) {
int hash = hashing(key);
buckets[hash].delete(key);
}
public void displayHashtable() {
for (int i = 0; i < hsize; i++) {
System.out.printf("Bucket %d :", i);
System.out.println(buckets[i].display());
}
}
public static class LinkedList {
private Node first;
public LinkedList() {
first = null;
}
public void insert(int key) {
if (isEmpty()) {
first = new Node(key);
return;
}
Node temp = findEnd(first);
temp.setNext(new Node(key));
}
private Node findEnd(Node n) {
if (n.getNext() == null) {
return n;
} else {
return findEnd(n.getNext());
}
}
public Node findKey(int key) {
if (!isEmpty()) {
return findKey(first, key);
} else {
System.out.println("List is empty");
return null;
}
}
private Node findKey(Node n, int key) {
if (n.getKey() == key) {
return n;
} else if (n.getNext() == null) {
System.out.println("Key not found");
return null;
} else {
return findKey(n.getNext(), key);
}
}
public void delete(int key) {
if (!isEmpty()) {
if (first.getKey() == key) {
first = null;
} else {
delete(first, key);
}
this.hsize = hsize;
} else {
System.out.println("List is empty");
}
}
public int hashing(int key) {
int hash = key % hsize;
if (hash < 0)
hash += hsize;
return hash;
}
public void insertHash(int key) {
int hash = hashing(key);
buckets[hash].insert(key);
}
public void deleteHash(int key) {
int hash = hashing(key);
buckets[hash].delete(key);
}
public void displayHashtable() {
for (int i = 0; i < hsize; i++) {
System.out.printf("Bucket %d :", i);
System.out.println(buckets[i].display());
private void delete(Node n, int key) {
if (n.getNext().getKey() == key) {
if (n.getNext().getNext() == null) {
n.setNext(null);
} else {
n.setNext(n.getNext().getNext());
}
}
}
public static class LinkedList {
private Node first;
public LinkedList() {
first = null;
}
public void insert(int key){
if(isEmpty()) {
first = new Node(key);
return;
}
Node temp = findEnd(first);
temp.setNext(new Node(key));
}
private Node findEnd(Node n) {
if(n.getNext() == null) {
return n;
} else {
return findEnd(n.getNext());
}
}
public Node findKey(int key) {
if(!isEmpty()) {
return findKey(first, key);
} else {
System.out.println("List is empty");
return null;
}
}
private Node findKey(Node n, int key) {
if(n.getKey() == key) {
return n;
} else if(n.getNext() == null) {
System.out.println("Key not found");
return null;
} else {
return findKey(n.getNext(),key);
}
}
public void delete(int key) {
if(!isEmpty()) {
if(first.getKey() == key) {
first = null;
} else {
delete(first,key);
}
} else {
System.out.println("List is empty");
}
}
private void delete(Node n, int key) {
if(n.getNext().getKey() == key) {
if(n.getNext().getNext() == null) {
n.setNext(null);
} else {
n.setNext(n.getNext().getNext());
}
}
}
public String display() {
return display(first);
}
private String display(Node n) {
if(n == null) {
return "null";
} else {
return n.getKey() + "->" + display(n.getNext());
}
}
public boolean isEmpty() {
return first == null;
}
public String display() {
return display(first);
}
public static class Node {
private Node next;
private int key;
public Node(int key) {
next = null;
this.key = key;
}
public Node getNext() {
return next;
}
public int getKey() {
return key;
}
public void setNext(Node next) {
this.next = next;
}
private String display(Node n) {
if (n == null) {
return "null";
} else {
return n.getKey() + "->" + display(n.getNext());
}
}
public boolean isEmpty() {
return first == null;
}
}
public static class Node {
private Node next;
private int key;
public Node(int key) {
next = null;
this.key = key;
}
public Node getNext() {
return next;
}
public int getKey() {
return key;
}
public void setNext(Node next) {
this.next = next;
}
}
}

359
DataStructures/HashMap/Hashing/HashMapLinearProbing.java
View File

@ -3,191 +3,194 @@ package DataStructures.HashMap.Hashing;
import java.util.*;
/**
* This class is an implementation of a hash table using linear probing
* It uses a dynamic array to lengthen the size of the hash table when
* load factor > .7
* This class is an implementation of a hash table using linear probing It uses a dynamic array to
* lengthen the size of the hash table when load factor > .7
*/
public class HashMapLinearProbing {
private int hsize; //size of the hash table
private Integer[] buckets; //array representing the table
private Integer AVAILABLE;
private int size; //amount of elements in the hash table
private int hsize; // size of the hash table
private Integer[] buckets; // array representing the table
private Integer AVAILABLE;
private int size; // amount of elements in the hash table
/**
* Constructor initializes buckets array, hsize, and creates dummy object for AVAILABLE
* @param hsize the desired size of the hash map
*/
public HashMapLinearProbing(int hsize) {
this.buckets = new Integer[hsize];
this.hsize = hsize;
this.AVAILABLE = new Integer(Integer.MIN_VALUE);
this.size = 0;
}
/**
* 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;
size++;
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);
/**
* Constructor initializes buckets array, hsize, and creates dummy object for AVAILABLE
*
* @param hsize the desired size of the hash map
*/
public HashMapLinearProbing(int hsize) {
this.buckets = new Integer[hsize];
this.hsize = hsize;
this.AVAILABLE = new Integer(Integer.MIN_VALUE);
this.size = 0;
}
if(isEmpty()) {
System.out.println("Table is empty");
return;
/**
* 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;
size++;
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;
size--;
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++) {
try {
if (buckets[hash].equals(wrappedInt)) {
buckets[hash] = AVAILABLE;
return hash;
}
for(int i = 0;i < hsize; i++) {
if(buckets[hash] != null && buckets[hash].equals(wrappedInt)) {
buckets[hash] = AVAILABLE;
size--;
return;
}
if(hash + 1 < hsize) {
hash++;
} else {
hash = 0;
}
}
System.out.println("Key " + key + " not found");
} catch (Exception E) {
}
if (hash + 1 < hsize) {
hash++;
} else {
hash = 0;
}
}
/**
* 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());
}
}
System.out.println("Key " + key + " not found");
return -1;
}
private void lengthenTable() {
buckets = Arrays.copyOf(buckets, hsize * 2);
hsize *= 2;
System.out.println("Table size is now: " + hsize);
}
/**
* Checks the load factor of the hash table if greater than .7, automatically lengthens table to
* prevent further collisions
*/
public void checkLoadFactor() {
double factor = (double) size / hsize;
if (factor > .7) {
System.out.println("Load factor is " + factor + ", lengthening table");
lengthenTable();
} else {
System.out.println("Load factor is " + factor);
}
/**
* 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++) {
try {
if(buckets[hash].equals(wrappedInt)) {
buckets[hash] = AVAILABLE;
return hash;
}
} catch (Exception E) {}
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;
}
}
private void lengthenTable() {
buckets = Arrays.copyOf(buckets, hsize * 2);
hsize *= 2;
System.out.println("Table size is now: " + hsize);
}
/**
* Checks the load factor of the hash table
* if greater than .7, automatically lengthens table
* to prevent further collisions
*/
public void checkLoadFactor() {
double factor = (double) size / hsize;
if(factor > .7) {
System.out.println("Load factor is " + factor + ", lengthening table");
lengthenTable();
} else {
System.out.println("Load factor is " + factor);
}
}
/**
* 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;
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;
}
}

81
DataStructures/HashMap/Hashing/Main.java
View File

@ -3,46 +3,49 @@ package DataStructures.HashMap.Hashing;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
public static void main(String[] args) {
int choice, key;
int choice, key;
HashMap h = new HashMap(7);
Scanner In = new Scanner(System.in);
HashMap h = new HashMap(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");
choice = In.nextInt();
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");
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;
}
}
}
}
}
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;
}
}
}
}
}

107
DataStructures/HashMap/Hashing/MainLinearProbing.java
View File

@ -3,58 +3,63 @@ package DataStructures.HashMap.Hashing;
import java.util.Scanner;
public class MainLinearProbing {
public static void main(String[] args) {
public static void main(String[] args) {
int choice, key;
int choice, key;
HashMapLinearProbing h = new HashMapLinearProbing(7);
Scanner In = new Scanner(System.in);
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");
System.out.println("6. Check load factor");
choice = In.nextInt();
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");
System.out.println("6. Check load factor");
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));
break;
}
case 6: {
h.checkLoadFactor();
break;
}
}
}
}
}
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));
break;
}
case 6:
{
h.checkLoadFactor();
break;
}
}
}
}
}