Question

我有一个问题，考虑一个刺激堆栈的程序（不使用任何内置的堆栈功能等）。

stack2= 1 2 3 4 5 //single dimension array of 5 elements

通过调用方法pop，堆栈应该如下所示，基本上每次重新调用堆栈时都会关闭一个元素。

stack2= 1 2 3 4 0  
stack2= 1 2 3 0 0  
stack2= 1 2 0 0 0  
stack2= 1 0 0 0 0  
stack2= 0 0 0 0 0

这是我的代码：

for (int i = 1; i <= 6; i++)
{
    number= TryPop(s2);
    //use number
    ShowStack(s2, "s2");
}

public void Push(int g)
{
    if (top == Max)
    {
        throw new Exception("Stack overflow...");
    }
    else
    {
        tabel[top] = g;
        top++;
    }
}/*Push*/

我已经有了用数字填充数组的代码（通过push方法）。 pop方法应取最后一个值并将其置于0，然后调用下一个堆栈并将以下内容置于0（如上面的stack2中所示）。

跟踪顶部索引的当前pop方法（0个元素= 0顶部，1个元素= 1个顶部等...）已经包含一个下溢警告，如果该值为0或更低（这是正确的）。

public int Pop()
{
    if(top <= 0)
    {
        throw new Exception("Stack underflow...");
    }
    else
    {
        for (int j = tabel.Length - 1; j >= 0; j--)  
        {
            //...Really not sure what to do here.
        }
    }

    return number; 

}/*Pop*/

因为在另一个类中我已经有一个循环（上面显示的for循环），它模拟了s2堆栈的6倍。（第一个堆栈：1 2 3 4 0，第二个堆栈1 2 3 0 0，依此类推。）我每次如何取消一个元素？我要么将整个显示设置为0，要么将0设置在错误的位置/出于索引错误。

编辑：工作流程方法：

public int Pop()
{
    if(top <= 0)
    {
        throw new Exception("Stack underflow...");
    }

    top--;
    tabel[top] = 0;
    number = tabel[top];

    return number;
}/*Pop*/

Answer 1

要实现堆栈，您需要一个数组和一个指向堆栈顶部的“指针”。

empty       _ _ _ _ _
            ↑

在您的代码中，table是数组，top是指针（作为数组索引）。

<强>推

要将项目推送到堆栈，请将项目放在堆栈顶部并将指针前进一个：

push 1      1 _ _ _ _
              ↑

push 2      1 2 _ _ _
                ↑

push 3      1 2 3 _ _
                  ↑

这就是你的代码已经做的事情：

table[top] = g;    // insert `g` at `top` into `table`
top++;             // advance `top` by one

<强>弹出

要弹出一个项目，请将指针向后移动一步，然后返回+删除顶部的项目：

pop 3       1 2 _ _ _
                ↑

pop 2       1 _ _ _ _
              ↑

pop 1       _ _ _ _ _
            ↑

现在尝试将Push的解决方案转换为反向，如下所示！

Answer 2

您应该声明一个局部变量result并将其设置为堆栈顶部的当前值，使用top作为数据的索引。然后递减top变量并返回result。由于它是作业，我不会发布代码 - 你应该尝试自己实现它，以确保你理解它。

无需循环实施Pop。删除它们也不需要零值，但如果您愿意，也可以这样做。

您还应该注意，此实现不是线程安全的。没关系，但要确保清楚地记录下来。

Answer 3

您不应在for中使用Pop()循环。您只删除了一个元素，并且知道该元素的位置（它位于索引top），因此您只需要处理该堆栈的元素。

Answer 4

假设top引用堆栈的顶部，将堆栈顶部的值设置为0并减少顶部就足够了。

public int Pop()
{
    if(top < 0)
    {
        throw new Exception("Stack underflow...");
    }
    else
    {
        table[top] = 0;
        top--;
    }

    // not sure where number comes from
    return number; 

}/*Pop*/

Answer 5

我确定我会因为给他答案而受到抨击，但我知道如果我在星期天穿上他的鞋子我会想要什么。我希望dtb的答案得到最多的赞成，因为它应该得到一个很好的堆栈解释！

这是堆栈的基本示例。请学习它。不要只是粘贴在你的作业中。

public class Stack<T>
{
    public int Count { get; private set; }
    private int _CurrentPosition;
    private T[] _Values;

    public Stack(int capacity)
    {
        _CurrentPosition = -1;
        _Values = new T[capacity];
        Count = capacity;
    }

    public T Peek()
    {
        if (_CurrentPosition < 0)
            return default(T);

        return _Values[_CurrentPosition];
    }

    public void Push(T item)
    {
        if (_CurrentPosition == Count)
            throw new Exception("Stack overflow...");

        _CurrentPosition++;
        _Values[_CurrentPosition] = item;
    }

    public T Pop()
    {
        if(_CurrentPosition < 0)
            throw new Exception("Stack underflow...");
        T item = _Values[_CurrentPosition];
        _Values[_CurrentPosition] = default(T);
        _CurrentPosition--;
        return item;
    }
}

从元组中取出每个方法调用的元素

5 个答案: