HashTable.java

/*
 * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
 * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
 */

/*
 * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
 * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
 */
package hospitalmanagementsystem;

/**
 *
 * @author egehanhatipoglu
 */

public class HashTable<K, V> {
    
    // INNER CLASS: HashNode (Like a LinkedList node)
    private class HashNode {
        K key;
        V value;
        HashNode next;
        
        public HashNode(K key, V value) {
            this.key = key;
            this.value = value;
            this.next = null;
        }
    }
    
    private HashNode[] buckets;  // Array of linked lists
    private int capacity;        // Size of array
    private int size;           // Number of elements
    
    // Constructor: Calculates the table capacity using the Student ID.
    // This ensures that the internal size of the data structure is unique 
    // to this specific project submission, preventing identical memory footprints.
    @SuppressWarnings("unchecked")
    
    public HashTable(int studentId) {
        this.capacity = (studentId % 100) + 50;
        this.buckets = (HashNode[]) new HashTable.HashNode[capacity];
        this.size = 0;
    }
    
    // Hash Function: Converts a generic key into a valid array index.
    // It uses the modulo operator (%) to ensure the index fits within the 'capacity'.
    // Includes a check to convert negative hash codes to positive integers.
    private int hash(K key) {
        int hashCode = key.hashCode();
        int index = hashCode % capacity;
        
        if (index < 0) {
            index = index * -1;
        }
        
        return index;
    }
    
   
    // PUT: Inserts or updates a key-value pair.
    // Implements 'Chaining' for collision resolution: if the calculated bucket index
    // is already occupied, the new node is added to the front (head) of the linked list.
    public void put(K key, V value) {
        int index = hash(key);
        
        HashNode head = buckets[index];
        
        // 1. Update: Check if key exists in the chain and update value
        HashNode current = head;
        while (current != null) {
            if (current.key.equals(key)) {
                current.value = value;
                return;
            }
            current = current.next;
        }
        
        // 2. Insert: Key not found, add new node to the head of the bucket
        HashNode newNode = new HashNode(key, value);
        newNode.next = head; 
        buckets[index] = newNode;
        size++;
    }
    
  
    // GET: Retrieves a value based on its key in O(1) average time.
    // It computes the hash index and traverses the linked list at that bucket
    // to find the matching key.
    
    public V get(K key) {
        int index = hash(key);
        
        HashNode current = buckets[index];
        while (current != null) {
            if (current.key.equals(key)) {
                return current.value; 
            }
            current = current.next;
        }
        
        return null;  // Key not found
    }
    
    
    // REMOVE: Deletes a key-value pair from the table.
    // Handles pointer manipulation to safely remove a node from the linked list chain,
    // whether it is the head node or a node in the middle/end.
    public V remove(K key) {
        int index = hash(key);
        
        HashNode current = buckets[index];
        HashNode prev = null;
        
        while (current != null) {
            
            if (current.key.equals(key)) {
                // Found the node to remove
                if (prev == null) {
                    // Case 1: Removing the first node in the bucket
                    buckets[index] = current.next;
                } else {
                    // Case 2: Removing a node from the middle or end
                    prev.next = current.next;
                }
                
                size--;
                return current.value;
            }
            
            prev = current;
            current = current.next;
        }
        
        return null; 
    }
    
    // ... (Remaining methods: containsKey, size, isEmpty, values, display)
    // These are standard utility methods and do not require complex documentation.
    
    public boolean containsKey( K key) {
        return get(key) != null;
    }
    
    public int size() {
        return size;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public java.util.ArrayList<V> values() {
        java.util.ArrayList<V> result = new java.util.ArrayList<>();
        for (int i = 0; i < capacity; i++) {
            HashNode current = buckets[i];
            while (current != null) {
                result.add(current.value);
                current = current.next;
            }
        }
        return result;
    }

    public void display() {
        
        System.out.println("\n=== Hash Table ===");
        System.out.println("Size: " + size + ", Capacity: " + capacity);
        int usedBuckets = 0;
        
        for (int i = 0; i < capacity; i++) {
            
            if (buckets[i] != null) {
                
                usedBuckets++;
                System.out.print("Bucket " + i + ": ");
                
                HashNode current = buckets[i];
                
                while (current != null) {
                    System.out.print("[" + current.key + "=" + current.value + "] -> ");
                    current = current.next;
                }
                System.out.println("null");
            }
        }
        System.out.println("Used Buckets: " + usedBuckets + "/" + capacity);
    }
}