# Second Largest Number In Array Java

What We Are Learn:

In this tutorial, we are going to write the java program to find the Second Largest Number In Array, so this is an important problem and it’s generally asked in interviews.

There are various ways available to find out the second largest number in array java. we are going to each of them with an examples

• Using Sorting technique
• Using Two Traverse of array

### Find Second Largest Number In Array Using the Sorting Technique

The goal is to sort the array in descending order and then return the second element that is not equal to the largest element from the sorted array.

```package com.softwaretestingo.interviewprograms;
import java.util.Arrays;
public class SecondLargestNoEx1
{
static void FindSecondlargest(int arr[], int arr_size)
{
int i, first, second;

// When array having less then 2 elements
if (arr_size < 2)
{
System.out.printf(" Invalid Input ");
return;
}

// Sort the array
Arrays.sort(arr);

// Start from second last element as the largest element is at last
for (i = arr_size - 2; i >= 0; i--)
{
// If the element is not equal to largest element
if (arr[i] != arr[arr_size - 1])
{
System.out.printf("The second largest " + "element is %d\n", arr[i]);
return;
}
}

System.out.printf("There is no second " + "largest element\n");
}
public static void main(String[] args)
{
int arr[] = {12, 35, 1, 10, 34, 1};
int n = arr.length;
FindSecondlargest(arr, n);
}
}```

Another Way to Find the Second Largest Number In Array using the sorting technique.

```package com.softwaretestingo.interviewprograms;
import java.util.Arrays;
public class SecondLargestNoEx2
{
public static void main(String[] args)
{
int array[] = {10, 20, 25, 63, 96, 57};
int size = array.length;
Arrays.sort(array);
System.out.println("sorted Array ::"+Arrays.toString(array));
int res = array[size-2];
System.out.println("2nd largest element is ::"+res);
}
}```

### Find Second Largest Number In Array Using Two Traverse of array

```package com.softwaretestingo.interviewprograms;
public class SecondLargestNoEx3
{
public static int getSecondLargest(int[] a)
{
int temp;
//sort the array
for (int i = 0; i < a.length; i++)
{
for (int j = i + 1; j < a.length; j++)
{
if (a[i] > a[j])
{
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
}
//return second largest element
return a[a.length - 2];
}
public static void main(String[] args)
{
int a[] = { 11,10,4, 15, 16, 13, 2 };
System.out.println("Second Largest: " +getSecondLargest(a));
}
}```

Another Method

```package com.softwaretestingo.interviewprograms;
public class SecondLargestNoEx3
{
static void secondLargest(int arr[], int arr_size)
{
int i, first, second;

if (arr_size < 2)
{
System.out.printf(" Invalid Input ");
return;
}

int largest = second = Integer.MIN_VALUE;

// Find the largest element
for(i = 0; i < arr_size; i++)
{
largest = Math.max(largest, arr[i]);
}

// Find the second largest element
for(i = 0; i < arr_size; i++)
{
if (arr[i] != largest)
second = Math.max(second, arr[i]);
}
if (second == Integer.MIN_VALUE)
System.out.printf("There is no second " +
"largest element\n");
else
System.out.printf("The second largest " +
"element is %d\n", second);
}

public static void main(String[] args)
{
int arr[] = { 12, 35, 1, 10, 34, 1 };
int n = arr.length;

secondLargest(arr, n);
}
}```

## Second Largest Number In Array Java

So when someone asks about any Java programs in interviews, first of all, we need to analyze the coding assignment and break it down. Now for this particular assignment, there are a couple of things that we need to take into account. so in order to find the Second Largest Number In Array we know one thing we must go through every element within the Array.

• We must iterate through the entire list another thing is that we need to be able to keep track of the second highest number.
• We also need to be able to keep track of the highest number now the reason we need to be able to keep track of these numbers is basically to make sure that we are going to calculate the proper values upon each iteration of this loop.
• We need to know how to store the value of the above numbers as we iterate through this list so basically what this means is we need to be able to set up conditional statements that are going to check for the highest and the second highest values.

Approach

First, take the number of elements that the user wants to enter in the array as input. Then, initialize an array with that size and take input from users. After taking input from the user, we will use the below approach to find out the second-highest number in an array.

• We’ll be initializing two integers – largest and second-largest. Both integers will be set to the possible minimum integer value (i.e., Integer.MIN_VALUE).
• This is the optional step where we are print all the elements of the array.
• The main logic to find out the second-highest or second maximum number in the array is very simple. Whenever the current element of the array is greater than the value present in integer largest then set the largest value to the second-largest and current element to the largest. If the current element is less than the largest but greater than the second-largest then we will assign the current element to the second-largest. And we will repeat this process until we reached the last element of the array.

If you have traverse the complete array list then we will able to find the Second Largest Number In Array. Here is the example program:

