FAQs in C: Largest Element in an Array

In this article, we provide a comprehensive guide to finding the largest element in an array in C. You’ll find a clear algorithm, the complete C program, and a step-by-step explanation of each part of the process. This guide is perfect for beginners and intermediate programmers looking to understand array manipulation in C.

Algorithm to Find the Largest Element in an Array

Step 1: Start
Step 2: Input: Read the number of elements in the array.
Step 3: Input Elements: Read the elements of the array.
Step 4: Initialize Largest Element: Assume the first element is the largest.

Step 5: Iterate Through the Array:
        (i) Compare each element with the current largest element.
        (ii) Update the largest element if a larger element is found.

Step 6: Output: Display the largest element.
Step 7: End

C Program to Find the Largest Element in an Array

#include <stdio.h>

int main() {
    int n;

    // Step 2: Input the number of elements in the array
    printf("Enter the number of elements in the array: ");
    scanf("%d", &n);

    int arr[n];

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

    // Step 4: Initialize the largest element
    int largest = arr[0];

    // Step 5: Iterate through the array to find the largest element
    for (int i = 1; i < n; i++) {
        if (arr[i] > largest) {
            largest = arr[i];
        }
    }

    // Step 6: Output the largest element
    printf("The largest element in the array is: %d\n", largest);

    // Step 7: End
    return 0;
}

Explanation of Each Step

Include Header:

#include <stdio.h>

• This line includes the standard input-output library for using functions like printf and scanf.

Input the Number of Elements:

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

• These lines read the number of elements in the array from the user and store it in the variable n.

Input the Elements of the Array:

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

• These lines declare an array arr of size n and use a loop to read the elements of the array from the user.

Initialize the Largest Element:

int largest = arr[0];

• This line initializes the variable largest to the first element of the array.

Iterate Through the Array:

for (int i = 1; i < n; i++) {
    if (arr[i] > largest) {
        largest = arr[i];
    }
}

• This loop iterates through the array starting from the second element. It compares each element with the current largest element and updates largest if a larger element is found.

Output the Largest Element:

printf("The largest element in the array is: %d\n", largest);

• This line prints the largest element found in the array.

End:

return 0;

• This line indicates the successful completion of the program.

This program efficiently finds and prints the largest element in an array input by the user, demonstrating basic array handling and comparison techniques in C.

More methods to find the largest element in an array:

There are several methods to find the largest element in an array. Below are a few common approaches:

Method 1: Iterative Comparison

This is the most straightforward method, where you iterate through the array and keep track of the largest element encountered.

Step 1: Start
Step 2: Initialize max with the first element of the array.
Step 3: Loop through the array starting from the second element.
Step 4: For each element, compare it with max.
Step 5: If the current element is greater than max, update max.
Step 6: After the loop ends, max will hold the largest element.
Step 7: Exit

Example Program in C:

#include <stdio.h>

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

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("Largest element (Iterative): %d\n", findLargestIterative(arr, n));
    return 0;
}

Step-by-Step Explanation

Include the Standard I/O Library

#include <stdio.h>

• This line includes the standard input-output library, which allows us to use functions like printf and scanf.

Define the Function to Find the Largest Element Iteratively

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

• int findLargestIterative(int arr[ ], int n): This line defines a function named findLargestIterative which takes an array of integers arr and its size n as parameters, and returns an integer which is the largest element in the array.

• int max = arr[0]; : This line initializes the variable max to the first element of the array. We assume that the first element is the largest until we find a larger element.

• for (int i = 1; i < n; i++) { … }: This for loop starts from the second element (index 1) and iterates through the rest of the array.

• if (arr[i] > max) { max = arr[i]; }: Inside the loop, we check if the current element arr[i] is greater than the current max. If it is, we update max to arr[i].

• return max;: After the loop completes, we return max,, which now holds the largest element in the array.

Define the main Function

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("Largest element (Iterative): %d\n", findLargestIterative(arr, n));
    return 0;
}

• int arr[] = {1, 2, 3, 4, 5}; :This line initializes an array arr with the elements {1, 2, 3, 4, 5}.

• int n = sizeof(arr) / sizeof(arr[0]);: This line calculates the number of elements in the array. and sizeof(arr[0]) gives the total size of the array in bytes, and sizeof(arr[0]) gives the size of one element in the array. Dividing these gives the number of elements in the array n.

• printf(“Largest element (Iterative): %d\n”, findLargestIterative(arr, n));: This line calls the findLargestIterative function with arr and n as arguments, and prints the largest element found by the function.

• return 0;: This line indicates that the program has executed successfully.

Execution Flow

The program starts with the main function.

The array arr is initialized with {1, 2, 3, 4, 5}.

The number of elements in the array n is calculated.

The findLargestIterative function is called with arr and n as arguments.

Inside the findLargestIterative function:

• The first element of the array is assumed to be the largest.
• The function iterates through the array starting from the second element.
• It compares each element with the current max and updates max if a larger element is found.
• After completing the iteration, the function returns the largest element found.

The main function prints the largest element found by the findLargestIterative function.

The program terminates successfully.

By following these steps, the program successfully finds and prints the largest element in the array.

Method 2: Sorting

Algorithm

Step 1: Start
Step 2: Define the Comparison Function:

        (i) Create a comparison function compare that takes two const void* 
        arguments and returns the difference between the two integers they 
        point to.

Step 3: Define the Function to Find the Largest Element Using Sorting:
        (i) Define a function findLargestSorting that takes an          
            array arr and its size n as parameters.
       
        (ii) Inside this function, call the qsort function to            
             sort the array in ascending order using the comparison 
             function.

        (iii) Return the last element of the sorted array, which         
              will be the largest element.

Step 4: Main Function:
        (i) Initialize the array arr with some integer values.
        (ii) Calculate the number of elements in the array n.
        (iii) Call the findLargestSorting function with arr and n as 
              arguments and print the result.
              
Step 5: Exit

Example Program in C:

#include <stdio.h>
#include <stdlib.h> // For qsort

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int findLargestSorting(int arr[], int n) {
    qsort(arr, n, sizeof(int), compare);
    return arr[n - 1];
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("Largest element (Sorting): %d\n", findLargestSorting(arr, n));
    return 0;
}

Step-by-Step Explanation

Include the Standard I/O and Standard Library Headers

#include <stdio.h>
#include <stdlib.h> // For qsort

• These lines include the standard input-output library (stdio.h) and the standard library (stdlib.h). The stdlib.h header is needed for the qsort function.

Define the Comparison Function for qsort

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

• This function defines the comparison logic for sorting. The qsort function requires a comparison function that takes two const void* arguments.

• const void *a and const void *b are pointers to the elements being compared.

• (*(int*)a – *(int*)b) converts the void* pointers to int* pointers, dereferences them to get the integer values, and returns the difference. This determines the order of the elements:

• If a is less than b, the result is negative (indicating that a should come before b).

• If a is greater than b, the result is positive (indicating that b should come before a).

• If a is equal to b, the result is zero (indicating that the order of a and b doesn’t matter).

Define the Function to Find the Largest Element Using Sorting

int findLargestSorting(int arr[], int n) {
    qsort(arr, n, sizeof(int), compare);
    return arr[n - 1];
}

int findLargestSorting(int arr[ ], int n): This function takes an array of integers arr and its size n as parameters and returns an integer which is the largest element in the array.

qsort(arr, n, sizeof(int), compare): This line calls the qsort function to sort the array. The parameters are:

• arr: the array to be sorted.
• n: the number of elements in the array.
• sizeof(int): the size of each element in the array.
• compare: The comparison function to determine the order of elements.
• return arr[n – 1];: After sorting, the largest element is the last element in the array (since the array is sorted in ascending order).

Define the main Function

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("Largest element (Sorting): %d\n", findLargestSorting(arr, n));
    return 0;
}

• int arr[ ] = {1, 2, 3, 4, 5}; :This line initializes an array arr with the elements {1, 2, 3, 4, 5}.

• int n = sizeof(arr) / sizeof(arr[0]);: This line calculates the number of elements in the array. sizeof(arr) gives the total size of the array in bytes, and sizeof(arr[0]) gives the size of one element in the array. Dividing these gives the number of elements in the array n.

• printf(“Largest element (Sorting): %d\n”, findLargestSorting(arr, n)); : This line calls the findLargestSorting function with arr and n as arguments, and prints the largest element found by the function.

• return 0; : This line indicates that the program has executed successfully.

Execution Flow

The program starts with the main function.

The array arr is initialized with {1, 2, 3, 4, 5}.

The number of elements in the array n is calculated.

The findLargestSorting function is called with arr and n as arguments.

Inside the findLargestSorting function:

• The qsort function sorts the array in ascending order using the compare function.
• After sorting, the function returns the last element of the array, which is the largest element.

