 GFG App
Open App Browser
Continue

Write a program to print all the LEADERS in the array. An element is a leader if it is greater than all the elements to its right side. And the rightmost element is always a leader.

For example:

Input: arr[] = {16, 17, 4, 3, 5, 2},
Output: 17, 5, 2

Input: arr[] = {1, 2, 3, 4, 5, 2},
Output: 5, 2

Recommended Practice

Naive Approach: The problem can be solved based on the idea mentioned below:

Use two loops. The outer loop runs from 0 to size – 1 and one by one pick all elements from left to right. The inner loop compares the picked element to all the elements on its right side. If the picked element is greater than all the elements to its right side, then the picked element is the leader.

Follow the below steps to implement the idea:

• We run a loop from the first index to the 2nd last index.
• And for each index, we run another loop from the next index to the last index.
• If all the values to the right of that index are smaller than the index, we simply add the value in our answer data structure.

Below is the implementation of the above approach.

## C

 `/*C Function to print leaders in an array */`   `#include `   `void` `printLeaders(``int` `arr[], ``int` `size)` `{` `    ``int` `i, j;` `    ``for` `(i = 0; i < size; i++) {` `        ``for` `(j = i + 1; j < size; j++) {` `            ``if` `(arr[i] <= arr[j])` `                ``break``;` `        ``}` `        ``if` `(j == size) ``// the loop didn't break` `            ``printf``(``"%d "``, arr[i]);` `    ``}` `}`   `/* Driver program to test above function */` `int` `main()` `{` `    ``int` `arr[] = { 16, 17, 4, 3, 5, 2 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `    ``printLeaders(arr, n);` `    ``return` `0;` `}`

## C++

 `#include` `using` `namespace` `std;`   `/*C++ Function to print leaders in an array */` `void` `printLeaders(``int` `arr[], ``int` `size)` `{` `    ``for` `(``int` `i = 0; i < size; i++)` `    ``{` `        ``int` `j;` `        ``for` `(j = i+1; j < size; j++)` `        ``{` `            ``if` `(arr[i] <=arr[j])` `                ``break``;` `        ``}    ` `        ``if` `(j == size) ``// the loop didn't break` `            ``cout << arr[i] << ``" "``;` `  ``}` `}`   `/* Driver program to test above function */` `int` `main()` `{` `    ``int` `arr[] = {16, 17, 4, 3, 5, 2};` `    ``int` `n = ``sizeof``(arr)/``sizeof``(arr);` `    ``printLeaders(arr, n);` `    ``return` `0;` `}`

## Java

 `import` `java.io.*;` `public` `class` `LeadersInArray ` `{` `    ``/*Java Function to print leaders in an array */` `    ``void` `printLeaders(``int` `arr[], ``int` `size) ` `    ``{` `        ``for` `(``int` `i = ``0``; i < size; i++) ` `        ``{` `            ``int` `j;` `            ``for` `(j = i + ``1``; j < size; j++) ` `            ``{` `                ``if` `(arr[i] <=arr[j])` `                    ``break``;` `            ``}` `            ``if` `(j == size) ``// the loop didn't break` `                ``System.out.print(arr[i] + ``" "``);` `        ``}` `    ``}`   `    ``/* Driver program to test above functions */` `    ``public` `static` `void` `main(String[] args) ` `    ``{` `        ``LeadersInArray lead = ``new` `LeadersInArray();` `        ``int` `arr[] = ``new` `int``[]{``16``, ``17``, ``4``, ``3``, ``5``, ``2``};` `        ``int` `n = arr.length;` `        ``lead.printLeaders(arr, n);` `    ``}` `}`

## Python3

 `# Python Function to print leaders in array `   `def` `printLeaders(arr,size): ` `    `  `    ``for` `i ``in` `range``(``0``, size): ` `        ``for` `j ``in` `range``(i``+``1``, size): ` `            ``if` `arr[i]<``=``arr[j]: ` `                ``break` `        ``if` `j ``=``=` `size``-``1``: ``# If loop didn't break ` `            ``print` `(arr[i],end``=``' '``) `   `# Driver function ` `arr``=``[``16``, ``17``, ``4``, ``3``, ``5``, ``2``] ` `printLeaders(arr, ``len``(arr)) `   `# This code is contributed by _Devesh Agrawal__ `

