Arrays - mehrdimensionale Felder (zwei- und dreidimensionale Arrays)

Mehrdimensionale Arrays bestehen wie der Name bereits sagt aus mehreren Dimensionen (Ebenen). Wie z.B. eine xy-Matrix aus zwei Dimensionen (Zeilen und Spalten) besteht, besteht auch auch ein zweidimensionales Array aus Zeilen und Spalten. 

 

                                                

Hier ist ein Array mit 3x3 Feldern grafisch dargestellt. Jedes Feld ist durch eine exakte Position im Koordinatensystem dargestellt. Das erste Feld links oben hat die Position 0,0 (Zeile 0, Spalte 0). Das Feld in der Mitte hat die Position 1,1 (Zeile 1, Spalte 1) usw.

Jedes Feld kann nun einen bestimmten Wert, je nach Datentyp des Arrays beinhalten.

Über die jeweilige Position eines Feldes, kann der Inhalt abgerufen werden.

In diesem Beispiel wird ein zweidimensionales int-Array mit 3 Zeilen und 3 Spalten erstellt.
Jedem Feld wird ein Wert zugewiesen. Anschließend wird das Array mit einer foreach-Schleife ausgelesen.

foreach-Schleife 

namespace ConsoleApplication_mehrdim_arrays
{
    class Program
    {
        static void Main(string[] args)
        {
            /* Zweidimensionales Array */
            int[,] myarray = new int[3, 3]; // Ein Array mit 3 Zeilen und 3 Spalten
            myarray[0, 0] = 1;              // 0.Zeile, 0.Spalte = 1
            myarray[0, 1] = 2;              // 0.Zeile, 1.Spalte = 2
            myarray[0, 2] = 3;              // 0.Zeile, 2.Spalte = 3
            myarray[1, 0] = 4;              // 1.Zeile, 0.Spalte = 4
            myarray[1, 1] = 5;              // 1.Zeile, 1.Spalte = 5
            myarray[1, 2] = 6;              // 1.Zeile, 2.Spalte = 6
            myarray[2, 0] = 7;              // 2.Zeile, 0.Spalte = 7
            myarray[2, 1] = 8;              // 2.Zeile, 1.Spalte = 8
            myarray[2, 2] = 9;              // 2.Zeile, 1.Spalte = 9

            foreach (int i in myarray)      // Ausgabe aller Elemente des Arrays
            {
                Console.WriteLine(i);
            }

            Console.WriteLine("\n");
        }
    }
}

 

geschachtelte for-Schleife

Hier ein Array mit 2 Zeilen und 3 Spalten welches mit Hilfe einer geschachtelten for-Schleife ausgelesen wird:

namespace ConsoleApplication_mehrdim_arrays
{
    class Program
    {
        static void Main(string[] args)
        {
            int zeilen = 2, spalten = 3;

            int[,] myarray1 = new int[zeilen, spalten]; // Ein Array mit 2 Zeilen und 3 Spalten
            myarray1[0, 0] = 1;              // 1.Zeile, 1.Spalte = 1
            myarray1[0, 1] = 2;              // 1.Zeile, 2.Spalte = 2
            myarray1[0, 2] = 3;              // 1.Zeile, 3.Spalte = 3
            myarray1[1, 0] = 4;              // 2.Zeile, 1.Spalte = 4
            myarray1[1, 1] = 5;              // 2.Zeile, 2.Spalte = 5
            myarray1[1, 2] = 6;              // 2.Zeile, 3.Spalte = 6


            for (int i = 0; i < zeilen; i++)
            {
                for (int j = 0; j < spalten; j++)
                {
                    Console.Write(myarray1[i, j]);
                }
                Console.Write("\n");    // Zeilenumbruch bei Beginn einer neuen Zeile
            }

            Console.ReadLine();
        }
    }
}

 

Möchte man z.B. Messwerte über 4 Wochen einlesen, so entsprechen die Wochen den Zeilen und die Tage den Spalten. Jedem Feld (Zeile x, Spalte y) wird ein Wert zugeordnet.

 

Hier ein Beispiel:

Mit diesem Programm sollen Einnahmen über 4 Wochen, a' 6 Tage eingelesen werden. Man benötigt also ein Feld mit 4 Zeilen und 6 Spalten [4,6].
Zusätzlich soll der Durchschnitt und der Tag mit den geringsten Einnahmen ausgegeben werden.

namespace einnahmen
{
    class Program
    {
        static void Main(string[] args)
        {
            //Einnahmen über 4 Wochen, à 6 Tage. Durchschnitt und Tag mit MIN?
            float summe = 0,durchschnitt=0,minimum=0,tag=0,woche=0;
            float[,] einnahmen = new float[4, 6]; //4 Zeilen und 6 Spalten

            for (int i = 0; i < 4; i++) //äussere Schleife für die Zeilen
               {

                   for (int j = 0; j < 6; j++) //innere Schleife für Spalten
                   {
                       Console.WriteLine("Einnahmen {0} Woche, {1} Tag: ", i + 1, j + 1);

                       einnahmen[i,j] = Convert.ToSingle(Console.ReadLine());

                       summe = summe + einnahmen[i,j];

                       if (j == 0 && i == 0)

                           minimum = einnahmen[i,j];

                       else if (einnahmen[i, j] < minimum)
                       {
                           minimum = einnahmen[i, j];

                           tag = j + 1;
                           woche = i + 1;
                       }
                   }
               }
               durchschnitt = summe / 24;

            Console.WriteLine("Summe der Einnahmen: {0}",summe);
            Console.WriteLine("Das minimum ist: {0} am {1} Tag der {2} Woche", minimum,tag,woche);

            Console.ReadLine();
        }
    }
}

 

Dreidimensionale Arrays

Um sich ein dreidimensionales Array vorstellen zu können, versuchen Sie sich einen Würfel vorzustellen. Neben der x- und y-Achse wie bei einem zweidimensionalen Array, kommt hier die z-Achse hinzu. Die z-Achse ist hierbei die 3. Dimension. Die folgende Abbildung soll ein Array mit der Größe 4x4x4 darstellen. Insgesamt beinhaltet dieses Array 64 Felder wobei jedes Feld über die x-y-z-Koordinaten exakt angesprochen werden kann.

Das 1.Feld (linkes oberes und vorderes Feld) hat hierbei die Koordinate [0,0,0].

Das rote Feld hat hier die Koordinate  [1,1,0] (Zeile1, Spalte1, Ebene0). Das blaue Feld hat die Koordinate [0,1,1] (Zeile0, Spalte1, Ebene1) und das grüne Feld die Koordinate [0,3,2] (Zeile0, Spalte3, Ebene2).

 

Man kann sich auch jede Ebene wie eine eigene Seite (engl. page) vorstellen wie die folgende Abbildung beschreibt:

Ein dreidimensionales Array wird verwendet um z.B. Daten oder Grafiken räumlich darzustellen.

 

Beispiele:

/* Das folgende Beispiel zeigt ein Array mit 3 Dimensionen:
 * Die 1. Dimension besteht aus 2 Elementen
 * Die 2. Dimension besteht aus 3 Elementen
 * Die 3. Dimension besteht aus 4 Elementen
 */
 int[, ,] myarray2 = new int[2, 3, 4] // Ein Array mit 3 Dimensionen
 { 
     { {111,112,113,114},{121,122,123,124},{131,132,133,134} },
     { {211,212,213,214},{221,222,223,224},{231,232,233,234} }
 };

/* Das folgende Beispiel zeigt ein Array mit 3 Dimensionen:
 * Die 1. Dimension besteht aus 2 Elementen
 * Die 2. Dimension besteht aus 3 Elementen
 * Die 3. Dimension besteht aus 1 Element
 */
 int[, ,] myarray4 = new int[2, 3, 1] // Ein Array mit 3 Dimensionen
 { 
     { {111},{121},{131} },
     { {211},{221},{231} }
 };

 

dreifach geschachtelte for-Schleife

