用java编写带堆栈的计算跨度

我正在写一个用堆栈计算跨度的程序 我已经编写了一个代码，下面是我在其中使用的变量：

一个名为X的52个整数数组：这是我们要计算其跨度的数组；在此代码中，X元素将由随机函数初始化

该程序的输出是一个名为S的整数数组，其大小与X相同； S[i]是股票在第i天的跨度

st是一个堆栈

下面是我根据算法编写的代码：

public class ComputingSpansInStack {

static int [] X = new int[52];
static int [] S = new int[52];
public static void SetX()
{

    Random rn = new Random();
    for (int i = 0; i < 52; i++) {
        X[i] = 1 + rn.nextInt(100);
    }
}

public static void main(String[] args) {
    SetX();
    int h;
    Stack<Integer> st=new MyStack<>();
    boolean done;
    for (int i = 0; i<52 ; i++)
    {
        done = false;

        while(!(st.isEmpty()||done))
                {
                    if(X[i]>= X[st.top()])
                        st.pop();
                    else 
                        done = true;
                }
        if(st.isEmpty())
            h = -1;
        else 
            h = st.top();

        S[i] = i - h;
        st.push(i);  
    }


    for (int i =0; i<52; i++)
    {
        System.out.println(X[i] + "   "+ S[i]);
    }
}

堆栈中的公共类计算{
静态int[]X=新int[52]；
静态int[]S=新int[52]；
公共静态void SetX（）
{
Random rn=新的Random（）；
对于（int i=0；i<52；i++）{
X[i]=1+rn.nextInt（100）；
}
}
公共静态void main（字符串[]args）{
SetX（）；
int-h；
Stack st=新的MyStack（）；
布尔完成；
对于（int i=0；i=X[st.top（）]））
圣普（）；
其他的
完成=正确；
}
if（st.isEmpty（））
h=-1；
其他的
h=圣托普（）；
S[i]=i-h；
圣普什（一）；
}
对于（int i=0；i您的实现是正确的。
S[i]
=i+1，其中
X[i]
大于前面的所有元素，因此由于
X[3]
（64）大于前面的所有元素，
S[3]
=（3+1）=4

换句话说，您认为
S[3]
应等于3的假设是不正确的。跨度的定义是“紧靠
X[i]
之前的最大连续元素数
X[j]
，并且
X[j]
≤ 
X[i]
”，但该算法似乎在结果中添加了一个。对于
X[0]
（没有紧接在前面的较小元素）它是1。对于
X[1]
（没有紧接在前面的较小元素）它是1。对于
X[3]
（3紧接在较小元素之前）它是4

这似乎不符合“最大值”的严格定义，但算法是一致的：如果
X[3]
应该等于3，那么X[0]和X[1]应该等于零，因为前面没有直接的较小元素

公营股票{

private int arr[] = { 10, 4, 5, 90, 120, 80 };

public void getSpan() {
    StackImpl s = new StackImpl<Integer>();
    s.push(0);
    int stockSpanRes[] = new int[arr.length];
    stockSpanRes[0] = 1;
    for (int i = 0; i < arr.length; i++) {
        while (!s.isEmpty() && arr[(int) s.peek()] <= arr[i]) {
            s.pop();
        }
        stockSpanRes[i] = s.isEmpty() ? i + 1 : i - (int) s.peek();
        s.push(i);
    }

    for (int i = 0; i < arr.length; i++) {
        System.out.println(stockSpanRes[i]);
    }
}

public static void main(String[] args) {
    StockSpan s = new StockSpan();
    s.getSpan();

}

private int arr[]={10,4,5,90,120,80}；
public void getSpan（）{
StackImpl s=新的StackImpl（）；
s、 推（0）；
整数stockSpanRes[]=新整数[arr.length]；
stockSpanRes[0]=1；
对于（int i=0；i虽然（！s.isEmpty（）&&arr[（int）s.peek（）]算法看起来是正确的，但您能否显示
MyStack
？@HunterMcMillen我已将其添加到post中，这是一种后进先出的数据结构，对吗？
Deque st=new ArrayDeque（）；
（Java 6+必需）@AnthonyAccioly你为什么要谈论Deque？问题是关于堆栈，它们不是一回事。在他的问题中，OP没有告诉我们他必须实现自己的堆栈。但是如果他为了学习的目的必须实现自己的堆栈，那么我同意你的看法。如果他不这样做，我代表
Deque
，每次专业开发人员编写使用遗留的
堆栈
实现或自制的脆弱集合编写代码粉色海豚死亡（严重！）。
private int arr[] = { 10, 4, 5, 90, 120, 80 };

public void getSpan() {
    StackImpl s = new StackImpl<Integer>();
    s.push(0);
    int stockSpanRes[] = new int[arr.length];
    stockSpanRes[0] = 1;
    for (int i = 0; i < arr.length; i++) {
        while (!s.isEmpty() && arr[(int) s.peek()] <= arr[i]) {
            s.pop();
        }
        stockSpanRes[i] = s.isEmpty() ? i + 1 : i - (int) s.peek();
        s.push(i);
    }

    for (int i = 0; i < arr.length; i++) {
        System.out.println(stockSpanRes[i]);
    }
}

public static void main(String[] args) {
    StockSpan s = new StockSpan();
    s.getSpan();

}