C Program to Find Largest Number Using Dynamic Memory Allocation

by

Finding the largest number in a set of data is a common problem in programming. Dynamic memory allocation allows us to handle variable-sized data sets efficiently. In this article, we will explore three different C Program to Find Largest Number Using Dynamic Memory Allocation. Each solution will include a detailed explanation, example code, and output.

Prerequisites

Before diving into the solutions, ensure you have the following prerequisites:

  • Basic understanding of C programming.
  • Familiarity with pointers and dynamic memory allocation.
  • A C compiler installed on your system (e.g., GCC).

Solution 1: Using malloc

1.1 Explanation

In this approach, we will use the malloc function to allocate memory dynamically for an array. We will then find the largest number by iterating through the array.

1.2 Program

C
#include <stdio.h>
#include <stdlib.h>

int findLargest(int *arr, int n) {
    int largest = arr[0];
    for (int i = 1; i < n; i++) {
        if (arr[i] > largest) {
            largest = arr[i];
        }
    }
    return largest;
}

int main() {
    int n;
    printf("Enter the number of elements: ");
    scanf("%d", &n);

    int *arr = (int *)malloc(n * sizeof(int));
    if (arr == NULL) {
        printf("Memory allocation failed.\n");
        return 1;
    }

    printf("Enter the elements:\n");
    for (int i = 0; i < n; i++) {
        scanf("%d", &arr[i]);
    }

    int largest = findLargest(arr, n);
    printf("The largest number is: %d\n", largest);

    free(arr);
    return 0;
}

1.3 Output

C
Enter the number of elements: 5
Enter the elements:
10 20 5 15 30
The largest number is: 30

Solution 2: Using calloc

2.1 Explanation

In this solution, we will use the calloc function to allocate memory dynamically. calloc initializes the allocated memory to zero, which can be useful in certain situations.

2.2 Program

C
#include <stdio.h>
#include <stdlib.h>

int findLargest(int *arr, int n) {
    int largest = arr[0];
    for (int i = 1; i < n; i++) {
        if (arr[i] > largest) {
            largest = arr[i];
        }
    }
    return largest;
}

int main() {
    int n;
    printf("Enter the number of elements: ");
    scanf("%d", &n);

    int *arr = (int *)calloc(n, sizeof(int));
    if (arr == NULL) {
        printf("Memory allocation failed.\n");
        return 1;
    }

    printf("Enter the elements:\n");
    for (int i = 0; i < n; i++) {
        scanf("%d", &arr[i]);
    }

    int largest = findLargest(arr, n);
    printf("The largest number is: %d\n", largest);

    free(arr);
    return 0;
}

Output

C
Enter the number of elements: 5
Enter the elements:
10 20 5 15 30
The largest number is: 30

Solution 3: Using realloc

3.1 Explanation

In this approach, we will use the realloc function to dynamically resize an array. This can be useful if the number of elements is initially unknown or changes during runtime.

3.2 Program

C
#include <stdio.h>
#include <stdlib.h>

int findLargest(int *arr, int n) {
    int largest = arr[0];
    for (int i = 1; i < n; i++) {
        if (arr[i] > largest) {
            largest = arr[i];
        }
    }
    return largest;
}

int main() {
    int n;
    printf("Enter the number of elements: ");
    scanf("%d", &n);

    int *arr = (int *)malloc(n * sizeof(int));
    if (arr == NULL) {
        printf("Memory allocation failed.\n");
        return 1;
    }

    printf("Enter the elements:\n");
    for (int i = 0; i < n; i++) {
        scanf("%d", &arr[i]);
    }

    // Simulate changing the size of the array
    printf("Enter the new number of elements: ");
    int new_n;
    scanf("%d", &new_n);
    arr = (int *)realloc(arr, new_n * sizeof(int));
    if (arr == NULL) {
        printf("Memory reallocation failed.\n");
        return 1;
    }

    if (new_n > n) {
        printf("Enter additional elements:\n");
        for (int i = n; i < new_n; i++) {
            scanf("%d", &arr[i]);
        }
    }

    int largest = findLargest(arr, new_n);
    printf("The largest number is: %d\n", largest);

    free(arr);
    return 0;
}

Output

C
Enter the number of elements: 3
Enter the elements:
10 20 5
Enter the new number of elements: 5
Enter additional elements:
15 30
The largest number is: 30

Conclusion

Dynamic memory allocation in C provides a flexible and efficient way to handle variable-sized data sets. In this article, we explored three different solutions to find the largest number using dynamic memory allocation: using malloc, calloc, and realloc. Each approach has its advantages and is suitable for different scenarios.

  • Using malloc: This method is straightforward and suitable for basic dynamic memory allocation.
  • Using calloc: This method initializes the allocated memory to zero, which can be useful in specific situations.
  • Using realloc: This method allows resizing the allocated memory, providing more flexibility when the number of elements changes during runtime.

By understanding and mastering these techniques, you can efficiently manage memory and handle dynamic data in your C programs, enhancing your ability to write robust and scalable code.