+1 (315) 557-6473 

Heap Sort for Customer Records in C

The C code implements a Heap Sort algorithm for sorting customer records stored in a file. Each record consists of a loyalty score and a name, prioritizing sorting based on loyalty and breaking ties alphabetically by name. The code opens the file, determines the number of records, allocates memory for an array, reads records from the file, and performs heap sort. The sorted records are then written back to the file. The algorithm involves building a heap and repeatedly extracting the highest-priority element. The code ensures proper memory allocation and file operations, providing a robust sorting mechanism for customer data based on specified criteria.

C Code: Heap Sort for Customer Records

This C code exemplifies a robust implementation of the Heap Sort algorithm tailored for sorting customer records stored in files. Prioritizing loyalty scores and leveraging alphabetical order for tie-breaking, the code efficiently organizes data within the given constraints. With a keen eye on readability and reliability, it serves as a valuable resource for those seeking guidance or assistance with their C assignments related to sorting algorithms and file manipulation. The code's modular structure, encompassing file operations, memory allocation, and the nuances of heap sorting, facilitates an in-depth understanding of these crucial programming concepts.

Block 1: Helper Method – heapify

void heapify(customer* records, int parentIndex, int lastIndex) { // Implementation of heapify algorithm to arrange the heap // based on loyalty scores and alphabetical order of names. }


  • This block defines a helper method heapify used in the heap sort algorithm.
  • It takes an array of customer records, an index of the parent element (parentIndex), and the last index of the heap (lastIndex).
  • The method rearranges the heap by comparing the loyalty scores of child elements and, in case of ties, comparing the names alphabetically.
  • It ensures that the highest priority element (based on loyalty and name) is at the root of the subtree.

Block 2: Helper Method – swap

void swap(customer* records, int i, int j) { // Swap two records at the specified positions in the array. }


  • This block defines a helper method swap used to swap two customer records in an array.
  • It takes the array of records (customer* records) and two indices (i and j) and swaps the records at those positions.

Block 3: Sorting Method - heapsort

int heapsort(const char *filename) { // Implementation of the heap sort algorithm for sorting customer records. }


  • This block defines the main sorting method heapsort that takes a filename as input.
  • It opens the file, reads the customer records into an array, and performs heap sort on the array.
  • The sorted records are then written back to the file.
  • The method returns 1 if the sorting is successful and 0 otherwise.

Block 4: Open and Validate File

FILE* file = fopen(filename, "rb"); // Stop if the file cannot be opened if (!file) return 0;


  • This block opens the file specified by the input filename in binary read mode ("rb").
  • If the file cannot be opened, the function returns 0, indicating failure.

Block 5: Determine Number of Records

fseek(file, 0, SEEK_END); long fileSize = ftell(file); int numRecords = fileSize / sizeof(customer);


  • This block uses file manipulation functions to determine the total number of records in the file.
  • It calculates the file size and divides it by the size of a customer record to get the number of records.

Block 6: Allocate Memory for Records

customer* records = (customer *)malloc(sizeof(customer) * numRecords); if (!records) return 0;


  • Memory is dynamically allocated for an array (records) to store the customer records.
  • If the allocation fails, the function returns 0.

Block 7: Read Records from File to Array

fseek(file, 0, SEEK_SET); for (int i = 0; i < numRecords; i++) if (!fread(&records[i], sizeof(customer), 1, file)) return 0; fclose(file);


  • This block reads the customer records from the file into the dynamically allocated array.
  • It uses a loop and fread to read each record into the array.
  • If any read operation fails, the function returns 0.

Block 8: Perform Heap Sort - Build Heap Phase

for (int parentIndex = numRecords / 2 - 1; parentIndex >= 0; parentIndex--) heapify(records, parentIndex, numRecords - 1);


  • This block initiates the heap sort by building the initial heap.
  • It iterates through the array starting from the last non-leaf node and calls the heapify function to arrange the elements into a heap.

Block 9: Perform Heap Sort - Sorting Phase

swap(records, 0, numRecords - 1); for (int lastIndex = numRecords - 2; lastIndex > 0; lastIndex--) { heapify(records, 0, lastIndex); swap(records, 0, lastIndex); }


  • This block performs the actual sorting phase of heap sort.
  • It swaps the root (highest priority element) with the last element and adjusts the heap.
  • The loop continues, reducing the heap size by one in each iteration, until the entire array is sorted.

Block 10: Write Sorted Records Back to File

file = fopen(filename, "wb"); for (int i = 0; i < numRecords; i++) fwrite(&records[i], sizeof(customer), 1, file); fclose(file);


  • The sorted records are written back to the file in binary write mode ("wb").
  • The function uses a loop and fwrite to write each record to the file.

Block 11: Clean Up and Return

free(records); return 1;


  • The dynamically allocated memory for the array is freed, and the function returns 1, indicating successful sorting.


In conclusion, this well-crafted C code not only provides a functional implementation of the Heap Sort algorithm for sorting customer records but also stands as a comprehensive educational resource. Its clarity, emphasis on readability, and attention to critical aspects like file manipulation and dynamic memory allocation make it a valuable asset for those grappling with C assignments related to sorting algorithms. By encapsulating essential programming concepts, the code not only achieves its practical sorting objective but also serves as an instructive guide for learners. Whether tackling file-based operations or delving into the intricacies of heap sorting, this code represents a robust foundation for understanding and mastering these fundamental aspects of C programming.