关于1：

Stack<T>和List<T>的性能相似并不奇怪，我希望它们都使用带倍增策略的数组，这会导致分摊的常数时间加法。
除了it leads to less expressive code之外，您可以在任何可以使用Stack<T>的地方使用List<T>。

关于2：

我想我知道为什么List<T>不能很好地处理前端了......因为List<T>在处理前端时需要来回移动整个列表。
是的。在开头插入/删除元素是昂贵的，因为它移动了所有元素。另一方面，在开头获取或替换元素是便宜的。

关于3：

缓慢的LinkedList<T>.RemoveLast值是基准测试代码中的一个错误。
移除或获取一个双向链表的最后一项是很便宜的，对于LinkedList<T>来说，这意味着RemoveLast和Last是很便宜的。
但是你没有使用Last属性，而是使用LINQ的扩展方法Last()，在没有实现IList<T>的集合上，它迭代整个列表，给它O(n)运行时。

List<T>是动态过度分配数组（在许多其他语言的标准库中也可以看到这种数据结构）。这意味着它在内部使用了“静态”数组（一个不能调整大小的数组，在.NET中称为“数组”），它可能并且经常大于列表的大小。然后追加只是增加一个计数器，并使用下一个先前未使用的内部数组的槽。只有当内部数组变得太小而无法容纳所有项时，才会重新分配数组（这需要复制所有元素）。当发生这种情况时，数组的大小将增加一个因子（不是常数），通常为2。
这确保了“分摊”时间复杂度（基本上，在长操作序列上每个操作的平均时间）是O（1）即使在最坏的情况下。对于在前面添加，这样的优化是不可行的（至少在保持随机访问和O（1）在末尾追加的情况下不会）。它总是必须复制所有元素以将它们移动到它们的新槽中（在第一个插槽中为添加的元素腾出空间）。Stack<T>做了同样的事情，您只是没有注意到添加到前面的差异，因为您只在一端（快速的一端）操作。
获取链表的末尾在很大程度上取决于链表的内部结构。一个 * 可以 * 维护对最后一个元素的引用，但是这使得链表上的所有操作更加复杂，并且可能（我手边没有例子）会使一些操作的开销更大，缺少这样的引用，追加到末尾需要遍历链表的 * 所有 * 元素以找到最后一个节点，这对于非平凡大小的列表来说当然非常慢。
正如@CodesInChaos所指出的，您的链表操作存在缺陷。您现在看到的快速检索结尾很可能是由于LinkedList<T>显式维护了对最后一个节点的引用，如上所述。请注意，获取不在任何一端的元素仍然很慢。

速度主要来自于插入、删除或搜索一个项目所需的操作数量。您已经注意到，该列表需要内存传输。
堆栈是一个列表，只能访问顶部元素--计算机总是知道它在哪里。
链表是另一回事：列表的开始是已知的，因此从开始添加或删除非常快--但是找到最后一个元素需要时间。缓存最后一个元素的位置OTOH只值得添加。对于删除，需要遍历减去一个元素的完整列表以找到指向最后一个元素的“钩子”或指针。
只要看看这些数字，就可以对每个数据结构的内部结构做出一些有根据的猜测：

• 从堆栈弹出的速度很快，正如预期的那样
• 压栈比较慢，而且比加到列表末尾要慢，为什么？
• 显然，堆栈的分配单元大小较小--它可能仅将堆栈大小增加100，而可以以1000为单位来完成列表的增长。
• 一个列表看起来像一个静态数组，访问前面的列表需要内存传输，这需要的时间与列表长度成正比。
• 基本的链表操作不应该花费那么长的时间，通常只需要
• 新项目。下一个=列表开始;列表开始=新项目;//添加
• 列表开始=列表开始.下一个;//删除
• 然而，由于addLast的速度很快，这意味着在对链表进行添加或删除时，也必须更新指向最后一个元素的指针，因此需要额外的簿记。
• 双向链表OTOH使得在列表两端插入和删除相对较快（我听说有更好的代码使用DLL），然而，
• 链接到上一个和下一个项目也加倍了簿记工作

