C und while? Wieso macht der Author das so?

Siassei

Servus,

am Anfang möchte ich mich für den Titel entschuldigen und falls jemand etwas besseres einfällt, bitte ich ihn, diesen zu ändern.

Im Wikipedia-Artikel zur binär Suche liefert der Author zwei Beispiele:

Java:

package org.wikipedia.de;

public final class BinäreSuche {

    public static int suche(final char zeichen, final char[] alphabet) {
        int ergebnis = -1;
        int erstes = 0;
        int letztes = alphabet.length - 1;

        while (erstes <= letztes && ergebnis < 0) {
            final int mitte = erstes + ((letztes - erstes) / 2);
            if (alphabet[mitte] < zeichen) {
                erstes = mitte + 1; // rechts weitersuchen
            } else if (alphabet[mitte] > zeichen) {
                letztes = mitte - 1; // links weitersuchen
            } else {
                ergebnis = mitte; // Zeichen gefunden
            }
        }

        return ergebnis;
    }

}

C:

/**
 * Liefert 1 zurück, wenn X in M gefunden wurde, ansonsten 0.
 * Beim Aufruf wird als 4. Argument eine Variable per Adresse
 * übergeben, in die bei Erfolg die Position von X in M geschrieben wird.
 * @param const int[] M      Feld, in dem gesucht werden soll
 * @param int n              Größe des Feldes
 * @param int X              der gesuchte Eintrag
 * @param int *index         Position des gesuchten Eintrags X in M
 * @return int 1=gefunden, 0=nicht gefunden
 */
int binary_search(const int M[], int n, int X, int *index)
{
    unsigned int mitte;
    unsigned int links = 0; /* man beginne beim kleinsten Index */
    unsigned int rechts = n - 1; /* Arrays sind 0-basiert */

    if (M == NULL || n <= 0 || X < M[0] || X > M[n - 1]) /* Bereichsüberprüfung */
    {
        return 0;	
    }

    while (1) /* Die endlose Schleife wird durch returns Unterbrochen */
    {
        mitte = links + ((rechts - links) / 2); /* Bereich halbieren */

        if (rechts < links) /* alles wurde durchsucht, aber X nicht gefunden */
        {
             printf("Nicht gefunden!\n");
             return 0;
        }

        if (M[mitte] == X) /* Element X gefunden? */
        {
            *index = mitte;
            return 1;
        }

        if (M[mitte] > X)
            rechts = mitte - 1; /* im rechten Abschnitt weitersuchen */
        else
            links = mitte + 1; /* im linken Abschnitt weitersuchen */
    } 
}

Wieso schreibt der Author in C folgendes

while (1)

und nicht

while (rechts < links)
// + ein paar Anpassungen

?

Ist der Grund auf der Performance-Seite zu suchen?
Und da hätte ich noch ne Frage. Spielt es in C eine Rolle, ob ich rekursiv oder in einer Schleife ein Problem löse?

Gruß,
Thomas

ich vermute er hats so geschrieben, damit er im fall rechts < links noch eine meldung ausgeben kann, bevor er die schleife abbricht.

Siassei schrieb:

Spielt es in C eine Rolle, ob ich rekursiv oder in einer Schleife ein Problem löse?

ja.

curry-king

solange(wahr); schrieb:

Siassei schrieb:

Spielt es in C eine Rolle, ob ich rekursiv oder in einer Schleife ein Problem löse?

ja.

... und zwar insofern, das pro rekursivem Funktionsaufruf ein neuer Stackframe erzeugt wird.
Iterationen laufen dagegen mit konstantem Stackspace.

Siassei

Servus,

danke für eure Antworten.

Gruß,
Thomas

Siassei schrieb:

Wieso schreibt der Author in C folgendes
while (1)
und nicht
while (rechts < links)
// + ein paar Anpassungen

weil eine endlosschleife den code manchmal einfacher/leserlicher macht (z.b. diese zwei entscheidungen, wann rausgesprungen wird).

Konfusius

while(rechts>=links) wäre tatsächlich besser. Der Autor hat das Beispiel einfach schlecht programmiert.