按相反顺序堆叠数组

本文关键字：数组 顺序 | 更新日期: 2023-09-27 17:59:56

我正在尝试创建一个数组，该数组由一个输入数组（长度=N）和同一个数组按相反顺序组成，因此输出数组为长度（2N）。类似于如果输入=｛1,2,3｝，则输出=｛1,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类型）。请问我哪里错了？这是最快的方法吗？

按相反顺序堆叠数组

另一个答案指出了它为什么不起作用，我将重点讨论如何使用Linq更容易地编写它。

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

Linq让生活更轻松：）

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

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

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（

LinqStack（）：710ms SimpleStack（

LinqStack（）：602ms SimpleStack（

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

它的工作

 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; 
}
相关文章：