C Program To Find Middle Maximum And Minimum Value From User Defined Value

A common task in data analysis involves identifying values that fall within the central distribution of a dataset, excluding the absolute extremes. Often, this means looking beyond the single smallest and largest numbers to understand the spread and typical range of values.

In this article, you will learn how to write a C program to find the "middle maximum" and "middle minimum" values from a user-defined set of numbers.

Problem Statement

When analyzing a set of numbers, the absolute minimum and maximum values can sometimes be outliers or less representative of the typical range. The challenge is to identify values that are significant but not at the very edges of the dataset. For this article, we define:

• Middle Minimum: The second smallest value in the set.
• Middle Maximum: The second largest value in the set.

This approach helps to filter out potential extreme outliers and provides a clearer view of the central tendencies of the data. This requires the input set to have at least two distinct values for these definitions to be meaningful, and ideally three or more to clearly differentiate from the absolute min/max.

Example

Consider the following set of numbers provided by a user: [10, 5, 20, 15, 25]

1. Sorted List: [5, 10, 15, 20, 25]
2. Absolute Minimum: 5
3. Absolute Maximum: 25
4. Middle Minimum (Second Smallest): 10
5. Middle Maximum (Second Largest): 20

Background & Knowledge Prerequisites

To effectively understand and implement the solutions, you should have a basic understanding of:

• C Programming Basics: Variables, data types, if-else statements, loops (for, while).
• Arrays: How to declare, initialize, and access elements in a C array.
• Functions: Defining and calling functions, especially for sorting.
• Standard Input/Output: Using printf and scanf for user interaction.
• Sorting Concepts: The fundamental idea behind arranging elements in ascending or descending order.

No specific imports beyond standard I/O (stdio.h) and potentially stdlib.h for advanced sorting are strictly required for the simpler approach.

Use Cases or Case Studies

Identifying middle maximum and minimum values is useful in various scenarios:

• Data Cleaning: Removing the most extreme outliers before performing statistical analysis to get more robust results.
• Performance Benchmarking: When testing system performance, discarding the absolute best and worst runtimes to focus on typical performance.
• Ranking Systems: In contests or evaluations, sometimes the top and bottom scores are discounted to prevent bias from exceptionally good or bad outliers, focusing on the scores just inside these extremes.
• Sensor Data Analysis: Filtering out noise or faulty readings at the absolute high and low ends from a stream of sensor data.
• Financial Analysis: Analyzing stock prices or market data by looking at performance excluding the highest and lowest volatility events.

Solution Approaches

We will explore two common methods to find the middle maximum and minimum values:

1. Manual Sorting (Bubble Sort): Implementing a simple sorting algorithm directly.
2. Using qsort from stdlib.h: Leveraging C's standard library for efficient sorting.

Approach 1: Manual Sorting (Bubble Sort)

This approach involves implementing a basic sorting algorithm, such as Bubble Sort, to arrange the numbers in ascending order. Once sorted, the second element will be the middle minimum, and the second-to-last element will be the middle maximum.

// Find Middle Max and Min using Bubble Sort
#include <stdio.h>

void bubbleSort(int arr[], int n) {
    int i, j, temp;
    for (i = 0; i < n - 1; i++) {
        for (j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                // Swap elements
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main() {
    // Step 1: Get array size from user
    int n;
    printf("Enter the number of elements (min 3): ");
    scanf("%d", &n);

    if (n < 3) {
        printf("Please enter at least 3 elements to find middle max/min.\\n");
        return 1; // Indicate an error
    }

    int arr[n]; // Declare array of size n (VLA - C99 feature)

    // Step 2: Get array elements from user
    printf("Enter %d integers:\\n", n);
    for (int i = 0; i < n; i++) {
        printf("Element %d: ", i + 1);
        scanf("%d", &arr[i]);
    }

    // Step 3: Sort the array using Bubble Sort
    bubbleSort(arr, n);

    // Step 4: Extract middle minimum and middle maximum
    int middleMin = arr[1];       // Second element (0-indexed)
    int middleMax = arr[n - 2];   // Second to last element

    // Step 5: Print the results
    printf("\\nSorted Array: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\\n");

    printf("Middle Minimum (Second Smallest): %d\\n", middleMin);
    printf("Middle Maximum (Second Largest): %d\\n", middleMax);

    return 0;
}

Run

Sample Output:

Enter the number of elements (min 3): 5
Enter 5 integers:
Element 1: 10
Element 2: 5
Element 3: 20
Element 4: 15
Element 5: 25

Sorted Array: 5 10 15 20 25
Middle Minimum (Second Smallest): 10
Middle Maximum (Second Largest): 20

Stepwise Explanation:

1. bubbleSort Function: This function takes an integer array arr and its size n as input. It iterates through the array multiple times, comparing adjacent elements and swapping them if they are in the wrong order, effectively "bubbling up" the largest elements to the end.
2. User Input: The main function first prompts the user to enter the number of elements (n). It includes a check to ensure n is at least 3, which is necessary for the concept of "second smallest/largest" to be distinct from absolute min/max. Then, it collects n integer values into an array.
3. Sorting: The bubbleSort function is called to sort the user-provided array in ascending order.
4. Extraction: After sorting, the element at index 1 (arr[1]) represents the second smallest value (middle minimum). The element at index n - 2 (arr[n - 2]) represents the second largest value (middle maximum).
5. Output: The program prints the sorted array, followed by the identified middle minimum and middle maximum values.

Approach 2: Using qsort from stdlib.h

The C standard library provides a powerful and efficient generic sorting function called qsort. This approach is generally preferred for its performance and flexibility, especially for larger datasets.

// Find Middle Max and Min using qsort
#include <stdio.h>
#include <stdlib.h> // Required for qsort

// Comparison function for qsort (for ascending order)
int compareIntegers(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int main() {
    // Step 1: Get array size from user
    int n;
    printf("Enter the number of elements (min 3): ");
    scanf("%d", &n);

    if (n < 3) {
        printf("Please enter at least 3 elements to find middle max/min.\\n");
        return 1; // Indicate an error
    }

    int arr[n]; // Declare array of size n (VLA - C99 feature)

    // Step 2: Get array elements from user
    printf("Enter %d integers:\\n", n);
    for (int i = 0; i < n; i++) {
        printf("Element %d: ", i + 1);
        scanf("%d", &arr[i]);
    }

    // Step 3: Sort the array using qsort
    // qsort(base, num, size, compar)
    // base: pointer to the first element of the array
    // num: number of elements in the array
    // size: size of each element in bytes
    // compar: pointer to a comparison function
    qsort(arr, n, sizeof(int), compareIntegers);

    // Step 4: Extract middle minimum and middle maximum
    int middleMin = arr[1];       // Second element (0-indexed)
    int middleMax = arr[n - 2];   // Second to last element

    // Step 5: Print the results
    printf("\\nSorted Array: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\\n");

    printf("Middle Minimum (Second Smallest): %d\\n", middleMin);
    printf("Middle Maximum (Second Largest): %d\\n", middleMax);

    return 0;
}

Run

Sample Output:

Enter the number of elements (min 3): 7
Enter 7 integers:
Element 1: 30
Element 2: 10
Element 3: 50
Element 4: 5
Element 5: 40
Element 6: 20
Element 7: 60

Sorted Array: 5 10 20 30 40 50 60
Middle Minimum (Second Smallest): 10
Middle Maximum (Second Largest): 50

Stepwise Explanation:

1. compareIntegers Function: qsort requires a comparison function. This function takes two const void* pointers, casts them to int*, dereferences them, and returns a negative value if the first integer is smaller, a positive value if the first is larger, and zero if they are equal. This dictates the sorting order (ascending in this case).
2. Include stdlib.h: This header file is necessary to use the qsort function.
3. User Input: Similar to Approach 1, the program gets the number of elements and the actual integer values from the user, with the same input validation.
4. Sorting with qsort:

• qsort(arr, n, sizeof(int), compareIntegers); This line is the core of this approach.
• arr: The array to be sorted.
• n: The number of elements in the array.
• sizeof(int): The size of each element in bytes.
• compareIntegers: A pointer to our custom comparison function.

qsort efficiently sorts the array in place.

1. Extraction: Once sorted by qsort, the second smallest (arr[1]) and second largest (arr[n - 2]) elements are retrieved.
2. Output: The program prints the sorted array and the calculated middle minimum and middle maximum.

Conclusion

Finding "middle" values like the second smallest and second largest elements can be a valuable technique for understanding data distribution beyond just the absolute extremes. Both manual sorting using algorithms like Bubble Sort and leveraging the optimized qsort function from the standard library offer effective ways to achieve this. While manual sorting provides a deeper understanding of sorting mechanisms, qsort is generally recommended for its efficiency and robustness in production code.

Summary

• Problem: Identify the second smallest (middle minimum) and second largest (middle maximum) values from a user-defined set of numbers.
• Requirement: The input set must contain at least three numbers for these values to be distinct from the absolute min/max.
• Approach 1 (Manual Sorting): Implement a simple sort (e.g., Bubble Sort) to arrange elements, then pick arr[1] and arr[n-2].
• Approach 2 (qsort): Use the qsort function from stdlib.h with a custom comparison function for efficient sorting, then pick arr[1] and arr[n-2].
• Benefits: Helps filter outliers, provides insight into central data tendencies, useful in various analytical and ranking applications.