Open In App

# Find the largest three distinct elements in an array

Given an array with all distinct elements, find the largest three elements. Expected time complexity is O(n) and extra space is O(1).

Examples :

`Input: arr[] = {10, 4, 3, 50, 23, 90}Output: 90, 50, 23`

Method 1:

Algorithm:

`1) Initialize the largest three elements as minus infinite.    first = second = third = -?2) Iterate through all elements of array.   a) Let current array element be x.   b) If (x > first)      {          // This order of assignment is important          third = second          second = first          first = x          }   c)  Else if (x > second and x != first)      {          third = second          second = x       }   d)  Else if (x > third and x != second)      {          third = x        }3) Print first, second and third.`

Below is the implementation of the above algorithm.

## C++

 `// C++ program for find the largest``// three elements in an array``#include ``using` `namespace` `std;` `// Function to print three largest elements``void` `print3largest(``int` `arr[], ``int` `arr_size)``{``    ``int` `first, second, third;` `    ``// There should be atleast three elements``    ``if` `(arr_size < 3)``    ``{``        ``cout << ``" Invalid Input "``;``        ``return``;``    ``}` `    ``third = first = second = INT_MIN;``    ``for``(``int` `i = 0; i < arr_size; i++)``    ``{``        ` `        ``// If current element is``        ``// greater than first``        ``if` `(arr[i] > first)``        ``{``            ``third = second;``            ``second = first;``            ``first = arr[i];``        ``}` `        ``// If arr[i] is in between first``        ``// and second then update second``        ``else` `if` `(arr[i] > second && arr[i] != first)``        ``{``            ``third = second;``            ``second = arr[i];``        ``}` `        ``else` `if` `(arr[i] > third && arr[i] != second && arr[i] != first)``            ``third = arr[i];``    ``}` `    ``cout << ``"Three largest elements are "``        ``<< first << ``" "` `<< second << ``" "``        ``<< third << endl;``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 12, 13, 1, 10, 34, 11, 34 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ` `    ``print3largest(arr, n);``    ``return` `0;``}` `// This code is contributed by Anjali_Chauhan`

## C

 `// C program for find the largest``// three elements in an array``#include /* For INT_MIN */``#include ` `/* Function to print three largest elements */``void` `print3largest(``int` `arr[], ``int` `arr_size)``{``    ``int` `i, first, second, third;` `    ``/* There should be atleast three elements */``    ``if` `(arr_size < 3) {``        ``printf``(``" Invalid Input "``);``        ``return``;``    ``}` `    ``third = first = second = INT_MIN;``    ``for` `(i = 0; i < arr_size; i++) {``        ``/* If current element is greater than first*/``        ``if` `(arr[i] > first) {``            ``third = second;``            ``second = first;``            ``first = arr[i];``        ``}` `        ``/* If arr[i] is in between first and second then update second  */``        ``else` `if` `(arr[i] > second) {``            ``third = second;``            ``second = arr[i];``        ``}` `        ``else` `if` `(arr[i] > third)``            ``third = arr[i];``    ``}` `    ``printf``(``"Three largest elements are %d %d %d\n"``, first, second, third);``}` `/* Driver program to test above function */``int` `main()``{``    ``int` `arr[] = { 12, 13, 1, 10, 34, 1 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``print3largest(arr, n);``    ``return` `0;``}``/*This code is edited by Ayush Singla(@ayusin51)*/`

