What is the C++ Program to Find the Second Largest Element in Array?

While dealing with arrays, there are several problem statements that you might have to resolve. One of such problem statements is the searching problems in an array.

Searching problems usually can be resolved by the simple application of the basic concept of arrays and its techniques.

Hence, various companies and technical assessments ask the candidates to resolve a basic yet tricky problem of finding the second largest element in an array.

Other than solving this problem efficiently, the methods or techniques you use to resolve it are quite significant. Usually, the recruiters analyse your approach and technique to resolve this problem statement in detail.

If the problem statement of finding the second largest element in array is tricky for you too and you don’t know the right technique to resolve it, this article will save hours of internet surfing for you.

We will discuss different methods to resolve this problem statement along with a brief yet interesting ninja technique problem in this article.

Before moving further, let’s understand the problem statement in detail first.

Problem Statement with example

Usually, the problem statement for this category of questions is kept quite simple. However, the recruiters can mould the problem statement in N number of ways.

The problem statement for this question is formed as:

” Given an array of N elements, find the second largest element in array”

The problem statement can also be formed as

“Accept an array of first 25 multiples of 8. And print the second largest multiple of 8 as an output”.

These problem statements can easily be resolved through the same approach.

To understand this problem, you can consider the following working example.

Let’s say A is an array of the first 5 positive integers. The array looks like {0, 1,2,3,4}. In this array, you can notice that the second largest element is 3.

Another example of this problem statement can be taken with an array of elements without sorting.

Let’s take an array P that contains elements as {3, 8,6,19,23,86,53}. In this an unsorted array. The second largest element in this array will be 53 whereas 86 is the largest in the array.

Finding the second largest element in an array through the theoretical approach is simple for the smaller arrays. However, for arrays with N number of elements, you will have to take technical approaches.

Let’s walk through these approaches one by one.

Methods to Find Second Largest Element in an Array

There are three main approaches through which you can resolve this problem statement. Depending on the size of your array and convenience, you can select an efficient approach to resolve this problem.

First, let’s understand the simple approach to solving this problem in detail.

Simple Approach

In this approach, the idea is simply to sort an array and return the second-largest value. The array is arranged in descending order based on the value of each element.

Once done, simply the second last element is returned as the output of this function.

The steps of this approach can be explained by a working example given below:

Let A be an array with unsorted elements. Say A looks like {1, 3,6,2,7}
Now, the first step is to run a loop and arrange these elements in a descending order
After the end of the loop, the array will become A={1, 2,3,6,7}
Now, as a return of this function, you will have to return the second last element of this array. In this case, this element will be 6.

As you can observe, the second largest element in an array given above is 6. Hence, this approach is quite efficient. However, you can not use this approach for solving bigger arrays given its space and time complexity.

Better solution

The second approach is quite simple as well. However, space complexity is still a challenge for this approach.

The idea of this approach is to transverse the given array two times. The first time, the code will find the largest element of the array. Then, this element will be deleted/removed from the second loop.

The second loop of this code will determine the largest array in the given elements of an array.

Following are the steps that elaborate the steps of this approach

Accept an array from the user. Let’s consider this array as P={3, 4,2,6}
Now, the first loop will remove the largest element from the array. Resultant array will become {3, 4,2}
After this, the second loop will run to return the largest value of the given array.

Finally, the largest element of the array will be 4 which is the second largest element of the primary array.

At last, let’s discuss the efficient solution for this problem statement.

Efficient solution

In this approach, the space and time complexity is resolved at once. The idea of this approach is to find the second largest element of the array with one transversal only.

Steps to implement this approach are:

Declare two variables that for the first largest and second largest element
Run a loop to find the largest element. Assign its value to the variable storing the first largest value.
In the same loop, simply find the second largest value by keeping the first aside.
Assign this value to the second variable
Return the value to the second variable

Since we are going through a significant interview question, another very important question is the ninja technique problem. Let’s take a brief look into this problem:

Overview of a ninja technique problem

The Ninja technique is an efficient manner to decide whether the code will make a certain decision or not.

In this technique, a string is generated with only the digits that can form efficient subarrays to make a certain decision.


Finding the second largest element in an array is a common problem statement asked by interviewers and test assessments. You can resolve this problem with various approaches.

However, you can also consider the Ninja technique to find an accurate solution and to make an efficient decision.

Leave a Reply

Your email address will not be published. Required fields are marked *