In diesem Beispiel wird ein 3x3x3 Array mit einer dreifach geschachtelten for-Schleife ausgelesen. Der Inhalt wird seitenweise auf der Konsole ausgegeben.

 

namespace ConsoleApplication_mehrdim_arrays
{
    class Program
    {
        static void Main(string[] args)
        {
            int zeilen = 3, spalten = 3, seiten = 3;

            int[, ,] myarray3 = new int[zeilen, spalten, seiten]; // Ein Array mit 3 Dimensionen

            myarray3[0, 0, 0] = 11;           // 0.Zeile, 0.Spalte, 0.Seite
            myarray3[0, 1, 0] = 12;           // 0.Zeile, 1.Spalte, 0.Seite
            myarray3[0, 2, 0] = 13;           // 0.Zeile, 2.Spalte, 0.Seite
            myarray3[1, 0, 0] = 14;           // 1.Zeile, 0.Spalte, 0.Seite
            myarray3[1, 1, 0] = 15;           // 1.Zeile, 1.Spalte, 0.Seite
            myarray3[1, 2, 0] = 16;           // 1.Zeile, 2.Spalte, 0.Seite
            myarray3[2, 0, 0] = 17;           // 2.Zeile, 0.Spalte, 0.Seite
            myarray3[2, 1, 0] = 18;           // 2.Zeile, 1.Spalte, 0.Seite
            myarray3[2, 2, 0] = 19;           // 2.Zeile, 2.Spalte, 0.Seite

            myarray3[0, 0, 1] = 21;           // 0.Zeile, 0.Spalte, 1.Seite
            myarray3[0, 1, 1] = 22;           // 0.Zeile, 1.Spalte, 1.Seite
            myarray3[0, 2, 1] = 23;           // 0.Zeile, 2.Spalte, 1.Seite
            myarray3[1, 0, 1] = 24;           // 1.Zeile, 0.Spalte, 1.Seite
            myarray3[1, 1, 1] = 25;           // 1.Zeile, 1.Spalte, 1.Seite
            myarray3[1, 2, 1] = 26;           // 1.Zeile, 2.Spalte, 1.Seite
            myarray3[2, 0, 1] = 27;           // 2.Zeile, 0.Spalte, 1.Seite
            myarray3[2, 1, 1] = 28;           // 2.Zeile, 1.Spalte, 1.Seite
            myarray3[2, 2, 1] = 29;           // 2.Zeile, 2.Spalte, 1.Seite

            myarray3[0, 0, 2] = 31;           // 0.Zeile, 0.Spalte, 2.Seite
            myarray3[0, 1, 2] = 32;           // 0.Zeile, 1.Spalte, 2.Seite
            myarray3[0, 2, 2] = 33;           // 0.Zeile, 2.Spalte, 2.Seite
            myarray3[1, 0, 2] = 34;           // 1.Zeile, 0.Spalte, 2.Seite
            myarray3[1, 1, 2] = 35;           // 1.Zeile, 1.Spalte, 2.Seite
            myarray3[1, 2, 2] = 36;           // 1.Zeile, 2.Spalte, 2.Seite
            myarray3[2, 0, 2] = 37;           // 2.Zeile, 0.Spalte, 2.Seite
            myarray3[2, 1, 2] = 38;           // 2.Zeile, 1.Spalte, 2.Seite
            myarray3[2, 2, 2] = 39;           // 2.Zeile, 2.Spalte, 2.Seite

            for (int i = 0; i < seiten; i++)                // 3.) zum Schluß die Seiten
            {
                for (int j = 0; j < zeilen; j++)            // 2.) dann die Zeilen
                {
                    for (int k = 0; k < spalten; k++)       // 1.) Zuerst die Spalten
                    {
                        Console.Write(" " + myarray3[j, k, i]);
                    }
                    Console.Write("\n");    // Zeilenumbruch bei Beginn einer neuen Zeile
                }
                Console.Write("\n");        // Zeilenumbruch bei Beginn einer neuen Seite
            }

            Console.ReadLine();
        }
    }
}