Algorithmen Grundlagen V

📋 Heute lernen wir

🥈 Das Zweithöchste finden

Aufgabe: Finde den zweitgrößten Wert!

🥈 Zweithöchstes: Die Idee

🥈 Zweithöchstes: Schritt für Schritt

Array: {7, 3, 12, 9, 5}

🥈 Zweithöchstes im Code

#include <stdio.h>
#include <limits.h>  // für INT_MIN

int main()
{
    int arr[5] = {7, 3, 12, 9, 5};
    int n = 5;
    int max = arr[0];
    int zweit = INT_MIN;  // noch KEIN Kandidat für Platz 2

    for (int i = 1; i < n; i++)
    {
        if (arr[i] > max)
        {
            zweit = max;      // Altes max wird zweit
            max = arr[i];     // Neues max
        }
        else if (arr[i] > zweit)
        {
            zweit = arr[i];   // Neues zweit
        }
    }

    printf("Maximum: %d, Zweithöchstes: %d\n", max, zweit);
    return 0;
}

🥈 Analog: Zweitkleinstes

Gleiche Logik, nur mit < statt >:

int min = arr[0];
int zweit = INT_MAX;  // Größter möglicher Wert

for (int i = 1; i < n; i++)
{
    if (arr[i] < min)
    {
        zweit = min;
        min = arr[i];
    }
    else if (arr[i] < zweit)
    {
        zweit = arr[i];
    }
}

📊 Häufigkeit zählen

Aufgabe: Wie oft kommt jede Zahl vor?

📊 Häufigkeit: Einfache Lösung

Für einen bestimmten Wert zählen (bekanntes Muster!):

#include <stdio.h>

int main()
{
    int arr[8] = {2, 5, 2, 3, 5, 2, 5, 3};
    int n = 8;
    int gesucht = 5;
    int zaehler = 0;

    for (int i = 0; i < n; i++)
    {
        if (arr[i] == gesucht)
        {
            zaehler++;
        }
    }

    printf("%d kommt %d mal vor.\n", gesucht, zaehler);

    return 0;
}

📊 Von einem Zähler zu vielen

Die einfache Lösung zählt nur einen Wert. Was, wenn wir alle gleichzeitig zählen wollen?

int zaehler = 0;
...
zaehler++;

int haeufigkeit[10] = {0};

🪣 Die Idee: Ein Eimer pro Zahl

Statt zu suchen, gibt jede mögliche Zahl (0–9) ihren eigenen Zähler-Eimer. Für jede Zahl im Array werfen wir einen Stein in ihren Eimer.

Eingabe: arr = {2, 5, 2, 3, 5, 2, 5, 3}  →  nacheinander lesen und einsortieren:

Steine im Eimer = wie oft die Zahl vorkam. Eimer 2 hat 3 Steine → die 2 kam 3× vor.

📊 Häufigkeit: Alle Werte (mit Zähler-Array)

Der Zähler-Array = die Eimer. Der Index ist das Etikett (welche Zahl), der Inhalt die Strichliste (wie oft). Nur für kleine positive Zahlen (z.B. 0-9):

#include <stdio.h>

int main()
{
    int arr[8] = {2, 5, 2, 3, 5, 2, 5, 3};
    int n = 8;
    int haeufigkeit[10] = {0};  // Zähler für 0-9, alle auf 0

    /* Häufigkeiten zählen */
    for (int i = 0; i < n; i++)
    {
        haeufigkeit[arr[i]]++;  // gehe zu Eimer arr[i] → +1 Stein
    }

    /* Ausgabe */
    for (int i = 0; i < 10; i++)
    {
        if (haeufigkeit[i] > 0)
            printf("%d kommt %d mal vor\n", i, haeufigkeit[i]);
    }

    return 0;
}

📊 So füllt sich der Zähler-Array

arr = {2, 5, 2, 3, 5, 2, 5, 3} – bei jedem Schritt: haeufigkeit[arr[i]]++

📊 Häufigkeit: Visualisierung (das Endergebnis von oben)

arr = {2, 5, 2, 3, 5, 2, 5, 3}

haeufigkeit[] (Zähler-Array):

🔍 Duplikate finden

Aufgabe: Gibt es Werte, die mehrfach vorkommen?

🔍 Duplikate: Die Idee

🤝 Duplikate: Jeder vergleicht sich mit allen rechts

Wie beim Händeschütteln in einer Reihe: Person i gibt jedem, der rechts von ihr steht, die Hand – dann ist jedes Paar genau einmal dran.

arr = {3, 7, 2, 7}

🔍 Duplikate im Code

#include <stdio.h>

