🏠 Startseite

🔍 Algorithmen Grundlagen III

Suchen und Sortieren

Elemente finden und ordnen

Grundlagen der Programmierung

📚 Was wir bisher gelernt haben

Vorlesung 9

  • 🔄 Swap (Tauschen)
  • ⬆️ Maximum finden
  • ⬇️ Minimum finden
  • 🔁 Schleifenrichtung

Vorlesung 10

  • ➕ Summe berechnen
  • 📊 Durchschnitt
  • 🔢 Elemente zählen
  • ✖️ Produkt

Heute lernen wir:

  • 🔍 Lineare Suche
  • 📍 Position eines Elements finden
  • 🔄 Bubble Sort (einfaches Sortieren)

🔍 Warum müssen wir suchen?

Suchen ist eine der häufigsten Operationen in der Programmierung!

📱 Alltag

  • Kontakt im Telefonbuch finden
  • Produkt im Online-Shop suchen
  • Wort in einem Text finden

💻 Programmierung

  • Ist ein Benutzername vergeben?
  • Wo steht ein bestimmter Wert?
  • Gibt es Duplikate?

🔍 Lineare Suche: Die Idee

Aufgabe: Ist die Zahl 7 im Array?

3[0]
9[1]
5[2]
7[3]
2[4]
8[5]

💡 Die Idee (wie im echten Leben):

  1. Schau dir das erste Element an
  2. Ist es das Gesuchte? → Gefunden!
  3. Wenn nicht → Schau das nächste Element an
  4. Wiederhole bis gefunden oder Array-Ende

🔍 Lineare Suche: Schritt für Schritt

Suche nach 7 in {3, 9, 5, 7, 2, 8}

1
3
9
5
7
2
8
3 == 7? ❌
2
3
9
5
7
2
8
9 == 7? ❌
3
3
9
5
7
2
8
5 == 7? ❌
4
3
9
5
7
2
8
7 == 7? ✅ Gefunden!

🔍 Lineare Suche: Existiert der Wert?

#include <stdio.h>

int main()
{
    int zahlen[6] = {3, 9, 5, 7, 2, 8};
    int gesucht = 7;
    int gefunden = 0;  // 0 = false, 1 = true

    for (int i = 0; i < 6; i++)
    {
        if (zahlen[i] == gesucht)
        {
            gefunden = 1;
            break;  // Schleife abbrechen - Element gefunden!
        }
    }

    if (gefunden)
        printf("%d wurde gefunden!\n", gesucht);
    else
        printf("%d wurde NICHT gefunden.\n", gesucht);

    return 0;
}
7 wurde gefunden!

⏹️ Was macht break?

break beendet die Schleife sofort.

✅ Mit break (effizient)

