Given an array of integers, our task is to write a program that efficiently finds the second-largest element present in the array.
Example:
Input: arr[] = {12, 35, 1, 10, 34, 1}
Output: The second largest element is 34.
Explanation: The largest element of the
array is 35 and the second
largest element is 34
Input: arr[] = {10, 5, 10}
Output: The second largest element is 5.
Explanation: The largest element of
the array is 10 and the second
largest element is 5
Input: arr[] = {10, 10, 10}
Output: The second largest does not exist.
Explanation: Largest element of the array
is 10 there is no second largest element
Naive approach:
The idea is to sort the array in descending order and then return the second element which is not equal to the largest element from the sorted array.
Below is the implementation of the above idea:
C++
#include <bits/stdc++.h>
using namespace std;
void print2largest(int arr[], int arr_size)
{
int i, first, second;
if (arr_size < 2) {
printf(" Invalid Input ");
return;
}
sort(arr, arr + arr_size);
for (i = arr_size - 2; i >= 0; i--) {
if (arr[i] != arr[arr_size - 1]) {
printf("The second largest element is %d\n",arr[i]);
return;
}
}
printf("There is no second largest element\n");
}
int main()
{
int arr[] = { 12, 35, 1, 10, 34, 1 };
int n = sizeof(arr) / sizeof(arr[0]);
print2largest(arr, n);
return 0;
}
|
C
#include <stdio.h>
#include<stdlib.h>
int cmpfunc(const void* a, const void* b)
{
return (*(int*)a - *(int*)b);
}
void print2largest(int arr[], int arr_size)
{
int i, first, second;
if (arr_size < 2) {
printf(" Invalid Input ");
return;
}
qsort(arr, arr_size, sizeof(int), cmpfunc);
for (i = arr_size - 2; i >= 0; i--) {
if (arr[i] != arr[arr_size - 1]) {
printf("The second largest element is %d\n",arr[i]);
return;
}
}
printf("There is no second largest element\n");
}
int main()
{
int arr[] = { 12, 35, 1, 10, 34, 1 };
int n = sizeof(arr) / sizeof(arr[0]);
print2largest(arr, n);
return 0;
}
|
Java
import java.util.*;
class GFG{
static void print2largest(int arr[],
int arr_size)
{
int i, first, second;
if (arr_size < 2)
{
System.out.printf(" Invalid Input ");
return;
}
Arrays.sort(arr);
for (i = arr_size - 2; i >= 0; i--)
{
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;
print2largest(arr, n);
}
}
|
Python3
def print2largest(arr, arr_size):
if (arr_size < 2):
print(" Invalid Input ")
return
arr.sort
for i in range(arr_size-2, -1, -1):
if (arr[i] != arr[arr_size - 1]):
print("The second largest element is", arr[i])
return
print("There is no second largest element")
arr = [12, 35, 1, 10, 34, 1]
n = len(arr)
print2largest(arr, n)
|
C#
using System;
class GFG{
static void print2largest(int []arr,
int arr_size)
{
int i;
if (arr_size < 2)
{
Console.Write(" Invalid Input ");
return;
}
Array.Sort(arr);
for(i = arr_size - 2; i >= 0; i--)
{
if (arr[i] != arr[arr_size - 1])
{
Console.Write("The second largest " +
"element is {0}\n", arr[i]);
return;
}
}
Console.Write("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;
print2largest(arr, n);
}
}
|
Javascript
<script>
function print2largest(arr, arr_size) {
let i, first, second;
if (arr_size < 2) {
document.write(" Invalid Input ");
return;
}
arr.sort();
for (i = arr_size - 2; i >= 0; i--) {
if (arr[i] != arr[arr_size - 1]) {
document.write("The second largest element is " + arr[i]);
return;
}
}
document.write("There is no second largest element<br>");
}
let arr= [ 12, 35, 1, 10, 34, 1 ];
let n = arr.length;
print2largest(arr, n);
</script>
|
OutputThe second largest element is 34
Complexity Analysis:
- Time Complexity: O(n log n).
The time required to sort the array is O(n log n). - Auxiliary space: O(1).
As no extra space is required.
Much More Efficient and Easy to Understand:
The Approach:
Here,we use set for avoiding duplicates and we just return the second last element as we know set store in sorted order.
C++
#include <iostream>
#include<bits/stdc++.h>
using namespace std;
int main() {
vector<int>v{12, 35, 1, 10, 34, 1};
set<int>s(v.begin(),v.end());
v.clear();
for(auto it:s)v.push_back(it);
int n=v.size();
cout<<"The Second Largest Element in Vector is: ";
cout<<v[n-2]<<endl;
return 0;
}
|
Java
import java.util.*;
public class Main {
public static void main(String[] args) {
List<Integer> v = new ArrayList<>(Arrays.asList(12, 35, 1, 10, 34, 1));
Set<Integer> s = new TreeSet<>(v);
v.clear();
for (int value : s) {
v.add(value);
}
int n = v.size();
System.out.print("The Second Largest Element in ArrayList is: ");
System.out.println(v.get(n-2));
}
}
|
Python3
if __name__ == "__main__":
v = [12, 35, 1, 10, 34, 1]
s = set(v)
s = sorted(s)
print("The Second Largest Element in Vector is: ",s[-2])
|
C#
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
public class Gfg
{
public static void Main(string[] args)
{
int[] v = {12, 35, 1, 10, 34, 1};
SortedSet<int> s = new SortedSet<int>();
for(int i = 0; i < v.Length; i++)
s.Add(v[i]);
List<int> ans = new List<int>();
foreach (int res in s) {
ans.Add(res);
}
int n = ans.Count;
Console.Write("The Second Largest Element in Vector is: ");
Console.Write(ans[n-2]);
}
}
|
Javascript
let v = [12, 35, 1, 10, 34, 1];
let s = new Set(v);
v = [];
for (let val of s){
v.push(val);
}
v.sort();
s.clear();
let n = v.length;
console.log("The Second largest element in vector is : " + v[n-2]);
|
OutputThe Second Largest Element in Vector is: 34
Complexity Analysis:
Time Complexity: O(N log N).
The Time Required To Insert Into Set And Traversing It O(N log N).
Auxiliary space: O(N).
As Required For Set.
Efficient Approach:
The approach is to traverse the array twice. In the first traversal find the maximum element. In the second traversal find the greatest element in the remaining excluding the previous greatest.
Below is the implementation of the above idea:
C++14
#include <iostream>
using namespace std;
int secondLargest(int arr[], int n) {
int largest = 0, secondLargest = -1;
for (int i = 1; i < n; i++) {
if (arr[i] > arr[largest])
largest = i;
}
for (int i = 0; i < n; i++) {
if (arr[i] != arr[largest]) {
if (secondLargest == -1)
secondLargest = i;
else if (arr[i] > arr[secondLargest])
secondLargest = i;
}
}
return secondLargest;
}
int main() {
int arr[] = { 12, 35, 1, 10, 34, 1 };
int n = sizeof(arr)/sizeof(arr[0]);
int second_Largest = secondLargest(arr, n);
if (second_Largest == -1)
cout << "Second largest didn't exit\n";
else
cout << "Second largest : " << arr[second_Largest];
}
|
Java
import java.io.*;
class GFG{
static void print2largest(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;
for(i = 0; i < arr_size; i++)
{
largest = Math.max(largest, arr[i]);
}
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;
print2largest(arr, n);
}
}
|
Python3
def print2largest(arr, arr_size):
if (arr_size < 2):
print(" Invalid Input ");
return;
largest = second = -2454635434;
for i in range(0, arr_size):
largest = max(largest, arr[i]);
for i in range(0, arr_size):
if (arr[i] != largest):
second = max(second, arr[i]);
if (second == -2454635434):
print("There is no second " +
"largest element");
else:
print("The second largest " +
"element is \n", second);
if __name__ == '__main__':
arr = [12, 35, 1,
10, 34, 1];
n = len(arr);
print2largest(arr, n);
|
C#
using System;
class GFG{
static void print2largest(int []arr, int arr_size)
{
int i, second;
if (arr_size < 2)
{
Console.Write(" Invalid Input ");
return;
}
int largest = second = int.MinValue;
for(i = 0; i < arr_size; i++)
{
largest = Math.Max(largest, arr[i]);
}
for(i = 0; i < arr_size; i++)
{
if (arr[i] != largest)
second = Math.Max(second, arr[i]);
}
if (second == int.MinValue)
Console.Write("There is no second " +
"largest element\n");
else
Console.Write("The second largest " +
"element is {0}\n", second);
}
public static void Main(String[] args)
{
int []arr = { 12, 35, 1, 10, 34, 1 };
int n = arr.Length;
print2largest(arr, n);
}
}
|
Javascript
<script>
function print2largest(arr, arr_size) {
let i;
let largest = second = -2454635434;
if (arr_size < 2) {
document.write(" Invalid Input ");
return;
}
for (i = 0;i<arr_size;i++){
if (arr[i]>largest){
largest = arr[i];
}
}
for (i = 0 ;i<arr_size;i++){
if (arr[i]>second && arr[i]<largest){
second = arr[i];
}
}
if (second == -2454635434){
document.write("There is no second largest element<br>");
}
else{
document.write("The second largest element is " + second);
return;
}
}
let arr= [ 12, 35, 1, 10, 34, 1 ];
let n = arr.length;
print2largest(arr, n);
</script>
|
OutputSecond largest : 34
Complexity Analysis:
- Time Complexity: O(n).
Two traversals of the array are needed. - Auxiliary space: O(1).
As no extra space is required.
Efficient Approach:
Find the second largest element in a single traversal.
Below is the complete algorithm for doing this:
1) Initialize the first as 0(i.e, index of arr[0] element
2) Start traversing the array from array[1],
a) If the current element in array say arr[i] is greater
than first. Then update first and second as,
second = first
first = arr[i]
b) If the current element is in between first and second,
then update second to store the value of current variable as
second = arr[i]
3) Return the value stored in second.
Below is the implementation of the above approach:
C++
#include <iostream>
using namespace std;
int secondLargest(int arr[], int n) {
int first = 0, second = -1;
for (int i = 1; i < n; i++) {
if (arr[i] > arr[first]) {
second = first;
first = i;
}
else if (arr[i] < arr[first]) {
if (second == -1 || arr[second] < arr[i])
second = i;
}
}
return second;
}
int main() {
int arr[] = { 12, 35, 1, 10, 34, 1 };
int index = secondLargest(arr, sizeof(arr)/sizeof(arr[0]));
if (index == -1)
cout << "Second Largest didn't exist";
else
cout << "Second largest : " << arr[index];
}
|
C
#include <limits.h>
#include <stdio.h>
void print2largest(int arr[], int arr_size)
{
int i, first, second;
if (arr_size < 2) {
printf(" Invalid Input ");
return;
}
first = second = INT_MIN;
for (i = 0; i < arr_size; i++) {
if (arr[i] > first) {
second = first;
first = arr[i];
}
else if (arr[i] > second && arr[i] != first)
second = arr[i];
}
if (second == INT_MIN)
printf("There is no second largest element\n");
else
printf("The second largest element is %d", second);
}
int main()
{
int arr[] = { 12, 35, 1, 10, 34, 1 };
int n = sizeof(arr) / sizeof(arr[0]);
print2largest(arr, n);
return 0;
}
|
Java
import java.io.*;
class GFG {
public static void print2largest(int arr[],
int arr_size)
{
int i, first, second;
if (arr_size < 2) {
System.out.print(" Invalid Input ");
return;
}
first = second = Integer.MIN_VALUE;
for (i = 0; i < arr_size; i++) {
if (arr[i] > first) {
second = first;
first = arr[i];
}
else if (arr[i] > second && arr[i] != first)
second = arr[i];
}
if (second == Integer.MIN_VALUE)
System.out.print("There is no second largest"
+ " element\n");
else
System.out.print("The second largest element"
+ " is " + second);
}
public static void main(String[] args)
{
int arr[] = { 12, 35, 1, 10, 34, 1 };
int n = arr.length;
print2largest(arr, n);
}
}
|
Python3
def print2largest(arr, arr_size):
if (arr_size < 2):
print(" Invalid Input ")
return
first = second = -2147483648
for i in range(arr_size):
if (arr[i] > first):
second = first
first = arr[i]
elif (arr[i] > second and arr[i] != first):
second = arr[i]
if (second == -2147483648):
print("There is no second largest element")
else:
print("The second largest element is", second)
arr = [12, 35, 1, 10, 34, 1]
n = len(arr)
print2largest(arr, n)
|
C#
using System;
class GFG {
public static void print2largest(int[] arr,
int arr_size)
{
int i, first, second;
if (arr_size < 2) {
Console.WriteLine(" Invalid Input ");
return;
}
first = second = int.MinValue;
for (i = 0; i < arr_size; i++) {
if (arr[i] > first) {
second = first;
first = arr[i];
}
else if (arr[i] > second && arr[i] != first)
second = arr[i];
}
if (second == int.MinValue)
Console.Write("There is no second largest"
+ " element\n");
else
Console.Write("The second largest element"
+ " is " + second);
}
public static void Main(String[] args)
{
int[] arr = { 12, 35, 1, 10, 34, 1 };
int n = arr.Length;
print2largest(arr, n);
}
}
|
Javascript
<script>
function print2largest(arr, arr_size) {
let i;
let largest = second = -2454635434;
if (arr_size < 2) {
document.write(" Invalid Input ");
return;
}
for (i = 0 ;i<arr_size;i++){
if (arr[i]>largest){
second = largest ;
largest = arr[i]
}
else if (arr[i]!=largest && arr[i]>second ){
second = arr[i];
}
}
if (second == -2454635434){
document.write("There is no second largest element<br>");
}
else{
document.write("The second largest element is " + second);
return;
}
}
let arr= [ 12, 35, 1, 10, 34, 1 ];
let n = arr.length;
print2largest(arr, n);
</script>
|
PHP
<?php
function print2largest($arr, $arr_size)
{
if ($arr_size < 2)
{
echo(" Invalid Input ");
return;
}
$first = $second = PHP_INT_MIN;
for ($i = 0; $i < $arr_size ; $i++)
{
if ($arr[$i] > $first)
{
$second = $first;
$first = $arr[$i];
}
else if ($arr[$i] > $second &&
$arr[$i] != $first)
$second = $arr[$i];
}
if ($second == PHP_INT_MIN)
echo("There is no second largest element\n");
else
echo("The second largest element is " . $second . "\n");
}
$arr = array(12, 35, 1, 10, 34, 1);
$n = sizeof($arr);
print2largest($arr, $n);
?>
|
OutputThe second largest element is 34
Complexity Analysis:
- Time Complexity: O(n).
Only one traversal of the array is needed. - Auxiliary space: O(1).
As no extra space is required.
Another Approach for finding the second largest using the map data structure
Step 1: Initialize a map data.
Step 2: Store the elements of the array with their count in the map and map data structure always arrange the elements in their increasing order.
Step 3: If map size is greater than 1 then second largest exist else not exist.
Step 4: If size greater 1 then get the second last key from end by using rbegin() of map data structure because every key will be distinct.
Step 5: Finally print the second largest.
Let’s see the implementation for the above algorithm : –
C++
#include <bits/stdc++.h>
using namespace std;
void secondLargest(int n, vector<int> vec){
if(n < 2){
cout << "Invalid Input";
return;
}
map<int, int> count;
for(int i = 0; i < n; i++){
count[vec[i]]++;
}
if(count.size() == 1){
cout << "No Second largest element exist";
return;
}
int size = 1;
for(auto it = count.rbegin(); it != count.rend(); it++){
if(size == 2){
cout << "The second largest element is: " << it->first;
break;
}
size++;
}
cout << endl;
}
int main() {
vector<int> vec = { 12, 35, 1, 10, 34, 1 };
secondLargest(vec.size(), vec);
return 0;
}
|
Java
import java.util.*;
public class Main {
public static void main(String[] args)
{
int[] vec = { 12, 35, 1, 34, 10, 1 };
secondLargest(vec.length, vec);
}
public static void secondLargest(int n, int[] vec)
{
if (n < 2) {
System.out.println("Invalid Input");
return;
}
TreeMap<Integer, Integer> count
= new TreeMap<>(Collections.reverseOrder());
for (int i = 0; i < n; i++) {
count.put(vec[i],
count.getOrDefault(vec[i], 0) + 1);
}
if (count.size() == 1) {
System.out.println(
"No Second largest element exist");
return;
}
int size = 1;
for (Map.Entry<Integer, Integer> it :
count.entrySet()) {
if (size == 2) {
System.out.println(
"The second largest element is: "
+ it.getKey());
break;
}
size++;
}
System.out.println();
}
}
|
Python3
from collections import defaultdict
def second_largest(n, vec):
if n < 2:
print("Invalid Input")
return
count = defaultdict(int)
for i in range(n):
count[vec[i]] += 1
if len(count) == 1:
print("No Second largest element exist")
return
count_sorted = sorted(count.items(), key=lambda x: x[0], reverse=True)
second_largest = None
for i, (key, value) in enumerate(count_sorted):
if i == 1:
second_largest = key
break
if second_largest is not None:
print("The second largest element is:", second_largest)
vec = [12, 35, 1, 10, 34, 1]
second_largest(len(vec), vec)
|
C#
using System;
class GFG {
public static void print2largest(int[] arr,
int arr_size)
{
int i, first, second;
if (arr_size < 2) {
Console.WriteLine(" Invalid Input ");
return;
}
first = second = int.MinValue;
for (i = 0; i < arr_size; i++) {
if (arr[i] > first) {
second = first;
first = arr[i];
}
else if (arr[i] > second && arr[i] != first)
second = arr[i];
}
if (second == int.MinValue)
Console.Write("There is no second largest"
+ " element\n");
else
Console.Write("The second largest element"
+ " is " + second);
}
public static void Main(String[] args)
{
int[] arr = { 12, 35, 1, 10, 34, 1 };
int n = arr.Length;
print2largest(arr, n);
}
}
|
Javascript
function secondLargest(n, vec){
if(n < 2){
console.log("Invalid Input");
return;
}
let count = {};
for(let i = 0; i < n; i++){
if(vec[i] in count){
count[vec[i]] += 1;
}
else{
count[vec[i]] = 1;
}
}
if(count.length == 1){
console.log("No second largest element exist");
return;
}
let keys = Object.keys(count);
console.log(keys[keys.length-2]);
}
let vec = [12, 35, 1, 10, 34, 1];
secondLargest(vec.length, vec);
|
OutputThe second largest element is: 34
Time Complexity: O(n), where n = size of array
Auxiliary Space: O(n)
Another Approach for finding the second largest element using the priority queue data structure
In C++ priority queue by default behaves like a max-heap. So in the priority queue, top element is the largest among all the elements that are present in that priority queue.
So here we will push all elements into a priority queue. Now its top element will be the largest element, so we will pop the top element. Now the element present at the top is the second largest element. So we will simply print that.
Code-
C++
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
int main()
{
vector<int> v{ 12, 35, 1, 10, 34, 1 };
priority_queue<int> pq;
for (int i = 0; i < v.size(); i++) {
pq.push(v[i]);
}
pq.pop();
cout << "The Second Largest Element in Vector is: ";
cout << pq.top() << endl;
return 0;
}
|
Java
import java.util.*;
public class Main {
public static void main(String[] args)
{
List<Integer> v
= Arrays.asList(12, 35, 1, 10, 34, 1);
PriorityQueue<Integer> pq = new PriorityQueue<>(
Collections.reverseOrder());
for (int i = 0; i < v.size(); i++) {
pq.add(v.get(i));
}
pq.poll();
System.out.println(
"The Second Largest Element in Vector is: "
+ pq.peek());
}
}
|
Python3
import queue
v = [12, 35, 1, 10, 34, 1]
pq = queue.PriorityQueue()
for i in range(len(v)):
pq.put(-v[i])
pq.get()
print("The Second Largest Element in Vector is:", -pq.get())
|
C#
using System;
using System.Collections.Generic;
using System.Linq;
class Program {
static void Main(string[] args)
{
List<int> v = new List<int>{ 12, 35, 1, 10, 34, 1 };
PriorityQueue<int> pq = new PriorityQueue<int>(
(x, y) = > y.CompareTo(x));
foreach(int item in v) { pq.Enqueue(item); }
pq.Dequeue();
Console.Write(
"The Second Largest Element in Vector is: ");
Console.WriteLine(pq.Peek());
}
}
class PriorityQueue<T> {
private List<T> heap = new List<T>();
private Comparison<T> comparison;
public PriorityQueue()
: this(null)
{
}
public PriorityQueue(Comparison<T> comparison)
{
this.comparison
= comparison ? ? Comparer<T>.Default.Compare;
}
public void Enqueue(T item)
{
heap.Add(item);
int i = Count - 1;
while (i > 0) {
int j = (i - 1) / 2;
if (comparison(heap[j], item) <= 0)
break;
heap[i] = heap[j];
i = j;
}
heap[i] = item;
}
public T Dequeue()
{
T item = heap[0];
int i = 0;
int last = Count - 1;
while (true) {
int j = i * 2 + 1;
if (j >= last || j < 0)
break;
if (j + 1 < last
&& comparison(heap[j + 1], heap[j]) < 0)
j++;
if (comparison(heap[j], heap[last]) >= 0)
break;
heap[i] = heap[j];
i = j;
}
heap[i] = heap[last];
heap.RemoveAt(last);
return item;
}
public T Peek() { return heap[0]; }
public int Count
{
get { return heap.Count; }
}
}
|
Javascript
class PriorityQueue {
constructor() {
this.items = [];
}
enqueue(element, priority) {
let qElement = { element, priority };
let contain = false;
for (let i = 0; i < this.items.length; i++) {
if (this.items[i].priority > qElement.priority) {
this.items.splice(i, 0, qElement);
contain = true;
break;
}
}
if (!contain) {
this.items.push(qElement);
}
}
dequeue() {
if (this.isEmpty()) {
return "Underflow";
}
return this.items.shift();
}
front() {
if (this.isEmpty()) {
return "No elements in Queue";
}
return this.items[0];
}
rear() {
if (this.isEmpty()) {
return "No elements in Queue";
}
return this.items[this.items.length - 1];
}
isEmpty() {
return this.items.length == 0;
}
size() {
return this.items.length;
}
printPQueue() {
let str = "";
for (let i = 0; i < this.items.length; i++) str += this.items[i].element + " ";
return str;
}
}
let v = [12, 35, 1, 10, 34, 1];
let pq = new PriorityQueue();
for (let i = 0; i < v.length; i++) {
pq.enqueue(v[i], -v[i]);
}
pq.dequeue();
console.log("The Second Largest Element in Vector is: " + pq.front().element);
|
OutputThe Second Largest Element in Vector is: 34
Time Complexity: O(nlogn)
Auxiliary Space: O(n), for priority queue
Related Article:
Smallest and second smallest element in an array
This article is contributed by Harsh Agarwal. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.