How to Find the Largest 5 Numbers in an Array of 10 Without Sorting?

How can I find the largest 5 numbers in an array of 10 numbers without sorting the array?

int[] findLargestFive(int[] arr) {
    int[] largest = new int[5];
    for (int num : arr) {
        for (int j = 0; j < 5; j++) {
            if (num > largest[j]) {
                // Shift smaller elements down
                for (int k = 4; k > j; k--) {
                    largest[k] = largest[k - 1];
                }
                largest[j] = num;
                break;
            }
        }
    }
    return largest;
}

Finding the largest 5 numbers in a fixed-size array without sorting involves maintaining a list of the top 5 numbers as you iterate through the original array. This is more efficient than sorting, especially when the list size is small and fixed.

int[] findLargestFive(int[] arr) {
    int[] largest = new int[5]; // To store the largest five numbers
    Arrays.fill(largest, Integer.MIN_VALUE); // Initialize with the smallest possible integer

    for (int num : arr) { // Iterate through each number in the arr
        for (int j = 0; j < 5; j++) { // Check against the top 5
            if (num > largest[j]) { // If the current number is larger
                // Shift smaller elements down
                for (int k = 4; k > j; k--) {
                    largest[k] = largest[k - 1];
                }
                largest[j] = num; // Insert the current number
                break; // Break to avoid further checks
            }
        }
    }
    return largest; // Return the largest five numbers
}

Causes

• Inefficient performance: Sorting an array can be slower when you only need a few top values.
• Memory overhead: Sorting can use additional memory resources.
• Unnecessary complexity: Using sorting techniques can complicate simple tasks.

Solutions

• Initialize an array to hold the largest numbers.
• Iterate through the original array and compare each element to the current largest numbers.
• Use a nested loop to find the correct position for inserting each new number.

Mistake: Not initializing the largest array.

Solution: Ensure to initialize the largest array with a minimum value (e.g., Integer.MIN_VALUE) to handle comparisons correctly.

Mistake: Forgetting to break out of inner loops once the number is placed.

Solution: Use a break statement to terminate further checks once a number is inserted into the largest array.

Mistake: Miscounting array bounds leading to ArrayIndexOutOfBoundsException.

Solution: Always ensure the bounds in your loops respect the size of the arrays you're working with.