for (i = 0; i < 1000; i++) { if (arr[i] == gesucht) { gefunden = 1; break; // Sofort aufhören! } }

Wenn bei i=3 gefunden → nur 4 Durchläufe

😐 Ohne break

for (i = 0; i < 1000; i++) { if (arr[i] == gesucht) { gefunden = 1; // Läuft weiter... } }

Läuft immer alle 1000 Durchläufe

📍 Position eines Elements finden

Manchmal brauchen wir nicht nur "gefunden", sondern wo:

#include <stdio.h>

int main()
{
    int zahlen[6] = {3, 9, 5, 7, 2, 8};
    int gesucht = 7;
    int position = -1;  // -1 bedeutet "nicht gefunden"

    for (int i = 0; i < 6; i++)
    {
        if (zahlen[i] == gesucht)
        {
            position = i;
            break;
        }
    }

    if (position != -1)
        printf("%d gefunden an Position %d\n", gesucht, position);
    else
        printf("%d nicht gefunden\n", gesucht);

    return 0;
}
7 gefunden an Position 3

❓ Warum position = -1?

Array-Indizes sind immer ≥ 0 (0, 1, 2, 3, ...)

Deshalb nutzen wir -1 als "ungültigen" Wert = "nicht gefunden"

3[0]
9[1]
5[2]
7[3]
2[4]
8[5]

Gültige Positionen: 0, 1, 2, 3, 4, 5

💡 Konvention: -1 wird in vielen Programmiersprachen als "nicht gefunden" verwendet (z.B. JavaScript indexOf(), Python find())

📝 Praxis: Hat jemand eine 1?

#include <stdio.h>

int main()
{
    int noten[8] = {3, 2, 4, 2, 1, 3, 2, 5};
    int position = -1;

    for (int i = 0; i < 8; i++)
    {
        if (noten[i] == 1)
        {
            position = i;
            break;
        }
    }

    if (position != -1)
        printf("Beste Note! Student %d hat eine 1.\n", position + 1);
    else
        printf("Niemand hat eine 1 bekommen.\n");

    return 0;
}
Beste Note! Student 5 hat eine 1.
💡 Hinweis: position + 1 weil Menschen ab 1 zählen, Arrays ab 0

🔍 Alle Vorkommen finden

Ohne break finden wir alle Positionen:

#include <stdio.h>

int main()
{
    int zahlen[8] = {3, 7, 5, 7, 2, 7, 8, 1};
    int gesucht = 7;
    int anzahl = 0;

    printf("%d gefunden an Position(en): ", gesucht);

    for (int i = 0; i < 8; i++)
    {
        if (zahlen[i] == gesucht)
        {
            printf("%d ", i);
            anzahl++;
            // KEIN break! Weiter suchen
        }
    }

    printf("\nInsgesamt: %d mal\n", anzahl);

    return 0;
}
7 gefunden an Position(en): 1 3 5 Insgesamt: 3 mal

🔄 Warum Sortieren?

Sortierte Daten sind einfacher zu verarbeiten!

📱 Beispiele

  • Kontakte alphabetisch sortieren
  • Preise aufsteigend/absteigend
  • Rangliste nach Punkten
  • Termine chronologisch ordnen

✅ Vorteile

  • Schnelleres Suchen möglich
  • Duplikate leichter finden
  • Min/Max direkt am Rand
  • Bessere Übersicht

🫧 Bubble Sort: Die Idee

Vergleiche benachbarte Elemente und tausche wenn falsch herum!

5[0]
3[1]
8[2]
1[3]

5 > 3? Ja! → Tauschen!

3[0]
5[1]
8[2]
1[3]

🫧 Wie Blasen: Große Werte "steigen" nach oben (ans Ende), kleine "sinken" nach unten (an den Anfang).

🫧 Bubble Sort: Durchlauf 1

Sortiere: {5, 3, 8, 1}

1
5
3
8
1
5 > 3? ✅ Tauschen → {3, 5, 8, 1}
2
3
5
8
1
5 > 8? ❌ Nicht tauschen → {3, 5, 8, 1}
3
3
5
8
1
8 > 1? ✅ Tauschen → {3, 5, 1, 8}
Nach Durchlauf 1: {3, 5, 1, 8}
→ Die größte Zahl (8) ist jetzt am Ende! 🫧

🫧 Bubble Sort: Durchlauf 2

Nach Durchlauf 1: {3, 5, 1, 8}

1
3
5
1
8
3 > 5? ❌ Nicht tauschen
2
3
5
1
8
5 > 1? ✅ Tauschen → {3, 1, 5, 8}
Nach Durchlauf 2: {3, 1, 5, 8}
→ Die zwei größten Zahlen sind richtig! 🫧🫧
💡 Optimierung: Die 8 ist schon sortiert → wir müssen sie nicht mehr prüfen!

🫧 Bubble Sort: Durchlauf 3 (Ende)

Nach Durchlauf 2: {3, 1, 5, 8}

1
3
1
5
8
3 > 1? ✅ Tauschen → {1, 3, 5, 8}

✅ Fertig sortiert!

1[0]
3[1]
5[2]
8[3]

🫧 Bubble Sort im Code

#include <stdio.h>

int main()
{
    int zahlen[4] = {5, 3, 8, 1};
    int n = 4;
    int temp;

    /* Äußere Schleife: Anzahl der Durchläufe */
    for (int i = 0; i < n - 1; i++)
    {
        /* Innere Schleife: Vergleiche Nachbarn */
        for (int j = 0; j < n - 1 - i; j++)
        {
            if (zahlen[j] > zahlen[j + 1])
            {
                /* Tauschen (Swap) */
                temp = zahlen[j];
                zahlen[j] = zahlen[j + 1];
                zahlen[j + 1] = temp;
            }
        }
    }

    printf("Sortiert: %d %d %d %d\n",
           zahlen[0], zahlen[1], zahlen[2], zahlen[3]);

    return 0;
}

❓ Warum j < n - 1 - i?

Nach jedem Durchlauf ist das größte Element am Ende → wir müssen es nicht mehr prüfen!

Durchlauf (i) Vergleiche bis Index Bereits sortiert
i = 0 j < 3 (bis Index 2) -
i = 1 j < 2 (bis Index 1) Index 3
i = 2 j < 1 (bis Index 0) Index 2, 3
💡 Ohne Optimierung: j < n - 1 funktioniert auch, ist aber langsamer weil bereits sortierte Elemente nochmal geprüft werden.

🫧 Absteigend sortieren

Nur das Vergleichszeichen ändern!

⬆️ Aufsteigend (klein → groß)

if (zahlen[j] > zahlen[j+1]) // tauschen

Ergebnis: {1, 3, 5, 8}

⬇️ Absteigend (groß → klein)

if (zahlen[j] < zahlen[j+1]) // tauschen

Ergebnis: {8, 5, 3, 1}

💡 Merke: > für aufsteigend, < für absteigend

🧠 Quiz: Lineare Suche

Was ist der Wert von pos nach diesem Code?

int arr[5] = {4, 2, 7, 2, 9}; int pos = -1; for (int i = 0; i < 5; i++) { if (arr[i] == 2) { pos = i; break; } }

A) -1

B) 1

C) 3

D) 2

