Question

我正在寻找一个基本上是有限堆栈的数据结构。

如果我声明堆栈最多可以容纳3个项目，并且我推送另一个项目，弹出最旧的项目。

Answer 1

您将能够使用deque（http://en.wikipedia.org/wiki/Deque）或双端队列上的包装器来实现此功能。如果达到堆栈大小，请确保在offerFirst方法内调用pollLast方法。

Answer 2

我会根据Deque

编写自己的ring buffer.实现

Answer 3

你需要一个队列。单个链接列表，记录第一个和最后一个项目。如果您想从O（n）更改为O（1）遍历以更新最后一项，则为双重链接。

您可以在队列前面推送对象。如果长度大于3，则弹出后面。

Answer 4

LIFO（后进先出）结构被称为堆栈，这是您需求的主要部分所需的

FIFO（先进先出）结构称为队列，这是您能够从背面弹出最旧的项目所需的。

这些的组合被称为Deque。你必须能够从任何一端推或弹。

我不确定Java是否有内置的Deque数据结构，但是如果它有（或者你可以在google上找到一个实现），你可以放一些包装逻辑来确保如果你推到前面，和deque.Count＆gt; 3，然后也从后面弹出。

Answer 5

这是在C＃，因为我不知道Java我害怕但这个想法应该翻译。

public class BoundedStack<T>
{
    private readonly int limit;
    private LinkedList<T> list;

    public BoundedStack(int limit)
    {
        this.limit = limit;
        list = new LinkedList<T>();
    }

    public void Push(T item)
    {
        if (list.Count == limit) list.RemoveFirst();
        list.AddLast(item);
    }

    public T Pop()
    {
        if (list.Count == 0) 
            throw new IndexOutOfRangeException("No items on the stack");

        var item = list.Last.Value;
        list.RemoveLast();

        return item;
    }

    public int Count()
    {
        return list.Count;
    }
}

Answer 6

Apache commons有一些接近你需要的东西，除了它是Fifo：CircularFifoBuffer。我认为你将不得不编写一个自定义包装器来实现像Lifo一样的实现。

Answer 7

以下是我的LIFO实施，灵感来自Garry Shutler的回答

public class BoundedStack<T> {

    private int limit;
    private LinkedList<T> list;

    public BoundedStack(int limit) {
        this.limit = limit;
        list = new LinkedList<>();
    }

    public void push(T item) {
        if (list. size() == limit) {
            list.removeLast();
        }
        list.addFirst(item);
    }

    public int size() {
        return list.size();
    }

    public List<T> getAll() {
        return list;
    }

    public T peek() {
        return list.get(0);
    }
}

什么数据结构将在LIFO中保存有限的项目堆栈？

7 个答案: