问题 最轻量级的.NET集合

如果你只需要添加和迭代，我会相信链表是最轻量级的。我没有看过Stack的实现，因此很容易创建一个不占用太多空间的实现。这是一个相当天真的解决方案，可以针对大小进行优化。我的观点是，实现轻量级集合很简单

public class Stack<T>{
   readonly T _head;
   readonly Stack<T> _tail;
   public Stack(T head,Stack<T> tail){
       _head = head;
       _tail = tail;
   }

   public Stack<T> Push(T element){
       return new Stack<T>(element,this);
   }

   public IEnumerator<T> GetEnumerator(){
         yield return _head;
         var current = _tail;
         while(_tail != null){
             yield return current._head;
             current = current._tail;
         }
   }
}

Performancewise这将比使用预分配数组的实现慢，因为分配给元素比新对象更新并且取决于例如内部数组的填充方式。 list这实际上可能会占用更多的空间，但是每次只使用一个元素来新建一个新数组时，可以通过新的数组来交换开销以获得性能，但这在性能方面具有显着的开销。您还可以选择在两者之间保持平衡，在大多数情况下，您可以为许多新元素提供足够的空间来提供内存，但在大多数情况下可以提高性能。

public class Stack<T>{
   T[] _heads;
   T[] _tail;
   int _next;
   public Stack(T head,T[] tail){
       _heads = new T[tail.length];
       _next = _heads.Length -2; 
       _heads[_heads.Length -1] = head;
       _tail = tail;
   }

   public void Push(T element){
        if(_next < 0){
            var length = _heads.Length;
            var _new = new T[length * 2];
            _heads = new T[length * 2];                
            _next = length * 2-1;
            Array.Copy(_heads,_new,length);
            Array.Copy(_tails,0,_new,length,length);
            _tails = _new;
        } else{
            _heads[_next--] = element;
        }
   }

   public IEnumerator<T> GetEnumerator(){
         yield return _head;
         var current = _tail;
         while(_tail != null){
             yield return current._head;
             current = current._tail;
         }
   }
}

而你基本上回到了List等集合的平衡。它建立在一个内部阵列上，这个阵列通常太大而不能高速添加而不会浪费太多内存。

因此，与所有优化问题一样，它实际上取决于您希望优化的内容。如果您愿意牺牲性能，您通常可以优化内存，反之亦然