The main function prints the largest element found by the findLargestSorting function.

The program terminates successfully.

By following these steps, the program successfully finds and prints the largest element in the array using the sorting method.

Method 3: Divide and Conquer (Recursive)

Algorithm:

Step 1: Start

Step 2: Initialization: Define a recursive function findLargestRecursive(arr, low, high).

Step 3: Base Case: If low is equal to high, return arr[low].

Step 4: Calculate Midpoint: Compute the midpoint mid as (low + high) / 2.

Step 5: Recursive Call on Left Half: Call findLargestRecursive(arr, low, mid) to find the largest element in the left half.

Step 6: Recursive Call on Right Half: Call findLargestRecursive(arr, mid + 1, high) to find the largest element in the right half.

Step 7: Compare and Return: Compare the results of the two recursive calls. Return the larger of the two.

Step 8: Main Function:
        (i) Initialize the array.
        (ii) Calculate the number of elements.
        (iii) Call findLargestRecursive with the full range of the array.
        (iv) Print the result.
        
Step 9:Exit 

Example Program in C:

#include <stdio.h>

int findLargestRecursive(int arr[], int low, int high) {
    if (low == high)
        return arr[low];

    int mid = (low + high) / 2;
    int max1 = findLargestRecursive(arr, low, mid);
    int max2 = findLargestRecursive(arr, mid + 1, high);

    return (max1 > max2) ? max1 : max2;
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("Largest element (Recursive): %d\n", findLargestRecursive(arr, 0, n - 1));
    return 0;
}

Step-by-Step Explanation

Include Standard I/O Library

#include <stdio.h>

• This line includes the standard input-output library, which allows us to use functions like printf for output.

Define the Recursive Function to Find the Largest Element

int findLargestRecursive(int arr[], int low, int high) {
    if (low == high)
        return arr[low];

    int mid = (low + high) / 2;
    int max1 = findLargestRecursive(arr, low, mid);
    int max2 = findLargestRecursive(arr, mid + 1, high);

    return (max1 > max2) ? max1 : max2;
}

• int findLargestRecursive(int arr[ ], int low, int high): This function takes an array of integers arr, and two integers low and high representing the indices of the subarray we are currently considering. It returns the largest element in the subarray.

• if (low == high) return arr[low];: This is the base case of the recursion. If the subarray has only one element (when low is equal to high), the function returns that single element.

• int mid = (low + high) / 2;: This line calculates the middle index of the current subarray.

• int max1 = findLargestRecursive(arr, low, mid);: This line recursively finds the largest element in the left half of the current subarray (from low to mid).

• int max2 = findLargestRecursive(arr, mid + 1, high);: This line recursively finds the largest element in the right half of the current subarray (from mid + 1 to high).

• return (max1 > max2) ? max1 : max2;: This line compares the largest elements found in the left and right halves, and returns the larger of the two.

Define the main Function

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("Largest element (Recursive): %d\n", findLargestRecursive(arr, 0, n - 1));
    return 0;
}

• int arr[ ] = {1, 2, 3, 4, 5};: This line initializes an array arr with the elements {1, 2, 3, 4, 5}.

• int n = sizeof(arr) / sizeof(arr[0]);: This line calculates the number of elements in the array. sizeof(arr) gives the total size of the array in bytes, and sizeof(arr[0]) gives the size of one element in the array. Dividing these gives the number of elements in the array n.

• printf(“Largest element (Recursive): %d\n”, findLargestRecursive(arr, 0, n – 1));: This line calls the findLargestRecursive function with arr, 0 (starting index), and n – 1 (ending index) as arguments, and prints the largest element found by the function.

• return 0; : This line indicates that the program has executed successfully.

Execution Flow

The program starts with the main function.

The array arr is initialized with {1, 2, 3, 4, 5}.

The number of elements in the array n is calculated.

The findLargestRecursive function is called with arr, 0, and n – 1 as arguments.

Inside the findLargestRecursive function:

• The base case is checked. If the subarray has only one element, that element is returned.
• The middle index mid is calculated.
• The function recursively finds the largest element in the left half (from low to mid).
• The function recursively finds the largest element in the right half (from mid + 1 to high).
• The function compares the largest elements found in the left and right halves and returns the larger of the two.

The main function prints the largest element found by the findLargestRecursive function.

The program terminates successfully.

By following these steps, the program successfully finds and prints the largest element in the array using the divide-and-conquer method.