Java中的堆栈值循环

在给定的数组中，我只想计算左侧小于或等于每个值的连续值

例如，在下面的数组中，第一个索引值是100，没有比它小的值，因此，它将是1。对于值70，有60小于它，因此计数为2，依此类推

注意：这应该使用堆栈来完成（这是一个堆栈实践问题）

我的方法：

import java.util.*;
import java.util.Stack;

public static int[] getStockSpan(int[] prices) {

        int[] arr = new int[prices.length];
        Stack<Integer> stack = new Stack<>();

        for ( int i = 0; i < prices.length; i++ ) {

            if ( stack.size() == 0 ) {

                arr[0] = 1;

            } else {

                if ( stack.peek() > prices[i] ) {

                    arr[i] = 1;

                } else {

                    int count = 1,t=0;
                    Iterator iter=stack.iterator();
                    int ia[]=new int[prices.length];
                    while ( iter.hasNext()  ) {
                        Integer k= (Integer)iter.next();

                        ia[t++]=k.intValue();
                    }
                    for(int j=t-1;j>=0;j--)
                    {

                        if(ia[j] <=  prices[i])
                            count++;
                        else
                            break;   
                    }
                    arr[i] = count;
                }
            }
            stack.push(prices[i]);
        }
        return arr;
    }

我试图用这种方式来解决：

在数组中运行循环，每次向堆栈添加数组值

如果堆栈为空，则将第一个数组元素设置为1

否则，如果

stack.peek（）

大于1，则添加1

如果

stack.peek（）

较小，则只要存在较小或相等的值，就在堆栈中循环

问题： 现在的问题是：由于

stack.pop（）

，它第一次可以正常工作，但下一次就不行了

问题： 我的问题是，如果没有

stack.pop（）

，如何循环遍历堆栈

代码： 以下是我正在尝试的：

public static int[] getStockSpan(int[] prices) {

        int[] arr = new int[prices.length];
        Stack<Integer> stack = new Stack<>();

        for ( int i = 0; i < prices.length; i++ ) {

            if ( stack.size() == 0 ) {

                arr[0] = 1;

            } else {

                if ( stack.peek() > prices[i] ) {

                    arr[i] = 1;

                } else {

                    int count = 1;

                    while ( stack.size() > 0 && stack.peek() <=  prices[i] ) {
                        count++;
                        stack.pop();
                    }

                    arr[i] = count;

                }

            }

            stack.push(prices[i]);

        }

        return arr;

    }

public static int[]getStockSpan（int[]prices）{
int[]arr=新int[prices.length]；
堆栈=新堆栈（）；
对于（int i=0；iprices[i]）{
arr[i]=1；
}否则{
整数计数=1；
而（stack.size（）>0&&stack.peek（）在java中导入它们：

import java.util.*;
import java.util.Stack;

public static int[] getStockSpan(int[] prices) {

        int[] arr = new int[prices.length];
        Stack<Integer> stack = new Stack<>();

        for ( int i = 0; i < prices.length; i++ ) {

            if ( stack.size() == 0 ) {

                arr[0] = 1;

            } else {

                if ( stack.peek() > prices[i] ) {

                    arr[i] = 1;

                } else {

                    int count = 1,t=0;
                    Iterator iter=stack.iterator();
                    int ia[]=new int[prices.length];
                    while ( iter.hasNext()  ) {
                        Integer k= (Integer)iter.next();

                        ia[t++]=k.intValue();
                    }
                    for(int j=t-1;j>=0;j--)
                    {

                        if(ia[j] <=  prices[i])
                            count++;
                        else
                            break;   
                    }
                    arr[i] = count;
                }
            }
            stack.push(prices[i]);
        }
        return arr;
    }

然后用以下代码替换代码：

import java.util.*;
import java.util.Stack;

public static int[] getStockSpan(int[] prices) {

        int[] arr = new int[prices.length];
        Stack<Integer> stack = new Stack<>();

        for ( int i = 0; i < prices.length; i++ ) {

            if ( stack.size() == 0 ) {

                arr[0] = 1;

            } else {

                if ( stack.peek() > prices[i] ) {

                    arr[i] = 1;

                } else {

                    int count = 1,t=0;
                    Iterator iter=stack.iterator();
                    int ia[]=new int[prices.length];
                    while ( iter.hasNext()  ) {
                        Integer k= (Integer)iter.next();

                        ia[t++]=k.intValue();
                    }
                    for(int j=t-1;j>=0;j--)
                    {

                        if(ia[j] <=  prices[i])
                            count++;
                        else
                            break;   
                    }
                    arr[i] = count;
                }
            }
            stack.push(prices[i]);
        }
        return arr;
    }

public static int[]getStockSpan（int[]prices）{
int[]arr=新int[prices.length]；
堆栈=新堆栈（）；
对于（int i=0；iprices[i]）{
arr[i]=1；
}否则{
整数计数=1，t=0；
迭代器iter=stack.Iterator（）；
int ia[]=新int[prices.length]；
while（iter.hasNext（））{
整数k=（整数）iter.next（）；
ia[t++]=k.intValue（）；
}
对于（int j=t-1；j>=0；j--）
{
if（ia[j]您是否考虑过与堆栈不同的数据结构？