Pseudo Code Generator

Employee Management System Pseudocode

This pseudocode outlines an Employee Management System, detailing employee attributes, utility functions for validation, CRUD operations for record management, and procedures for displaying, searching, and file operations, all structured

Prompt

#include 
#include 
#include 
#include 
#include 

using namespace std;

const int MAX_LENGTH = 100; // Maximum length for char arrays

// Class to represent an employee record
class Employee {
public:
    int empId;
    char empName[MAX_LENGTH];
    char fatherName[MAX_LENGTH];
    char motherName[MAX_LENGTH];
    char rank[MAX_LENGTH];
    char department[MAX_LENGTH];
    char doj[9]; // date of joining in DDMMYYYY format, 8 digits + null terminator
    char houseNo[MAX_LENGTH];
    char streetName[MAX_LENGTH];
    char city[MAX_LENGTH];
    char state[MAX_LENGTH];
    char country[MAX_LENGTH];
    int pin;
    Employee* next;

    Employee(int id, const char* name, const char* father, const char* mother, const char* rnk, const char* dept, const char* date,
             const char* house, const char* street, const char* cty, const char* st, const char* cntry, int p)
        : empId(id), pin(p), next(nullptr) {
        strncpy(empName, name, MAX_LENGTH);
        empName[MAX_LENGTH - 1] = '\0';
        strncpy(fatherName, father, MAX_LENGTH);
        fatherName[MAX_LENGTH - 1] = '\0';
        strncpy(motherName, mother, MAX_LENGTH);
        motherName[MAX_LENGTH - 1] = '\0';
        strncpy(rank, rnk, MAX_LENGTH);
        rank[MAX_LENGTH - 1] = '\0';
        strncpy(department, dept, MAX_LENGTH);
        department[MAX_LENGTH - 1] = '\0';
        strncpy(doj, date, 8);
        doj[8] = '\0';
        strncpy(houseNo, house, MAX_LENGTH);
        houseNo[MAX_LENGTH - 1] = '\0';
        strncpy(streetName, street, MAX_LENGTH);
        streetName[MAX_LENGTH - 1] = '\0';
        strncpy(city, cty, MAX_LENGTH);
        city[MAX_LENGTH - 1] = '\0';
        strncpy(state, st, MAX_LENGTH);
        state[MAX_LENGTH - 1] = '\0';
        strncpy(country, cntry, MAX_LENGTH);
        country[MAX_LENGTH - 1] = '\0';
    }
};

// Function to check if a year is a leap year
bool isLeapYear(int year) {
    return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
}