## Java

 `// Java code to find largest three elements``// in an array` `class` `PrintLargest {``    ``/* Function to print three largest elements */``    ``static` `void` `print3largest(``int` `arr[], ``int` `arr_size)``    ``{``        ``int` `i, first, second, third;` `        ``/* There should be atleast three elements */``        ``if` `(arr_size < ``3``) {``            ``System.out.print(``" Invalid Input "``);``            ``return``;``        ``}` `        ``third = first = second = Integer.MIN_VALUE;``        ``for` `(i = ``0``; i < arr_size; i++) {``            ``/* If current element is greater than``            ``first*/``            ``if` `(arr[i] > first) {``                ``third = second;``                ``second = first;``                ``first = arr[i];``            ``}` `            ``/* If arr[i] is in between first and``            ``second then update second  */``            ``else` `if` `(arr[i] > second) {``                ``third = second;``                ``second = arr[i];``            ``}` `            ``else` `if` `(arr[i] > third)``                ``third = arr[i];``        ``}` `        ``System.out.println(``"Three largest elements are "` `+ first + ``" "` `+ second + ``" "` `+ third);``    ``}` `    ``/* Driver program to test above function*/``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `arr[] = { ``12``, ``13``, ``1``, ``10``, ``34``, ``1` `};``        ``int` `n = arr.length;``        ``print3largest(arr, n);``    ``}``}``/*This code is contributed by Prakriti Gupta``and edited by Ayush Singla(@ayusin51)*/`

## Python3

 `# Python3 code to find largest three``# elements in an array``import` `sys` `# Function to print three largest``# elements``def` `print3largest(arr, arr_size):` `    ``# There should be atleast three``    ``# elements``    ``if` `(arr_size < ``3``):``    ` `        ``print``(``" Invalid Input "``)``        ``return``    ` `    ``third ``=` `first ``=` `second ``=` `-``sys.maxsize``    ` `    ``for` `i ``in` `range``(``0``, arr_size):``    ` `        ``# If current element is greater``        ``# than first``        ``if` `(arr[i] > first):``        ` `            ``third ``=` `second``            ``second ``=` `first``            ``first ``=` `arr[i]``        `  `        ``# If arr[i] is in between first``        ``# and second then update second``        ``elif` `(arr[i] > second):``        ` `            ``third ``=` `second``            ``second ``=` `arr[i]``        ` `        ``elif` `(arr[i] > third):``            ``third ``=` `arr[i]``    ` `    ``print``(``"Three largest elements are"``,``                  ``first, second, third)` `# Driver program to test above function``arr ``=` `[``12``, ``13``, ``1``, ``10``, ``34``, ``1``]``n ``=` `len``(arr)``print3largest(arr, n)` `# This code is contributed by Smitha Dinesh Semwal``# and edited by Ayush Singla(@ayusin51).`

## C#

 `// C# code to find largest``// three elements in an array``using` `System;` `class` `PrintLargest {` `    ``// Function to print three``    ``// largest elements``    ``static` `void` `print3largest(``int``[] arr,``                              ``int` `arr_size)``    ``{``        ``int` `i, first, second, third;` `        ``// There should be atleast three elements``        ``if` `(arr_size < 3) {``            ``Console.WriteLine(``"Invalid Input"``);``            ``return``;``        ``}` `        ``third = first = second = 000;``        ``for` `(i = 0; i < arr_size; i++) {``            ``// If current element is``            ``// greater than first``            ``if` `(arr[i] > first) {``                ``third = second;``                ``second = first;``                ``first = arr[i];``            ``}` `            ``// If arr[i] is in between first``            ``// and second then update second``            ``else` `if` `(arr[i] > second && arr[i] != first) {``                ``third = second;``                ``second = arr[i];``            ``}` `            ``else` `if` `(arr[i] > third && arr[i]!=second)``                ``third = arr[i];``        ``}` `        ``Console.WriteLine(``"Three largest elements are "` `+ first + ``" "` `+ second + ``" "` `+ third);``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``int``[] arr = ``new` `int``[] { 12, 13, 1, 10, 34, 1 };``        ``int` `n = arr.Length;``        ``print3largest(arr, n);``    ``}``}` `// This code is contributed by KRV and edited by Ayush Singla(@ayusin51).`

## Javascript

 ``

## PHP

 ` ``\$first``)``        ``{``            ``\$third` `= ``\$second``;``            ``\$second` `= ``\$first``;``            ``\$first` `= ``\$arr``[``\$i``];``        ``}` `        ``// If arr[i] is in between first``        ``// and second then update second``        ``else` `if` `(``\$arr``[``\$i``] > ``\$second``)``        ``{``            ``\$third` `= ``\$second``;``            ``\$second` `= ``\$arr``[``\$i``];``        ``}` `        ``else` `if` `(``\$arr``[``\$i``] > ``\$third``)``            ``\$third` `= ``\$arr``[``\$i``];``    ``}` `    ``echo` `"Three largest elements are "``,``       ``\$first``, ``" "``, ``\$second``, ``" "``, ``\$third``;``}`  `// Driver Code``\$arr` `= ``array``(12, 13, 1,``             ``10, 34, 1);``\$n` `= ``count``(``\$arr``);``print3largest(``\$arr``, ``\$n``);` `// This code is contributed by anuj_67 and edited by Ayush Singla(@ayusin51).``?>`