✅ Lösung: Lineare Suche

Antwort B: 1

Die erste 2 steht an Position 1 (Index beginnt bei 0!)

Ablauf:

  • i=0: arr[0]=4, 4==2? ❌ Nein
  • i=1: arr[1]=2, 2==2? ✅ Ja! pos=1, break
  • Schleife beendet → pos bleibt 1
💡 Hinweis: Die zweite 2 an Position 3 wird wegen break nicht gefunden!

🧠 Quiz: Bubble Sort

Nach dem ersten Durchlauf von Bubble Sort (aufsteigend), was ist garantiert?

Array: {3, 1, 4, 2}

A) Das kleinste Element ist vorne

B) Das größte Element ist hinten

C) Das Array ist halb sortiert

D) Alle Elemente sind sortiert

✅ Lösung: Bubble Sort

Antwort B: Das größte Element ist hinten

Durchlauf 1 für {3, 1, 4, 2}:

  • 3 > 1? ✅ Tauschen → {1, 3, 4, 2}
  • 3 > 4? ❌
  • 4 > 2? ✅ Tauschen → {1, 3, 2, 4}

→ Die 4 (größtes Element) ist jetzt am Ende!

🫧 "Bubble" = Blase: Das größte Element "steigt auf" wie eine Luftblase im Wasser

🧠 Quiz: Swap

Was fehlt in diesem Bubble Sort Code?

if (arr[j] > arr[j+1]) { arr[j] = arr[j+1]; arr[j+1] = arr[j]; }

A) Nichts, der Code ist korrekt

B) Es fehlt die Hilfsvariable (temp)

C) Das Vergleichszeichen ist falsch

D) Es fehlt ein break

✅ Lösung: Swap