## C#

 `// C# program to print` `// leaders in array` `using` `System;` `class` `GFG ` `{` `    ``void` `printLeaders(``int` `[]arr, ` `                      ``int` `size) ` `    ``{` `        ``for` `(``int` `i = 0; i < size; i++) ` `        ``{` `            ``int` `j;` `            ``for` `(j = i + 1; j < size; j++) ` `            ``{` `                ``if` `(arr[i] <=arr[j])` `                    ``break``;` `            ``}` `            `  `            ``// the loop didn't break` `            ``if` `(j == size) ` `                ``Console.Write(arr[i] + ``" "``);` `        ``}` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main() ` `    ``{` `        ``GFG lead = ``new` `GFG();` `        ``int` `[]arr = ``new` `int``[]{16, 17, 4, 3, 5, 2};` `        ``int` `n = arr.Length;` `        ``lead.printLeaders(arr, n);` `    ``}` `}`   `// This code is contributed by` `// Akanksha Rai(Abby_akku)`

## PHP

 ``

## Javascript

 ``

Output

`17 5 2 `

Time Complexity: O(N * N)
Auxiliary Space: O(1)

### Find Leader by finding suffix maximum:

The idea is to scan all the elements from right to left in an array and keep track of the maximum till now. When the maximum changes its value, print it.

Follow the below illustration for a better understanding

Illustration:

Let the array be arr[] = {16, 17, 4, 3, 5, 2}

• arr[] = {16, 17, 4, 3, 5, 2} , max_from_right = 2 , ans[] = { 2 }
• arr[] = {16, 17, 4, 3, 5, 2} , max_from_right = 5 , ans[] = { 2, 5 }
• arr[] = {16, 17, 4, 3, 5, 2} , max_from_right = 5 , ans[] = { 2, 5 }
• arr[] = {16, 17, 4, 3, 5, 2} , max_from_right = 5 , ans[] = { 2, 5 }
• arr[] = {16, 17, 4, 3, 5, 2} , max_from_right = 17 , ans[] = { 2, 5, 17 }
• arr[] = {16, 17, 4, 3, 5, 2} , max_from_right = 17 , ans[] = { 2, 5, 17 }

Follow the steps mentioned below to implement the idea:

• We start from the last index position. The last position is always a leader, as there are no elements towards its right.
• And then we iterate on the array till we reach index position = 0.
• Each time we keep a check on the maximum value
• Every time we encounter a maximum value than the previous maximum value encountered, we either print or store the value as it is the leader

Below is the implementation of the above approach.

## C

 `#include `   `/* C Function to print leaders in an array */` `void` `printLeaders(``int` `arr[], ``int` `size)` `{` `    ``int` `max_from_right = arr[size - 1];`   `    ``/* Rightmost element is always leader */` `    ``printf``(``"%d "``, max_from_right);`   `    ``for` `(``int` `i = size - 2; i >= 0; i--) {` `        ``if` `(max_from_right < arr[i]) {` `            ``max_from_right = arr[i];` `            ``printf``(``"%d "``, max_from_right);` `        ``}` `    ``}` `}`   `/* Driver program to test above function*/` `int` `main()` `{` `    ``int` `arr[] = { 16, 17, 4, 3, 5, 2 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `    ``printLeaders(arr, n);` `    ``return` `0;` `}`

## C++

 `#include ` `using` `namespace` `std;`   `/* C++ Function to print leaders in an array */` `void` `printLeaders(``int` `arr[], ``int` `size)` `{` `    ``int` `max_from_right =  arr[size-1];`   `    ``/* Rightmost element is always leader */` `    ``cout << max_from_right << ``" "``;` `    `  `    ``for` `(``int` `i = size-2; i >= 0; i--)` `    ``{` `        ``if` `(max_from_right < arr[i]) ` `        ``{           ` `            ``max_from_right = arr[i];` `            ``cout << max_from_right << ``" "``;` `        ``}` `    ``}    ` `}`   `/* Driver program to test above function*/` `int` `main()` `{` `    ``int` `arr[] = {16, 17, 4, 3, 5, 2};` `    ``int` `n = ``sizeof``(arr)/``sizeof``(arr);` `    ``printLeaders(arr, n);` `    ``return` `0;` `}    `

## Java

 `import` `java.io.*;` `public` `class` `LeadersInArray ` `{` `    ``/* Java Function to print leaders in an array */` `    ``void` `printLeaders(``int` `arr[], ``int` `size)` `    ``{` `        ``int` `max_from_right =  arr[size-``1``];` ` `  `        ``/* Rightmost element is always leader */` `        ``System.out.print(max_from_right + ``" "``);` `     `  `        ``for` `(``int` `i = size-``2``; i >= ``0``; i--)` `        ``{` `            ``if` `(max_from_right < arr[i])` `            ``{           ` `            ``max_from_right = arr[i];` `            ``System.out.print(max_from_right + ``" "``);` `            ``}` `        ``}    ` `    ``}`   `    ``/* Driver program to test above functions */` `    ``public` `static` `void` `main(String[] args) ` `    ``{` `        ``LeadersInArray lead = ``new` `LeadersInArray();` `        ``int` `arr[] = ``new` `int``[]{``16``, ``17``, ``4``, ``3``, ``5``, ``2``};` `        ``int` `n = arr.length;` `        ``lead.printLeaders(arr, n);` `    ``}` `}`

