🎓

Vorlesung 14 — Zusammenfassung & Klausurvorbereitung

Alle Vorlesungen 1–13 auf einen Blick
Grundlagen der Programmierung in C

Semesterrückblick & Prüfungsvorbereitung
HTW Berlin | WiSe 2025/26

Semesterüberblick Klausur-Checkliste Schnellreferenz

📋 Semesterüberblick: Alle 13 Vorlesungen

VL	Thema
1	Einführung in die Programmierung — Was ist ein Programm/Algorithmus, warum C
2	Unser erstes C-Programm — main, #include, printf + Ein-/Ausgabe (printf/scanf, Format-Specifier)
3	Wie funktioniert ein Computer? — CPU, RAM/Speicher, Bits & Bytes, Binär-/Hexzahlen
4	Datentypen (int, double, char) & Operatoren (arithmetisch, Vergleich, logisch)
5	Verzweigungen — if/else if/else, switch/case
6	Schleifen — for, while, do-while, break/continue
7	Arrays und Strings — Index 0-basiert, Strings als char-Arrays mit \0, string.h
8	Funktionen — Prototyp, Definition, return/void, pass-by-value, Arrays übergeben
9	Algorithmen I — Tauschen (Swap) & Extremwerte (Maximum/Minimum)
10	Algorithmen II — Akkumulieren (Summe/Produkt/Durchschnitt) & Zählen
11	Algorithmen III — Suchen (Lineare Suche) & Sortieren (Bubble Sort)
12	Array-Manipulation — Kopieren, Umkehren/Reverse, Shift, Palindrom-Prüfung
13	Clevere Array-Algorithmen — Zweithöchstes, Häufigkeit zählen, Duplikate, Merge

VL 1–2: Einführung & erstes C-Programm

Algorithmus: eine eindeutige Handlungsvorschrift zur Lösung eines Problems in endlich vielen Schritten. Programmieren = Algorithmen in einer Sprache wie C formulieren.

Grundstruktur & Hello World

#include <stdio.h>

int main() {
    printf("Hello World!\n");
    return 0;
}

                            #include <stdio.h> — Bibliothek einbinden
main() — Startpunkt des Programms
printf() — Text ausgeben, \n = Zeilenumbruch
return 0; — erfolgreich beenden

                        

Ein-/Ausgabe: printf & scanf

int alter;
double preis;

printf("Alter: ");
scanf("%d", &alter);   // MIT &
scanf("%lf", &preis);  // MIT &

printf("Du bist %d Jahre alt.\n", alter);

Format-Specifier

%d int · %f/%lf float/double · %c char · %s String

⚠️ typischer Fehler: Bei scanf das & vergessen (außer bei Strings)!

VL 3: Wie funktioniert ein Computer?

CPU & RAM

Die CPU rechnet und führt Befehle aus. Der RAM (Speicher) hält Programm und Variablen zur Laufzeit — jede Variable liegt an einer Speicheradresse.

Bits & Bytes

Ein Bit ist 0 oder 1. 8 Bit = 1 Byte. Ein int belegt typischerweise 4 Byte, ein char 1 Byte.

Zahlensysteme

Computer rechnen binär (Basis 2). Hex (Basis 16) ist eine kompakte Schreibweise.

5  = 0101  (binär)
10 = 1010  = 0xA (hex)

                    💡 Merke: Datentypen (VL 4) legen fest, wie viele Bytes eine Variable belegt und wie die Bits interpretiert werden.
                

VL 4: Datentypen in C

Datentyp	Beschreibung	Beispiel	printf	scanf
int	Ganzzahlen	int alter = 25;	%d	%d
double	Dezimalzahlen (genau)	double pi = 3.14159;	%f / %lf	%lf
float	Dezimalzahlen (einfach)	float x = 3.14f;	%f	%f
char	Einzelnes Zeichen	char c = 'A';	%c	%c
char[]	String (Zeichenkette)	char name[20] = "Anna";	%s	%s (ohne &!)

sizeof & Typumwandlung

printf("%d", sizeof(int)); // 4

int a = 7, b = 2;
double d = (double)a / b; // 3.5

                        ⚠️ typischer Fehler: Variablen immer initialisieren! int summe = 0; statt nur int summe;
                    

VL 4: Operatoren

Arithmetisch

+  // Addition
-  // Subtraktion
*  // Multiplikation
/  // Division
%  // Modulo (Rest)

7 / 2   // = 3 (Ganzzahl!)
7.0 / 2 // = 3.5
7 % 2   // = 1 (Rest)

Vergleich

==  // gleich
!=  // ungleich
<   // kleiner
>   // größer
<=  // kleiner/gleich
>=  // größer/gleich

