Grundlegende Operationen mit eindimensionalen Arrays

1. Einführung

Was will man normalerweise mit Arrays machen?

Lass uns die grundlegenden Operationen aufzählen:

• Lesen und Ändern von Array-Elementen per Index.
• Suchen eines Elements nach Wert.
• Kopieren eines Arrays, Erstellen von "Schnitten" (Teile des Arrays).
• Sortieren eines Arrays.
• Reverse (Umkehren) eines Arrays.
• Befüllen eines Arrays mit einem Wert.
• Prüfen, ob ein Element vorhanden ist (ob das Array einen bestimmten Wert enthält).
• Größe ändern (resize).

In echten Aufgaben stößt du oft auf diese Aktionen – zum Beispiel: „Gibt es eine Summe über 4000?“, „Finde den ersten Preis unter 1000“, „Sortiere die Preise aufsteigend“ und so weiter.

Und für all das haben wir Funktionen

arr[n] = x

Array.IndexOf(arr, v)

Array.Exists(arr, pred)

Array.Sort(arr)

Array.Reverse(arr)

arr.Clone(), Array.Copy

Array.Fill(arr, val)

Array.Resize(ref arr, len)

arr.Max(), arr.Min()

2. Lesen und Ändern von Elementen per Index

Das kennst du schon, aber lass uns das nochmal an einem einfachen Beispiel festigen (nehmen wir mal ein Array mit Noten):

// Array mit Noten eines Studenten
int[] grades = { 4, 3, 5, 2, 5 };

// Erste Note lesen
int firstGrade = grades[0];
Console.WriteLine($"Erste Note: {firstGrade}");

// Letzte Note auf "sehr gut" (5) ändern
grades[^1] = 5;
Console.WriteLine("Geänderte letzte Note: " + grades[^1]);

Wichtig: Indizierung startet bei Null, ein Versuch auf einen nicht existierenden Index zuzugreifen führt zum Fehler IndexOutOfRangeException – ein Klassiker im Vorstellungsgespräch und im echten Leben.

3. Element im Array suchen

Wir haben zwei Funktionen, die ein Element im Array suchen und dessen Index zurückgeben, falls gefunden.

Funktion Array.IndexOf(value [, from])

Die Funktion Array.IndexOf sucht das angegebene Element vom Anfang des Arrays. Wenn sie es findet, gibt sie dessen Index zurück. Wenn nicht – gibt sie -1 zurück.

Aber was, wenn du die nächsten Vorkommen des Elements im Array finden willst? Dafür gibst du der Funktion Array.IndexOf einen zweiten Parameter – den Index, ab dem gesucht wird. Das sollte der Index des zuletzt gefundenen Elements + 1 sein.

Lass uns alle Vorkommen der Zahl 2 im Array finden:

int[] grades = { 4, 3, 5, 2, 5, 2 };
int x = 2; // Element, das wir suchen

int index = Array.IndexOf(grades, x);
while (index != -1)
{
    Console.WriteLine($"Element {x} gefunden an Position: {index}");
    // Suche nächsten Index, ab Position index + 1
    index = Array.IndexOf(grades, x, index + 1);
} 

Funktion Array.LastIndexOf(value [, from])

Die Funktion Array.LastIndexOf sucht das angegebene Element vom Ende des Arrays. Wenn sie es findet, gibt sie dessen Index zurück. Wenn nicht – gibt sie -1 zurück. Ansonsten ist sie komplett analog zu Array.IndexOf.

Lass uns alle Vorkommen der Zahl 2 im Array finden, aber diesmal vom Ende aus:

int[] grades = { 4, 3, 5, 2, 5, 2 };
int x = 2; // Element, das wir suchen

int index = Array.LastIndexOf(grades, x);
while (index != -1)
{
    Console.WriteLine($"Element {x} gefunden an Position: {index}");
    // Suche nächsten Index, ab vorheriger Position - 1
    index = Array.LastIndexOf(grades, x, index - 1);
}

4. Prüfen, ob ein Element im Array vorhanden ist

