Java 从列表中返回具有下一个高温的列表

我有一个列表输入：[70,71,74,69,70,76,71,80,70,65] 它代表了一天的温度，我应该返回一个列表，指出未来比现在更热的天数。如果没有比现在更热的天气，只需在列表中添加0即可

对于上述输入，预期输出为[1,1,3,1,1,2,1,0,0]

为澄清必要的工作： 我们搜索下一个更高温度的位置。如果没有更高的值，则返回零。e、 g.Index0是70。70后的下一个温度更高（71）。所以我们写一个1。71后面跟着74，所以我们再写一次1。74之后是69和70，它们较低，但76较高。所以我们写了一个3。等等

我能想到的一种方法是使用两个for循环并找到下一个更高的值

        List<Integer> result =  new ArrayList<>(Collections.nCopies(size,0));
        for(int i = 0; i<list.size();i++){
            for(int j=i+1;j<list.size();j++){
                if(list.get(i)<list.get(j)){
                    result.add(i,j-i);
                    break;
                }
            }
        }

List result=newarraylist（Collections.nCopies（size，0））；
对于（int i=0；i我假设您的意思是，您不想知道每个元素和下一个严格较大的元素之间的距离，因为这与您的预期输出相匹配

只需使用堆栈，首先将第一个元素推入堆栈，然后从第二个元素开始在数组上迭代，检查当前元素是否大于堆栈中的顶部元素。如果大于，则当前索引是堆栈中顶部元素的答案，更新其答案并弹出，然后对新元素重复堆栈中的顶部元素。重复此操作，直到堆栈为空或当前元素不大于堆栈顶部元素。然后将当前元素也推到堆栈中，以便我们可以找到其答案并继续迭代

该方法的复杂度为O（n）

这是我在中找到的一个代码，它经过轻微修改以满足您的确切需求：

//Java program to print next 
//greater element using stack 

import java.util.ArrayList;
import java.util.Collections;

public class NGE
{
    static class stack
    {
        int top;
        int items[] = new int[100];

        // Stack functions to be used by printNGE
        void push(int x)
        {
            if (top == 99)
            {
                System.out.println("Stack full");
            }
            else
            {
                items[++top] = x;
            }
        }

        int pop()
        {
            if (top == -1)
            {
                System.out.println("Underflow error");
                return -1;
            }
            else
            {
                int element = items[top];
                top--;
                return element;
            }
        }

        boolean isEmpty()
        {
            return (top == -1) ? true : false;
        }
    }

    /* prints element and NGE pair for
    all elements of arr[] of size n */
    static void printNGE(int arr[], int n)
    {
        int i = 0;
        stack s = new stack();
        s.top = -1;
        int element, next;

        //answer initialized with zeros
        ArrayList<Integer> answer = new ArrayList<>(Collections.nCopies(n, 0));

        /* push the first element to stack */
        s.push(0);

        // iterate for rest of the elements
        for (i = 1; i < n; i++)
        {
            next = i;

            if (s.isEmpty() == false)
            {

                // if stack is not empty, then
                // pop an element from stack
                element = s.pop();

                /* If the popped element is smaller than 
                next, then a) print the pair b) keep 
                popping while elements are smaller and 
                stack is not empty */
                while (arr[element] < arr[next])
                {
                    answer.set(element, next - element);
                    if (s.isEmpty() == true)
                        break;
                    element = s.pop();
                }

                /* If element is greater than next, then 
                push the element back */
                if (arr[element] > arr[next])
                    s.push(element);
            }

            /* push next to stack so that we can find next 
            greater for it */
            s.push(next);
        }

        System.out.println(answer);
    }

    public static void main(String[] args)
    {
        int arr[] = { 70, 71, 74, 69, 70, 76, 71, 80, 70, 65 };
        int n = arr.length;
        printNGE(arr, n);
    }
}

//下一步要打印的Java程序
//使用堆栈的更大元素
导入java.util.ArrayList；
导入java.util.Collections；
公共类NGE
{
静态类堆栈
{
int top；
整数项目[]=新整数[100]；
//printNGE要使用的堆栈函数
无效推送（整数x）
{
如果（顶部==99）
{
System.out.println（“堆栈已满”）；
}
其他的
{
项目[++顶部]=x；
}
}
int-pop（）
{
如果（顶部==-1）
{
System.out.println（“下溢错误”）；
返回-1；
}
其他的
{
int元素=项目[顶部]；
顶部--；
返回元素；
}
}
布尔isEmpty（）
{
返回值（top==-1）？真：假；
}
}
/*打印元件和NGE对，用于
大小为n的arr[]的所有元素*/
静态无效打印（整数arr[]，整数n）
{
int i=0；
堆栈s=新堆栈（）；
s、 top=-1；
int元素，下一个；
//答案初始化为零
ArrayList answer=新的ArrayList（Collections.nCopies（n，0））；
/*将第一个元素推送到堆栈*/
s、 推（0）；
//对其余元素进行迭代
对于（i=1；iarr[next]）
s、 推（元件）；
}
/*按“下一步”到堆栈，以便找到下一步
更重要的是*/
s、 推（下一步）；
}
System.out.println（应答）；
}
公共静态void main（字符串[]args）
{
int arr[]={70,71,74,69,70,76,71,80,70,65}；
int n=阵列长度；
printNGE（arr，n）；
}
}
预期输出与问题描述不匹配。第一个值应为5。这表示未来比当前更热的天数。-我对您的输出感到困惑，因为有5天比[0]天热。今天是什么？每个人似乎都认为今天是名单上的第一天。。。是吗？啊，我想我看到了。今天，循环中的一个在循环中。因此，对于每一个，你需要计算有多少比你现在穿的更热。在整个列表中，索引0、索引5比它热，索引2、索引3比它热，等等。但这与预期的输出不符。代码示例似乎也进行了比较。所以，让我问一下：定义“更热”。我相信你想使用
result。设置（I，j-I）
而不是
result。添加（I，j-I）
后者会增加结果列表的大小，这不是你想要的。谢谢@Moustafa的评论。这真的很有帮助，解决了上面发布的问题。我们应该使用堆栈中的列表索引（如果我们使用检索它们的温度值，将导致错误的答案，因为给定列表中有重复的元素）。我试图更新您的答案，因为我是这里的新手。我应该用关键词“下一个更大元素”（NGE）以更好的方式发布这个问题。@Oskar You're welcome；）。是的，使用数值而不是索引会导致错误的答案，因为存在重复项。除非你有15+的声誉，否则不允许向上投票，但你可以