C# 按相反顺序堆叠阵列

我试图创建一个数组，它由一个输入数组（长度=N）和同一个数组按相反的顺序组成，这样输出数组的长度为（2N）。如果输入={1,2,3}，那么输出={1,2,3,3,2,1}

这就是我所尝试的：

public static double[] stack(double[] input)
{
    int N = input.Length;
    var z = new double[2 * N];
    input.CopyTo(z, 0);
    Array.Reverse(input).CopyTo(z, N);

    return z;
}

但这会引发错误（运算符不能应用于void类型）。请问我哪里出错了？这是最快的方法吗？

该方法修改传入的数组并返回void。试试这个：

public static double[] stack(double[] input)
{
    int N = input.Length;        // assuming input = { 1, 2, 3 }
    var z = new double[2 * N];   // z = { 0, 0, 0, 0, 0, 0 }
    input.CopyTo(z, 0);          // z = { 1, 2, 3, 0, 0, 0 }
    input.CopyTo(z, N);          // z = { 1, 2, 3, 1, 2, 3 }
    Array.Reverse(z, N, N);      // z = { 1, 2, 3, 3, 2, 1 }

    return z;
}

正如它指出了它不起作用的原因一样，我将重点介绍如何使用Linq更容易地编写它

public static double[] Stack(double[] input)
{
    return input.Concat(input.Reverse())
                 .ToArray();
}

Linq让生活更轻松：）

这是工作

 public  static  double []  stack ( double [] input ) 
{ 
    int N = input.Length; 
    var z =  new  double[2*N]; 
    input.CopyTo(z, 0); 
    Array.Reverse(input);
    input.CopyTo( z , N );
    return z; 
}

---

以下是我对用户提出的三种方法的简单基准：

static void Main(string[] args)
{
    Stopwatch sw = new Stopwatch();

    double[] input = Enumerable.Range(0, 10000000).Select(i => (double)i).ToArray();

    while (true)
    {
        sw.Start();

        LinqStack(input);

        sw.Stop();

        Console.WriteLine("LinqStack(): {0}ms", sw.ElapsedMilliseconds);

        sw.Restart();

        SimpleStack(input);

        sw.Stop();

        Console.WriteLine("SimpleStack(): {0}ms", sw.ElapsedMilliseconds);

        sw.Restart();

        OriginalStack(input);

        sw.Stop();

        Console.WriteLine("OriginalStack(): {0}ms", sw.ElapsedMilliseconds);

        sw.Reset();

        Console.ReadLine();
    }
}

/// <summary>
/// By Sriram Sakthivel
/// </summary>
static double[] LinqStack(params double[] input)
{
    return input.Concat(input.Reverse())
                    .ToArray();
}

static double[] SimpleStack(params double[] input)
{
    int length = input.Length;

    double[] output = new double[length * 2];

    for (int i = 0; i < length; i++)
    {
        output[i] = input[i];
    }

    for (int i = 0; i < length; i++)
    {
        output[i + length] = input[length - i - 1];
    }

    return output;
}

/// <summary>
/// By p.s.w.g
/// </summary>
static double[] OriginalStack(params double[] input)
{
    int N = input.Length;        // assuming input = { 1, 2, 3 }
    var z = new double[2 * N];   // z = { 0, 0, 0, 0, 0, 0 }
    input.CopyTo(z, 0);          // z = { 1, 2, 3, 0, 0, 0 }
    input.CopyTo(z, N);          // z = { 1, 2, 3, 1, 2, 3 }
    Array.Reverse(z, N, N);      // z = { 1, 2, 3, 3, 2, 1 }

    return z;
}

static void Main（字符串[]args）
{
秒表sw=新秒表（）；
double[]input=Enumerable.Range（010000）。选择（i=>（double）i.ToArray（）；
while（true）
{
sw.Start（）；
LinqStack（输入）；
sw.Stop（）；
WriteLine（“LinqStack（）：{0}ms”，sw.elapsedmillisons）；
sw.Restart（）；
SimpleStack（输入）；
sw.Stop（）；
WriteLine（“SimpleStack（）：{0}ms”，sw.elapsedmillesons）；
sw.Restart（）；
原始策略（输入）；
sw.Stop（）；
WriteLine（“OriginalStack（）：{0}ms”，sw.elapsedmillesons）；
sw.Reset（）；
Console.ReadLine（）；
}
}
/// 
///斯里拉姆·萨基维尔
/// 
静态双[]LinqStack（参数双[]输入）
{
返回input.Concat（input.Reverse（））
.ToArray（）；
}
静态双[]SimpleStack（参数双[]输入）
{
int length=input.length；
double[]输出=新的double[length*2]；
for（int i=0；i

结果:

LinqStack（）：647ms SimpleStack（）：184ms原始Stack（）：66ms

LinqStack（）：710ms SimpleStack（）：175ms OriginalStack（）：66ms

LinqStack（）：602ms SimpleStack（）：334ms OriginalStack（）：95ms

---

正如您所看到的，虽然linq方法是最简单、可读性最好的，但它并不是最有效的。如果您担心性能，使用自写循环也不是最好的主意。Standart阵列操作更快。

neat。你认为哪一个更快？@nik我不担心性能，除非它非常重要。只需使用可读性更强的代码。顺便说一句，如果您需要性能结果，请自己进行基准测试。您应该注意，这会修改

输入。这可能是目的，也可能不是。你认为哪一个更快？你的还是林克？谢谢大家!@nik我希望使用数组方法会更快，但是为什么不对这两种方法进行基准测试以查看结果呢？