Antwort B: Es fehlt die Hilfsvariable (temp)

❌ Falsch

arr[j] = arr[j+1]; // arr[j] überschrieben! arr[j+1] = arr[j]; // Beide gleich!

✅ Richtig

temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp;
⚠️ Klassischer Fehler: Swap braucht IMMER eine Hilfsvariable! (Vorlesung 9)

📋 Zusammenfassung: Lineare Suche

🔍 Suche-Muster

int position = -1; // -1 = nicht gefunden for (int i = 0; i < n; i++) { if (arr[i] == gesucht) { position = i; break; // Gefunden → aufhören } } if (position != -1) // Gefunden an Position "position" else // Nicht gefunden

📋 Zusammenfassung: Bubble Sort

🫧 Sortier-Muster

for (int i = 0; i < n - 1; i++) // Durchläufe { for (int j = 0; j < n - 1 - i; j++) // Vergleiche { if (arr[j] > arr[j + 1]) // Nachbarn vergleichen { /* Swap */ int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } }
Für absteigend: Ändere > zu <

📊 Algorithmen-Übersicht

Algorithmus Schleifen Wichtige Elemente
🔄 Swap 0 temp Variable
⬆️⬇️ Min/Max 1 Startwert arr[0], Vergleich
➕ Summe 1 Startwert 0, +=
🔢 Zählen 1 Startwert 0, if + ++
🔍 Suche 1 position = -1, break
🫧 Bubble Sort 2 (verschachtelt) Nachbarn vergleichen + Swap

🎯 Praxis: Alles kombinieren

Aufgabe: Array sortieren, dann Durchschnitt und Maximum ausgeben

int zahlen[5] = {7, 2, 9, 4, 5};
int n = 5, summe = 0, temp;

/* 1. Bubble Sort */
for (int i = 0; i < n - 1; i++)
    for (int j = 0; j < n - 1 - i; j++)
        if (zahlen[j] > zahlen[j+1]) {
            temp = zahlen[j];
            zahlen[j] = zahlen[j+1];
            zahlen[j+1] = temp;
        }

/* 2. Summe berechnen */
for (int i = 0; i < n; i++)
    summe += zahlen[i];

/* 3. Nach Sortierung: Min = erstes, Max = letztes Element! */
printf("Sortiert: %d %d %d %d %d\n", ...);
printf("Min: %d, Max: %d\n", zahlen[0], zahlen[n-1]);
printf("Durchschnitt: %.2f\n", (double)summe / n);

💡 Tipps für Algorithmen

✅ Immer tun:

  • Variablen initialisieren
  • Schritt für Schritt durchdenken
  • Auf Papier skizzieren
  • Mit kleinen Arrays testen

⚠️ Häufige Fehler:

  • Swap ohne temp
  • Falsche Schleifengrenzen
  • Vergessenes break
  • Off-by-one Fehler (n vs n-1)

🎓 Rückblick: Algorithmen-Serie

VL 9: Grundlagen

  • 🔄 Swap
  • ⬆️ Maximum
  • ⬇️ Minimum
  • 🔁 Schleifenrichtung

VL 10: Akkumulieren

  • ➕ Summe
  • 📊 Durchschnitt
  • 🔢 Zählen
  • ✖️ Produkt

VL 11: Suchen/Sort

  • 🔍 Lineare Suche
  • 📍 Position finden
  • ⏹️ break
  • 🫧 Bubble Sort

🎉 Glückwunsch! Sie kennen jetzt die wichtigsten Algorithmen-Bausteine!

🚀 Weiter geht's!

Sie haben jetzt das Werkzeug für:

  • ✅ Daten verarbeiten und zusammenfassen
  • ✅ Elemente suchen und finden
  • ✅ Arrays sortieren
  • ✅ Komplexere Probleme lösen

💪 Übung macht den Meister!
Probieren Sie die Algorithmen mit eigenen Arrays aus!