Output

```Three largest elements are 34 13 12

```

Time Complexity: O(n)
Auxiliary Space: O(1)

Method 2:

An efficient way to solve this problem is to use any O(nLogn) sorting algorithm & simply returning the last 3 largest elements.

## C++

 `// C++ code to find largest three elements in an array``#include ``using` `namespace` `std;` `void` `find3largest(``int` `arr[], ``int` `n)``{``    ``sort(arr, arr + n); ``// It uses Tuned Quicksort with``    ``// avg. case Time complexity = O(nLogn)` `    ``int` `check = 0, count = 1;``    ``for` `(``int` `i = 1; i <= n; i++) {``        ``if` `(count < 4) {``            ``if` `(check != arr[n - i]) {``                ``// to handle duplicate values``                ``cout << arr[n - i] << ``" "``;``                ``check = arr[n - i];``                ``count++;``            ``}``        ``}``        ``else``            ``break``;``    ``}``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 12, 45, 1, -1, 45, 54, 23, 5, 0, -10 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``find3largest(arr, n);``}` `// This code is contributed by Aditya Kumar (adityakumar129)`

## C

 `// C code to find largest three elements in an array``#include ``#include ` `// Compare function for qsort``int` `cmpfunc(``const` `void``* a, ``const` `void``* b)``{``    ``return` `(*(``int``*)a - *(``int``*)b);``}` `void` `find3largest(``int` `arr[], ``int` `n)``{``    ``qsort``(arr, n, ``sizeof``(``int``),``          ``cmpfunc); ``// It uses Tuned Quicksort with``    ``// avg. case Time complexity = O(nLogn)` `    ``int` `check = 0, count = 1;``    ``for` `(``int` `i = 1; i <= n; i++) {``        ``if` `(count < 4) {``            ``if` `(check != arr[n - i]) {``                ``// to handle duplicate values``                ``printf``(``"%d "``, arr[n - i]);``                ``check = arr[n - i];``                ``count++;``            ``}``        ``}``        ``else``            ``break``;``    ``}``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 12, 45, 1, -1, 45, 54, 23, 5, 0, -10 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``find3largest(arr, n);``}` `// This code is contributed by Aditya Kumar (adityakumar129)`

## Java

 `// Java code to find largest``// three elements in an array` `import` `java.io.*;``import` `java.util.Arrays;` `class` `GFG {``    ``void` `find3largest(``int``[] arr)``    ``{``        ``Arrays.sort(arr); ``// It uses Tuned Quicksort with``        ``// avg. case Time complexity = O(nLogn)``        ``int` `n = arr.length;``        ``int` `check = ``0``, count = ``1``;` `        ``for` `(``int` `i = ``1``; i <= n; i++) {` `            ``if` `(count < ``4``) {``                ``if` `(check != arr[n - i]) {``                    ``// to handle duplicate values``                    ``System.out.print(arr[n - i] + ``" "``);``                    ``check = arr[n - i];``                    ``count++;``                ``}``            ``}``            ``else``                ``break``;``        ``}``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``GFG obj = ``new` `GFG();``        ``int``[] arr = { ``12``, ``45``, ``1``, -``1``, ``45``, ``54``, ``23``, ``5``, ``0``, -``10` `};``        ``obj.find3largest(arr);``    ``}``}``// This code is contributed by Prashant Malik`

## Python3

 `# Python3 code to find largest``# three elements in an array``def` `find3largest(arr, n):``    ``arr ``=` `sorted``(arr) ``# It uses Tuned Quicksort with``                      ``# avg. case Time complexity = O(nLogn)` `    ``check ``=` `0``    ``count ``=` `1` `    ``for` `i ``in` `range``(``1``, n ``+` `1``):` `        ``if``(count < ``4``):``            ``if``(check !``=` `arr[n ``-` `i]):``                ` `                ``# to handle duplicate values``                ``print``(arr[n ``-` `i], end ``=` `" "``)``                ``check ``=` `arr[n ``-` `i]``                ``count ``+``=` `1``        ``else``:``            ``break` `# Driver code``arr ``=` `[``12``, ``45``, ``1``, ``-``1``, ``45``,``       ``54``, ``23``, ``5``, ``0``, ``-``10``]``n ``=` `len``(arr)``find3largest(arr, n)` `# This code is contributed by mohit kumar`

