堆栈和队列枚举顺序

Question

我知道List 枚举器保证枚举顺序并尊重最后的排序操作，我知道Dictionary 和HashSet 不能，即你可以不确定 p>

Dictionary<string, string> dictionary = ...;

foreach(var pair in dictionary)
{

}

将按照它们附加的顺序处理对。

Stack 和 Queue 呢？他们的枚举器是否保证任何顺序？

Answer 1

对于Stack，枚举当前由一个名为StackEnumerator 的嵌套私有类完成（来自Reference Source）：

private class StackEnumerator : IEnumerator, ICloneable
{
    private Stack _stack;
    private int _index;
    private int _version;
    private Object currentElement;

    internal StackEnumerator(Stack stack) {
        _stack = stack;
        _version = _stack._version;
        _index = -2;
        currentElement = null;
    }

    public Object Clone()
    {
        return MemberwiseClone();
    }

    public virtual bool MoveNext() {
        bool retval;
        if (_version != _stack._version) throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumFailedVersion));
        if (_index == -2) {  // First call to enumerator.
            _index = _stack._size-1;
            retval = ( _index >= 0);
            if (retval)
                currentElement = _stack._array[_index];
            return retval;
        }
        if (_index == -1) {  // End of enumeration.
            return false;
        }

        retval = (--_index >= 0);
        if (retval)
            currentElement = _stack._array[_index];
        else
            currentElement = null;
        return retval;
    }

    public virtual Object Current {
        get {
            if (_index == -2) throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumNotStarted));
            if (_index == -1) throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumEnded));
            return currentElement;
        }
    }

    public virtual void Reset() {
        if (_version != _stack._version) throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumFailedVersion));
        _index = -2;
        currentElement = null;
    }
}    

注意它是如何从设置为_stack._size-1 的索引开始枚举并递减索引以按后进先出顺序返回每个元素的。

但是，由于没有记录，因此您不能保证它会一直这样（尽管微软现在改变枚举器的工作方式将是疯狂的！） p>

您可以检查嵌套的QueueEnumerator 类的实现，并类似地确定枚举是按照项目出列的顺序完成的。

Stack.GetEnumerator() 强烈暗示使用 LIFO 顺序。

如果您查看 the example for Stack<T>.GetEnumerator() in Microsoft's documentation 并检查声明的输出，您可以看到它是 LIFO 顺序的。

这强烈表明 Microsoft 完全打算按 LIFO 顺序枚举堆栈 - 但他们忘记（或没有费心）明确记录这一点！

Answer 2

Queue 是一个先进先出 (FIFO) 集合（在文档中这么说）。这意味着枚举器按添加顺序为您提供项目。

Stack 是一个后进先出 (LIFO) 集合。这意味着枚举器以与添加方式相反的顺序为您提供项目。

堆栈和队列是非常标准的计算机科学构造，因此如果没有严重的反弹，它们真的无法重新使用。当您查看 GetEnumerator() 函数的示例时，它清楚地记录了枚举的顺序：

Stack Enumeration:

    Stack<string> numbers = new Stack<string>();
    numbers.Push("one");
    numbers.Push("two");
    numbers.Push("three");
    numbers.Push("four");
    numbers.Push("five");

    // A stack can be enumerated without disturbing its contents.
    foreach( string number in numbers )
    {
        Console.WriteLine(number);
    }

    /* This code example produces the following output:

     five
     four
     three
     two
     one

    */

Queue Enumeration:

    Queue<string> numbers = new Queue<string>();
    numbers.Enqueue("one");
    numbers.Enqueue("two");
    numbers.Enqueue("three");
    numbers.Enqueue("four");
    numbers.Enqueue("five");

    // A queue can be enumerated without disturbing its contents.
    foreach( string number in numbers )
    {
        Console.WriteLine(number);
    }

    /* This code example produces the following output:

     one
     two
     three
     four
     five

    */

同样，对于基本的计算机科学定义，枚举器或迭代器必须以集合的自然顺序呈现元素。特定的集合类型具有定义的顺序。

警告

请注意，虽然枚举过程确实反映了 FIFO 和 LIFO 集合 (ref) 的自然顺序，但这不是队列 (ref) 和堆栈 (ref) 的意图 /em> 被使用。它们旨在与Enqueue()/Dequeue() 和Push()/Pop()/Peek() 交互一起使用。 Microsoft 包含枚举器以使所有内容与基本ICollection<T> 接口保持一致，并使枚举器保持集合的自然顺序。

队列的目的是提供可以按顺序处理的工作管道。 Stack 的目的是提供一种在本地工作完成时返回到先前上下文的方法。它们旨在一次处理一个项目。使用枚举器类型的侧步骤迭代集合，整个目的并且不会从队列/堆栈中删除项目。它本质上是对那里所有项目的一瞥。

Answer 3

是的。它似乎没有明确记录，但元素的枚举顺序与您将它们弹出/出列时的顺序相同。