使用Stack和End of List在性能上的相似性，
正如delnan所解释的那样，它们都在内部使用了一个简单的数组，所以它们在最后工作时的行为非常相似，你可以看到堆栈是一个列表，只访问最后一个对象。
使用List的前端和后端的区别
你已经猜对了。操作一个列表的开头，意味着底层数组需要改变。添加一个项通常意味着你需要将所有其他元素移动一位，移除也一样。如果你知道你将操作列表的两端，你最好使用链表。
为什么使用LinkedIn列表的结尾会这么慢？
通常情况下，链表在任意位置的元素插入和删除都可以在恒定时间内完成，因为你最多只需要改变两个指针。问题是如何到达位置。一个普通的链表只有一个指向它的第一个元素的指针。所以如果你想到达最后一个元素，你需要遍历所有的元素。2用链表实现的队列通常通过增加一个指向最后一个元素的指针来解决这个问题，所以添加元素也可以在恒定时间内完成。2更复杂的数据结构是一个双向链表，它既有指向第一个 * 元素的指针，也有指向最后一个 * 元素的指针，而且每个元素还包含指向下一个 * 元素和前一个 * 元素的指针。
您应该了解的是，有许多不同的数据结构都是为了同一个目的而创建的，它们可以非常有效地处理这些目的。选择正确的结构在很大程度上取决于您想要做什么。

我有Java背景，我猜你的问题更多地涉及到一般的数据结构，而不是特定的语言。另外，如果我的陈述不正确，我道歉。

1.使用Stack和List结尾的性能相似
2.使用List前端和后端的差异，以及

至少在Java中，Stacks是使用arrays实现的（如果C#不是这样，请道歉。您可以参考实现的源代码），Lists也是如此。通常，对于数组，所有在末尾的插入所花费的时间都比在开头的要少，因为数组中预先存在的值需要下移，以适应在开头的插入。
Link to Stack.java source及其超类向量

3.使用LinkedList的结尾如此缓慢的原因是什么？

LinkedList不允许随机访问并且在到达插入点之前必须遍历节点。如果您发现最后一个节点的性能比较慢，那么我认为LinkedList实现应该是一个单链表。我猜您可能希望在访问最后的元素时考虑使用双链表以获得最佳性能。
http://en.wikipedia.org/wiki/Linked_list

只是改进了之前代码的一些不足，特别是随机和虚拟计算的影响。数组仍然是最重要的，但列表的性能令人印象深刻，LinkedIn列表非常适合随机插入。
排序结果为：

12      array[i]
40      list2[i]
62      FillArray
68      list2.RemoveAt
78      stack.Pop
126     list2.Add
127     queue.Dequeue
159     stack.Push
161     foreach_linkedlist1
191     queue.Enqueue
218     linkedlist1.RemoveFirst
219     linkedlist2.RemoveLast
2470        linkedlist2.AddLast
2940        linkedlist1.AddFirst

代码为：