Logisch

&&  // UND
||  // ODER
!   // NICHT

Inkrement/Dekrement:

i++  // i = i + 1
i--  // i = i - 1

                    ⚠️ typischer Fehler: = ist Zuweisung, == ist Vergleich! Ganzzahldivision: 7 / 2 = 3, nicht 3.5.
                

VL 5: Verzweigungen

if / else if / else

if (note < 1.5) {
    printf("Sehr gut!\n");
} else if (note < 2.5) {
    printf("Gut!\n");
} else if (note <= 4.0) {
    printf("Bestanden\n");
} else {
    printf("Nicht bestanden\n");
}

// Mit logischen Operatoren
if (tag == 6 || tag == 7) {
    printf("Wochenende!\n");
}

switch / case

switch (tag) {
    case 1:
        printf("Montag\n");
        break;
    case 2:
        printf("Dienstag\n");
        break;
    default:
        printf("Anderer Tag\n");
}

                            ⚠️ typischer Fehler: if (x = 5) statt ==, und fehlendes break; im switch (fällt sonst durch)!
                        

VL 6: Schleifen

for

Anzahl bekannt

for (int i = 0; i < 5; i++) {
    printf("%d ", i);
}
// 0 1 2 3 4

while

Bedingung am Anfang

int i = 0;
while (i < 5) {
    printf("%d ", i);
    i++;  // nicht vergessen!
}

do-while

Mind. 1x ausgeführt

int i = 0;
do {
    printf("%d ", i);
    i++;
} while (i < 5);

                        break; – Schleife sofort beenden  ·  continue; – zum nächsten Durchlauf springen
                    

⚠️ typischer Fehler: Schleifenvariable nicht verändert → Endlosschleife!

VL 7: Arrays und Strings

Arrays

int zahlen[5] = {10, 20, 30, 40, 50};

// Index 0-basiert: 0 .. n-1
int x = zahlen[0];  // erstes Element

for (int i = 0; i < 5; i++) {
    printf("%d ", zahlen[i]);
}

                            ⚠️ Off-by-one: gültige Indizes sind 0 bis n-1 — Schleife mit i < n, nicht <=!
                        

Strings = char-Arrays mit \0

char name[20] = "Anna"; // A n n a \0

// string.h
strlen(name);        // Länge
strcpy(ziel, name);  // kopieren
strcat(a, b);        // anhängen
strcmp(a, b) == 0   // gleich?

⚠️ typischer Fehler: Strings mit strcmp vergleichen, nicht mit ==!

VL 8: Funktionen

Prototyp, Definition, Aufruf

#include <stdio.h>

// Prototyp über main
int addiere(int a, int b);

int main() {
    int s = addiere(3, 4); // 7
    return 0;
}

// Definition unter main
int addiere(int a, int b) {
    return a + b;
}

void & Arrays übergeben

// void = keine Rückgabe
void printArray(int arr[], int n) {
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
}

pass-by-value: normale Parameter sind Kopien — Änderungen bleiben lokal.

                            Arrays: als int arr[] + Größe n übergeben — Änderungen wirken auf das Original!
                        

VL 9: Algorithmen I — Tauschen & Extremwerte

Tauschen (Swap)

int a = 5, b = 10;

int temp = a;
a = b;
b = temp;
// a=10, b=5

Maximum finden

int max = arr[0];
int pos = 0;
for (int i = 1; i < n; i++) {
    if (arr[i] > max) {
        max = arr[i];
        pos = i; // Index merken
    }
}

Minimum finden

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

                    💡 Merke: Startwert immer das erste Element (arr[0]), Schleife ab i = 1 vergleichen. Für die Position den Index mitspeichern.
                

VL 10: Algorithmen II — Akkumulieren & Zählen

Summe

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

Produkt

int prod = 1;
for (int i=0; i<n; i++) {
    prod *= arr[i];
}

Durchschnitt

double avg =
  (double)summe / n;
// (double)-Cast!

Zählen

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

                    ⚠️ typischer Fehler: Summe/Zähler mit 0, Produkt mit 1 starten. Beim Durchschnitt (double)-Cast, sonst Ganzzahldivision!
                

VL 11: Algorithmen III — Suchen & Sortieren

Lineare Suche

int lineareSuche(int arr[], int n,
                  int gesucht) {
    for (int i = 0; i < n; i++) {
        if (arr[i] == gesucht) {
            return i;  // gefunden
        }
    }
    return -1;  // nicht gefunden
}

Worst Case: n Vergleiche (jedes Element prüfen).

Bubble Sort

