Code Praxis - Informatik Lernzettel

1. Code lesen und verstehen

🔍 Strategie: Schreibtischtest (Trace Table)

Um Code zu verstehen, gehe ihn Zeile für Zeile durch und notiere die Werte der Variablen.

int x = 2;
int y = 5;
while (x < y) {
    x = x + 1;
    y = y - 1;
}
System.out.println(x * y);

Durchlauf	x (Start: 2)	y (Start: 5)	Bedingung (x < y)
1	3	4	true (3 < 4)
2	4	3	false (4 < 3) → Abbruch

Ausgabe: 4 * 3 = 12

2. Wichtige Standard-Algorithmen

2.1 Summe und Durchschnitt berechnen

📝 Muster: Akkumulation

Eine Variable (meist summe) wird initialisiert und in einer Schleife immer weiter erhöht.

public static double berechneDurchschnitt(int[] zahlen) {
    if (zahlen.length == 0) return 0.0;
    
    int summe = 0;
    
    // 1. Summe berechnen
    for (int i = 0; i < zahlen.length; i++) {
        summe = summe + zahlen[i];  // oder summe += zahlen[i]
    }
    
    // 2. Durchschnitt berechnen (Achtung: Cast zu double!)
    return (double) summe / zahlen.length;
}

2.2 Minimum und Maximum finden

📝 Muster: Min/Max Suche

Setze das erste Element als vorläufiges Minimum/Maximum und vergleiche alle anderen damit.

public static int findeMaximum(int[] zahlen) {
    // Annahme: Array ist nicht leer
    int max = zahlen[0];  // Erstes Element als Startwert
    
    for (int i = 1; i < zahlen.length; i++) {
        // Wenn aktuelles Element größer als bisheriges Max...
        if (zahlen[i] > max) {
            max = zahlen[i];  // ...dann ist das das neue Max
        }
    }
    
    return max;
}

2.3 Lineare Suche (Linear Search)

🔍 Funktionsweise

Gehe das Array von vorne bis hinten durch. Wenn das gesuchte Element gefunden wird, gib den Index zurück. Wenn nicht gefunden, gib -1 zurück.

public static int lineareSuche(int[] zahlen, int gesucht) {
    for (int i = 0; i < zahlen.length; i++) {
        if (zahlen[i] == gesucht) {
            return i;  // Gefunden an Position i
        }
    }
    return -1;  // Nicht gefunden
}

3. Sortieralgorithmen

3.1 Bubblesort

🫧 Wie funktioniert Bubblesort?

Beim Bubblesort werden benachbarte Elemente vertauscht, wenn sie in der falschen Reihenfolge sind. In jedem Durchlauf "blubbert" das größte Element ans Ende.

⚙️ Algorithmus-Schritte

Äußere Schleife: Wiederhole n-mal
Innere Schleife: Gehe durch das Array (bis zum sortierten Bereich)
Vergleich: Ist Element[i] > Element[i+1]?
Tausch: Wenn ja, tausche die beiden Elemente

public static void bubbleSort(int[] arr) {
    int n = arr.length;
    
    // Äußere Schleife: Anzahl der Durchläufe
    for (int i = 0; i < n - 1; i++) {
        
        // Innere Schleife: Vergleiche Nachbarn
        // -i, weil die letzten i Elemente schon sortiert sind
        for (int j = 0; j < n - i - 1; j++) {
            
            // Wenn linker Nachbar größer als rechter...
            if (arr[j] > arr[j + 1]) {
                // ...dann tauschen (Dreieckstausch)
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

Dreieckstausch merken:
1. temp = a (Sichere a)
2. a = b (Überschreibe a mit b)
3. b = temp (Schreibe gesichertes a in b)

4. Typische Fehler vermeiden

⚠️ Off-by-One Fehler

Passiert oft bei Schleifen und Arrays.

int[] arr = new int[5];

// FALSCH: <= length führt zu IndexOutOfBoundsException
for (int i = 0; i <= arr.length; i++) { ... }

// RICHTIG: < length
for (int i = 0; i < arr.length; i++) { ... }

⚠️ String-Vergleich

Strings niemals mit == vergleichen!

String s1 = "Hallo";
String s2 = new String("Hallo");

// FALSCH: Vergleicht Speicheradressen
if (s1 == s2) { ... }  // false

// RICHTIG: Vergleicht Inhalt
if (s1.equals(s2)) { ... }  // true

⚠️ Integer-Division

Bei Division von zwei Integern gehen Nachkommastellen verloren.

int a = 5;
int b = 2;

double erg1 = a / b;         // 2.0 (Falsch!)
double erg2 = (double) a / b; // 2.5 (Richtig!)

📋 Zusammenfassung: Code Praxis

Schreibtischtest: Code manuell durchgehen und Variablenwerte notieren.
Akkumulation: Variable initialisieren (0 oder 1) und in Schleife updaten.
Min/Max: Erstes Element als Startwert, dann alle vergleichen.
Bubblesort: Verschachtelte Schleifen, Nachbarn tauschen.
Dreieckstausch: Braucht Hilfsvariable temp.
Strings: Immer mit .equals() vergleichen.

← Java Grundlagen Zu den Übungsaufgaben →