Rekursion in C

Hallo那里，未来的程序员们！今天，我们将深入编程中最吸引人的概念之一：递归。别担心，如果听起来令人生畏 - 到了这个教程的结尾，你们将成为递归专家！让我们一起开始这段激动人心的旅程。

Was ist eine rekursive Funktion in C?

Stellen Sie sich vor, Sie schauen sich selbst im Spiegel an, und hinter Ihnen ist ein weiterer Spiegel. Sie sehen eine unendliche Anzahl von Reflektionen von sich selbst. Das ist etwas so wie die Rekursion in der Programmierung!

Eine rekursive Funktion ist eine Funktion, die während ihrer Ausführung sich selbst aufruft. Es ist so, als würde eine Funktion sagen: "Hey, ich brauche Hilfe. Wer könnte mir besser helfen als... ich selbst?"

Hier ist ein einfaches Beispiel:

void countdown(int n) {
if (n == 0) {
printf("Blastoff!\n");
} else {
printf("%d\n", n);
countdown(n - 1);
}
}

In dieser Funktion ruft countdown sich selbst mit einer kleineren Zahl auf every time. Es ist wie eine Raketenstartsanzahl, bei der wir bis Null zählen und dann abheben!

Warum wird Rekursion in C verwendet?

Vielleicht fragen Sie sich, "Warum machen wir uns die Mühe mit Rekursion, wenn wir Schleifen haben?" Tolle Frage! Rekursion hat mehrere Vorteile:

1. Sie kann den Code für bestimmte Probleme lesbarer und eleganter machen.
2. Sie ist hervorragend für Aufgaben, die eine rekursive Natur haben, wie das Durchlaufen von baumartigen Strukturen.
3. Sie kann die Notwendigkeit komplexer Schleifenstrukturen und temporärer Variablen reduzieren.

Allerdings ist Rekursion nicht immer die beste Wahl. Sie kann speicherintensiv und langsamer für einige Probleme sein. Wie bei vielen Dingen in der Programmierung geht es darum, das richtige Werkzeug für die Aufgabe zu wählen.

Faktorisierung mit Rekursion

Schauen wir uns ein klassisches Beispiel für Rekursion an: die Berechnung von Faktorien. Die Faktorie einer Zahl n (als n! geschrieben) ist das Produkt aller positiven Integer kleiner oder gleich n.

Hier ist, wie wir Faktorien rekursiv berechnen können:

int factorial(int n) {
if (n == 0 || n == 1) {
return 1;
} else {
return n * factorial(n - 1);
}
}

Lassen Sie uns das aufschlüsseln:

1. Wenn n 0 oder 1 ist, geben wir 1 zurück (das ist unser Basisfall).
2. Andernfalls multiplizieren wir n mit der Faktorie von (n-1).

Wenn wir also factorial(5) aufrufen, passiert folgendes:

• 5 * factorial(4)
• 5 (4 factorial(3))
• 5 (4 (3 * factorial(2)))
• 5 (4 (3 (2 factorial(1))))
• 5 (4 (3 (2 1)))
• 5 (4 (3 * 2))
• 5 (4 6)
• 5 * 24
• 120

Und da haben Sie es - 5! = 120.

Binärsuche mit Rekursion

Die Binärsuche ist ein effizienter Algorithmus zum Auffinden eines Elements in einer sortierten Liste. Sie funktioniert, indem sie wiederholt den Suchintervall halbiert. Lassen Sie uns sie rekursiv implementieren:

int binarySearch(int arr[], int l, int r, int x) {
if (r >= l) {
int mid = l + (r - l) / 2;

if (arr[mid] == x)
return mid;

if (arr[mid] > x)
return binarySearch(arr, l, mid - 1, x);

return binarySearch(arr, mid + 1, r, x);
}

return -1;
}

Diese Funktion doet das Folgende:

1. Berechnet den mittleren Index.
2. Wenn das mittlere Element das Ziel ist, sind wir fertig!
3. Wenn das Ziel kleiner als das mittlere Element ist, durchsuchen wir die linke Hälfte.
4. Wenn das Ziel größer als das mittlere Element ist, durchsuchen wir die rechte Hälfte.
5. Wenn wir das Element nicht finden können, geben wir -1 zurück.

Es ist wie ein High-Tech-Spiel "Rate die Zahl", bei dem Sie immer die mittlere Zahl im verbleibenden Bereich erraten!

Fibonacci-Folge mit Rekursion

Die Fibonacci-Sequenz ist eine Reihe von Zahlen, bei der jede Zahl die Summe der beiden vorangehenden ist. Sie ist ein perfekter Kandidat für Rekursion!

Hier ist, wie wir Fibonacci-Zahlen rekursiv erzeugen können:

int fibonacci(int n) {
if (n <= 1)
return n;
return fibonacci(n-1) + fibonacci(n-2);
}

Diese Funktion funktioniert如此:

1. Wenn n 0 oder 1 ist, geben wir n zurück (diese sind unsere Basisfälle).
2. Für jeden anderen n geben wir die Summe der beiden vorangehenden Fibonacci-Zahlen zurück.

Wenn wir also fibonacci(5) aufrufen, passiert folgendes:

• fibonacci(5) = fibonacci(4) + fibonacci(3)
• fibonacci(4) = fibonacci(3) + fibonacci(2)
• fibonacci(3) = fibonacci(2) + fibonacci(1)
• fibonacci(2) = fibonacci(1) + fibonacci(0)
• fibonacci(1) = 1
• fibonacci(0) = 0

Arbeiten wir rückwärts, erhalten wir:

• fibonacci(2) = 1 + 0 = 1
• fibonacci(3) = 1 + 1 = 2
• fibonacci(4) = 2 + 1 = 3
• fibonacci(5) = 3 + 2 = 5

Also ist die 5. Fibonacci-Zahl 5!

Häufige rekursive Methoden

Hier ist eine Tabelle der häufigen rekursiven Methoden, die wir besprochen haben:

Methode	Beschreibung	Basisfall	Rekursiver Fall
Faktorie	Berechnet n!	n = 0 oder 1	n * factorial(n-1)
Binärsuche	Findet ein Element in einem sortierten Array	Element gefunden oder nicht im Array	Sucht linke oder rechte Hälfte
Fibonacci	Generiert Fibonacci-Zahlen	n <= 1	fibonacci(n-1) + fibonacci(n-2)

Erinnern Sie sich daran, der Schlüssel zum Verständnis der Rekursion ist es, zu vertrauen, dass der rekursive Aufruf seine Aufgabe korrekt erledigen wird. Es ist wie das Delegieren einer Aufgabe an eine Kopie von sich selbst - Sie wissen, dass sie es genauso gut erledigen werden!

Rekursion kann initially ein bisschen kopfzerbrechend sein, aber mit Übung wird sie ein mächtiges Werkzeug in Ihrem Programmierwerkzeugkasten. Bleiben Sie experimentierfreudig, und bald werden Sie überall rekursive Lösungen sehen!

Frohes Coden, und denken Sie daran - um Rekursion zu verstehen, müssen Sie zuerst Rekursion verstehen. ?

Credits: Image by storyset