Benutzer-Werkzeuge

Webseiten-Werkzeuge


schule:arrays_und_listen

Arrays und Listen

Arrays und Listen sind zwei wichtige Datenstrukturen, in denen mehrere Daten vom gleichen Typ abgelegt werden können.

Arrays

Gleichartigen Daten können in einem Array zusammengefasst werden. Hierbei werden die Daten in einer Reihe angeordnet und können über eine Nummer (den Index) abgerufen werden. Kapitel 2.5 des Buches Visual C# 2012 und das Lernprogramm für Arrays erläutern Arrays im Detail.

Im Quelltext erkennt man Arrays an den eckigen Klammern hinter dem Datentyp. Sie werden mit new erzeugt und es muss eine Länge in den eckigen Klammern angegeben werden – sie gibt an, wie viele Elemente das Array aufnehmen kann. So erzeugen wir zwei Arrays mit 4 bzw. 2 Elementen. Sie können ganze Zahlen (int) bzw. Zeichenketten (string) aufnehmen.

int[] intVars = new int[4];
string[] strArr = new String[2];

Allgemein würde man also schreiben: Datentyp[] bezeichner = new Datentyp[Anzahl];.

Einzelne Elemente können nun über einen Index gesetzt werden. Achtung: Die Zählung beginnt immer mit 0! Der Index des letzten Elements ist demnach eins kleiner als die Länge des Arrays. Der Index ist immer eine ganze Zahl (int).

//    Index
//      v        // Inhalt des Arrays
intVars[0] = 5;  // 5 0 0 0
intVars[3] = 7;  // 5 0 0 7
 
strArr[0] = "Ja"  // "Ja"  ""
strArr[1] = "Nö"  // "Ja"  "Nö"
strArr[0] = "Yes" // "Yes" "Nö"

So können wir das Array mit einer Schleife durchlaufen.

for(int i=0; i<4; i++)
{
  Console.WriteLine("Element " + i + " hat den Inhalt " + intVars[i]);
}

Wenn die Länge des Arrays nicht bekannt ist, kann sie mit intVars.Length abgerufen werden.

for(int i=0; i<intVars.Length; i++)
{
  Console.WriteLine("Element " + i + " hat den Inhalt " + intVars[i]);
}

Eine weitere Möglichkeit, ein Array zu durchlaufen, bietet eine foreach-Schleife. Hierbei nimmt die Variable i nacheinander die Werte aller Einträge des Arrays an. Wir wissen dann jedoch nicht, an welcher Stelle diese stehen.

foreach(int i in intVars)
{
  Console.WriteLine(i + " ist ein Element des Arrays.");
}

Listen

Listen sind den Arrays sehr ähnlich. Auch sie speichern Daten des gleichen Typs ab. Jedoch muss ihre Größe nicht zu Beginn feststehen. Sie wachsen dynamisch mit. Kapitel 9.9. aus dem Buch Visual C# 2012 stellt Listen genauer vor.

Beim Erzeugen einer Liste werden die Typen der Elemente der Liste in spitzen statt eckigen Klammern angegeben. So wird eine Liste aus ints erzeugt und mit zwei Einträgen gefüllt. Die Länge können wir mit Count abrufen.

                               // Inhalt der Liste
List<int> l = new List<int>(); // leer
l.Add(3);                      // 3
l.Add(6);                      // 3 6
l.Count;                       // -> 2

Einzelne Elemente werden wie bei Arrays abgerufen.

Console.WriteLine("Element an Stelle 0: " + l[0]);
Console.WriteLine("Element an Stelle 1: " + l[1]);

Alle Elemente können auch wieder mit einer Schleife ausgegeben werden. Beim Abfragen der Länge wird Count in der Schleifenbedingung verwendet.

for(int i=0; i<l.Count; i++) 
{
  Console.WriteLine("Element an Stelle " + i + " ist " + l[i]);
}

Übungen

Abstimmung

Wir simulieren eine Abstimmung bei „Deutschland sucht den Superstar“. Die Zuschauer können anrufen und ihren Favoriten aus einer bestimmten Anzahl an Sängerinnen und Sängern wählen. Auf dem TV ausgeben wird letztendlich pro Sängerin bzw. Sänger die Anzahl an Zuschauern, die für sie bzw. ihn gestimmt haben, und zwar prozentual.

Schreiben Sie ein Programm, in dem der Benutzer zunächst die Anzahl an Sängern und anschließend für jeden Sänger die Anzahl an Anrufen eingeben muss. Speichern Sie die Daten in einem geeigneten Array ab. Anschließend soll das Ergebnis der Abstimmung in Form eines Balkendiagramms auf den Bildschirm ausgegeben werden. Und zwar sollen entsprechend der prozentualen Verteilung der Telefonanrufe jeweils Balken aus *-Zeichen (100 % entsprechen dabei 100 *-Zeichen) sowie anschließend der absolute Wert der Telefonanrufe auf den Bildschirm ausgegeben werden.

