Optimize the given Solution without changing the logic of the program. Also calculate the Time Complexity

This is a GFG practice problem hence compiler cannot be configured

Question
Given an array of positive integers. Your task is to find the leaders in the array.
Note: An element of array is leader if it is greater than or equal to all the elements to its right side. Also, the rightmost element is always a leader.

Input:
The first line of input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test case contains a single integer N denoting the size of array.
The second line contains N space-separated integers A1, A2, ..., AN denoting the elements of the array.

Output:
Print all the leaders.

Constraints:<br>
1 <= T <= 100<br>
1 <= N <= 107<br>
0 <= Ai <= 107<br>

My Solution :

import java.util.*;
import java.io.*;
import java.lang.*;
public class Main
{  
static BufferedReader z1 = new BufferedReader(new InputStreamReader(System.in));
public static void main (String[] args)throws Exception
{    
int T=Integer.parseInt(z1.readLine());
while(T-- > 0)
{      
int N=Integer.parseInt(z1.readLine());
solution ob = new solution();
int []a=new int[N];
a=ob.input(N,z1);
int x=0;
ob.leader(a,N,x);
}
}
}
class solution
{  
static int[] input(int N, BufferedReader z1)throws Exception
{    
int a[]=new int[N];
String s=z1.readLine();
String []str=s.split(" ");
/* for(int y=0;y<N;y++)
a[y]=Integer.parseInt(str[y]); */
toInts(str,a,0);
return a;
} 
static void toInts(String[] strings, int[] ints, int start) {
if (start > strings.length - 1) {
return;
}
ints[start] = Integer.parseInt(strings[start]);
toInts(strings, ints, start+1);
}
static void leader(int []a,int N,int x)
{    
int count = 0;
if(x==N-1)
System.out.println(a[x]);
else
{ 
count = compare(a,x,x+1,count,N);
/* for(int y=x+1;y<N;y++)
if(a[x]>=a[y])
count++; */
if(count==(N-x-1))
System.out.print(a[x]);
leader(a,N,x+1);
}
}
static int compare(int []a,int x,int y,int count,int N)
{
if(y==N)
return count;
else
{
if(a[x]>=a[y])
count ++;
return compare(a,x,y+1,count,N);
}
}
}

Error :

Runtime Error:
Runtime ErrorTime Limit Exceeded
Your program took more time than expected.Time Limit Exceeded
Expected Time Limit 3.00sec

A problem (and the likely cause for the long time it takes) is that your compare() method doesn't stop once it encounters a larger value and it is therefore obvious that the current element is not a leader. Instead it will always compare all values.
This makes the runtime of your code O(N^2) for an array of size N.

This problem can be solved in O(N).
Start on the right end of the array and print the last element as leader and set it as the current maximum. Then go left and check if the current element is greater or equal than the maximum. If yes print it as a leader and set is as the maximum. Continue until you reach the left end of the array.

You can also probably save some time by replacing your recursive toInts() method with a simple for-loop to convert the strings.