Exercice : Gestion des Polynômes avec les listes chainées

Le but de cet exercice est d’implémenter des opérations sur des polynômes par des listes chaînées.

On représente un polynôme par une liste chaînée. Chaque cellule de la liste correspond à un monôme, avec son coefficient et son exposant. 

Par exemple, sur la figure ci-dessous, on représente la liste chaînée correspondant au polynôme $5{ x }^{ 4 }+2{ x }^{ 2 }+3$.

en représente le Polynôme nul par une liste vide .

Question 1 : Définir la structure Poly qui a pour champs : le coefficient ( réel ) , l'exposant ( entier positif ) . 

typedef struct Poly{
    int exp;
    float coef;
    struct Poly * suivant;
}Poly;

Question 2 : Écrire une fonction de saisie au clavier d’un monôme .

Poly * creerMonome( float coef , int exp ){
    if ( exp < 0 ) { // il n y a pas de monome ayant une puissance negative
        printf("erreur : puissance negative");
        return NULL;
    }
    else {
        Poly * P;
        P = ( Poly * )malloc( sizeof(Poly) );
        P->coef = coef;
        P->exp = exp;
        P->suivant = NULL;
        return P;
    }
};

Question 3 : Écrire une fonction qui ajout un monôme a la liste du polynôme , en traite tous les cas possibles .

attention : le Polynôme doit être trié toujours en exposant décroissant . 

Poly * ajouterMonome( Poly * monPoly , float coef , int exp ){

    if ( monPoly == NULL ) return creerMonome( coef , exp ); // si monPoly est nul , alors la somme serait just un monome
    else {
        if ( exp > monPoly->exp ) {
            Poly * P = creerMonome( coef , exp );
            P->suivant = monPoly;
            return P;
        }
        else {
                Poly * R = monPoly;
                while ( R->suivant != NULL && R->suivant->exp > exp ) R = R->suivant;

                if ( R->suivant != NULL && R->suivant->exp = exp ) R->suivant->coef += coef;
                else {
                    Poly * P = creerMonome( coef , exp );
                    P->suivant = R->suivant;
                    R->suivant = P;
                }
                return monPoly;
         }
    }
}

Question 4 : Écrire une fonction qui revoie une copie du polynôme . 

Poly * copierPolynome( Poly * monPoly ){

    Poly * copie=NULL, * R = monPoly;

    while ( R != NULL ) { 
        copie = ajouterMonome( copie , R->coef , R->exp );
        R = R->suivant;
    }
    
    return copie;
    
}

Question 5 :  Écrire une fonction qui créer et renvoi la somme de deux polynômes . 

Poly * sommerPolynomes( Poly * monPoly1 , Poly * monPoly2 ){

    Poly * somme = copierPolynome( monPoly1 ), * R = monPoly2;

    while ( R != NULL ) {
        somme = ajouterMonome( somme , R->coef , R->exp );
        R = R->suivant;
    }

    return somme;
}

Question 6 : Écrire une fonction qui créer et renvoi le polynôme dérivé .

Poly * deriverPolynome( Poly * monPoly ){

    Poly * derive = copierPolynome( monPoly ), * R = derive;

    while ( R != NULL ) {
        
        R->coef *= R->exp;
        R->exp--;

        if ( R->suivant->exp == 0 ) R->suivant = NULL;
        else R = R->suivant;

    }
    return derive;
}

Question 7 : Écrire une fonction qui affiche le polynôme .
c'est a vous de proposer une solution :-P