```package com.softwaretestingo.interviewprograms;
import java.util.Arrays;
import java.util.Scanner;
public class SecondLargestNoEx4
{
public static void main(String[] args)
{
Scanner scanner = new Scanner(System.in);
System.out.println("Enter array size :");
Integer numberOfElements = scanner.nextInt();
int arr[] = new int[numberOfElements];
System.out.println("Enter array elements :");
for (int i = 0; i < arr.length; i++)
{
arr[i] = scanner.nextInt();
}
System.out.println("Array elements are" + Arrays.toString(arr));
int largest = Integer.MIN_VALUE;
int secondLargest = Integer.MIN_VALUE;
for (int i = 0; i < arr.length; i++)
{
if (arr[i] > largest)
{
secondLargest = largest;
largest = arr[i];
} else if (arr[i] > secondLargest && arr[i] != largest)
{
secondLargest = arr[i];
}
}
if (secondLargest == Integer.MIN_VALUE)
{
System.out.println("There is no second highest/largest element in the array");
} else
{
System.out.println("Second highest element in array is :" + secondLargest);
}
scanner.close();
}
}```

### Second Lowest Number In Array Java [ Using Loops ]

As we are discussing about how to find the second largest element in the array, sometime in interviews it was also asked to find out the second Highest and Second lowest elements of the array.

• Declare two variables say first = INT_MAX and second = INT_MAX to hold the first and second smallest elements respectively.
• Now, iterate over the entire array i.e, from index 0 to n-1
• Inside the loop check if (arr[i]<first) then set second = first and first = arr[i].
• Else check if(second > arr[i]) then set second = arr[i]
• After complete iteration print the value of second.
```package com.softwaretestingo.interviewprograms;
public class SecondLowestNoEx1
{
static int secSmallest(int arr[], int n)
{
int first = Integer.MAX_VALUE, second = Integer.MAX_VALUE;

for (int i=0; i < n; i++)
{
if(arr[i] < first)
{
second = first; first = arr[i];
}
else if(second>arr[i])
second = arr[i];
}

return second;

}
public static void main(String[] args)
{
int arr[] = {12, 13, 1, 10, 34, 10};
int n = arr.length;
System.out.print("Second Lowest Number: " +secSmallest(arr, n));
}
}```

### Second Lowest Number In Array Java [ Using Two Loops ]

We can also find out the second lowest number by using two loops.

• Take a variable say smallest = Integer.MAX_VALUE
• Run a loop over the entire array and check if (arr[i]<smallest)
• Then set smallest = arr[i].
• Declare another variable say sec_smallest = Integer.MAX_VALUE
• Run a loop and check if arr[i] != smallest and arr[i] < sec_smallest
• Then print(sec_smallest) after completing the iteration.
```package com.softwaretestingo.interviewprograms;
public class SecondLowestNoEx2
{
static int secLowest(int arr[], int n)
{
// assigning first element as smallest temporarily
int smallest = arr[0];

// we find the smallest element here
for (int i=0; i < n; i++){
if(arr[i] < smallest)
smallest = arr[i];
}

// temporarily assinging largest max value
int sec_smallest = Integer.MAX_VALUE;

// finding second smallest here
for (int i=0; i < n; i++){
if(arr[i] != smallest && arr[i] < sec_smallest)
sec_smallest = arr[i];
}

return sec_smallest;

}
public static void main(String[] args)
{
int arr[] = {12, 13, 1, 10, 34, 10};
int n = arr.length;
System.out.print("Second Lowest Number: " +secLowest(arr, n));
}
}```

## Find Second Smallest and Second Largest Element in an array

We can find the Second Smallest and Second Largest elements by using 3 methods:

### Solution 1: Brute Force Approach

You can use this approach when there is not duplicates. So for this approach you have to follow the below steps:

• Sort the array in ascending order
• The element present at the second index is the second smallest element
• The element present at the second index from the end is the second largest element
```package com.softwaretestingo.interviewprograms;
import java.util.Arrays;
public class SecondSmallestSecondLargestEx1
{
static private void getElements(int[] arr, int n)
{
if (n == 0 || n==1)
{
System.out.print(-1);
System.out.print(" ");
System.out.print(-1);
System.out.print("\n");
}
Arrays.sort(arr);
int small = arr[1];
int large = arr[n - 2];
System.out.println("Second smallest is "+small);
System.out.println("Second largest is "+large);
}
public static void main(String[] args)
{
int[] arr = {1, 2, 4, 6, 7, 5};
int n = arr.length;
getElements(arr, n);
}
}```

### Solution 2:

We definitely want to avoid sorting the whole array if we can help it – doing so would increase our time complexity. Is there some way we can get our answer without having to sort everything?

