From d9e90f6501726fd8f4ac69abd05f1d394e1b3375 Mon Sep 17 00:00:00 2001
From: cdez <cde@cdezselfhosted.pw>
Date: Wed, 8 Nov 2023 17:15:25 -0700
Subject: [PATCH] "Finish" PA09 +- GeneralUtility.c +- HeapUtility.c +-
 StudentUtility.c +- PA09_Main

---
 PA09-1108/GeneralUtility.c | 206 ++++++++++++++++++++
 PA09-1108/HeapUtility.c    | 390 +++++++++++++++++++++++++++++++++++++
 PA09-1108/PA09_Main        | Bin 0 -> 37176 bytes
 PA09-1108/StudentUtility.c |  67 +++++++
 4 files changed, 663 insertions(+)
 create mode 100644 PA09-1108/GeneralUtility.c
 create mode 100644 PA09-1108/HeapUtility.c
 create mode 100755 PA09-1108/PA09_Main
 create mode 100644 PA09-1108/StudentUtility.c

diff --git a/PA09-1108/GeneralUtility.c b/PA09-1108/GeneralUtility.c
new file mode 100644
index 0000000..2b30327
--- /dev/null
+++ b/PA09-1108/GeneralUtility.c
@@ -0,0 +1,206 @@
+// header file
+#include "GeneralUtility.h"
+
+// constants
+
+/* Data Structures
+
+typedef enum { NO_RESULT = -1, INITIALIZE_RAND_GENERATOR = 101,
+                       GET_RANDOM_VALUE, CLEAR_RAND_GENERATOR } RandControlCode;
+
+typedef enum { LOW_RAND_LIMIT = 10, HIGH_RAND_LIMIT = 99 } RandLimits;
+
+Data Structures */
+
+// function implementations
+
+/*
+Name: privateCompareStrings
+Process: compares two strings as follows:
+         - if left string is alphabetically greater than the right string,
+         returns value greater than zero
+         - if left string is alphabetically less than the right string,
+         returns value less than zero
+         - if strings are alphabetically equal but one is longer,
+           longer one is greater
+         - otherwise, returns zero
+Function input/parameters: two strings to be compared (const char *)
+Function output/parameters: none
+Function output/returned: result as specified above (int)
+Device input/ ---: none
+Device output/ ---: none
+Dependencies: privateGetStringLen
+*/
+int privateCompareStrings(const char *leftStr, const char *rightStr)
+{
+    int diff, index = 0;
+    int leftStrLen = privateGetStringLen(leftStr);
+    int rightStrLen = privateGetStringLen(rightStr);
+
+    while (index < leftStrLen && index < rightStrLen)
+    {
+        diff = leftStr[index] - rightStr[index];
+        if (diff != 0)
+        {
+            return diff;
+        }
+        index = index + 1;
+    }
+    return leftStrLen - rightStrLen;
+}
+
+/*
+Name: privateCopyString
+Process: copies string character for character up to NULL_CHAR of source string
+Function input/parameters: source string to be copied (const char *)
+Function output/parameters: destination string (char *)
+Function output/returned: none
+Device input/---: none
+Device output/---: none
+Dependencies: none
+*/
+void privateCopyString(char *dest, const char *source)
+{
+    int characterCount = 0;
+    // use a while loop, check for !NULL_CHAR
+    while (source[characterCount] != NULL_CHAR)
+    {
+        // copy the character accessed into dest string
+        dest[characterCount] = source[characterCount];
+        // iterate the number of characters
+        characterCount = characterCount + 1;
+    }
+    // add a NULL_CHAR once done, characterCount is in the right place for \0
+    dest[characterCount] = NULL_CHAR;
+    // no return, void.
+}
+
+/*
+Name: privateGenUniqueRandom
+Process: generates a unique random value for a given set of data
+         during a program,
+         for control code:
+         INITIALIZE_RAND_GENERATOR - initializes lookup array for use
+         GET_RANDOM_VALUE - creates, tests, and returns random value
+         CLEAR_RAND_GENERATOR - deallocates lookup array
+Method input/parameters: HeapType item (const HeapType),
+                         control code (RandControlCode)
+Method output/parameters: none
+Method output/returned: unique random value (int)
+Device input/---: none
+Device output/---: none
+Dependencies: srand, privateGetRandBetween, privateIsInArray, malloc, free
+Notes: protects from:
+       accidental reinitialization,
+       acquiring value without initialization,
+       or deallocation without initialization
+*/
+int privateGenUniqueRandom(int heapCapacity, RandControlCode ctrlCode)
+{
+    // define the static array and size
+    static int *randArray = NULL;
+    static int size = 0;
+    // check which ctrlCode is used
+    if(ctrlCode == INITIALIZE_RAND_GENERATOR)
+    {
+        // if initializing
+        // create the array with the capacity given
+        randArray = (int *)malloc(sizeof(int) * heapCapacity);
+        // set random seed
+        srand(time(NULL));
+        // set size to zero(just to be safe)
+        size = 0;
+    }
+    else if(ctrlCode == GET_RANDOM_VALUE)
+    {
+        // if requesting for rand
+        // generate random value, 
+                            // makes sure the value currently isn't in the array
+        int currentRand = privateGetRandBetween(LOW_RAND_LIMIT, HIGH_RAND_LIMIT);
+        while (privateIsInArray(randArray, size, currentRand))
+        {
+            // generate new random.
+            currentRand = privateGetRandBetween(LOW_RAND_LIMIT, HIGH_RAND_LIMIT);
+        }
+        // once found a number that isn't in array, put into array.
+        randArray[size] = currentRand;
+        // increment size
+        size = size + 1;
+        return currentRand;
+    }
+    // check to see if the array is actually initialized
+    if(size != 0 && randArray != NULL)
+    {
+        // otherwise, clearing and freeing things if initialized.
+        free(randArray);
+    }
+    return NO_RESULT;
+}
+
+/*
+Name: privateGetRandBetween
+Process: generates a random value between two limits, inclusive
+Method input/parameters: lower and upper limits (int)
+Method output/parameters: none
+Method output/returned: random value generated as specified (int)
+Device input/---: none
+Device output/---: none
+Dependencies: rand
+*/
+int privateGetRandBetween(int lowLimit, int highLimit)
+{
+    // return random number that was previously seeded
+    return ((rand() % (highLimit - lowLimit + 1)) + lowLimit);
+}
+
+/*
+Name: privateGetStringLen
+Process: finds length of string
+Function input/parameters: c-style string (const char *)
+Function output/parameters: none
+Function output/returned: calculated length of string (int)
+Device input/ ---: none
+Device output/ ---: none
+Dependencies: none
+*/
+int privateGetStringLen(const char *str)
+{
+    int strLen = 0;
+    // while through string until hit null.
+    while (str[strLen] != NULL_CHAR)
+    {
+        // increment the length string iterator
+        strLen = strLen + 1;
+    }
+    // return strLen
+    return strLen;
+}
+
+/*
+Name: privateIsInArray
+Process: provided integer array, its size, and a test value,
+         returns true if test value is in the array, false otherwise
+Method input/parameters: integer array (int *),
+                         test value (int)
+Method output/parameters: none
+Method output/returned: Boolean result of operation (bool)
+Device input/---: none
+Device output/---: none
+Dependencies: none
+*/
+bool privateIsInArray(const int *array, int size, int testVal)
+{
+    int arrayIterator;
+    // for loop through the array.
+    for(arrayIterator = 0; arrayIterator < size; arrayIterator++)
+    {
+        // check to see if the testVal is at the location.
+        if(array[arrayIterator] == testVal)
+        {
+            // if there, return true
+            return true;
+        }
+    }
+    // otherwise, return false since not found
+    return false;
+}
\ No newline at end of file
diff --git a/PA09-1108/HeapUtility.c b/PA09-1108/HeapUtility.c
new file mode 100644
index 0000000..8db54ad
--- /dev/null
+++ b/PA09-1108/HeapUtility.c
@@ -0,0 +1,390 @@
+// header file
+#include "HeapUtility.h"
+
+// constants
+
+/* Data Structures
+
+typedef struct HeapStruct
+   {
+    StudentType *array;
+
+    int size, capacity;
+   } HeapType;
+
+Data Structures */
+
+// function implementations
+
+/*
+Name: addStudentWithData
+Process: adds student data to the array with internally generated priority,
+         returns true if array not full, false otherwise
+Method input/parameters: pointer to HeapType item (HeapType *),
+                          name (const char *), student id (int),
+                          gender (char), gpa (double), priority (int),
+                          display flag (bool)
+Method output/parameters: pointer to HeapType item (HeapType *)
+Method output/returned: Boolean result of function (bool)
+Device input/---: none
+Device output/---: none
+Dependencies: privateCopyString, privateGenUniqueRandom,
+              studentDataToString, privateBubbleUp
+*/
+bool addStudentWithData(HeapType *heap, const char *inName, int inStudentId,
+                        char inGender, double inGpa, bool displayFlag)
+{
+    // create variables for string display
+    char dispString[MAX_STR_LEN];
+    // check to see if the size is equal to capacity
+    if(heap->size == heap->capacity)
+    {
+        // if the capacity and the size are equal
+        return false;
+    }
+    // copy the data out of the input variables
+    privateCopyString(heap->array[heap->size].name, inName);
+    heap->array[heap->size].studentId = inStudentId;
+    heap->array[heap->size].gender = inGender;
+    heap->array[heap->size].gpa = inGpa;
+    heap->array[heap->size].priority = 
+                       privateGenUniqueRandom(heap->capacity, GET_RANDOM_VALUE);
+    // display if enabled
+    if(displayFlag)
+    {
+        // "cast" our data to a string
+        studentDataToString(dispString, heap->array[heap->size]);
+        // print out the string
+        printf("\nAdding new student: %s\n", dispString);
+    }
+    // call bubble up to get to the right place
+    privateBubbleUp(heap, heap->size, displayFlag);
+    // increment the size of the heap
+    heap->size = heap->size + 1;
+    // return true since operation complete
+    return true;
+}
+
+/*
+Name: addStudentFromStudentElement
+Process: adds student element to the array from other element,
+         returns true if array not full, false otherwise
+Method input/parameters: student data type item to be added (const StudentType)
+Method output/parameters: pointer to HeapType (HeapType *)
+Method output/returned: Boolean result of function
+Device input/---: none
+Device output/---: none
+Dependencies: one line of code - addStudentWithData
+*/
+bool addStudentFromElement(HeapType *heap,
+                           const StudentType sourceElement, bool displayFlag)
+{
+    // return the added student with data
+    return addStudentWithData(heap, sourceElement.name, sourceElement.studentId,
+                          sourceElement.gender, sourceElement.gpa, displayFlag);
+}
+
+/*
+Name: clearHeapType
+Process: deallocates heap and internal array, clears unique random source,
+         returns NULL
+Method input/parameters: pointer to HeapType (HeapType *)
+Method output/parameters: none
+Method output/returned: NULL (HeapType *)
+Device input/---: none
+Device output/---: none
+Dependencies: free, privateGenUniqueRandom
+*/
+HeapType *clearHeapType(HeapType *heap)
+{
+    // free the heap's array
+    free(heap->array);
+    // free the random number generator
+    privateGenUniqueRandom(heap->capacity, CLEAR_RAND_GENERATOR);
+    // free the rest of the heap
+    free(heap);
+    // return NULL since cleared
+    return NULL;
+}
+
+/*
+Name: createHeapType
+Process: initializes heap, and internal array, creates unique random source
+Method input/parameters: capacity (int)
+Method output/parameters: none
+Method output/returned: initialized heap (HeapType *)
+Device input/---: none
+Device output/---: none
+Dependencies: malloc, privateGenUniqueRandom
+*/
+HeapType *createHeapType(int capacity)
+{
+    // dynamically allocate the heap
+    HeapType *createdHeap = (HeapType *) malloc(sizeof(HeapType));
+    // set the heap's capacity to the given capacity
+    createdHeap->capacity = capacity;
+    // set the heap's size to zero to start
+    createdHeap->size = 0;
+    // allocate the internal array for the heap
+    createdHeap->array = (StudentType *) malloc(sizeof(StudentType) * capacity);
+    // initialize the random number generator
+    privateGenUniqueRandom(capacity, INITIALIZE_RAND_GENERATOR);
+    // return created heap
+    return createdHeap;
+}
+
+/*
+Name: getTreeHeight
+Process: recursively finds tree height by using number of nodes
+Method input/parameters: node count (int)
+Method output/parameters: none
+Method output/returned: calculated tree height (int)
+Device input/---: none
+Device output/---: none
+Dependencies: findTreeHeight (recursively)
+*/
+int findTreeHeight(int nodeCount)
+{
+    // define height
+    int treeHeight = 0;
+    // check to see if the count of nodes is more than zero
+    if(nodeCount > 1)
+    {
+        // count the tree height recursively.
+        treeHeight = 1 + findTreeHeight((nodeCount - 1)/2);
+    }
+    // return treeHeight
+    return treeHeight;
+}
+
+/*
+Name: isEmpty
+Process: checks for empty list, reports
+Method input/parameters: none
+Method output/parameters: none
+Method output/returned: Boolean result of operation (bool)
+Device input/---: none
+Device output/---: none
+Dependencies: none
+*/
+bool isEmpty(HeapType *heap)
+{
+    // return false (temp)
+    return heap->size == 0;
+}
+
+/*
+Name: privateBubbleUp
+Process: recursively traverses tree to place new data element
+       in the correct location in the tree/array,
+       if display flag set, reports bubble up actions
+Method input/parameters: pointer to heap (HeapType *),
+                         index at current location in tree/array (int),
+                         display flag (bool)
+Method output/parameters: pointer to updated heap (HeapType *)
+Method output/returned: none
+Device input/---: none
+Device output/---: none
+Dependencies: deepCopyStudentData, printf, studentDataToString,
+              privateBubbleUp (recursive)
+Notes: No more than two statements for any swap operation
+*/
+void privateBubbleUp(HeapType *heap, int currentIndex, bool displayFlag)
+{
+    // initialize variables
+    int parentIndex = (currentIndex - 1) / 2;
+    char bubbleStr[MAX_STR_LEN];
+    StudentType swapParent;
+    // prepare the swap
+    deepCopyStudentData(&swapParent, heap->array[currentIndex]);
+    // check for parent and valid index
+    if(parentIndex >= 0) //used to be currentIndex > 0
+    {
+        // compare parent and child priorities
+        if(heap->array[parentIndex].priority < 
+                                             heap->array[currentIndex].priority)
+        {
+            // if priorities are BLANK than, swap.
+            deepCopyStudentData(&heap->array[currentIndex], 
+                                                      heap->array[parentIndex]);
+            deepCopyStudentData(&heap->array[parentIndex], swapParent);
+            // check for display information
+            if(displayFlag)
+            {
+                // "cast" data to string
+                studentDataToString(bubbleStr, heap->array[parentIndex]);
+                // print the bubbling
+                printf("   - Bubble up swap:\n");
+                // print the swapping parts
+                printf("     - moving up child: %s", bubbleStr);
+                studentDataToString(bubbleStr, heap->array[currentIndex]);
+                printf("     - moving down parent: %s\n", bubbleStr);
+            }
+            // bubbleUp again since swapped
+            privateBubbleUp(heap, parentIndex, displayFlag);
+        }
+    }
+    // no return, void.
+}
+
+/*
+Name: privateTrickleDown
+Process: recursively traverses tree to place reordered data element
+       in the correct location in the tree/array,
+       if display flag set, reports trickle down actions
+Method input/parameters: pointer to heap (HeapType *),
+                         index at current location in tree/array (int),
+                         display flag (bool)
+Method output/parameters: pointer to updated heap (HeapType *)
+Method output/returned: none
+Device input/---: none
+Device output/---: none
+Dependencies: deepCopyStudentData, printf, studentDataToString,
+              privateTrickleDown (recursive)
+Notes: No more than two copy operations for any swap operation
+*/
+void privateTrickleDown(HeapType *heap, int currentIndex, bool displayFlag)
+{
+    // initialize variables
+    bool leftChildSwap = false, rightChildSwap = false;
+    int leftChildIndex = currentIndex * 2 + 1;
+    int rightChildIndex = currentIndex * 2 + 2;
+    int swapStudentIndex;
+    StudentType swapStudent;
+    char trickleStr[MAX_STR_LEN];
+    // check left child and data(priority)
+    if(heap->size <= leftChildIndex)
+    {
+        // check left child exists (given index within size)
+        // compare currentIndex priority < leftChildPriority
+        if(heap->array[leftChildIndex].priority > 
+                                             heap->array[currentIndex].priority)
+        {
+            // left child > currentIndex, leftChildSwap = true
+            leftChildSwap = true;
+        }
+    }
+    // otherwise, check right child and data(priority)
+    else
+    {
+        // check right child exists (given index within size)
+        // compare currentIndex priority < rightChildPriority
+        if (heap->array[rightChildIndex].priority > 
+                                             heap->array[currentIndex].priority)
+        {
+            // right child > currentIndex, rightChildSwap = true
+            rightChildSwap = true;
+        }
+    }
+    // decide to swap with left or right child based on which is max priority
+    // if both can be swapped, take the greater priority one.
+    if(leftChildSwap && rightChildSwap)
+    {
+        // set the swapStudent to the greater priority (deepCopy)
+        // set the swapStudentIndex to whichever side was picked
+        if(heap->array[leftChildIndex].priority > 
+                                          heap->array[rightChildIndex].priority)
+        {
+            rightChildSwap = false;
+        }
+        else
+        {
+            leftChildSwap = false;
+        }
+    }
+    // check to see if the leftChildSwap is true
+    else if(leftChildSwap)
+    {
+        // set the swapStudent to the leftChild
+        deepCopyStudentData(&swapStudent, heap->array[leftChildIndex]);
+        // set the swapStudentIndex to the left
+        swapStudentIndex = leftChildIndex;
+    }
+    // otherwise, check to see if the rightChildSwap is true
+    else if(rightChildSwap)
+    {
+        // set the swapStudent to the rightChild
+        deepCopyStudentData(&swapStudent, heap->array[rightChildIndex]);
+        // set the swapStudentIndex to the right
+        swapStudentIndex = rightChildIndex;
+    }
+    // swapping operation block and check
+    if(leftChildSwap || rightChildSwap)
+    {
+        // check if displayFlag is true
+        if (displayFlag)
+        {
+            // print out the relevant information
+            printf("   - Trickle down swap:\n");
+            studentDataToString(trickleStr, heap->array[currentIndex]);
+            printf("     - moving down parent:%s", trickleStr);
+            // get the swapping side index information
+            studentDataToString(trickleStr, heap->array[swapStudentIndex]);
+            // check which side is being swapped to display accurate info
+            if(leftChildSwap)
+            {
+                printf("     - moving up left child:%s\n", trickleStr);
+            }
+            else
+            {
+                printf("     - moving up right child:%s\n", trickleStr);
+            }
+        }
+        // swapping operation given that there needs to be a swap
+        // heap->array[swapStudentIndex] = heap->array[currentIndex]
+        deepCopyStudentData(&heap->array[swapStudentIndex], 
+                                                     heap->array[currentIndex]);
+        // heap->array[currentIndex] = swapStudent
+        deepCopyStudentData(&heap->array[currentIndex], swapStudent);
+        // trickleDown to next recursion since swapped
+        privateTrickleDown(heap, swapStudentIndex, displayFlag);
+    }
+    // no return, void.
+}
+
+/*
+Name: removeItem
+Process: removes item from heap, adjusts tree, returns
+Method input/parameters: pointer to heap type (HeapType *)
+Method output/parameters: returned data, or empty returnVal if not found
+                                                            (StudentDataType *),
+                          pointer to updated heap type (HeapType *)
+Method output/returned: none
+Device input/---: none
+Device output/---: none
+Dependencies: deepCopyStudentData, studentDataToString,
+              printf, privateTrickleDown
+*/
+void removeItem(StudentType *returnVal, HeapType *heap, bool displayFlag)
+{
+    // define a removedItemStr
+    char removedItemStr[MAX_STR_LEN];
+    // removes item @ index zero
+    // (item @ last index of array @ index zero)
+    // check to make sure within valid space
+    if(heap->size > 0)
+    {
+        // set the returnVal to the heap's index zero by deep copy
+        deepCopyStudentData(returnVal, heap->array[0]);
+        // set last to first
+        deepCopyStudentData(&heap->array[0], heap->array[heap->size - 1]);
+        // decrement size by 1 for array
+        heap->size = heap->size - 1;
+        // check the displayFlag
+        if (displayFlag)
+        {
+            studentDataToString(removedItemStr, *returnVal);
+            // if true, print the removed item
+            // print the string for the removed item
+            printf("\nRemoving student: %s\n", removedItemStr);
+        }
+        // call privateTrickleDown to move into correct place
+        privateTrickleDown(heap, 0, displayFlag);
+        if (displayFlag)
+        {
+            // show the removed student complete
+            printf("%s removed\n", removedItemStr);
+        }
+    }
+    // no return, void.
+}
\ No newline at end of file
diff --git a/PA09-1108/PA09_Main b/PA09-1108/PA09_Main
new file mode 100755
index 0000000000000000000000000000000000000000..adac5ceb442beee4498586dd3cb899f997a313d6
GIT binary patch
literal 37176
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
E1KQo75dZ)H

