如何在一维数组中访问多维？

Question

我得到以下代码：

Boo[,,] boos = new Boo[8, 8, 8];
Boo GetMe(int i, int j, int k)
{
    return boos[i, j, k];
}

上面的代码是低效的，所以我将其转换为一维数组：

Boo[] boosone;
Boo[,,] boos = new Boo[8, 8, 8];
Boo GetMe(int i, int j, int k)
{
   if (boosone == null)
   {
       boosone = new Boo[8 * 8 * 8];
       int num = 0;
       for (int x = 0; x < 8; x++)
       {
           for (int y = 0; y < 8; y++)
           {
               for (int z = 0; z < 8; z++)
               {
                   boosone[num] = boos[x, y, z];
                   num++;
               }
           }
       }
    }
    return boosone[?];
}

如何从一维数组Boo获得j（来自多维数组k l boosone中的相同位置）？

Answer 1

为什么不看看提供更好性能的锯齿状阵列？我做了一个测试（在RELEASE配置下），它显示你的包装器比d3阵列快两倍，但锯齿状的速度比d3阵列快3倍。

using System;
using System.Diagnostics;
using System.Linq;
using System.Threading;

namespace ArrayWrapper
{
    class ArrayPerformanceTest
    {
        int xSize = 2;
        int ySize = 3;
        int zSize = 4;
        int count = 100000000;
        int delay = 500;

        static void Main(string[] args)
        {
            new ArrayPerformanceTest().Run();
        }

        private void Run()
        {

            var d3Array = CreateD3Array();
            var wrapped = GetD1Adapter(d3Array);
            var jagged = GetJaggedArray(d3Array);

            Thread.Sleep(delay);
            TestD3Array(d3Array);
            Thread.Sleep(delay);
            TestWrappedArray(wrapped);
            Thread.Sleep(delay);
            TestJaggeddArray(jagged);
            Thread.Sleep(delay);
        }

        private int[,,] CreateD3Array()
        {
            var rectangular = new int[xSize, ySize, zSize];

            int i = 7;
            for (var x = 0; x < xSize; x++)
                for (var y = 0; y < ySize; y++)
                    for (var z = 0; z < zSize; z++)
                        rectangular[x, y, z] = ++i;

            return rectangular;
        }

        private int[] GetD1Adapter(int[,,] d3Array)
        {
            return d3Array.Cast<int>().ToArray();
        }

        private int[][][] GetJaggedArray(int[,,] d3Array)
        {
            var xSize = d3Array.GetUpperBound(0) + 1;
            var ySize = d3Array.GetUpperBound(1) + 1;
            var zSize = d3Array.GetUpperBound(2) + 1;

            var jagged = new int[xSize].Select(j => new int[ySize].Select(k => new int[zSize].ToArray()).ToArray()).ToArray();

            for (var x = 0; x < xSize; x++)
                for (var y = 0; y < ySize; y++)
                    for (var z = 0; z < zSize; z++)
                        jagged[x][y][z] = d3Array[x, y, z];

            return jagged;
        }

        private void TestD3Array(int[,,] d3Array)
        {
            int i;
            var sw = new Stopwatch();
            sw.Start();
            for (var c = 0; c < count; c++)
                for (var x = 0; x < xSize; x++)
                    for (var y = 0; y < ySize; y++)
                        for (var z = 0; z < zSize; z++)
                            i = d3Array[x, y, z];
            sw.Stop();
            Console.WriteLine($"{nameof(d3Array),7} {sw.ElapsedTicks,10}");
        }

        private void TestWrappedArray(int[] wrapped)
        {
            int i;
            var sw = new Stopwatch();
            sw.Start();
            for (var c = 0; c < count; c++)
                for (var x = 0; x < xSize; x++)
                    for (var y = 0; y < ySize; y++)
                        for (var z = 0; z < zSize; z++)
                            i = wrapped[x * ySize * zSize + y * zSize + z];
            sw.Stop();
            Console.WriteLine($"{nameof(wrapped),7} {sw.ElapsedTicks,10}");
        }

        private void TestJaggeddArray(int[][][] jagged)
        {
            int i;
            var sw = new Stopwatch();
            sw.Start();
            for (var c = 0; c < count; c++)
                for (var x = 0; x < xSize; x++)
                    for (var y = 0; y < ySize; y++)
                        for (var z = 0; z < zSize; z++)
                            i = jagged[x][y][z];
            sw.Stop();
            Console.WriteLine($"{nameof(jagged),7} {sw.ElapsedTicks,10}");
        }
    }
}

输出：

d3Array   15541709
wrapped    8213316
 jagged    5322008

我还分析了CPU的使用情况。

对于所有3种方法，它的速率相同。

Answer 2

int index = (8 * 8 * i) + (8 * j) + k;
return boosone[index];

Answer 3

访问多维数组并不比访问单维数组慢，实际上它们都以完全相同的方式存储在内存中。它不是你正在做的事情。

如果要在一个简单的方法中包装任一数组，请为编译器提供一个可以内联的提示

[MethodImpl(MethodImplOptions.AggressiveInlining)]
Boo GetMe(int i, int j, int k)
{
    return boos[i, j, k];
}

说这个，这个方法绝对没有任何优势，只有使用数组索引器才有优势。

如果你想使用数组的片段而没有重新分配的开销，可以考虑使用Span<T>或Memory<T>或ArraySegment

在这一点上我会编写示例代码，但是由于我不知道你在做什么，很难猜到你需要什么。

我建议，下载BenchmarkDotNet，并开始分析你的代码，找出最有效和最高效的方式来做你想做的事，不要猜...

Answer 4

不确定为什么你说第一个3D阵列效率不高（我的意思是，你真的注意到使用它时特别沉重的减速吗？），但你可以通过一些简单的偏移计算来做到这一点。

首先，如果你定位最新的C＃版本，你可以用两行替换整个复制功能，你的代码将如下所示：

using System;
using System.Runtime.InteropServices;

Boo[] boosone;
Boo[,,] boos = new Boo[8, 8, 8];

Boo GetMe(int i, int j, int k)
{
    if (boosone == null)
    {
        boosone = new Boo[boos.Length];
        MemoryMarshal.CreateSpan(ref boos[0, 0, 0], boosone.Length).CopyTo(boosone);
    }

    return boosone[boos.GetLength(1) * boos.GetLength(2) * i + boos.GetLength(2) * j + k];
}

如果由于某种原因你不想使用MemoryMarshal类，你也可以使用LINQ来展平你的3D数组，尽管这种方法效率低得多：

boosone = boos.Cast<Boo>().ToArray();