Question

我试图创建一个数组，它由一个输入数组（长度= 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类型）。我哪里出错了？这是最快的方法吗？

Answer 1

由于another answer指出了为什么它不起作用，我将专注于如何使用Linq更容易编写。

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

Linq让生活更轻松：）

Answer 2

Reverse方法修改传递给它的数组并返回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;
}

Answer 3

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

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;
}

结果：

LinqStack（）：647ms SimpleStack（）：184ms OriginalStack（）：66ms

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

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

如您所见，虽然linq方法是最简单和最易读的，但它并不是最有效的方法。如果您担心性能，使用自编循环也不是最佳选择。标准阵列操作更快。

Answer 4

它的工作

 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; 
}

堆栈数组的顺序相反

4 个答案: