Question

code in C language

ADT:
typedef struct{
int ID;
float salary;
int age;
}Employee;

Specification:
In this lab, five functions need to be implemented using the given ADT.

1. Employee* readRecord(FILE*)
This function receives a FILE pointer created before. It reads a line from the provided csv file, and creates an Employee struct pointer with the information from that line then returns the pointer back to the calling function. Each line in the provided csv file contains the id, salary, and age for an employee. Store id and age as integers while saving salary as a floating point number.

2. int comparison(void*,void*);
This function takes two pointers of any data type as inputs, and
returns positive number if the age value inside first pointer is larger than the age value inside the second pointer, negative number if the age value inside the second pointer is larger than the age value inside first pointer, and 0 if the two values are equal.

3. void mergesort(void**,int,int);
4. void merge(void**,int,int,int);
These two generic functions receive an array of pointers of any data type, and sort the array using merge sort. In this lab, this Employee struct pointer array should be sorted based on employees’ ages in descending order.

5. int binarySearch(void**,int,int,void*);
This generic function receives the sorted array from merge sort, which should have been sorted based on employees’ ages in descending order. It then searches the age query in the array and returns the index of the age query if it exists in the array. This function will return -1 if the age query doesn’t exist in the array.
Note: this function should be implemented recursively, not iteratively.

Main program output:
Age 20 exists in the following record: ID: 4583, Salary: 96159.00, Age: 20
Age 35 exists in the following record: ID: 1136, Salary: 101475.00, Age: 35
Age 5 doesn't exist in array

Answer 1

// C program for reading
// struct from a file
#include <stdio.h>
#include <stdlib.h>

// struct person with 3 fields
struct person
{
   int id;
   char fname[20];
   char lname[20];
};

// Driver program
int main ()
{
   FILE *infile;
   struct person input;
  
   // Open person.dat for reading
   infile = fopen ("person.dat", "r");
   if (infile == NULL)
   {
       fprintf(stderr, "\nError opening file\n");
       exit (1);
   }
  
   // read file contents till end of file
   while(fread(&input, sizeof(struct person), 1, infile))
       printf ("id = %d name = %s %s\n", input.id,
       input.fname, input.lname);

   // close file
   fclose (infile);

   return 0;
}
2.typedef struct node

{ int id; char foo[255];

}

Node;

int compare(const void * x, const void * y)

{ Node * a = (Node *) x; Node * b = (Node *) y;

return a->id - b->id;

}

int main()

{ Node array[SIZE];

int n; ... qsort(array, n, sizeof(Node), compare); ...

return 0;

}

3.

/* C program for Merge Sort */
#include<stdlib.h>
#include<stdio.h>

// Merges two subarrays of arr[].
// First subarray is arr[l..m]
// Second subarray is arr[m+1..r]
void merge(int arr[], int l, int m, int r)
{
   int i, j, k;
   int n1 = m - l + 1;
   int n2 = r - m;

   /* create temp arrays */
   int L[n1], R[n2];

   /* Copy data to temp arrays L[] and R[] */
   for (i = 0; i < n1; i++)
       L[i] = arr[l + i];
   for (j = 0; j < n2; j++)
       R[j] = arr[m + 1+ j];

   /* Merge the temp arrays back into arr[l..r]*/
   i = 0; // Initial index of first subarray
   j = 0; // Initial index of second subarray
   k = l; // Initial index of merged subarray
   while (i < n1 && j < n2)
   {
       if (L[i] <= R[j])
       {
           arr[k] = L[i];
           i++;
       }
       else
       {
           arr[k] = R[j];
           j++;
       }
       k++;
   }

   /* Copy the remaining elements of L[], if there
   are any */
   while (i < n1)
   {
       arr[k] = L[i];
       i++;
       k++;
   }

   /* Copy the remaining elements of R[], if there
   are any */
   while (j < n2)
   {
       arr[k] = R[j];
       j++;
       k++;
   }
}