// Function to check if a date is valid
bool isValidDate(const char* date) {
    if (strlen(date) != 8) {
        cout << "Date should be in DDMMYYYY format." << endl;
        return false; // Date should be in DDMMYYYY format
    }

    for (int i = 0; i < 8; ++i) {
        if (!isdigit(date[i])) {
            cout << "All characters must be digits." << endl;
            return false; // All characters must be digits
        }
    }

    int day = (date[0] - '0') * 10 + (date[1] - '0');
    int month = (date[2] - '0') * 10 + (date[3] - '0');
    int year = (date[4] - '0') * 1000 + (date[5] - '0') * 100 + (date[6] - '0') * 10 + (date[7] - '0');

    if (year < 1950 || year > 2024) {
        cout << "Year must be between 1950 and 2024." << endl;
        return false; // Year must be between 1950 and 2024
    }

    if (month < 1 || month > 12) {
        cout << "Invalid month." << endl;
        return false; // Invalid month
    }

    if (day < 1) {
        cout << "Invalid day." << endl;
        return false; // Invalid day
    }

    // Days in each month
    int daysInMonth[] = {31, isLeapYear(year) ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

    if (day > daysInMonth[month - 1]) {
        cout << "Invalid day for the given month." << endl;
        return false; // Invalid day for the given month
    }

    return true; // Date is valid
}

// Function to check if a string contains only alphabetic characters or spaces
bool isValidName(const char* str) {
    for (int i = 0; i < strlen(str); ++i) {
        if (!isalpha(str[i]) && str[i] != ' ') {
            return false; // Invalid character found
        }
    }
    return true; // All characters are valid
}

// Function to check if empId is valid (exactly 6 digits)
bool isValidEmpId(int empId) {
    return empId >= 100000 && empId <= 999999;
}

// Function to check if pin is valid (contains only numbers)
bool isValidPin(int pin) {
    return pin >= 100000 && pin <= 999999; // Assuming pin should be a 6-digit number
}

// Function to create a new employee record
Employee* createEmployee(int empId, const char* empName, const char* fatherName, const char* motherName, const char* rank,
                         const char* department, const char* doj, const char* houseNo, const char* streetName,
                         const char* city, const char* state, const char* country, int pin) {
    return new Employee(empId, empName, fatherName, motherName, rank, department, doj, houseNo, streetName, city, state, country, pin);
}

// Function to check for duplicate Employee ID
bool isDuplicate(Employee* head, int empId) {
    while (head != nullptr) {
        if (head->empId == empId) {
            return true; // Duplicate found
        }
        head = head->next;
    }
    return false; // No duplicate
}

// Function to insert a record into the database
void insertRecord(Employee*& head, int empId, const char* empName, const char* fatherName, const char* motherName,
                   const char* rank, const char* department, const char* doj, const char* houseNo,
                   const char* streetName, const char* city, const char* state, const char* country, int pin) {
    Employee* newEmp = createEmployee(empId, empName, fatherName, motherName, rank, department, doj, houseNo, streetName, city, state, country, pin);
    if (head == nullptr || head->empId > empId) {
        newEmp->next = head;
        head = newEmp;
    } else {
        Employee* temp = head;
        while (temp->next != nullptr && temp->next->empId < empId) {
            temp = temp->next;
        }
        newEmp->next = temp->next;
        temp->next = newEmp;
    }
    cout << "Record inserted successfully." << endl;
}

// Function to delete a record from the database
void deleteRecord(Employee*& head, int empId) {
    Employee* temp = head;
    Employee* prev = nullptr;
    while (temp != nullptr && temp->empId != empId) {
        prev = temp;
        temp = temp->next;
    }
    if (temp != nullptr) {
        if (prev == nullptr) {
            head = temp->next;
        } else {
            prev->next = temp->next;
        }
        delete temp;
        cout << "Record deleted successfully." << endl;
    } else {
        cout << "Employee ID not found." << endl;
    }
}

// Function to update an employee's details (except Employee ID)
void updateRecord(Employee* head, int empId) {
    Employee* temp = head;
    while (temp != nullptr) {
        if (temp->empId == empId) {
            char empName[MAX_LENGTH];
            char fatherName[MAX_LENGTH];
            char motherName[MAX_LENGTH];
            char rank[MAX_LENGTH];
            char department[MAX_LENGTH];
            char doj[9];
            char houseNo[MAX_LENGTH];
            char streetName[MAX_LENGTH];
            char city[MAX_LENGTH];
            char state[MAX_LENGTH];
            char country[MAX_LENGTH];
            int pin;

            cout << "Enter new employee name (or press enter to keep it unchanged): ";
            cin.ignore();
            cin.getline(empName, MAX_LENGTH);
            if (strlen(empName) > 0) {
                if (isValidName(empName)) {
                    strncpy(temp->empName, empName, MAX_LENGTH);
                    temp->empName[MAX_LENGTH - 1] = '\0';
                } else {
                    cout << "Invalid name. Keeping the old value." << endl;
                }
            }

            cout << "Enter new father's name (or press enter to keep it unchanged): ";
            cin.getline(fatherName, MAX_LENGTH);
            if (strlen(fatherName) > 0) {
                if (isValidName(fatherName)) {
                    strncpy(temp->fatherName, fatherName, MAX_LENGTH);
                    temp->fatherName[MAX_LENGTH - 1] = '\0';
                } else {
                    cout << "Invalid father's name. Keeping the old value." << endl;
                }
            }

            cout << "Enter new mother's name (or press enter to keep it unchanged): ";
            cin.getline(motherName, MAX_LENGTH);
            if (strlen(motherName) > 0) {
                if (isValidName(motherName)) {
                    strncpy(temp->motherName, motherName, MAX_LENGTH);
                    temp->motherName[MAX_LENGTH - 1] = '\0';
                } else {
                    cout << "Invalid mother's name. Keeping the old value." << endl;
                }
            }

            cout << "Enter new rank (or press enter to keep it unchanged): ";
            cin.getline(rank, MAX_LENGTH);
            if (strlen(rank) > 0) {
                if (isValidName(rank)) {
                    strncpy(temp->rank, rank, MAX_LENGTH);
                    temp->rank[MAX_LENGTH - 1] = '\0';
                } else {
                    cout << "Invalid rank. Keeping the old value." << endl;
                }
            }

            cout << "Enter new department (or press enter to keep it unchanged): ";
            cin.getline(department, MAX_LENGTH);
            if (strlen(department) > 0) {
                if (isValidName(department)) {
                    strncpy(temp->department, department, MAX_LENGTH);
                    temp->department[MAX_LENGTH - 1] = '\0';
                } else {
                    cout << "Invalid department. Keeping the old value." << endl;
                }
            }

            cout << "Enter new date of joining (or press enter to keep it unchanged): ";
            cin.getline(doj, 9);
            if (strlen(doj) > 0) {
                if (isValidDate(doj)) {
                    strncpy(temp->doj, doj, 8);
                    temp->doj[8] = '\0';
                } else {
                    cout << "Invalid date. Keeping the old value." << endl;
                }
            }

            cout << "Enter new house number (or press enter to keep it unchanged): ";
            cin.getline(houseNo, MAX_LENGTH);
            if (strlen(houseNo) > 0) {
                strncpy(temp->houseNo, houseNo, MAX_LENGTH);
                temp->houseNo[MAX_LENGTH - 1] = '\0';
            }

            cout << "Enter new street name (or press enter to keep it unchanged): ";
            cin.getline(streetName, MAX_LENGTH);
            if (strlen(streetName) > 0) {
                strncpy(temp->streetName, streetName, MAX_LENGTH);
                temp->streetName[MAX_LENGTH - 1] = '\0';
            }

            cout << "Enter new city (or press enter to keep it unchanged): ";
            cin.getline(city, MAX_LENGTH);
            if (strlen(city) > 0) {
                strncpy(temp->city, city, MAX_LENGTH);
                temp->city[MAX_LENGTH - 1] = '\0';
            }

            cout << "Enter new state (or press enter to keep it unchanged): ";
            cin.getline(state, MAX_LENGTH);
            if (strlen(state) > 0) {
                strncpy(temp->state, state, MAX_LENGTH);
                temp->state[MAX_LENGTH - 1] = '\0';
            }

            cout << "Enter new country (or press enter to keep it unchanged): ";
            cin.getline(country, MAX_LENGTH);
            if (strlen(country) > 0) {
                strncpy(temp->country, country, MAX_LENGTH);
                temp->country[MAX_LENGTH - 1] = '\0';
            }

            cout << "Enter new pin (or press enter to keep it unchanged): ";
            cin >> pin;
            if (pin >= 100000 && pin <= 999999) {
                temp->pin = pin;
            } else {
                cout << "Invalid pin. Keeping the old value." << endl;
            }

            cout << "Record updated successfully." << endl;
            return;
        }
        temp = temp->next;
    }
    cout << "Employee ID not found." << endl;
}

// Function to display all employee records
void displayRecords(Employee* head) {
    if (head == nullptr) {
        cout << "No records found." << endl;
        return;
    }

    Employee* temp = head;
    while (temp != nullptr) {
        cout << "Employee ID: " << temp->empId << endl;
        cout << "Name: " << temp->empName << endl;
        cout << "Father's Name: " << temp->fatherName << endl;
        cout << "Mother's Name: " << temp->motherName << endl;
        cout << "Rank: " << temp->rank << endl;
        cout << "Department: " << temp->department << endl;
        cout << "Date of Joining: " << temp->doj << endl;
        cout << "Address: " << temp->houseNo << ", " << temp->streetName << ", " << temp->city << ", " << temp->state << ", " << temp->country << endl;
        cout << "Pin: " << temp->pin << endl;
        cout << "---------------------------------------------" << endl;
        temp = temp->next;
    }
}

// Function to search for an employee record by Employee ID
void searchRecord(Employee* head, int empId) {
    while (head != nullptr) {
        if (head->empId == empId) {
            cout << "Employee ID: " << head->empId << endl;
            cout << "Name: " << head->empName << endl;
            cout << "Father's Name: " << head->fatherName << endl;
            cout << "Mother's Name: " << head->motherName << endl;
            cout << "Rank: " << head->rank << endl;
            cout << "Department: " << head->department << endl;
            cout << "Date of Joining: " << head->doj << endl;
            cout << "Address: " << head->houseNo << ", " << head->streetName << ", " << head->city << ", " << head->state << ", " << head->country << endl;
            cout << "Pin: " << head->pin << endl;
            return;
        }
        head = head->next;
    }
    cout << "Employee ID not found." << endl;
}

// Function to save the database to a file
void saveToFile(Employee* head, const char* filename) {
    ofstream outFile(filename);
    if (!outFile) {
        cout << "Error opening file for writing." << endl;
        return;
    }

    Employee* temp = head;
    while (temp != nullptr) {
        outFile << temp->empId << ','
                << temp->empName << ','
                << temp->fatherName << ','
                << temp->motherName << ','
                << temp->rank << ','
                << temp->department << ','
                << temp->doj << ','
                << temp->houseNo << ','
                << temp->streetName << ','
                << temp->city << ','
                << temp->state << ','
                << temp->country << ','
                << temp->pin << '\n';
        temp = temp->next;
    }

    outFile.close();
    cout << "Database saved to file successfully." << endl;
}
void readLine(char* str, int maxLength) {
    int i = 0;
    char ch;
    while (cin.get(ch) && ch != '\n' && i < maxLength - 1) {
        str[i++] = ch;
    }
    str[i] = '\0';
}

// Function to load the database from a file
void loadFromFile(Employee*& head, const char* filename) {
    ifstream inFile(filename);
    if (!inFile) {
        cout << "Error opening file for reading." << endl;
        return;
    }

    int empId;
    char empName[MAX_LENGTH];
    char fatherName[MAX_LENGTH];
    char motherName[MAX_LENGTH];
    char rank[MAX_LENGTH];
    char department[MAX_LENGTH];
    char doj[9];
    char houseNo[MAX_LENGTH];
    char streetName[MAX_LENGTH];
    char city[MAX_LENGTH];
    char state[MAX_LENGTH];
    char country[MAX_LENGTH];
    int pin;

    while (inFile >> empId) {
        inFile.ignore(1); // Ignore comma
        inFile.getline(empName, MAX_LENGTH, ',');
        inFile.getline(fatherName, MAX_LENGTH, ',');
        inFile.getline(motherName, MAX_LENGTH, ',');
        inFile.getline(rank, MAX_LENGTH, ',');
        inFile.getline(department, MAX_LENGTH, ',');
        inFile.getline(doj, 9, ',');
        inFile.getline(houseNo, MAX_LENGTH, ',');
        inFile.getline(streetName, MAX_LENGTH, ',');
        inFile.getline(city, MAX_LENGTH, ',');
        inFile.getline(state, MAX_LENGTH, ',');
        inFile.getline(country, MAX_LENGTH, ',');
        inFile >> pin;
        inFile.ignore(1); // Ignore newline

        insertRecord(head, empId, empName, fatherName, motherName, rank, department, doj, houseNo, streetName, city, state, country, pin);
    }

    inFile.close();
    cout << "Database loaded from file successfully." << endl;
}

int main() {
    Employee* head = nullptr;

    int choice;
    do {
        cout << "Employee Database Management System" << endl;
        cout << "1. Add Record" << endl;
        cout << "2. Delete Record" << endl;
        cout << "3. Update Record" << endl;
        cout << "4. Search Record" << endl;
        cout << "5. Display All Records" << endl;
        cout << "6. Save Database to File" << endl;
        cout << "7. Load Database from File" << endl;
        cout << "8. Exit" << endl;
        cout<<"---------------------------------------------------"<> choice;

        int empId;
        char empName[MAX_LENGTH];
        char fatherName[MAX_LENGTH];
        char motherName[MAX_LENGTH];
        char rank[MAX_LENGTH];
        char department[MAX_LENGTH];
        char doj[9];
        char houseNo[MAX_LENGTH];
        char streetName[MAX_LENGTH];
        char city[MAX_LENGTH];
        char state[MAX_LENGTH];
        char country[MAX_LENGTH];
        int pin;

        switch (choice) {
            case 1:
               {
                cout << "Enter Employee ID (6 digits): ";
                cin >> empId;
                while (!isValidEmpId(empId)) {
                 cout << "Employee ID should be a 6-digit number." << endl;
             	cout << "Enter Employee ID (6 digits): ";
                cin>>empId;}
         	
             	if(isDuplicate(head, empId)) {
                cout << "Employee ID " << empId << " already exists. Cannot insert duplicate record."<> pin;
                while (!isValidPin(pin)) {
                cout << "Pin should be a 6-digit number." << endl;
                cout << "Enter Pin (6 digits): ";
                cin >> pin;
        
    }
                insertRecord(head, empId, empName, fatherName, motherName, rank, department, doj, houseNo, streetName, city, state, country, pin);
                break;
            }
            case 2:
                cout << "Enter Employee ID to delete: ";
                cin >> empId;
                deleteRecord(head, empId);
                break;
            case 3:
                cout << "Enter Employee ID to update: ";
                cin >> empId;
                updateRecord(head, empId);
                break;
            case 4:
                cout << "Enter Employee ID to search: ";
                cin >> empId;
                searchRecord(head, empId);
                break;
            case 5:
                displayRecords(head);
                break;
            case 6:
                saveToFile(head, "database");
                break;
            case 7:
                loadFromFile(head, "database");
                break;
            case 8:
                cout << "Exiting the program." << endl;
                break;
            default:
                cout << "Invalid choice. Please try again." << endl;
                break;
        }
    } while (choice != 8);

   // Clean up dynamically allocated memory
    while (head != nullptr) {
        Employee* temp = head;
        head = head->next;
        delete temp;
    }

    return 0;
} give algorithm in form of pseudo code

Answer

Pseudocode for Employee Management System

The pseudocode below translates the provided C++ code into human-readable pseudocode that adheres to common programming conventions and structures.

Constants and Class Definition

CONSTANT MAX_LENGTH = 100

CLASS Employee:
    ATTRIBUTES:
        INTEGER empId
        CHAR ARRAY empName[MAX_LENGTH]
        CHAR ARRAY fatherName[MAX_LENGTH]
        CHAR ARRAY motherName[MAX_LENGTH]
        CHAR ARRAY rank[MAX_LENGTH]
        CHAR ARRAY department[MAX_LENGTH]
        CHAR ARRAY doj[9]
        CHAR ARRAY houseNo[MAX_LENGTH]
        CHAR ARRAY streetName[MAX_LENGTH]
        CHAR ARRAY city[MAX_LENGTH]
        CHAR ARRAY state[MAX_LENGTH]
        CHAR ARRAY country[MAX_LENGTH]
        INTEGER pin
        POINTER to Employee next

    FUNCTION Constructor:
        INPUT: INTEGER id, CHAR ARRAY name, CHAR ARRAY father, CHAR ARRAY mother, CHAR ARRAY rnk, CHAR ARRAY dept, CHAR ARRAY date,
               CHAR ARRAY house, CHAR ARRAY street, CHAR ARRAY cty, CHAR ARRAY st, CHAR ARRAY cntry, INTEGER p
        SET empId = id
        SET empName to name with length MAX_LENGTH
        SET fatherName to father with length MAX_LENGTH
        SET motherName to mother with length MAX_LENGTH
        SET rank to rnk with length MAX_LENGTH
        SET department to dept with length MAX_LENGTH
        SET doj to date with length 8
        SET houseNo to house with length MAX_LENGTH
        SET streetName to street with length MAX_LENGTH
        SET city to cty with length MAX_LENGTH
        SET state to st with length MAX_LENGTH
        SET country to cntry with length MAX_LENGTH
        SET pin = p
        SET next = NULL

Utility Functions

FUNCTION isLeapYear:
    INPUT: INTEGER year
    RETURN TRUE if year is divisible by 4 and not 100 OR divisible by 400
    ELSE RETURN FALSE

FUNCTION isValidDate:
    INPUT: CHAR ARRAY date
    VERIFY date length is 8
    VERIFY date characters are all digits
    PARSE date into INTEGER day, month, year
    VERIFY year is between 1950 and 2024
    VERIFY month is between 1 and 12
    VERIFY day is valid for the given month considering leap years
    RETURN TRUE if all conditions are met
    ELSE RETURN FALSE

FUNCTION isValidName:
    INPUT: CHAR ARRAY str
    RETURN TRUE if all characters in str are alphabets or spaces
    ELSE RETURN FALSE

FUNCTION isValidEmpId:
    INPUT: INTEGER empId
    RETURN TRUE if empId is a 6-digit number

FUNCTION isValidPin:
    INPUT: INTEGER pin
    RETURN TRUE if pin is a 6-digit number

FUNCTION createEmployee:
    INPUT: INTEGER empId, CHAR ARRAY empName, CHAR ARRAY fatherName, CHAR ARRAY motherName, CHAR ARRAY rank,
           CHAR ARRAY department, CHAR ARRAY doj, CHAR ARRAY houseNo, CHAR ARRAY streetName, CHAR ARRAY city,
           CHAR ARRAY state, CHAR ARRAY country, INTEGER pin
    RETURN NEW Employee initialized with inputs

FUNCTION isDuplicate:
    INPUT: POINTER head, INTEGER empId
    WHILE head is not NULL
        IF head->empId equals empId
            RETURN TRUE
        MOVE head to head->next
    RETURN FALSE

CRUD Operations

FUNCTION insertRecord:
    INPUT: POINTER & head, INTEGER empId, CHAR ARRAY empName, CHAR ARRAY fatherName, CHAR ARRAY motherName,
           CHAR ARRAY rank, CHAR ARRAY department, CHAR ARRAY doj, CHAR ARRAY houseNo, CHAR ARRAY streetName,
           CHAR ARRAY city, CHAR ARRAY state, CHAR ARRAY country, INTEGER pin
    SET newEmp = createEmployee with inputs
    IF head is NULL OR head->empId > empId
        SET newEmp->next = head
        SET head = newEmp
    ELSE
        INITIALIZE temp = head
        WHILE temp->next is not NULL AND temp->next->empId < empId
            MOVE temp to temp->next
        SET newEmp->next = temp->next
        SET temp->next = newEmp
    OUTPUT "Record inserted successfully."

FUNCTION deleteRecord:
    INPUT: POINTER & head, INTEGER empId
    INITIALIZE temp = head
    INITIALIZE prev = NULL
    WHILE temp is not NULL AND temp->empId not equals empId
        SET prev = temp
        MOVE temp to temp->next
    IF temp is not NULL
        IF prev is NULL
            SET head = temp->next
        ELSE
            SET prev->next = temp->next
        DELETE temp
        OUTPUT "Record deleted successfully."
    ELSE
        OUTPUT "Employee ID not found."

FUNCTION updateRecord:
    INPUT: POINTER head, INTEGER empId
    INITIALIZE temp = head
    WHILE temp is not NULL
        IF temp->empId equals empId
            PROMPT user and UPDATE temp's attributes with validation
            OUTPUT "Record updated successfully."
            RETURN
        MOVE temp to temp->next
    OUTPUT "Employee ID not found."

Display, Search, and File Operations

FUNCTION displayRecords:
    INPUT: POINTER head
    IF head is NULL
        OUTPUT "No records found."
    ELSE
        INITIALIZE temp = head
        WHILE temp is not NULL
            OUTPUT temp's attributes
            MOVE temp to temp->next

FUNCTION searchRecord:
    INPUT: POINTER head, INTEGER empId
    WHILE head is not NULL
        IF head->empId equals empId
            OUTPUT head’s attributes
            RETURN
        MOVE head to head->next
    OUTPUT "Employee ID not found."

FUNCTION saveToFile:
    INPUT: POINTER head, CHAR ARRAY filename
    OPEN file for writing
    IF file not opened successfully
        OUTPUT "Error opening file for writing."
        RETURN
    INITIALIZE temp = head
    WHILE temp is not NULL
        WRITE temp's attributes to file
        MOVE temp to temp->next
    CLOSE file
    OUTPUT "Database saved to file successfully."

FUNCTION loadFromFile:
    INPUT: POINTER & head, CHAR ARRAY filename
    OPEN file for reading
    IF file not opened successfully
        OUTPUT "Error opening file for reading."
        RETURN
    INITIALIZE empId, empName[MAX_LENGTH], fatherName[MAX_LENGTH], motherName[MAX_LENGTH], rank[MAX_LENGTH], department[MAX_LENGTH], 
               doj[9], houseNo[MAX_LENGTH], streetName[MAX_LENGTH], city[MAX_LENGTH], state[MAX_LENGTH], country[MAX_LENGTH], pin
    WHILE reading from file
        READ empId and other attributes
        insertRecord with read attributes
    CLOSE file
    OUTPUT "Database loaded from file successfully."

Main Program

START:
    INITIALIZE Employee pointer head to NULL
    LOOP until choice is 8
        DISPLAY menu
        READ choice
        SWITCH on choice:
            CASE 1:
                PROMPT for Employee attributes
                INSERT record after validation
            CASE 2:
                PROMPT for Employee ID
                DELETE record
            CASE 3:
                PROMPT for Employee ID
                UPDATE record
            CASE 4:
                PROMPT for Employee ID
                SEARCH record
            CASE 5:
                DISPLAY all records
            CASE 6:
                SAVE to file
            CASE 7:
                LOAD from file
            CASE 8:
                OUTPUT "Exiting the program."
            DEFAULT:
                OUTPUT "Invalid choice."
    CLEAN UP dynamically allocated memory by deleting all nodes in linked list
END