## Python3

 `# Python function to print leaders in array` `def` `printLeaders(arr, size):` `   `  `    ``max_from_right ``=` `arr[size``-``1``]   ` `    ``print` `(max_from_right,end``=``' '``)    ` `    ``for` `i ``in` `range``( size``-``2``, ``-``1``, ``-``1``):        ` `        ``if` `max_from_right < arr[i]:        ` `            ``print` `(arr[i],end``=``' '``)` `            ``max_from_right ``=` `arr[i]` `        `  `# Driver function` `arr ``=` `[``16``, ``17``, ``4``, ``3``, ``5``, ``2``]` `printLeaders(arr, ``len``(arr))`   `# This code contributed by _Devesh Agrawal__`

## C#

 `// C# program to find Leaders in an array` `using` `System;`   `class` `LeadersInArray {` `    `  `    ``// C# Function to print leaders` `    ``// in an array ` `    ``void` `printLeaders(``int` `[]arr, ``int` `size)` `    ``{` `        ``int` `max_from_right = arr[size - 1];`   `        ``// Rightmost element is always leader` `        ``Console.Write(max_from_right +``" "``);` `    `  `        ``for` `(``int` `i = size - 2; i >= 0; i--)` `        ``{` `            ``if` `(max_from_right < arr[i])    ` `            ``{     ` `                ``max_from_right = arr[i];` `                ``Console.Write(max_from_right +``" "``);` `            ``}` `        ``} ` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main(String[] args) ` `    ``{` `        ``LeadersInArray lead = ``new` `LeadersInArray();` `        ``int` `[]arr = ``new` `int``[]{16, 17, 4, 3, 5, 2};` `        ``int` `n = arr.Length;` `        ``lead.printLeaders(arr, n);` `    ``}` `}`   `// This code is contributed ` `// by Akanksha Rai(Abby_akku)`

## PHP

 `= 0; ``\$i``--)` `    ``{` `        ``if` `(``\$max_from_right` `< ``\$arr``[``\$i``])    ` `        ``{         ` `            ``\$max_from_right` `= ``\$arr``[``\$i``];` `            ``echo``(``\$max_from_right``);` `            ``echo``(``" "``);` `        ``}` `    ``} ` `}`   `// Driver Code` `\$arr` `= ``array``(16, 17, 4, 3, 5, 2);` `\$n` `= sizeof(``\$arr``);` `printLeaders(``\$arr``, ``\$n``);`   `// This code is contributed ` `// by Shivi_Aggarwal` `?>`

## Javascript

 ``

Output

`2 5 17 `

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

### Find leaders and print them in the same order as they are:

In the previous method, we get time linear complexity, but the output we get is not in the same order as the elements that appear in our input array, so to get out output in the same order as in the input array, we can use stack data structure.

Illustration:

Let the array be arr[] = {16, 17, 4, 3, 5, 2}, we will store the ans in a stack to print in the same order.

• arr[] = {16, 17, 4, 3, 5, 2} , max_from_right = 2 , ans[] = { 2 }
• arr[] = {16, 17, 4, 3, 5, 2} , max_from_right = 5 , ans[] = { 5, 2 }
• arr[] = {16, 17, 4, 3, 5, 2} , max_from_right = 5 , ans[] = { 5, 2 }
• arr[] = {16, 17, 4, 3, 5, 2} , max_from_right = 5 , ans[] = { 5, 2 }
• arr[] = {16, 17, 4, 3, 5, 2} , max_from_right = 17 , ans[] = { 17, 5, 2 }
• arr[] = {16, 17, 4, 3, 5, 2} , max_from_right = 17 , ans[] = { 17, 5, 2 }

Follow the below steps to implement the idea:

• We start from the last index position. The last position is always a leader, as there are no elements towards its right.
• And then we iterate on the array till we reach index position = 0.
• Each time we keep a check on the maximum value
• Every time we encounter a maximum value than the previous maximum value encountered, we will store the value in the stack as it is the leader
• We will iterate on the stack and print the values

Below is the implementation of the above approach.