/* l is for left index and r is right index of the
sub-array of arr to be sorted */
void mergeSort(int arr[], int l, int r)
{
   if (l < r)
   {
       // Same as (l+r)/2, but avoids overflow for
       // large l and h
       int m = l+(r-l)/2;

       // Sort first and second halves
       mergeSort(arr, l, m);
       mergeSort(arr, m+1, r);

       merge(arr, l, m, r);
   }
}

/* UTILITY FUNCTIONS */
/* Function to print an array */
void printArray(int A[], int size)
{
   int i;
   for (i=0; i < size; i++)
       printf("%d ", A[i]);
   printf("\n");
}

/* Driver program to test above functions */
int main()
{
   int arr[] = {12, 11, 13, 5, 6, 7};
   int arr_size = sizeof(arr)/sizeof(arr[0]);

   printf("Given array is \n");
   printArray(arr, arr_size);

   mergeSort(arr, 0, arr_size - 1);

   printf("\nSorted array is \n");
   printArray(arr, arr_size);
   return 0;
}

5.

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define BOOL int
#define TRUE 1
#define FALSE 0

static inline char *sgets(size_t buflen, char *buffer)
{
    char *result = fgets(buffer, buflen, stdin);
    if (result)
        buffer[strcspn(buffer, "\n")] = '\0';
    return result;
}

#define checkAllocation(x) assert((x) != 0)

#define SIZE 100
typedef unsigned char BYTE;

char **getStringArr(int *stringSize);
int stringBinSearch(char **stringArr, int stringSize, char *stringToFind);
int binSearch(void *Arr, int size, int ElemSize, void *Item, int (*compare)(void *, void *));
int compare2Strings(void *str1, void *str2);

int main(void)
{
    char **stringArr, stringToFind[SIZE];
    int stringSize;
    int res;

    stringArr = getStringArr(&stringSize);

    sgets(sizeof(stringToFind), stringToFind);

    printf("Strings: %d\n", stringSize);
    for (int i = 0; i < stringSize; i++)
        printf("[%d] = [%s]\n", i, stringArr[i]);
    printf("Search: [%s]\n", stringToFind);

    res = stringBinSearch(stringArr, stringSize, stringToFind);

    if (res == 1)
        printf("The string %s was found\n", stringToFind);
    else
        printf("The string %s was not found\n", stringToFind);
    return 0;
}

char **getStringArr(int *stringSize)
{
    int i, size, len;
    char **arr;
    char temp[SIZE];

    scanf("%d", &size);
    getchar();

    arr = (char **)malloc(size * sizeof(char *));
    checkAllocation(arr);

    for (i = 0; i < size; i++)
    {
        sgets(sizeof(temp), temp);
        len = strlen(temp);
        temp[len] = '\0';
        arr[i] = (char *)malloc((len + 1) * sizeof(char));
        checkAllocation(arr[i]);
        strcpy(arr[i], temp);
    }

    *stringSize = size;
    return arr;
}

int stringBinSearch(char **stringArr, int stringSize, char *stringToFind)
{
    return binSearch(stringArr, stringSize, sizeof(char *), &stringToFind, compare2Strings);
}

int binSearch(void *Arr, int size, int ElemSize, void *Item, int (*compare)(void *, void *))
{
    int left = 0, right = size - 1, place;
    BOOL found = FALSE;

    while (found == FALSE && left <= right)
    {
        place = (left + right) / 2;

        if (compare(Item, (BYTE *)Arr + place * ElemSize) == 0)
            found = TRUE;

        else if (compare(Item, (BYTE *)Arr + place * ElemSize) < 0)
            right = place - 1;

        else
            left = place + 1;
    }
    return found;
}

int compare2Strings(void *str1, void *str2)
{
    char *elemA = *(char **)str1;
    char *elemB = *(char **)str2;

    return strcmp(elemA, elemB);
}

I know the answers are not int he same format as that demanded in the question But i am sure it will help to frame it in that way as the basic coding logic can be studied from the code snippets given above.