int main()
{
    int arr[6] = {3, 7, 2, 7, 5, 1};
    int n = 6;
    int hatDuplikate = 0;

    for (int i = 0; i < n - 1; i++)
    {
        for (int j = i + 1; j < n; j++)  // Nur nach rechts schauen!
        {
            if (arr[i] == arr[j])
            {
                printf("Duplikat: %d (Positionen %d und %d)\n",
                       arr[i], i, j);
                hatDuplikate = 1;
            }
        }
    }

    if (!hatDuplikate)
        printf("Keine Duplikate gefunden.\n");

    return 0;
}

🔍 Duplikate: Vergleiche visualisiert

arr = {3, 7, 2, 7}

➕ Arrays zusammenführen (Merge)

Aufgabe: Zwei Arrays zu einem kombinieren

Array A:

Array B:

⬇️

Ergebnis C:

➕ Merge: Erst A hinlegen, dann B dahinter

Wie zwei Kartenstapel zu einem: den ersten Stapel ablegen, den zweiten direkt dahinter anlegen. Zwei einfache Kopier-Schleifen.

Schritt 1: A nach C kopieren (Plätze 0,1,2)

Schritt 2: B ab Platz nA (=3) anhängen

➕ Erst die Variablen verstehen

Bevor wir den Code lesen: Was ist was? Wir haben drei Arrays und zwei Zähl-Variablen.

➕ Merge im Code

#include <stdio.h>

int main()
{
    int a[3] = {1, 2, 3};  // erstes Array
    int b[2] = {4, 5};     // zweites Array
    int c[5];  // Ergebnis, groß genug für beide (3+2)
    int nA = 3, nB = 2;  // Anzahl: a hat 3, b hat 2 Elemente

    /* Erst Array A kopieren */
    for (int i = 0; i < nA; i++)
    {
        c[i] = a[i];
    }

    /* Dann Array B anhängen */
    for (int i = 0; i < nB; i++)
    {
        c[nA + i] = b[i];  // Ab Position nA einfügen!
    }

    printf("Zusammengeführt: ");
    for (int i = 0; i < nA + nB; i++)
        printf("%d ", c[i]);

    return 0;
}

❓ Warum c[nA + i]?

B muss ab Position nA (=3) eingefügt werden!

📝 Praxis: Notenverteilung

#include <stdio.h>

int main()
{
    int noten[10] = {2, 1, 3, 2, 1, 4, 2, 3, 5, 1};
    int anzahl[6] = {0};  // Zähler für Noten 1-5 (Index 0 ungenutzt)

    /* Noten zählen */
    for (int i = 0; i < 10; i++)
    {
        anzahl[noten[i]]++;
    }

    /* Balkendiagramm ausgeben */
    printf("Notenverteilung:\n");
    for (int note = 1; note <= 5; note++)
    {
        printf("Note %d: ", note);
        for (int j = 0; j < anzahl[note]; j++)
            printf("*");
        printf(" (%d)\n", anzahl[note]);
    }

    return 0;
}

📝 Ausgabe: Notenverteilung

🧠 Quiz: Zweithöchstes

✅ Lösung: Zweithöchstes

🧠 Quiz: Häufigkeit

int arr[5] = {1, 3, 3, 2, 3};
int h[10] = {0};
for (int i = 0; i < 5; i++) h[arr[i]]++;

✅ Lösung: Häufigkeit

🧠 Quiz: Merge

✅ Lösung: Merge

📋 Zusammenfassung: Zweithöchstes

int max = arr[0], zweit = INT_MIN;

for (int i = 1; i < n; i++)
{
    if (arr[i] > max)
    {
        zweit = max;   // Altes max → zweit
        max = arr[i];  // Neues max
    }
    else if (arr[i] > zweit)
    {
        zweit = arr[i];
    }
}

📋 Zusammenfassung: Häufigkeit

/* Zähler-Array für Werte 0 bis MAX */
int haeufigkeit[MAX + 1] = {0};

for (int i = 0; i < n; i++)
{
    haeufigkeit[arr[i]]++;  // Wert als Index!
}

📋 Zusammenfassung: Duplikate

/* Verschachtelte Schleifen */
for (int i = 0; i < n - 1; i++)
{
    for (int j = i + 1; j < n; j++)  // j startet bei i+1!
    {
        if (arr[i] == arr[j])
            // Duplikat gefunden!
    }
}

📋 Zusammenfassung: Merge

/* Erst A kopieren */
for (int i = 0; i < nA; i++)
    c[i] = a[i];

/* Dann B anhängen */
for (int i = 0; i < nB; i++)
    c[nA + i] = b[i];  // Ab Position nA!

📊 Alle Algorithmen der Serie

🎓 Abschluss der Algorithmen-Serie

🔗 Weiterlernen & Links

Zum Üben und Nachschauen – besonders hilfreich: Werkzeuge, die Code Schritt für Schritt sichtbar machen.