Zum Prüfen, ob ein Element vorhanden ist, gibt es die Funktion Contains. Diese Methode gibt true zurück, wenn das Array das angegebene Element enthält. Dafür musst du unbedingt das Modul System.Linq einbinden. Beispiel:

using System.Linq; // using System.Linq; einbinden, falls nicht vorhanden

bool hasExcellent = grades.Contains(5); 
Console.WriteLine($"Gibt es eine Fünf? {hasExcellent}");

Super einfach und schön.

5. Array umkehren: Array.Reverse

Angenommen, du willst das Array „rückwärts“ machen. Benutze:

int[] grades = { 2, 3, 4, 5 };

// Array umkehren
Array.Reverse(grades);
Console.WriteLine("Umgekehrte Noten: " + string.Join(", ", grades));

Sehr praktisch, um die „frischesten“ Daten zu finden oder wenn du die Welt gerne auf den Kopf stellst.

6. Array sortieren: Array.Sort

Früher oder später willst du ein Array sortieren. Der kürzeste und sicherste Weg – die Standard-Sortierfunktion nutzen:

int[] grades = { 4, 3, 5, 2, 5 };
// Aufsteigend sortieren
Array.Sort(grades);
Console.WriteLine("Sortierte Noten: " + string.Join(", ", grades));

Diese Funktion sortiert auch Strings, aber alphabetisch.

Absteigend sortieren

Standardmäßig sortiert Array.Sort nur aufsteigend. Für absteigend kannst du sortieren + reverse machen:

Array.Sort(grades); // Erst aufsteigend
Array.Reverse(grades); // Dann umkehren
Console.WriteLine("Absteigend: " + string.Join(", ", grades));

Hinweis: Viele vergessen, dass das Sortieren „in-place“ passiert: Das Array wird verändert, es gibt kein neues zurück. Wenn du die ursprüngliche Reihenfolge brauchst, kopiere das Array zuerst.

7. Array klonen: Clone und Array.Copy

Wenn du eine Kopie brauchst (und das Original beim Bearbeiten nicht kaputt machen willst), nutze Clone() und Array.Copy().

Die Methode Clone() rufst du beim Array auf, und sie gibt eine komplette Kopie zurück.

Die Methode Array.Copy() braucht ein paar Daten:

• Quell-Array;
• Array, wohin kopiert wird;
• Wie viele Zellen kopiert werden sollen.

int[] original = { 1, 2, 3, 4, 5 };

// Weg 1: Clone()
// Funktioniert für ein- und mehrdimensionale Arrays, gibt aber object zurück, also type cast nötig:
int[] copy1 = (int[]) original.Clone();

// Weg 2: Array.Copy
int[] copy2 = new int[original.Length];
Array.Copy(original, copy2, original.Length);

Wichtige Besonderheit: Arrays werden per Wert kopiert, wenn es primitive Typen sind (int, double). Wenn es ein Array von Objekten ist, werden nur die Referenzen kopiert! (sog. „shallow copy“).

8. Array mit einem Wert befüllen: Array.Fill

Willst du das Array „nullen“ oder komplett mit Fünfen befüllen? Dafür gibt’s die praktische Methode Array.Fill:

int[] grades = new int[5];
Array.Fill(grades, 5); // Jetzt sind alle Elemente 5
Console.WriteLine("Hypothetisch perfekter Student: " + string.Join(", ", grades));

Nützlich, wenn du das Array schnell mit einem bestimmten Wert initialisieren willst.

9. Maximum und Minimum finden

Das Modul System.Linq hat Arrays viele nützliche Methoden spendiert, und zwei davon geben dir das Minimum und Maximum im Array zurück. Sie heißen Max() und Min().

Lass uns die höchste und niedrigste Note im Array finden:

int maxGrade = grades.Max();
int minGrade = grades.Min();
Console.WriteLine($"Maximale Note: {maxGrade}, minimale: {minGrade}");

Vergiss nicht, using System.Linq; für diese Methoden einzubinden.