using System;
using System.Collections.Generic;
using System.Diagnostics;
//
namespace Benchmarking {
    //
    static class Collections {
        //
        public static void Main() {
            const int limit = 9000000;
            Stopwatch sw = new Stopwatch();
            Stack<int> stack = new Stack<int>();
            Queue<int> queue = new Queue<int>();
            List<int> list1 = new List<int>();
            List<int> list2 = new List<int>();
            LinkedList<int> linkedlist1 = new LinkedList<int>();
            LinkedList<int> linkedlist2 = new LinkedList<int>();
            int dummy;

            sw.Reset();
            Console.Write( "{0,40}  ", "stack.Push");
            sw.Start();
            for ( int i = 0; i < limit; i++ ) {
                stack.Push( i );
            }
            sw.Stop();
            Console.WriteLine( sw.ElapsedMilliseconds.ToString() );
            sw.Reset();
            Console.Write( "{0,40}  ", "stack.Pop" );
            sw.Start();
            for ( int i = 0; i < limit; i++ ) {
                stack.Pop();
            }
            sw.Stop();
            Console.WriteLine( sw.ElapsedMilliseconds.ToString() );

            sw.Reset();
            Console.Write( "{0,40}  ", "queue.Enqueue" );
            sw.Start();
            for ( int i = 0; i < limit; i++ ) {
                queue.Enqueue( i );
            }
            sw.Stop();
            Console.WriteLine( sw.ElapsedMilliseconds.ToString() );
            sw.Reset();
            Console.Write( "{0,40}  ", "queue.Dequeue" );
            sw.Start();
            for ( int i = 0; i < limit; i++ ) {
                queue.Dequeue();
            }
            sw.Stop();
            Console.WriteLine( sw.ElapsedMilliseconds.ToString() );

            //sw.Reset();
            //Console.Write( "{0,40}  ", "Insert to List at the front..." );
            //sw.Start();
            //for ( int i = 0; i < limit; i++ ) {
            //  list1.Insert( 0, i );
            //}
            //sw.Stop();
            //Console.WriteLine( sw.ElapsedMilliseconds.ToString() );
            //
            //sw.Reset();
            //Console.Write( "{0,40}  ", "RemoveAt from List at the front..." );
            //sw.Start();
            //for ( int i = 0; i < limit; i++ ) {
            //  dummy = list1[ 0 ];
            //  list1.RemoveAt( 0 );
            //  dummy++;
            //}
            //sw.Stop();
            //Console.WriteLine( sw.ElapsedMilliseconds.ToString() );

            sw.Reset();
            Console.Write( "{0,40}  ", "list2.Add" );
            sw.Start();
            for ( int i = 0; i < limit; i++ ) {
                list2.Add( i );
            }
            sw.Stop();
            Console.WriteLine( sw.ElapsedMilliseconds.ToString() );
            sw.Reset();
            Console.Write( "{0,40}  ", "list2.RemoveAt" );
            sw.Start();
            for ( int i = 0; i < limit; i++ ) {
                list2.RemoveAt( list2.Count - 1 );
            }
            sw.Stop();
            Console.WriteLine( sw.ElapsedMilliseconds.ToString() );

            sw.Reset();
            Console.Write( "{0,40}  ", "linkedlist1.AddFirst" );
            sw.Start();
            for ( int i = 0; i < limit; i++ ) {
                linkedlist1.AddFirst( i );
            }
            sw.Stop();
            Console.WriteLine( sw.ElapsedMilliseconds.ToString() );
            sw.Reset();
            Console.Write( "{0,40}  ", "linkedlist1.RemoveFirst" );
            sw.Start();
            for ( int i = 0; i < limit; i++ ) {
                linkedlist1.RemoveFirst();
            }
            sw.Stop();
            Console.WriteLine( sw.ElapsedMilliseconds.ToString() );

            sw.Reset();
            Console.Write( "{0,40}  ", "linkedlist2.AddLast" );
            sw.Start();
            for ( int i = 0; i < limit; i++ ) {
                linkedlist2.AddLast( i );
            }
            sw.Stop();
            Console.WriteLine( sw.ElapsedMilliseconds.ToString() );
            sw.Reset();
            Console.Write( "{0,40}  ", "linkedlist2.RemoveLast" );
            sw.Start();
            for ( int i = 0; i < limit; i++ ) {
                linkedlist2.RemoveLast();
            }
            sw.Stop();
            Console.WriteLine( sw.ElapsedMilliseconds.ToString() );

            // Fill again
            for ( int i = 0; i < limit; i++ ) {
                list2.Add( i );
            }
            sw.Reset();
            Console.Write( "{0,40}  ", "list2[i]" );
            sw.Start();
            for ( int i = 0; i < limit; i++ ) {
                dummy = list2[ i ];
            }
            sw.Stop();
            Console.WriteLine( sw.ElapsedMilliseconds.ToString() );

            // Fill array
            sw.Reset();
            Console.Write( "{0,40}  ", "FillArray" );
            sw.Start();
            var array = new int[ limit ];
            for ( int i = 0; i < limit; i++ ) {
                array[ i ] = i;
            }
            sw.Stop();
            Console.WriteLine( sw.ElapsedMilliseconds.ToString() );

            sw.Reset();
            Console.Write( "{0,40}  ", "array[i]" );
            sw.Start();
            for ( int i = 0; i < limit; i++ ) {
                dummy = array[ i ];
            }
            sw.Stop();
            Console.WriteLine( sw.ElapsedMilliseconds.ToString() );

            // Fill again
            for ( int i = 0; i < limit; i++ ) {
                linkedlist1.AddFirst( i );
            }
            sw.Reset();
            Console.Write( "{0,40}  ", "foreach_linkedlist1" );
            sw.Start();
            foreach ( var item in linkedlist1 ) {
                dummy = item;
            }
            sw.Stop();
            Console.WriteLine( sw.ElapsedMilliseconds.ToString() );

            //
            Console.WriteLine( "Press Enter to end." );
            Console.ReadLine();
        }
    }
}

我很晚才开始讨论这个问题，但是有一个BoundedChannel对我来说非常适合保持一个滑动窗口缓冲区。
https://learn.microsoft.com/en-us/dotnet/core/extensions/channels