c# 克隆一个堆栈

Question

我的代码中有几个堆栈用于跟踪我的逻辑位置。在某些时候我需要复制堆栈，但我似乎无法以保留顺序的方式克隆它们。我只需要浅复制（引用，而不是对象）。

正确的方法是什么？还是应该使用其他类型的堆栈？

注意：我看到了这个帖子Stack Clone Problem: .NET Bug or Expected Behaviour?，但不确定如何为 Stack 类设置克隆方法。

注意 #2：我使用 System.Collection.Generic.Stack

Answer 1

var clonedStack = new Stack<T>(new Stack<T>(oldStack));

你可以把它写成扩展方法

public static Stack<T> Clone<T>(this Stack<T> stack) {
    Contract.Requires(stack != null);
    return new Stack<T>(new Stack<T>(stack));
}

这是必要的，因为我们在这里使用的Stack<T> 构造函数是Stack<T>(IEnumerable<T> source)，当然，当您为Stack<T> 迭代IEnumerable<T> 实现时，它会重复从堆栈中弹出项目，从而提供它们以与您希望它们进入新堆栈的顺序相反的顺序发送给您。因此，执行此过程两次将导致堆栈的顺序正确。

或者：

var clonedStack = new Stack<T>(oldStack.Reverse());


public static Stack<T> Clone<T>(this Stack<T> stack) {
    Contract.Requires(stack != null);
    return new Stack<T>(stack.Reverse());
}

同样，我们必须以与迭代堆栈的输出相反的顺序遍历堆栈。

我怀疑这两种方法之间存在性能差异。

Answer 2

这是一种使用 LINQ 的简单方法：

var clone = new Stack<ElementType>(originalStack.Reverse());

您可以创建一个扩展方法来简化此操作：

public static class StackExtensions
{
    public static Stack<T> Clone<T>(this Stack<T> source)
    {
        return new Stack<T>(originalStack.Reverse());
    }
}

用法：

var clone = originalStack.Clone();

Answer 3

如果您不需要实际的Stack`1，而只是想要一个现有Stack`1 的快速副本，您可以按照Pop 返回的相同顺序进行操作，另一种选择是复制Stack`1变成Queue`1。然后，这些元素将按照与原始 Stack`1 中的 Pop 相同的顺序 Dequeue。

using System;
using System.Collections.Generic;

class Test
{
  static void Main()
  {
    var stack = new Stack<string>();

    stack.Push("pushed first, pop last");
    stack.Push("in the middle");
    stack.Push("pushed last, pop first");

    var quickCopy = new Queue<string>(stack);

    Console.WriteLine("Stack:");
    while (stack.Count > 0)
      Console.WriteLine("  " + stack.Pop());
    Console.WriteLine();
    Console.WriteLine("Queue:");
    while (quickCopy.Count > 0)
      Console.WriteLine("  " + quickCopy.Dequeue());
  }
}

输出：

堆： 最后推，先弹出 在中间 先推，最后弹出 队列： 最后推，先弹出 在中间 先推，最后弹出

Answer 4

对于那些关心性能的人。还有其他几种方法可以迭代原始堆栈成员而不会对性能造成很大损失：

public T[] Stack<T>.ToArray();
public void Stack<T>.CopyTo(T[] array, int arrayIndex);

我编写了一个粗略的程序（链接将在文章末尾提供）来测量性能，并为已经建议的实现添加了两个测试（参见 Clone1 和 Clone2 em>），以及 ToArray 和 CopyTo 方法的两个测试（参见 Clone3 和 Clone4，它们都使用更高效的 Array.Reverse 方法）。

public static class StackExtensions
{
    public static Stack<T> Clone1<T>(this Stack<T> original)
    {
        return new Stack<T>(new Stack<T>(original));
    }

    public static Stack<T> Clone2<T>(this Stack<T> original)
    {
        return new Stack<T>(original.Reverse());
    }

    public static Stack<T> Clone3<T>(this Stack<T> original)
    {
        var arr = original.ToArray();
        Array.Reverse(arr);
        return new Stack<T>(arr);
    }

    public static Stack<T> Clone4<T>(this Stack<T> original)
    {
        var arr = new T[original.Count];
        original.CopyTo(arr, 0);
        Array.Reverse(arr);
        return new Stack<T>(arr);
    }
}

结果是：

• 克隆 1：318,3766 毫秒
• 克隆 2：269,2407 毫秒
• 克隆 3：50,6025 毫秒
• Clone4：37,5233 毫秒 - 获胜者

如我们所见，使用 CopyTo 方法的方法快 8 倍，同时实现非常简单直接。此外，我对堆栈大小的最大值进行了快速研究：Clone3 和 Clone4 测试在 OutOfMemoryException 发生之前适用于更大的堆栈大小：

• Clone1：67108765 个元素
• 克隆 2：67108765 个元素
• Clone3：134218140 个元素
• Clone4：134218140 个元素

Clone1 和 Clone2 的上述结果更小，因为显式/隐式定义了额外的集合，因此影响了内存消耗。因此，Clone3 和 Clone4 方法允许以更少的内存分配更快地克隆堆栈实例。使用反射可以获得更好的结果，但情况不同 :)

完整的节目列表可以在here找到。