## C

 `#include ` `#include `   `/* C Function to print leaders in an array */` `void` `printLeaders(``int` `arr[], ``int` `size)` `{` `    ``/* create stack to store leaders*/` `    ``int``* sk = (``int``*)``malloc``(size * ``sizeof``(``int``));` `    ``int` `top = -1;` `    ``sk[++top] = arr[size - 1];`   `    ``for` `(``int` `i = size - 2; i >= 0; i--) {` `        ``if` `(arr[i] >= sk[top]) {` `            ``sk[++top] = arr[i];` `        ``}` `    ``}`   `    ``/* print stack elements*/` `    ``/* run loop till stack is not empty*/` `    ``while` `(top != -1) {` `        ``printf``(``"%d "``, sk[top--]);` `    ``}` `    ``free``(sk);` `}`   `/* Driver program to test above function*/` `int` `main()` `{` `    ``int` `arr[] = { 16, 17, 4, 3, 5, 2 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `    ``printLeaders(arr, n);` `    ``return` `0;` `}`

## C++

 `#include ` `using` `namespace` `std;` `  `  `/* C++ Function to print leaders in an array */` `void` `printLeaders(``int` `arr[], ``int` `size)` `{` `      ``/* create stack to store leaders*/` `      ``stack<``int``> sk;` `      ``sk.push(arr[size-1]);` `    `  `    ``for` `(``int` `i = size-2; i >= 0; i--)` `    ``{` `        ``if``(arr[i] >= sk.top())` `        ``{          ` `            ``sk.push(arr[i]);` `        ``}` `    ``}   ` `    `  `      ``/* print stack elements*/` `      ``/* run loop till stack is not empty*/` `      ``while``(!sk.empty()){      ` `        ``cout<

## Java

 `// JAVA code for the above approach` `import` `java.io.*;` `import` `java.util.*;` `class` `LeadersInArray {` `    ``/* Java Function to print leaders in an array */` `    ``void` `printLeaders(``int` `arr[], ``int` `size)` `    ``{` `        ``/* create stack to store leaders*/` `        ``Stack stack = ``new` `Stack();` `        ``stack.push(arr[size - ``1``]);`   `        ``for` `(``int` `i = size - ``2``; i >= ``0``; i--) {` `            ``if` `(arr[i] >= stack.peek()) {` `                ``stack.push(arr[i]);` `            ``}` `        ``}`   `        ``/* print stack elements*/` `        ``/* run loop till stack is not empty*/` `        ``while` `(!stack.empty()) {` `            ``System.out.print(stack.pop() + ``" "``);` `        ``}` `    ``}`   `    ``/* Driver program to test above function*/` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``LeadersInArray lead = ``new` `LeadersInArray();` `        ``int` `arr[] = ``new` `int``[] { ``16``, ``17``, ``4``, ``3``, ``5``, ``2` `};` `        ``int` `n = arr.length;` `        ``lead.printLeaders(arr, n);` `    ``}` `}`

## Python3

 `# Python Function to print leaders in an array` `def` `printLaders(arr, size):` `    ``# create stack to store leaders` `    ``sk ``=` `[]` `    ``sk.append(arr[size ``-` `1``])` `    ``for` `i ``in` `range``(size ``-` `2``, ``-``1``, ``-``1``):` `        ``if``(arr[i] >``=` `sk[``len``(sk) ``-` `1``]):` `            ``sk.append(arr[i])`   `    ``# print stack elements` `    ``# run loop till stack is not empty` `    ``while``(``len``(sk) !``=` `0``):` `        ``print``(sk[``len``(sk)``-``1``],end ``=` `' '``)` `        ``sk.pop()`   `# Driver program to test above function` `if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``16``,``17``,``4``,``3``,``5``,``2``]` `    ``n ``=` `len``(arr)` `    ``printLaders(arr,n)` `    `  `    ``# This code is contributed by ajaymakvana`

## C#

 `// C# code for the above approach` `using` `System;` `using` `System.Collections;`   `public` `class` `GFG {`   `  ``// C# Function to print leaders in an array` `  ``public` `static` `void` `printLeaders(``int``[] arr, ``int` `size) {` `    ``// create stack to store leaders` `    ``Stack stack = ``new` `Stack();` `    ``stack.Push(arr[size - 1]);`   `    ``for` `(``int` `i = size - 2; i >= 0; i--) {` `      ``if` `(arr[i] >= Convert.ToInt32(stack.Peek())) {` `        ``stack.Push(arr[i]);` `      ``}` `    ``}`   `    ``// print stack elements` `    ``// run loop till stack is not empty` `    ``while` `(stack.Count > 0) {` `      ``Console.Write(stack.Pop() + ``" "``);` `    ``}` `  ``}`   `  ``// Driver program to test above function` `  ``public` `static` `void` `Main(``string``[] args) {` `    ``int``[] arr = { 16, 17, 4, 3, 5, 2 };` `    ``int` `n = arr.Length;` `    ``printLeaders(arr, n);` `  ``}` `}`   `// This code is contributed by ajaymakavana.`

## Javascript

 ``

Output

`17 5 2 `

Time complexity: O(n)
Auxiliary space: O(n)