Course Capstone Project

// The standard data container
class User {
    String userId;
    String name;
    int age;

    public User(String id, String n, int a) {
        this.userId = id; this.name = n; this.age = a;
    }
}

import java.util.*;

public class CoreDatabaseEngine {
    // 1. The O(1) Hash Map for Instant Lookup by ID
    private HashMap<String, User> userLookup;
    
    // 2. The O(log n) BST for Sorted Data by Age
    // Maps Age -> List of Users (because multiple users can have the same age!)
    private TreeMap<Integer, List<User>> ageIndex;
    
    // 3. The Stack for LIFO Undo Operations
    private Stack<User> deletionHistory;

    public CoreDatabaseEngine() {
        userLookup = new HashMap<>();
        ageIndex = new TreeMap<>();
        deletionHistory = new Stack<>();
    }
    
    // ... Methods will be added here ...
}

    public void insertUser(String id, String name, int age) {
        User newUser = new User(id, name, age);
        
        // 1. Inject into the Hash Map O(1)
        userLookup.put(id, newUser);
        
        // 2. Inject into the BST Index O(log n)
        // If the age bracket doesn't exist, create a new list branch
        if (!ageIndex.containsKey(age)) {
            ageIndex.put(age, new ArrayList<>());
        }
        ageIndex.get(age).add(newUser);
        
        System.out.println("Inserted: " + name);
    }

    // Fast O(1) Search utilizing the Hash Map
    public User findUserById(String id) {
        return userLookup.get(id); 
    }

    // Fast O(log n) Range Query utilizing the Binary Search Tree
    public void printUsersOlderThan(int thresholdAge) {
        System.out.println("Users older than " + thresholdAge + ":");
        
        // The BST natively provides a .tailMap() function to instantly chop 
        // the tree and only traverse the Right subtrees larger than the threshold!
        SortedMap<Integer, List<User>> rightBranches = ageIndex.tailMap(thresholdAge, false);
        
        for (List<User> userList : rightBranches.values()) {
            for (User u : userList) {
                System.out.println(u.name + " (Age: " + u.age + ")");
            }
        }
    }

    public void deleteUser(String id) {
        if (!userLookup.containsKey(id)) return;
        
        // 1. Extract the user from the Hash Map
        User deletedUser = userLookup.remove(id);
        
        // 2. Extract the user from the BST Index
        ageIndex.get(deletedUser.age).remove(deletedUser);
        
        // 3. Push to the Undo Stack O(1)
        deletionHistory.push(deletedUser);
        System.out.println("Deleted: " + deletedUser.name);
    }

    public void undoDelete() {
        if (deletionHistory.isEmpty()) {
            System.out.println("Nothing to Undo!");
            return;
        }
        
        // 1. Pop the LIFO Stack
        User restoredUser = deletionHistory.pop();
        
        // 2. Re-insert the data into the database engines
        insertUser(restoredUser.userId, restoredUser.name, restoredUser.age);
        System.out.println("UNDO SUCCESS: Restored " + restoredUser.name);
    }

public static void main(String[] args) {
    CoreDatabaseEngine db = new CoreDatabaseEngine();
    
    db.insertUser("U101", "Alice", 28);
    db.insertUser("U102", "Bob", 45);
    db.insertUser("U103", "Charlie", 32);
    
    // O(1) Hash Map fetch
    System.out.println("Found: " + db.findUserById("U101").name); 
    
    // O(log n) BST fetch
    db.printUsersOlderThan(30); 
    // Output: Charlie (Age: 32), Bob (Age: 45) -> Perfectly Sorted!
    
    // Test the Stack Undo logic
    db.deleteUser("U103");
    db.undoDelete(); // Restores Charlie!
}