Java 阵列中的领导者 class-LeadersInArray { 无效打印引线（int arr[]，int size） { int max_from_right=arr[size-1]； /*最右边的元素始终是leader*/ System.out.print（从右+开始的最大值）； 对于（int i=size-2；i>=0；i--） { 如果（从右至右的最大值 class LeadersInArray { 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); } } void打印引线（int-arr[]，int-size）{ 对于（int i=0；i

该程序的输出为2,5,17。我的问题是，除了将结果存储在单独的数组中，然后以相反的方式遍历外，我是否可以以就地方式打印结果，即17、5和2（正如它们在原始数组中显示的那样）。这将增加O（n）的空间复杂度。

您可以使用两个循环，因为您需要在看到元素之后检查元素。但复杂度是O（n*n）。不认为是一个好的解决方案< /P>

class LeadersInArray 
{

    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);
    }
}

void打印引线（int-arr[]，int-size）{
对于（int i=0；i如果（arr[i]可以证明你不能

在不占用更多空间或增加算法复杂度的情况下，按照正确数字在数组中出现的顺序输出正确数字的唯一方法是向前遍历数组

考虑以下情况：

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] + " ");
        }
    }

假设您正在迭代数组并到达
17
。知道是否打印它的唯一方法是知道数组下一步的
18
。如果您只是向前走，您将不知道。
其他可能的解决方案是使用堆栈。时间复杂度将为O（n）

import java.util.*；
导入java.lang.*；
导入java.io.*；
GFG类
{
公共静态void main（字符串[]args）
{
扫描仪scn=新扫描仪（System.in）；
int tcs=scn.nextInt（）；
int输入=0；
内部温度=0；
List stks=new ArrayList（）；
用于（int i=0；i System.out.print（x+）；
}
}
}
请参阅可能的副本
    int arr[] = new int[]{16, 17, 4, 3, /* ... many more numbers */, 18, 5, 2};

import java.util.*;
import java.lang.*;
import java.io.*;
class GFG
 {
    public static void main (String[] args)
     {
        Scanner scn = new Scanner(System.in);
        int tcs = scn.nextInt();
        int input = 0;
        int temp = 0;
        List<Stack<Integer>> stks = new ArrayList<Stack<Integer>>();
        for(int i=0;i<tcs;i++){
            int arrSize = scn.nextInt();
            Stack<Integer> stk = new Stack<Integer>();
            for(int j=0;j<arrSize;j++){
                input = scn.nextInt();
                if(stk.empty()){
                    stk.push(input);
                } else {
                    temp = stk.peek();
                    while(true) {
                        if(input>temp) {
                            stk.pop();
                            if(!stk.empty())
                                temp = stk.peek();
                            else
                                break;
                        } else {
                            break;
                        }
                    }
                    stk.push(input);
                }
            }
            stks.add(stk);
        }
        for(Stack<Integer> stk: stks) {
             System.out.println("");
             stk.forEach(x -> System.out.print(x+ " "));
        }
}
}