literal 0
HcmV?d00001

diff --git a/PA09-1108/StudentUtility.c b/PA09-1108/StudentUtility.c
new file mode 100644
index 0000000..3a6d0d7
--- /dev/null
+++ b/PA09-1108/StudentUtility.c
@@ -0,0 +1,67 @@
+// header file
+#include "StudentUtility.h"
+
+// constants
+
+/* Data Structures
+
+typedef struct StudentStruct
+   {
+    char name[ MAX_STR_LEN ];
+    int studentId;
+    char gender;
+    double gpa;
+    int priority;
+
+   } StudentType;
+
+typedef struct StudentArrayStruct
+   {
+    StudentType *array;
+
+    int size, capacity;
+   } StudentArrayType;
+
+Data Structures */
+
+// function implementations
+
+/*
+Name: deepCopyStudentDAta
+Process: copies one StudentType item into another
+Function input/parameters: source data (const StudentType)
+Function output/parameters: destination data (StudentType *)
+Function output/returned: none
+Device input/ ---: none
+Device output/ ---: none
+Dependencies: privateCopyString
+*/
+void deepCopyStudentData(StudentType *dest, const StudentType source)
+{
+    // copy each piece of data out of the source given
+    privateCopyString(dest->name, source.name);
+    dest->studentId = source.studentId;
+    dest->gender = source.gender;
+    dest->gpa = source.gpa;
+    dest->priority = source.priority;
+    // no return, void.
+}
+
+/*
+Name: studentDataToString
+Process: creates display string from all object data
+Method input/parameters: none
+Method output/parameters: pointer to return string (char * const)
+Method output/returned: none
+Device input/keyboard: none
+Device output/monitor: none
+Dependencies: sprintf
+*/
+void studentDataToString(char *outString, const StudentType toDisplay)
+{
+    // use sprintf to "cast" the data to a string
+    sprintf(outString, "Nm: %s, Id: %d, Gndr: %c, GPA: %.4f, Priority: %d\n", 
+                          toDisplay.name, toDisplay.studentId, toDisplay.gender, 
+                                             toDisplay.gpa, toDisplay.priority);
+    // no return, void.
+}
\ No newline at end of file