## C#

 `// C# code to find largest``// three elements in an array``using` `System;` `class` `GFG {``    ``void` `find3largest(``int``[] arr)``    ``{``        ``Array.Sort(arr); ``// It uses Tuned Quicksort with``        ``// avg. case Time complexity = O(nLogn)``        ``int` `n = arr.Length;``        ``int` `check = 0, count = 1;` `        ``for` `(``int` `i = 1; i <= n; i++) {``            ``if` `(count < 4) {``                ``if` `(check != arr[n - i]) {``                    ``// to handle duplicate values``                    ``Console.Write(arr[n - i] + ``" "``);``                    ``check = arr[n - i];``                    ``count++;``                ``}``            ``}``            ``else``                ``break``;``        ``}``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``GFG obj = ``new` `GFG();``        ``int``[] arr = { 12, 45, 1, -1, 45,``                      ``54, 23, 5, 0, -10 };``        ``obj.find3largest(arr);``    ``}``}` `// This code is contributed by Code_Mech`

## Javascript

 ``

Output

```54 45 23

```

Time Complexity: O(n log n)
Auxiliary Space: O(1)

Method 3:
We can use Partial Sort of C++ STL. partial_sort uses Heapselect, which provides better performance than Quickselect for small M. As a side effect, the end state of Heapselect leaves you with a heap, which means that you get the first half of the Heapsort algorithm “for free”. The complexity is “approximately” O(N log(M)), where M is distance(middle-first).

## C++

 `#include ``using` `namespace` `std;``int` `main()``{``    ``vector<``int``> V = { 11, 65, 193, 36, 209, 664, 32 };``    ``partial_sort(V.begin(), V.begin() + 3, V.end(), greater<``int``>());` `    ``cout << ``"first = "` `<< V[0] << ``"\n"``;``    ``cout << ``"second = "` `<< V[1] << ``"\n"``;``    ``cout << ``"third = "` `<< V[2] << ``"\n"``;``    ``return` `0;``}`

## Java

 `// java program to find``// three largest elements``// in array.``import` `java.io.*;``import` `java.util.Arrays;``class` `GFG{``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int``[] V = { ``11``, ``65``, ``193``, ``36``, ``209``, ``664``, ``32` `};` `    ``// sorting the array``    ``Arrays.sort(V);` `    ``// taking the length of array``    ``int` `x = V.length;` `    ``System.out.println(``"first = "` `+ V[x-``1``] );``    ``System.out.println(``"second = "` `+ V[x-``2``]);``    ``System.out.println(``"third = "` `+ V[x-``3``] );` `  ``}``}` `// This code is Contributed Machhaliya Muhammad`

## Python3

 `# Python program to implement``# the above approach` `# Driver Code``V ``=` `[ ``11``, ``65``, ``193``, ``36``, ``209``, ``664``, ``32` `];``V.sort()``V.reverse()` `print``(f``"first =  {V[0]}"``);``print``(f``"second =  {V[1]}"``);``print``(f``"third =  {V[2]}"``);``    ` `# This code is contributed by Saurabh Jaiswal`

## C#

 `// C# program to implement``// the above approach``using` `System;` `class` `GFG``{`  `// Driver Code``public` `static` `void` `Main()``{``    ``int``[] V = { 11, 65, 193, 36, 209, 664, 32 };``    ``Array.Sort(V);``    ``Array.Reverse(V);``   ` ` ` `    ``Console.WriteLine(``"first = "` `+ V[0] );``    ``Console.WriteLine(``"second = "` `+ V[1]);``    ``Console.WriteLine(``"third = "` `+ V[2] );``    ` `}``}` `// This code is contributed by code_hunt.`

## Javascript

 ``

Output

```first = 664
second = 209
third = 193

```

Time Complexity: O(n log m) where m is distance(middle-first).
Auxiliary Space: O(1)