• Find the smallest and largest element in the array in a single traversal
• After this, we once again traverse the array and find an element that is just greater than the smallest element we just found.
• Similarly, we would find the largest element which is just smaller than the largest element we just found
• Indeed, this is our second smallest and second largest element.
```package com.softwaretestingo.interviewprograms;
public class SecondSmallestSecondLargestEx2
{
static private void getElements(int[] arr, int n)
{
if (n == 0 || n==1)
{
System.out.print(-1);
System.out.print(" ");
System.out.print(-1);
System.out.print("\n");
}
int small = Integer.MAX_VALUE;
int second_small = Integer.MAX_VALUE;
int large = Integer.MIN_VALUE;
int second_large = Integer.MIN_VALUE;
int i;
for (i = 0;i < n;i++)
{
small = Math.min(small,arr[i]);
large = Math.max(large,arr[i]);
}
for (i = 0;i < n;i++)
{
if (arr[i] < second_small && arr[i] != small)
{
second_small = arr[i];
}
if (arr[i] > second_large && arr[i] != large)
{
second_large = arr[i];
}
}

System.out.println("Second smallest is "+second_small);
System.out.println("Second largest is "+second_large);
}

public static void main(String[] args)
{
int[] arr = {11, 22, 54, 96, 37, 55};
int n = arr.length;
getElements(arr, n);
}
}```

Solution 3:

In our previous solution, we were able to bring the time complexity down to O(N) by doing two traversals. But there is another more efficient way, which requiring only a single traversal to find the answer. By using smart comparisons, we can eliminate the need for a second traversal.

Second Smallest Algo:

• If the current element is smaller than ‘small’, then we update second_small and small variables
• Else if the current element is smaller than ‘second_small’ then we update the variable ‘second_small’
• Once we traverse the entire array, we would find the second smallest element in the variable second_small.
• Here’s a quick demonstration of the same.

Second Largest Algo:

• If the current element is larger than ‘large’ then update second_large and large variables
• Else if the current element is larger than ‘second_large’ then we update the variable second_large.
• Once we traverse the entire array, we would find the second largest element in the variable second_large.
• Here’s a quick demonstration of the same.
```package com.softwaretestingo.interviewprograms;
public class SecondSmallestSecondLargestEx3
{
static private int secondSmallest(int[] arr, int n)
{
if (n < 2)
{
return -1;
}
int small = Integer.MAX_VALUE;
int second_small = Integer.MAX_VALUE;
int i;
for (i = 0; i < n; i++)
{
if (arr[i] < small)
{
second_small = small;
small = arr[i];
}
else if (arr[i] < second_small && arr[i] != small)
{
second_small = arr[i];
}
}
return second_small;
}
static private int secondLargest(int[] arr, int n)
{
if(n<2)
return -1;
int large = Integer.MIN_VALUE;
int second_large = Integer.MIN_VALUE;
int i;
for (i = 0; i < n; i++)
{
if (arr[i] > large)
{
second_large = large;
large = arr[i];
}

else if (arr[i] > second_large && arr[i] != large)
{
second_large = arr[i];
}
}
return second_large;
}
public static void main(String[] args)
{
int[] arr = {18, 22, 46, 77, 77, 53};
int n = arr.length;
int sS = secondSmallest(arr, n);
int sL = secondLargest(arr, n);
System.out.println("Second smallest is "+sS);
System.out.println("Second largest is "+sL);
}
}```

## Get Second Highest/Lowest Number using Streams

```package com.softwaretestingo.interviewprograms;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class SecondSmallestSecondLargestEx4
{
public static void main(String[] args)
{
List<Integer> list=Arrays.asList(11,6,2,978,78,45,87,23,9,11,76,56);

//Print Second Highest
int sechH=list.stream().sorted(Collections.reverseOrder()).distinct().limit(2).skip(1).findFirst().get();
System.out.println("Second Highest Number: "+sechH);

int sechHH=list.stream().sorted(Collections.reverseOrder()).distinct().skip(1).findFirst().get();
System.out.println("Second Highest Number: "+sechHH);

//Print Second Lowest
int secL=list.stream().sorted().distinct().skip(1).findFirst().get();
System.out.println("Second lowest Number: "+secL);
}
}```

Conclusion:

We belive in this blog post we tryied to cover all the possisble ways to find the second largest and second smallest element from the array list. We hope this Java Programs Examples will be informative and helpful.

If you found this tutorial helpful, be sure to share it with others who might find it informative. And don’t forget to leave your thoughts in the comment section below! If you’re on the hunt for more interview programs, visit our interview category.

I love open-source technologies and am very passionate about software development. I like to share my knowledge with others, especially on technology that's why I have given all the examples as simple as possible to understand for beginners. All the code posted on my blog is developed, compiled, and tested in my development environment. If you find any mistakes or bugs, Please drop an email to softwaretestingo.com@gmail.com, or You can join me on Linkedin.