void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n-1; i++) {
        for (int j = 0; j < n-i-1; j++) {
            if (arr[j] > arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

Prinzip: benachbarte Elemente vergleichen & tauschen, in mehreren Durchläufen — Größte "blubbern" nach oben.

VL 12: Array-Manipulation

Umkehren (Reverse) — zwei Indizes

void reverse(int arr[], int n) {
    int links = 0;
    int rechts = n - 1;
    while (links < rechts) {
        int temp = arr[links];
        arr[links] = arr[rechts];
        arr[rechts] = temp;
        links++;
        rechts--;
    }
}
// {1,2,3,4,5} -> {5,4,3,2,1}

Kopieren, Shift & Palindrom

// Kopieren
for (int i = 0; i < n; i++)
    ziel[i] = quelle[i];

// Shift nach links
for (int i = 0; i < n-1; i++)
    arr[i] = arr[i+1];

                            Palindrom-Prüfung: von außen nach innen arr[links] mit arr[rechts] vergleichen, bis links >= rechts.
                        

VL 13: Clevere Array-Algorithmen

Zweithöchstes finden

int max1 = arr[0], max2 = arr[0];
for (int i = 1; i < n; i++) {
    if (arr[i] > max1) {
        max2 = max1;
        max1 = arr[i];
    } else if (arr[i] > max2) {
        max2 = arr[i];
    }
}
// max2 = zweithöchstes

Häufigkeit zählen: mit einem Zähler-Array count[] pro Wert mitzählen.

Duplikate finden (verschachtelt)

for (int i = 0; i < n; i++) {
    for (int j = i+1; j < n; j++) {
        if (arr[i] == arr[j]) {
            printf("Duplikat: %d\n", arr[i]);
        }
    }
}

                            Merge: zwei Arrays zusammenführen, indem man beide nacheinander ins Ziel-Array kopiert und die Ziel-Position mitzählt.
                        

🔟 Häufige Fehler vermeiden

❌ Häufige Fehler

Off-by-one / Array-Grenzen (i <= n)
= statt == im Vergleich
Ganzzahldivision: 7 / 2 = 3
Strings mit == vergleichen
Fehlendes break; im switch
Uninitialisierte Variablen
& bei scanf vergessen

✅ Richtig machen

Index: 0 bis n-1, Schleife i < n
if (x == 5) nicht if (x = 5)
(double)summe / n für Kommazahl
strcmp(a, b) == 0 statt a == b
break; nach jedem case
int x = 0; initialisieren
scanf("%d", &x); (Strings ohne &)

FALSCH:

if (x = 5);  // zwei Fehler!
    printf("x ist 5");

RICHTIG:

if (x == 5) {
    printf("x ist 5");
}

✅ Klausur-Checkliste

Ich kann … (VL 1–8)

ein C-Programm mit main & printf schreiben
scanf mit den richtigen Specifiern & & nutzen
Datentypen wählen & (double)-Cast einsetzen
arithmetische, Vergleichs- & logische Operatoren anwenden
if/else if/else und switch schreiben
for, while, do-while mit break/continue
Arrays anlegen & durchlaufen, Strings mit string.h
Funktionen mit Prototyp, Parametern & return schreiben

Ich kann … (VL 9–13)

zwei Werte tauschen (Swap mit temp)
Maximum/Minimum & deren Position finden
Summe, Produkt & Durchschnitt berechnen
Elemente bedingt zählen
lineare Suche implementieren
Bubble Sort verstehen & anwenden
ein Array umkehren, kopieren & shiften
Palindrome prüfen & Duplikate finden
Zweithöchstes finden & zwei Arrays mergen

⚡ Schnellreferenz

// Grundstruktur
#include <stdio.h>

int main() {
    return 0;
}

// Specifier
// %d int
// %lf double
// %c char
// %s String

// Schleifen
for (int i=0; i<n; i++) {
    ...
}

while (bed) {
    ...
}

// scanf
scanf("%d", &x);
scanf("%s", str);

// Array + Funktion
int a[5] = {1,2,3,4,5};

int max(int a, int b) {
    if (a > b)
        return a;
    return b;
}

// Array-Param
void f(int arr[], int n);

// string.h
strlen(s);
strcpy(z, q);
strcat(a, b);
strcmp(a, b);

// Swap
int t = a;
a = b;
b = t;

🎓

Viel Erfolg bei der Klausur!

Sie haben das ganze Semester fleißig gearbeitet!

Zusammenfassung: 13 Vorlesungen

Einführung → Erstes Programm → Computer → Datentypen → Verzweigungen → Schleifen → Arrays & Strings → Funktionen → Algorithmen

Wiederholen Sie die Algorithmen aktiv am Papier —
bei Fragen: Moodle oder Sprechstunde.

Grundlagen der Programmierung
HTW Berlin | WiSe 2025/26