Find The Largest and Second Largest Numbers in an Array (JavaScript)

In this article, we’ll explore the common problem of finding the largest and second-largest numbers in an array. It’s a useful problem to solve in programming interviews, and in this case, we’ll also address an issue in a common approach—where the first element of the array might be overlooked when it’s the largest.

Problem Overview:

We need a program that can identify the largest and second-largest numbers in a given array. A common problem with existing solutions arises when the first element of the array is the largest, and the code fails to account for this scenario properly.

Code Breakdown

The goal of the program is to:

1. Accept an array of numbers.
2. Identify the largest number (largest1).
3. Identify the second-largest number (largest2).

However, in some cases, such as when the first element is the largest number, the logic may break or produce an incorrect result. Let’s first look at the traditional approach, identify the issue, and then propose a fix.

Original Code in JavaScript:

 codefunction findLargestAndSecondLargest(arr) {
    let largest1, largest2;
    
    // Check if the array has less than two elements
    if (arr.length < 2) {
        console.log("Array must contain at least two elements.");
        return;
    }

    // Step 1: Initialize the largest and second largest values
    largest1 = arr[0];
    for (let i = 1; i < arr.length; i++) {
        if (arr[i] > largest1) {
            largest1 = arr[i];
        }
    }

    // Step 2: Initialize second largest
    largest2 = arr[0];
    for (let i = 1; i < arr.length; i++) {
        if (arr[i] > largest2 && arr[i] < largest1) {
            largest2 = arr[i];
        }
    }

    console.log("First and second largest numbers are: " + largest1 + " and " + largest2);
}

let arr = [10, 5, 20, 30, 25];
findLargestAndSecondLargest(arr);

Issue with the Original Code:

1. Initialization of Largest and Second-Largest Values:
   • The code initially assigns largest1 = arr[0] (first element) and then checks for the largest value in the rest of the array.
   • The second loop initializes largest2 = arr[0], which is problematic if arr[0] is the largest number. This approach results in an incorrect calculation of the second-largest number if the largest element is at the first index.
2. Edge Cases:
   • If the first element is the largest, the second loop will wrongly treat the first element as a potential candidate for the second-largest value, which could lead to incorrect results.
   • The program assumes the array always has at least two elements, which isn’t always the case. A check for the array’s length could improve robustness.

Fixing the Code:

To resolve the issue, we need to:

1. Properly initialize both largest1 and largest2 based on the first two elements.
2. Iterate through the rest of the array and update largest1 and largest2 based on comparisons.
3. Ensure that we are correctly considering only distinct elements for the second-largest value.
4. Add a validation check to ensure the array has at least two elements.

Corrected Code:

codefunction findLargestAndSecondLargest(arr) {
    // Ensure the array has at least two elements
    if (arr.length < 2) {
        console.log("Array must contain at least two elements.");
        return;
    }

    let largest1, largest2;

    // Initialize the largest and second-largest based on the first two elements
    if (arr[0] > arr[1]) {
        largest1 = arr[0];
        largest2 = arr[1];
    } else {
        largest1 = arr[1];
        largest2 = arr[0];
    }

    // Iterate through the array to find the largest and second largest
    for (let i = 2; i < arr.length; i++) {
        if (arr[i] > largest1) {
            largest2 = largest1; // Move current largest to second largest
            largest1 = arr[i];   // Update largest
        } else if (arr[i] > largest2 && arr[i] !== largest1) {
            largest2 = arr[i];   // Update second largest
        }
    }

    console.log("First and second largest numbers are: " + largest1 + " and " + largest2);
}

let arr = [10, 5, 20, 30, 25];
findLargestAndSecondLargest(arr);  // Output: 30 and 25

Explanation of Changes:

1. Initial Values:
   • We initialize largest1 and largest2 by comparing the first two elements. This step ensures that we don’t miss the case where the largest element is at index 0.
2. Comparison Logic:
   • Starting from the third element (i = 2), the code checks if the current element is larger than largest1 (the largest so far). If it is, we update largest1 and move the old largest1 to largest2.
   • If the element is not larger than largest1, we check if it is larger than largest2 and ensure it’s not equal to largest1. This ensures that we don’t mistakenly choose the largest number again for the second-largest slot.
3. Array Length Check:
   • The program first checks if the array has at least two elements. This prevents errors if the array is too small to calculate a second-largest number.

Conclusion:

This corrected approach ensures that the program handles all edge cases, including when the largest element is the first element in the array. By initializing both largest1 and largest2 based on the first two elements, and then iterating through the rest of the array, we can correctly find the largest and second-largest numbers.

This logic is simple and efficient, and it’s designed to work correctly for arrays of varying sizes while handling edge cases effectively.