Question

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

该程序的输出为2,5,17。我的问题是我可以以原位方式打印结果，即17,5然后2（因为它们出现在原始数组中），除了将它存储在单独的数组中然后以相反的方式遍历，因为这会增加O（n）的空间复杂度

Answer 1

其他可能的解决方案是使用堆栈。时间复杂度将为O（n）

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

Answer 2

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

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

Answer 3

有可能证明你不能。

按照它们在数组中出现的顺序输出正确数字而不使用更多空间或增加算法复杂性的唯一方法是在数组中走前进。

考虑类似的事情：

    int arr[] = new int[]{16, 17, 4, 3, /* ... many more numbers */, 18, 5, 2};

想象一下，您正在遍历数组并已到达17。知道是否打印它的唯一方式是了解数组中的18。如果你只是向前走，你就不会知道。

数组中的领导者

3 个答案: