Appendix B · Full source code.

public class Registration {    private String studentID;    private String courseID;    private int academicLevel; // Field to store class/group    private int regTime; // Field to store time    private double studDemandScore;     // Constructor to initialize fields    public Registration(String studentID, String courseID, int academicLevel, int regTime, double studDemandScore) {        this.studentID = studentID;        this.courseID = courseID;        this.academicLevel = academicLevel;        this.regTime = regTime;        this.studDemandScore = 0;// temporary value prior to processing demand score (score hasn't been recorded                                 // yet)    }     // Getters and setters for all fields    public String getStudentID() {        return studentID;    }     public void setStudentID(String studentID) {        this.studentID = studentID;    }     public String getCourseID() {        return courseID;    }     public void setCourseID(String courseID) {        this.courseID = courseID;    }     public int getAcademicLevel() {        return academicLevel;    }     public void setAcademicLevel(int academicLevel) {        this.academicLevel = academicLevel;    }     public int getRegTime() {        return regTime;    }     public void setRegTime(int regTime) {        this.regTime = regTime;    }     public double getStudDemandScore() {        return studDemandScore;    }     public void setStudDemandScore(double studDemandScore) {        this.studDemandScore = studDemandScore;    }     // toString() method to format output line    @Override    public String toString() {        return studentID + ";" + courseID + ";" + academicLevel + ";" + regTime + ";" + Math.round(studDemandScore)                + ";";    }// Math.round function used to round the demand score to the nearest whole     // number}

public class LinkedList {// Task: Field to store head node    Node head;// Task: Field to store size of list    int size;// Task: (Optional) Field to store tail node for faster inserts    Node tail; // Task: Method to insert node at head    public void insertNodeAtHead(Registration data) {         Node newNode = new Node(data);         if (head == null) {            head = newNode;            tail = newNode;            size++;             return;        }         newNode.next = head;        head = newNode;        size++;     }// Task: Method to insert node at tail     public void insertNodeAtTail(Registration data) {         Node newNode = new Node(data);        //Case 1: handle special case (if node is empty)        if (head == null) {             head = newNode;            tail = newNode;            size++;            return;        }         tail.next = newNode;        tail = newNode;        size++;     }// Task: Method to delete node by value public void deleteNodeByValue(Registration data) {         //Case 1: empty list         if (head == null) {            return;        }         //Case 2: if head node is to be deleted         if (head.studData.equals(data)) {            head = head.next;            size--;            return;        }         //Case 3: if any other node is to be deleted         Node prev = head;        Node curr = head.next;                while (curr != null) {            if (curr.studData.equals(data)) {                prev.next = curr.next;                size--;                return;            }            prev = curr;            curr = curr.next;        }     } // Task: Method to search for a node    public boolean searchKey(Registration data) {         Node temp = head;        while (temp.next != null) {            if (temp.studData.equals(data)) {                return true;            }              temp = temp.next;        }         return false;    }// Task: Method to display/traverse all nodes     public void displayLinkedList() {         Node temp = head;        while (temp != null) {            System.out.println(temp.studData);            temp = temp.next;        }    }// Task: Method to convert list to array (Registration[])     public Registration[] convToArray() {         //count number of nodes         int size = 0;        Node temp = head;        while (temp != null) {            size++;            temp = temp.next;        }         //create an array of that size         Registration[] dataArray = new Registration[size];         //traverse through node to store into array         temp = head;        int index = 0;        while (temp != null) {            dataArray[index++] = temp.studData;            temp = temp.next;        }         return dataArray;     }}

import java.io.*; public class FileService {     // Method to read registrations from Input.txt into LinkedList    public static LinkedList readRegistrationsFromFile(String filename) {        return InputValidator.readAndValidateFile(filename);    }     // Method to write array of registrations to Output.txt    public static void writeRegistrationsToFile(Registration[] array, String filename) {         try {            BufferedWriter writer = new BufferedWriter(new FileWriter(filename));             for (Registration reg : array) {                if (reg != null) {// Checks for null entries to avoid file writing loop from crashing with                                  // NullPointerException                    writer.write(reg.toString());                    writer.newLine();                }            }            writer.close();            System.out.println("Registrations successfully written to " + filename);        } catch (IOException e) {            System.out.println("An error occurred while writing to the file: " + e.getMessage());        }    }}

import java.io.*;import java.util.*; public class InputValidator {     private static Set<String> validCourses = new HashSet<>(); // Empty list to store valid course codes extracted from                                                               // text file     // Method to validate file path exists and is readable.    public static boolean isValidFilePath(String filePath) {        File file = new File(filePath);        return file.exists() && file.canRead();    }     // Method to read and validate input file.    public static LinkedList readAndValidateFile(String input) {        LinkedList registrations = new LinkedList(); // Create instance of Layan's list (LinkedList class).         // Check if file exists and is readable to avoid FileNotFoundException.        if (!isValidFilePath(input)) {            System.out.println(                    "ERROR: File '" + input + "' not found or not readable. Please check that the file exists.");            return registrations; // Stop the entire method        }        // If file is found, proceed to the BufferedReader section to actually read the        // file.        try (BufferedReader list = new BufferedReader(new FileReader(input))) { // BufferedReader to read the input file                                                                                // more efficiently. It reads larger                                                                                // chunks of data at a time, reducing                                                                                // the number of I/O operations.            String line;            while ((line = list.readLine()) != null) { // readLine is like nextLine but for BufferedReader.                String[] parts = line.split(";"); // Split line into parts based on semicolon.                if (parts.length != 4) { // We are expecting exactly 4 fields per line.                    System.out.println("Invalid entry (wrong number of fields): " + line);                    continue; // Skip invalid entry                }                // Example line: 2021555;CS222;2;10;                String studentID = parts[0];                String courseID = parts[1];                 // We need to parse integers to convert from String.                try {                    int academicLevel = Integer.parseInt(parts[2]);                    int studyTime = Integer.parseInt(parts[3]);                     // Validate non-empty string (for names, course titles)                    if (studentID.isEmpty() || courseID.isEmpty()) {                        System.out.println("Invalid string field in entry: " + line);                        continue; // Skip invalid entry                    }                    // Validate studentId.                    if (studentID.length() != 7 && studentID.length() != 5 ) { // Assuming student ID should be exactly 7 or 5 characters.                        System.out.println("Invalid student ID in entry: " + line);                        continue; // Skip invalid entry                    }                    // Validate credits/section as positive integers within range.                    if (academicLevel < 1 || academicLevel > 5) { // Student class should be 1-5.                        System.out.println("Invalid academic level in entry: " + line);                        continue; // Skip invalid entry                    }                     if (studyTime < 0 || studyTime > 23) { // Assuming time is in 24-hour format                        System.out.println("Invalid study time in entry: " + line);                        continue; // Skip invalid entry                    }                     // If all validations pass, add courseID to validCourses Hashset. (Previously it                    // was empty).                    validCourses.add(courseID);                     // Create Registration object and add to linked list.                    Registration reg = new Registration(studentID, courseID, academicLevel, studyTime, 0);                    registrations.insertNodeAtTail(reg);                    System.out.println("VALID: " + line);                } catch (NumberFormatException e) {                    System.out.println("Invalid number format in entry: " + line);                    continue; // Skip invalid entry.                }            }        } catch (IOException e) {            System.out.println("Error reading file: " + e.getMessage());        }        return registrations;    }}

public class DemandScorer {    public static void computeDemandScore(Registration reg) {        double score = 50; // Base score         score = applyStudentClassMultiplier(score, reg.getAcademicLevel());        score = applyTimePreferenceMultiplier(score, reg.getRegTime());        score = applyCoursePriority(score, reg.getCourseID());         score = Math.round(score); // Round to nearest whole number.        score = Math.max(0, Math.min(100, score)); // Stop between 0-100.         reg.setStudDemandScore(score); // Save the final score to the Registration object.    }     private static double applyStudentClassMultiplier(double score, int studentClass) {         if (studentClass == 1) {            score = score * 0.75; // Freshman bonus        } else if (studentClass == 2) {            score = score * 0.90; // Sophomore bonus        } else if (studentClass == 3) {            score = score * 1.10; // Junior bonus        } else if (studentClass == 4) {            score = score * 1.25; // Senior bonus        } else if (studentClass == 5) {            score = score * 1.5; // Graduate bonus        }        return score;    }     public static double applyTimePreferenceMultiplier(double score, int time) {        if (time >= 6 && time < 8) {            score += 5;        } else if (time >= 8 && time < 10) {            score += 10; // 8:00 - 10:00: +10        } else if (time >= 10 && time < 12) {            score += 5; // 10:00 - 12:00: +5        } else if (time >= 12 && time < 14) {            score += 0; // 12:00 - 14:00: No change.        } else if (time >= 14 && time < 16) {            score -= 5; // 14:00 - 16:00: -5        } else if (time >= 16 && time < 20) {            score -= 10; // 16:00 - 20:00: -10        } else {            score -= 15; // After 20:00: -15 (also covers 0-6 AM).        }        return score;    }     private static double applyCoursePriority(double score, String courseID) {        // Get the last character of the course code.        char lastChar = courseID.charAt(courseID.length() - 1);         // Check if it's a digit and whether it's odd/even.        if (Character.isDigit(lastChar)) {            int lastDigit = Integer.parseInt(String.valueOf(lastChar)); // Convert char to int            if (lastDigit % 2 == 1) { // Odd number.                score += 20;            } else { // Even number.                score -= 10;            }        }        return score;    }}

public class MergeSort implements Sorter {     @Override    public void sort(Registration[] array) {        if (array.length < 2) {            return; // Base case: arrays of size 0 or 1 are already sorted        }         // Split the array into two halves.        int mid = array.length / 2;        Registration[] left = new Registration[mid];        Registration[] right = new Registration[array.length - mid];         // Copy first half of original array into left array.        for (int i = 0; i < mid; i++) {            left[i] = array[i]; // Copy elements from start to mid-1.        }         // Copy second half of original array into right array.        for (int i = mid; i < array.length; i++) {            right[i - mid] = array[i]; // Copy elements from mid to end.            // i-mid converts the index (ex. if mid = 2, i = 2 becomes right[0]).        }         // Recursively sort both halves.        sort(left);        sort(right);         // Merge the sorted halves back together.        merge(array, left, right);    }     private void merge(Registration[] result, Registration[] left, Registration[] right) {        // Three pointers:        int i = 0; // Tracks position in left array        int j = 0; // Tracks position in right array        int k = 0; // Tracks position in result array         // Compare elements from left and right arrays, take the larger one (descending        // order).        while (i < left.length && j < right.length) {            if (left[i].getStudDemandScore() >= right[j].getStudDemandScore()) {                result[k++] = left[i++];            } else {                result[k++] = right[j++];            }        }        // Copy any remaining elements from left array.        while (i < left.length) {            result[k++] = left[i++];        }        // Copy any remaining elements from right array.        while (j < right.length) {            result[k++] = right[j++];        }    }     @Override    public String name() {        return "Merge Sort";    }}

public class QuickSort implements Sorter {     @Override    public void sort(Registration[] array) {        quickSort(array, 0, array.length - 1);    }     private void quickSort(Registration[] array, int low, int high) {        if (low < high) {            // Partition the array and get the pivot index.            int pivotIndex = partition(array, low, high);             // Recursively sort elements before and after pivot.            quickSort(array, low, pivotIndex - 1);            quickSort(array, pivotIndex + 1, high);        }    }     private int partition(Registration[] array, int low, int high) {        // Choose the rightmost element as pivot.        double pivot = array[high].getStudDemandScore();        int i = low - 1; // Index of smaller element.         for (int j = low; j < high; j++) {            // If current element is greater than or equal to pivot (descending order).            if (array[j].getStudDemandScore() >= pivot) {                i++;                // Swap array[i] and array[j]                Registration temp = array[i];                array[i] = array[j];                array[j] = temp;            }        }         // Swap array[i+1] and array[high] (put pivot in correct position).        Registration temp = array[i + 1];        array[i + 1] = array[high];        array[high] = temp;         return i + 1;    }     @Override    public String name() {        return "Quick Sort";    }}

import java.util.Comparator; public final class Comparators {    // Private constructor to prevent instantiation (utility class)     private Comparators() {    }     // Comparator to sort Registration by studentId (ascending)    public static final Comparator<Registration> by_ID = new Comparator<Registration>() {        @Override        public int compare(Registration r1, Registration r2) {            return r1.getStudentID().compareTo(r2.getStudentID());        }    };     // Comparator to sort Registration by courseCode (A–Z)    public static final Comparator<Registration> by_CourseCode = new Comparator<Registration>() {        @Override        public int compare(Registration r1, Registration r2) {            return r1.getCourseID().compareTo(r2.getCourseID());        }    };    // Comparator to sort Registration by academicLevel (ascending)    public static final Comparator<Registration> by_Level = new Comparator<Registration>() {        @Override        public int compare(Registration r1, Registration r2) {            return Integer.compare(r1.getAcademicLevel(), r2.getAcademicLevel());        }    };     // Comparator to sort Registration by regTime (ascending)    public static final Comparator<Registration> by_RegTime = new Comparator<Registration>() {        @Override        public int compare(Registration r1, Registration r2) {            return Integer.compare(r1.getRegTime(), r2.getRegTime());        }    };     // Static helper to get comparator by user choice (e.g., "id", "name",    // "course")    public static Comparator<Registration> getComparator(String criterion) {        switch (criterion.toLowerCase()) { // Case insensitive matching            case "id":                return by_ID;            case "course":                return by_CourseCode;            case "level":                return by_Level;            case "time":                return by_RegTime;            default:                throw new IllegalArgumentException("Unknown sorting criterion: " + criterion);        }    }}

public class Benchmarker {    // Helper method to make a copy of the array    private static Registration[] makeCopy(Registration[] original) {        Registration[] copy = new Registration[original.length]; // Create new empty array        for (int i = 0; i < original.length; i++) { // Loop through each element            copy[i] = original[i]; // Copy each element        }        return copy; // Return the copy    }     // Runs all 4 sorting algorithms and times them.    public static void runAllSorts(Registration[] originalArray) {        System.out.println("--- RUNNING ALL SORTS ---");         Timer timer = new Timer();         // 1. SELECTION SORT        Registration[] copy1 = makeCopy(originalArray); // Make fresh copy.        timer.start(); // Start timer.        new SelectionSort().sort(copy1); // Do the sorting + create an object.        timer.stop(); // Stop timer        // File writing moved OUTSIDE timed section to measure only sorting time        FileService.writeRegistrationsToFile(copy1, "Sorted_Output_SS.txt"); // Save result.        System.out.println("Selection Sort: " + timer.getElapsedTimeMillis() + " ms");         // 2. INSERTION SORT        Registration[] copy2 = makeCopy(originalArray); // Fresh copy again.        timer.start();        new InsertionSort().sort(copy2); // Do the sorting + create an object.        timer.stop();        // File writing moved OUTSIDE timed section to measure only sorting time        FileService.writeRegistrationsToFile(copy2, "Sorted_Output_IS.txt"); // Save result.        System.out.println("Insertion Sort: " + timer.getElapsedTimeMillis() + " ms");         // 3. MERGE SORT        Registration[] copy3 = makeCopy(originalArray); // Fresh copy again.        timer.start();        new MergeSort().sort(copy3); // Do the sorting.        timer.stop();        // File writing moved OUTSIDE timed section to measure only sorting time        FileService.writeRegistrationsToFile(copy3, "Sorted_Output_MS.txt"); // Save result.        System.out.println("Merge Sort: " + timer.getElapsedTimeMillis() + " ms");         // 4. QUICK SORT        Registration[] copy4 = makeCopy(originalArray); // Fresh copy again.        timer.start();        new QuickSort().sort(copy4); // Do the sorting + create an object.        timer.stop();        // File writing moved OUTSIDE timed section to measure only sorting time        FileService.writeRegistrationsToFile(copy4, "Sorted_Output_QS.txt"); // Save result.        System.out.println("Quick Sort: " + timer.getElapsedTimeMillis() + " ms");    }}

import java.util.Arrays; public class Main {    public static void main(String[] args) {        Timer timer = new Timer();         // Time reading operation        System.out.println("Starting file reading...");        timer.start();        LinkedList registrations = InputValidator.readAndValidateFile("Input.txt");        timer.stop(); // This timer times the file reading only        System.out.println();        System.out.println("File reading completed in: " + timer.getElapsedTimeMillis() + " ms");        System.out.println("Successfully read " + registrations.size + " registrations.");        System.out.println();         // Time processing operation        System.out.println("Starting demand score calculations...");        timer.start();        calculateAllDemandScores(registrations);        timer.stop(); // This timer times the demand score calculations only        System.out.println("Demand score calculations completed in: " + timer.getElapsedTimeMillis() + " ms");        System.out.println();         // Convert linked list to array        Registration[] array = registrations.convToArray();         // Time writing operation        System.out.println("Writing unsorted data to file...");        timer.start();        FileService.writeRegistrationsToFile(array, "Output.txt");        timer.stop(); // This timer times the file writing only        System.out.println("File writing completed in: " + timer.getElapsedTimeMillis() + " ms");        System.out.println("Saved unsorted data to Output.txt");        System.out.println();         // Run and time all sorting algorithms        System.out.println("Starting sorting algorithms...");        Benchmarker.runAllSorts(array);        System.out.println("All sorting completed and results saved.");        System.out.println();         // Additional sorting using comparators (Not required but useful)        System.out.println("\n--- ADDITIONAL COMPARATOR SORTING ---");         // Sort by Student ID        Registration[] idSorted = registrations.convToArray();        Arrays.sort(idSorted, Comparators.by_ID);        FileService.writeRegistrationsToFile(idSorted, "Sorted_By_ID.txt");        System.out.println("Saved student ID sorted data to Sorted_By_ID.txt");         // Sort by Course Code        Registration[] courseSorted = registrations.convToArray();        Arrays.sort(courseSorted, Comparators.by_CourseCode);        FileService.writeRegistrationsToFile(courseSorted, "Sorted_By_Course.txt");        System.out.println("Saved course code sorted data to Sorted_By_Course.txt");         // Sort by Academic Level        Registration[] levelSorted = registrations.convToArray();        Arrays.sort(levelSorted, Comparators.by_Level);        FileService.writeRegistrationsToFile(levelSorted, "Sorted_By_Level.txt");        System.out.println("Saved academic level sorted data to Sorted_By_Level.txt");         // Sort by Registration Time        Registration[] timeSorted = registrations.convToArray();        Arrays.sort(timeSorted, Comparators.by_RegTime);        FileService.writeRegistrationsToFile(timeSorted, "Sorted_By_Time.txt");        System.out.println("Saved registration time sorted data to Sorted_By_Time.txt");    }     // Calculate scores for all registrations    public static void calculateAllDemandScores(LinkedList registrations) {        Node current = registrations.head;        while (current != null) {            DemandScorer.computeDemandScore(current.studData);            current = current.next;        }    }}