Beispiel für einen Programmablauf (Eingaben stehen in <>):

Anzahl der Saenger (> 0): <4>
Anrufe für Saenger 1 (>= 0): <50>
Anrufe für Saenger 2 (>= 0): <50>
Anrufe für Saenger 3 (>= 0): <40>
Anrufe für Saenger 4 (>= 0): <60>

Abstimmungsergebnis:
************************* 50
************************* 50
******************** 40
****************************** 60

Enthalten

Schreiben Sie eine Methode bool istEnthalten(int[] arrZahlen, int iZahl), die prüft, ob eine gegebene Zahl iZahl in dem übergebenen Array arrZahlen enthalten ist. Falls ja, wird true sonst false zurückgegeben.

Gleichheit prüfen

Schreiben Sie eine Methode bool sindGleich(double[] arr1, double[] arr2), die zwei Arrays aus double-Zahlen als Parameter übergeben bekommt und prüfen soll, ob die beiden Arrays identische Inhalte haben.

using System;
 
namespace Test
{
  class Testklasse
  {
    static void Main()
    {
      double[] arr1;
      double[] arr2;
 
      arr1 = new double[] { 1.0, 2, -1 };
      arr2 = new double[] { 1.0, 2, -1 };
 
      Console.WriteLine(sindGleich(arr1, arr2)); // -> True
 
      arr1 = new double[] { 1.0, 2, -1, 5 };
      arr2 = new double[] { 1.0, 2, -1 };
 
      Console.WriteLine(sindGleich(arr1, arr2)); // -> False, arr1 hat ein Element mehr.
 
      arr1 = new double[] { 1.0, 2, -1, 5 };
      arr2 = new double[] { 1.0, 2, -1, 6 };
 
      Console.WriteLine(sindGleich(arr1, arr2)); // -> False, Arrays unterscheiden sich im letzten Element.
 
    }
 
    static bool sindGleich(double[] arr1, double[] arr2)
    {
      // Quelltext hier ergänzen
    }
  }
}

Sieb des Eratosthenes

Mit Hilfe des Sieb des Eratosthenes lassen sich schnell und einfach Primzahlen bestimmen.

Zunächst werden alle Zahlen 2, 3, 4, … bis zu einem Maximalwert aufgeschrieben. Die zunächst unmarkierten Zahlen sind mögliche Primzahlen. Die kleinste unmarkierte Zahl ist immer eine Primzahl. Nachdem eine Primzahl gefunden wurde, werden alle Vielfachen dieser Primzahl markiert. Man bestimmt die nächstgrößere nicht markierte Zahl. Diese wird dementsprechend als Primzahl ausgegeben. Man streicht wieder alle Vielfachen und führt das Verfahren fort, bis man am Ende der Liste angekommen ist. Im Verlauf des Verfahren werden alle Primzahlen ausgegeben.
  1. Probiere den Algorithmus zunächst auf einem Blatt Papier mit einem Sieb bis zur Zahl 20 aus.1)
  2. Entwickle ein Programm, das nach Eingabe einer Zahl alle Primzahlen bis zur eingegebenen Zahl ausgibt.

Zentrieren

Schreibe eine Methode center, die als Parameter eine Liste von Strings erhält und diese zentriert auf dem Bildschirm ausgibt. Dabei richtet sich die Methode nach dem längsten String in der Liste. Für die Strings „cat“, „zebra“, „elephant“ und „egg“ würde die Ausgabe wie folgt aussehen.

  cat
 zebra
elephant
  egg

Verwende den folgenden Quelltext als Vorlage.

using System;
 
namespace Zentrieren
{
    class MainClass
    {
        public static void Main(string[] args)
        {
            string[] arrAnimals = {"cat", "zebra", "elephant", "egg"};
            center(arrAnimals);
        }
 
        public static void center(string[] arrStrings)
        {
          // Quelltext hier einfügen
        }
    }
}

Zahlen sortieren

Der Benutzer kann fünf Zahlen eingeben. Anschließend werden die Zahlen in aufsteigender Reihenfolge ausgeben.

Hinweis: Schaue dir den Artikel zu Bubblesort an.


Lösungen

1) Auf der Seite von Arndt Brunner könnt ihr das Ergebnis prüfen.
schule/arrays_und_listen.txt · Zuletzt geändert: 19.04.2017 08:39 (Externe Bearbeitung)