Gezackte Arrays in C#

Gezackte Arrays in C#

In diesem Artikel besprechen wir:

Was sind gezackte Arrays in C#?

Ein gezacktes Array ist ein Array von Arrays. Im Gegensatz zu rechteckigen Arrays können die Subarrays eines gezackten Arrays eine unterschiedliche Anzahl von Elementen haben.
Schauen wir uns das folgende Beispiel an, um es besser zu verstehen.

Der folgende Code deklariert ein zweidimensionales gezacktes Array.

int[][] jagArr = new int[3][]; // Declare and create top-level array.
... // Declare and create subarrays.

Die Länge der ersten Dimension ist 3. Die Deklaration kann gelesen werden als „jagArr ist ein Array aus drei Arrays von Ints.“

Ein gezacktes Array kann eine beliebige Anzahl von Dimensionen größer als eins haben. In rechteckigen Arrays können Dimensionslängen nicht in den Array-Typ-Abschnitt der Deklaration aufgenommen werden.

Die Syntax für gezackte Arrays erfordert einen separaten Satz eckiger Klammern für jede Dimension. Die Anzahl der eckigen Klammern in der Deklaration der Array-Variablen bestimmt den Rang des Arrays.

Instanziieren eines gezackten Arrays:

Gezacktes Array ist ein Array unabhängiger Arrays, jedes Array muss separat erstellt werden. Die Instanziierung eines vollständigen gezackten Arrays erfordert die folgenden Schritte:
1. Instanziiere das Array der obersten Ebene.
2. Instanziiere jedes Subarray separat, indem du die Referenz des neu erstellten Arrays dem entsprechenden Element seines enthaltenden Arrays zuweist .

Schauen wir uns das folgende Beispiel an, um es besser zu verstehen.

int[][] Arr = new int[3][]; // 1. Instantiate top level.
Arr[0] = new int[] {10, 20, 30}; // 2. Instantiate subarray.
Arr[1] = new int[] {40, 50, 60, 70}; // 3. Instantiate subarray.
Arr[2] = new int[] {80, 90, 100, 110, 120}; // 4. Instantiate subarray.


Subarrays in gezackten Arrays:

Subarrays in einem gezackten Array sind selbst Arrays, es ist möglich, rechteckige Arrays in gezackten Arrays zu haben.

class Program
    {
        static void Main()
        {
            int[][,] Arr; // An array of 2D arrays
            Arr = new int[3][,]; // Instantiate an array of three 2D arrays.
            Arr[0] = new int[,] { { 10, 20 },{ 100, 200 } };
            Arr[1] = new int[,] { { 30, 40, 50 },{ 300, 400, 500 } };
            Arr[2] = new int[,] { { 60, 70, 80, 90 },{ 600, 700, 800, 900 } };//Get length of dimension 0 of Arr.
            for (int i = 0; i < Arr.GetLength(0); i++)
            {//Get length of dimension 0 of Arr[ i ].
                for (int j = 0; j < Arr[i].GetLength(0); j++)
                {//Get length of dimension 1 of Arr[ i ].
                    for (int k = 0; k < Arr[i].GetLength(1); k++)
                    {
                        Console.WriteLine
                        ("[{0}][{1},{2}] = {3}", i, j, k, Arr[i][j, k]);
                    }
                    Console.WriteLine("");
                }
                Console.WriteLine("");
            }
        }
    }

Ausgabe:

[0][1,0] = 100
[0][1,1] = 200

[1][0,0] = 30
[1][0,1] = 40
[1][0,2] = 50

[1][1,0] = 300
[1][1,1] = 400
[1][1,2] = 500

[2][0,0] = 60
[2][0,1] = 70
[2][0,2] = 80
[2][0,3] = 90

[2][1,0] = 600
[2][1,1] = 700
[2][1,2] = 800
[2][1,3] = 900

Unterschied zwischen Jagged Array und Rectangular Array:

Die Struktur von rechteckigen und gezackten Arrays unterscheidet sich erheblich. Eindimensionale Arrays haben spezifische Anweisungen in der CIL, die es ermöglichen, sie auf Leistung zu optimieren. Rechteckige Arrays haben diese Anweisungen nicht und sind nicht auf die gleiche Ebene optimiert.
Es ist effizienter, gezackte Arrays von eindimensionalen Arrays zu verwenden – die optimiert werden können – als rechteckige Arrays. Auf der anderen Seite die Programmierung Die Komplexität kann bei einem rechteckigen Array erheblich geringer sein, da es als eine einzelne Einheit behandelt werden kann und nicht als ein Array von Arrays.



Im obigen Diagramm ist die Struktur eines rechteckigen Drei-mal- drei Arrays sowie ein gezacktes Array aus drei eindimensionalen Arrays der Länge 3.
-Beide Arrays enthalten neun ganze Zahlen, aber wie Sie sehen können, sind ihre Strukturen ziemlich unterschiedlich.
-Das rechteckige Array hat ein einzelnes Array-Objekt, während das gezackte Array vier Array-Objekte hat.

Zusammenfassung:

In diesem Artikel haben wir Folgendes besprochen:

Vielen Dank für Ihren Besuch !!