Leaders in an array
Last Updated :
25 Apr, 2023
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
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
#include <stdio.h>
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)
printf("%d ", arr[i]);
}
}
int main()
{
int arr[] = { 16, 17, 4, 3, 5, 2 };
int n = sizeof(arr) / sizeof(arr[0]);
printLeaders(arr, n);
return 0;
}
|
C++
#include<iostream>
using namespace std;
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)
cout << arr[i] << " ";
}
}
int main()
{
int arr[] = {16, 17, 4, 3, 5, 2};
int n = sizeof(arr)/sizeof(arr[0]);
printLeaders(arr, n);
return 0;
}
|
Java
import java.io.*;
public class LeadersInArray
{
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)
System.out.print(arr[i] + " ");
}
}
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
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:
print (arr[i],end=' ')
arr=[16, 17, 4, 3, 5, 2]
printLeaders(arr, len(arr))
|
C#
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;
}
if (j == size)
Console.Write(arr[i] + " ");
}
}
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);
}
}
|
PHP
<?php
function printLeaders($arr, $size)
{
for ($i = 0; $i < $size; $i++)
{
for ($j = $i + 1;
$j < $size; $j++)
{
if ($arr[$i] <=$arr[$j])
break;
}
if ($j == $size)
echo($arr[$i] . " ");
}
}
$arr = array(16, 17, 4, 3, 5, 2);
$n = sizeof($arr);
printLeaders($arr, $n);
?>
|
Javascript
<script>
function printLeaders( arr, size)
{
for (let i = 0; i < size; i++)
{
let j;
for (j = i+1; j < size; j++)
{
if (arr[i] <=arr[j])
break;
}
if (j == size)
document.write(arr[i] + " ");
}
}
let arr = [ 16, 17, 4, 3, 5, 2 ];
let n = arr.length;
printLeaders(arr, n);
</script>
|
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 <stdio.h>
void printLeaders(int arr[], int size)
{
int max_from_right = arr[size - 1];
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);
}
}
}
int main()
{
int arr[] = { 16, 17, 4, 3, 5, 2 };
int n = sizeof(arr) / sizeof(arr[0]);
printLeaders(arr, n);
return 0;
}
|
C++
#include <iostream>
using namespace std;
void printLeaders(int arr[], int size)
{
int max_from_right = arr[size-1];
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 << " ";
}
}
}
int main()
{
int arr[] = {16, 17, 4, 3, 5, 2};
int n = sizeof(arr)/sizeof(arr[0]);
printLeaders(arr, n);
return 0;
}
|
Java
import java.io.*;
public class LeadersInArray
{
void printLeaders(int arr[], int size)
{
int max_from_right = arr[size-1];
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 + " ");
}
}
}
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
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]
arr = [16, 17, 4, 3, 5, 2]
printLeaders(arr, len(arr))
|
C#
using System;
class LeadersInArray {
void printLeaders(int []arr, int size)
{
int max_from_right = arr[size - 1];
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 +" ");
}
}
}
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);
}
}
|
PHP
<?php
function printLeaders(&$arr, $size)
{
$max_from_right = $arr[$size - 1];
echo($max_from_right);
echo(" ");
for ($i = $size - 2;
$i >= 0; $i--)
{
if ($max_from_right < $arr[$i])
{
$max_from_right = $arr[$i];
echo($max_from_right);
echo(" ");
}
}
}
$arr = array(16, 17, 4, 3, 5, 2);
$n = sizeof($arr);
printLeaders($arr, $n);
?>
|
Javascript
<script>
function printLeaders(arr,size)
{
let max_from_right = arr[size-1];
document.write(max_from_right + " ");
for (let i = size-2; i >= 0; i--)
{
if (max_from_right < arr[i])
{
max_from_right = arr[i];
document.write(max_from_right + " ");
}
}
}
let arr = [16, 17, 4, 3, 5, 2];
let n = arr.length;
printLeaders(arr, n);
</script>
|
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 <stdio.h>
#include <stdlib.h>
void printLeaders(int arr[], int size)
{
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];
}
}
while (top != -1) {
printf("%d ", sk[top--]);
}
free(sk);
}
int main()
{
int arr[] = { 16, 17, 4, 3, 5, 2 };
int n = sizeof(arr) / sizeof(arr[0]);
printLeaders(arr, n);
return 0;
}
|
C++
#include <bits/stdc++.h>
using namespace std;
void printLeaders(int arr[], int size)
{
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]);
}
}
while(!sk.empty()){
cout<<sk.top()<<" ";
sk.pop();
}
}
int main()
{
int arr[] = {16, 17, 4, 3, 5, 2};
int n = sizeof(arr)/sizeof(arr[0]);
printLeaders(arr, n);
return 0;
}
|
Java
import java.io.*;
import java.util.*;
class LeadersInArray {
void printLeaders(int arr[], int size)
{
Stack<Integer> stack = new Stack<Integer>();
stack.push(arr[size - 1]);
for (int i = size - 2; i >= 0; i--) {
if (arr[i] >= stack.peek()) {
stack.push(arr[i]);
}
}
while (!stack.empty()) {
System.out.print(stack.pop() + " ");
}
}
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
def printLaders(arr, size):
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])
while(len(sk) != 0):
print(sk[len(sk)-1],end = ' ')
sk.pop()
if __name__ == "__main__":
arr = [16,17,4,3,5,2]
n = len(arr)
printLaders(arr,n)
|
C#
using System;
using System.Collections;
public class GFG {
public static void printLeaders(int[] arr, int size) {
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]);
}
}
while (stack.Count > 0) {
Console.Write(stack.Pop() + " ");
}
}
public static void Main(string[] args) {
int[] arr = { 16, 17, 4, 3, 5, 2 };
int n = arr.Length;
printLeaders(arr, n);
}
}
|
Javascript
<script>
function printLeaders(arr, size)
{
let stack = [];
stack.push(arr[size - 1]);
for (let i = size - 2; i >= 0; i--) {
let temp = stack.pop();
stack.push(temp);
if (arr[i] >= temp) {
stack.push(arr[i]);
}
}
while (stack.length>0) {
console.log(stack.pop() + " ");
}
}
let arr = [ 16, 17, 4, 3, 5, 2 ];
let n = arr.length;
printLeaders(arr, n);
</script>
|
Time complexity: O(n)
Auxiliary space: O(n)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...