Fonction récursive pour comparer des chaînes sans fonctions de bibliothèque

Vous ne passez pas à la fonction les variables i, n, p . De cette façon, votre fonction ne se terminera pas, car elle commencera à chaque fois avec les variables de compteur à 0.

Dans la partie:

int rStrcmp(char *s1, char *s2)
{
    if (*s1 =='\0' && *s2 !='\0') //s1 shorter than s2
        return -1;

    else if (*s1 !='\0' && *s2 =='\0') //s1 longer than s2
        return 1;

    else if (*s1 !='\0' && *s2 !='\0')  //both not equal to null
    {
        if (*s1>*s2)  return 1; //s1
        else if (*s1<*s2) return -1; //s2
        else
            return rStrcmp(s1+1,s2+1);
    }
    else    //if s1[i] & s2[i] are null
    {
        // since both are null, they are the same length and each
        // character was the same: equal
        return 0;
    }
}

vous appelez rStrcmp (s1, s2); avec s1 et s2 code>, cependant, vous venez de traiter un caractère. Appelez rStrcmp (s1 + 1, s2 + 1); .

Remarque: puisque votre fonction ne traite qu'un seul caractère par appel, vous n'avez pas besoin d'indexer les chaînes avec i . Il vaut toujours 0 sauf avant une instruction return, donc sa valeur n'est jamais utilisée:

    else if (s1[i] !='\0' && s2[i] !='\0')  //both not equal to null
    {
        if (s1[i]>s2[i])  n+=1; //s1
        else if (s1[i]<s2[i]) p+=1; //s2
        else
        {
           n+=1; //s1
           p+=1; //s2
        }
        i+=1;
        return rStrcmp(s1,s2);

Changez simplement le return rStrcmp (s1, s2); en return rStrcmp (s1 + i, s2 + i); . Ainsi, vous stockez les incréments de la position de votre tableau.

Le principal problème dans votre fonction est que vous ne transmettez pas de pointeurs mis à jour dans l'appel récursif à modifiedStrcmp , provoquant une boucle infinie et un potentiel débordement de pile .

Voici une version corrigée et simplifiée:

int revisedStrcmp(const char *s1, const char *s2) {
    unsigned char c1 = *s1, c2 = *s2;
    if (c1 < c2)
        return -1;
    if (c1 > c2)
        return +1;
    // c1 == c2
    if (c1 == '\0')
        return 0;
    return revisedStrcmp(s1 + 1, s2 + 1);
}

Il n'est pas nécessaire de faire des cas particuliers pour les chaînes plus courtes car le terminateur nul peut être utilisé dans les comparaisons.

Ce style particulier de récursivité est appelé récursivité de queue et sera compilé dans une boucle par les compilateurs modernes.

Notez cependant que pour modifiedStrcmp () renvoyer le même ordre que strcmp , les comparaisons doivent être effectuées sur des valeurs de unsigned char au lieu de simples char , qui peuvent être signés par défaut sur de nombreuses architectures:

int revisedStrcmp(const char *s1, const char *s2) {
    if (*s1 < *s2)
        return -1;
    if (*s1 > *s2)
        return +1;
    // *s1 == *s2
    if (*s1 == '\0')
        return 0;
    return revisedStrcmp(s1 + 1, s2 + 1);
}

La raison est que s1 et s2 sont les mêmes en récursivité. Ce que je veux dire: si vous avez char * s1 = "Hello"; et char * s2 == Elloh , vos appels récursifs sont les mêmes. vous commencez au même point, toujours, vous ne passez aucun incrément de quelque manière que ce soit (n, p) donc vous partez essentiellement du même point à chaque appel récursif. Ce que vous pouvez faire est d'incrémenter le pointeur et voici une solution courte:

return revisedStrcmp(s1+i, s2+i);

ou vous pouvez faire ce qui suit:

int revisedStrcmp (char *s1, char *s2) {
    if (*s1 == *s2)
        return *s1 == '\0' ? 0 : revisedStrcmp(s1 + 1, s2 + 1);

    return (*s1 > *s2) ? 1 : -1; 
}