Нахождение всех разъединенных подграфов в графике

Многомерный массив создает хорошее линейное расположение памяти, в то время как зубчатый массив подразумевает несколько дополнительных уровней абстракции.

Поиск значения jagged[3][6] в зубчатом массиве var jagged = new int[10][5] работы как это: Ищите элемент в индексе 3 (который является массивом), и ищите элемент в индексе 6 в том массиве (который является значением). Для каждого размера в этом случае, существует дополнительный взгляд (это - дорогой шаблон доступа к памяти).

многомерный массив А размечается линейно в памяти, фактическое значение найдено путем умножения вместе индексов. Однако, учитывая массив var mult = new int[10,30], Length свойство того многомерного массива возвращает общее число элементов т.е. 10 * 30 = 300.

Rank свойство зубчатого массива всегда равняется 1, но многомерный массив может иметь любой разряд. GetLength метод любого массива может использоваться для получения длины каждого размера. Для многомерного массива в этом примере mult.GetLength(1) возвраты 30.

Индексация многомерного массива быстрее. например, учитывая многомерный массив в этом примере mult[1,7] = 30 * 1 + 7 = 37, получите элемент в том индексе 37. Это - лучший шаблон доступа к памяти, потому что только одна ячейка памяти включена, который является базовым адресом массива.

многомерный массив А поэтому выделяет непрерывный блок памяти, в то время как зубчатый массив не должен быть квадратным, например, jagged[1].Length не должен равняться jagged[2].Length, который был бы верен для любого многомерного массива.

Производительность

Производительность мудрые, многомерные массивы должны быть быстрее. Намного быстрее, но из-за действительно плохой реализации CLR они не.

 23.084  16.634  15.215  15.489  14.407  13.691  14.695  14.398  14.551  14.252 
 25.782  27.484  25.711  20.844  19.607  20.349  25.861  26.214  19.677  20.171 
  5.050   5.085   6.412   5.225   5.100   5.751   6.650   5.222   6.770   5.305 

первая строка является синхронизациями зубчатых массивов, вторых выставочных многомерных массивов и третьего, хорошо это - то, как это должно быть. Программу показывают ниже, к вашему сведению это было протестировано, работая моно. (Синхронизации окон весьма отличаются, главным образом из-за изменений реализации CLR).

окна On, синхронизации зубчатых массивов значительно выше о том же как моя собственная интерпретация того, какой многомерный массив ищут, должен быть похожим, видеть 'Единственный ()'. Печально JIT-компилятор окон действительно глуп, и это, к сожалению, делает эти обсуждения производительности трудными, существует слишком много несоответствий.

Это синхронизации, я вошел в окна, то же соглашение здесь, первая строка являются зубчатыми массивы, вторые многомерный и третий моя собственная реализация многомерных, отмечают, насколько медленнее это находится на окнах по сравнению с моно.

  8.438   2.004   8.439   4.362   4.936   4.533   4.751   4.776   4.635   5.864
  7.414  13.196  11.940  11.832  11.675  11.811  11.812  12.964  11.885  11.751
 11.355  10.788  10.527  10.541  10.745  10.723  10.651  10.930  10.639  10.595

Исходный код:

using System;
using System.Diagnostics;
static class ArrayPref
{
    const string Format = "{0,7:0.000} ";
    static void Main()
    {
        Jagged();
        Multi();
        Single();
    }

    static void Jagged()
    {
        const int dim = 100;
        for(var passes = 0; passes < 10; passes++)
        {
            var timer = new Stopwatch();
            timer.Start();
            var jagged = new int[dim][][];
            for(var i = 0; i < dim; i++)
            {
                jagged[i] = new int[dim][];
                for(var j = 0; j < dim; j++)
                {
                    jagged[i][j] = new int[dim];
                    for(var k = 0; k < dim; k++)
                    {
                        jagged[i][j][k] = i * j * k;
                    }
                }
            }
            timer.Stop();
            Console.Write(Format,
                (double)timer.ElapsedTicks/TimeSpan.TicksPerMillisecond);
        }
        Console.WriteLine();
    }

    static void Multi()
    {
        const int dim = 100;
        for(var passes = 0; passes < 10; passes++)
        {
            var timer = new Stopwatch();
            timer.Start();
            var multi = new int[dim,dim,dim];
            for(var i = 0; i < dim; i++)
            {
                for(var j = 0; j < dim; j++)
                {
                    for(var k = 0; k < dim; k++)
                    {
                        multi[i,j,k] = i * j * k;
                    }
                }
            }
            timer.Stop();
            Console.Write(Format,
                (double)timer.ElapsedTicks/TimeSpan.TicksPerMillisecond);
        }
        Console.WriteLine();
    }

    static void Single()
    {
        const int dim = 100;
        for(var passes = 0; passes < 10; passes++)
        {
            var timer = new Stopwatch();
            timer.Start();
            var single = new int[dim*dim*dim];
            for(var i = 0; i < dim; i++)
            {
                for(var j = 0; j < dim; j++)
                {
                    for(var k = 0; k < dim; k++)
                    {
                        single[i*dim*dim+j*dim+k] = i * j * k;
                    }
                }
            }
            timer.Stop();
            Console.Write(Format,
                (double)timer.ElapsedTicks/TimeSpan.TicksPerMillisecond);
        }
        Console.WriteLine();
    }
}