DEVOIR LIBRE

Programmation avancée

RAPPORT DU TP 
LISTES DOUBLEMENT CHAÎNÉES EN C++

Réalisé par :
NAJI Hanaa
LAAMCHI Oumaima
#include<iostream>

using namespace std;

/**
* Bimone : NAJI Hanaa
 *         LAAMCHI Oumaima
 * Date : 2023-04-17
 * version : 1.0
 */

/**
 * Definition des types
 */

typedef struct {
    double coefficient ;
    int exposant ;
} Monome ;

typedef Monome TypeListe;

typedef struct cellule {

     TypeListe donnee ;
    struct cellule * suivant ;
    struct cellule * precedent ;
} Cellule ;

typedef struct {
    Cellule * debut ; // pointeur sur le début
    Cellule * fin ; // pointeur sur le fin
} Liste;

typedef Liste polynome;

void ajouter_fin(Liste* L, TypeListe valeur) {

    Cellule* c = new Cellule;
    c->donnee = valeur;
    c->suivant = NULL;
    c->precedent = L->fin;
    if (L->fin == NULL) {
        L->debut = c;
    } else {
        L->fin->suivant = c;
    }
    L->fin = c;
}
void ajouter_debut(Liste* L, TypeListe valeur){
    Cellule* c = new Cellule;
    c->donnee = valeur;
    c->precedent = NULL;
    c->suivant = L->debut;
    if (L->debut == NULL) {
        L->fin = c;
    } else {
        L->debut->precedent = c;
    }
    L->debut = c;
}
// Fonction pour supprimer un terme de la liste
void supprimerTerm(polynome* p, cellule* term) {
    if (term == p->debut) {
        p->debut = term->suivant;
    }
    if (term->precedent!= nullptr) {
        term->precedent->suivant = term->suivant;
    }
    if (term->suivant!= nullptr) {
        term->suivant->precedent= term->precedent;
    }
    delete term;
}

// Fonction pour supprimer un monôme du polynôme

void supprimer_monome(polynome* p, int exp) {
    cellule*currenTerm=new cellule;
    cellule* currentTerm = p->debut;
    currentTerm->donnee.exposant=exp;
    while (currentTerm != nullptr) {
        if (currentTerm->donnee.exposant == exp) {
            supprimerTerm(p, currentTerm);
           
        }
        currentTerm = currentTerm->suivant;
    }
}
polynome *init(){
    polynome*p = new polynome;
    p->debut=NULL;
    p->fin=NULL;
    return p;
}

polynome *lire(){
Monome m;
polynome*p=new polynome;
while(true){

    cout<<"entrer les coefficients du polynome"<<endl;

    cin>>m.coefficient;
    cout<<"entrer les exposants du polynome"<<endl;
    cin>>m.exposant;
    if(m.coefficient==0||m.exposant<0){
        return p;
    ajouter_fin(p,m);
}
}
}
void afficher(polynome*p) {
    cellule*d = new cellule;
    TypeListe donnee;
    cout << "Polynome dans l'ordre decroissant des exposants : ";
    d = p->fin;
    while (d != NULL) {
        cout << d->donnee.coefficient << "*x^" << d->donnee.exposant << " ";
        d = d->precedent;
    }
    cout << endl;
    // Affichage de l'exposant le plus petit au plus grand
    cout << "Polynome dans l'ordre croissant des exposants : ";
    d= p->debut;
   
    while (d != NULL) {
       
        cout << d->donnee.coefficient << "x^" << d->donnee.exposant << " ";
        d = d->suivant;
    }
    cout << endl;
}
void afficher2(polynome* p) {
    Cellule* c = p->debut;
    TypeListe donnee;
    char choix;
    cout << "Vous voulez afficher le polynôme en ordre croissant ou
décroissant ? (c/d) : " << endl;
    cin >> choix;
    Cellule *k = new Cellule;
    Cellule *temp, *t;
    if (choix == 'c' || choix == 'C') {
        bool sorted = false;
        while (!sorted) {
            sorted = true;
            t = c;
            while (t->suivant != NULL) {
                temp = t->suivant;
                if (t->donnee.exposant > temp->donnee.exposant) {
                    k->donnee = temp->donnee;
                    temp->donnee = t->donnee;
                    t->donnee = k->donnee;
                    sorted = false;
                }
                t = t->suivant;
            }
        }
    }
    else if (choix == 'd' || choix == 'D') {
        bool sorted = false;
        while (!sorted) {
            sorted = true;
            t = c;
            while (t->suivant != NULL) {
                temp = t->suivant;
                if (t->donnee.exposant < temp->donnee.exposant) {
                    k->donnee = temp->donnee;
                    temp->donnee = t->donnee;
                    t->donnee = k->donnee;
                    sorted = false;
                }
                t = t->suivant;
            }
        }ajouter_fin(p, donnee);
    }

    while (c != NULL) {
        cout << c->donnee.coefficient << "*x^" << c->donnee.exposant;
        c = c->suivant;
        if (c != NULL) {
            cout << " + ";
        }
    }
    cout << endl;
   
}

void ajouter_monome(polynome *p, double coef, int exp) {

    Cellule * n = new Cellule;
    TypeListe donnee;
    n->donnee.coefficient = coef;
    n->donnee.exposant    = exp;
    if (p->debut == NULL) {     // Liste vide
        p->debut = n;
        p->fin  = n;
        n->suivant = NULL;
        n->precedent = NULL;
    }
    else {
        Cellule * a = p->debut;
        while (a != NULL && a->donnee.exposant > exp){
            a = a->suivant;
        }
        if (a == NULL){
            n->suivant   = NULL;
            n->precedent = p->fin;
            p->fin->suivant = n;
            p->fin = n;
        }
        else if (a->donnee.exposant < exp) {
            n->suivant   = a;
            n->precedent = a->precedent;
            a->precedent = n;
        }
        else {      // a->m.expopsant = exp
            if (a->donnee.coefficient + coef != 0){
                a->donnee.coefficient += coef;
                delete n;
            }
            else {
                a->precedent->suivant = a->suivant;
                a->suivant->precedent = a->precedent;
                delete a;
                delete n;
            }
        }
    }
}

int degre(polynome*p){
    cellule*d=new cellule;
    d=p->debut;
    TypeListe donnee;
    int degre=0;
    while (d!= NULL) {
        if (d->donnee.exposant > degre) {
           degre = d->donnee.exposant;
        }
        d = d->suivant;
    }
        return degre;
}

polynome*somme(polynome*a,polynome*b){
    polynome*s=init();
    cellule*h=new cellule;
    cellule*i=new cellule;
    cellule*n=new cellule;
    h=a->debut;
    i=b->debut;
    while(h!=NULL||i!=NULL){
        if(h!=NULL){
            ajouter_monome(s,h->donnee.coefficient,h->donnee.exposant);
            h=h->suivant;
        }
            if(i!=NULL){
                ajouter_monome(s,i->donnee.coefficient,i->donnee.exposant);
                i=i->suivant;
            }
           
    n=s->debut;
    while(n!=NULL){
        if(n->donnee.coefficient==0)
        supprimer_monome(s,n->donnee.exposant);
        n=n->suivant;
    }
     return s;      
           
           
        }
       
}
   

polynome *oppose(polynome *p){

     p = init();
        TypeListe s;
    Cellule *c = p->debut;
    while (c!=NULL){
        TypeListe s=c->donnee;
        s.coefficient = -(s.coefficient);
        c=c->suivant;
        afficher(p);
       
    }return p;
}
polynome *soustraction (polynome *a, polynome *b){
    polynome *o = oppose(*b);
    polynome *d = somme (a,o);
    return d;
}

polynome *multiplication (polynome *a, polynome *b){

    polynome * q = new polynome;
    n = a->debut;
    m = b->debut;
    while (n->suivant !=NULL){      //pour chaque monome de a
        while (m->suivant != NULL){     //pour chaque monome de b
            Cellule * c = new Cellule;  //nouveau monome produit
            c->donnee.coefficient = n->donnee.coefficient * m-
>donnee.coefficient;
            c->donnee.exposant = n->donnee.exposant + m->donnee.exposant;
            ajouter_debut (q, c->donnee);   //inserer les monomes produits
dans le nouveau polynome produit
    }
}
    return q;
}

int main(){
 polynome *p;
 cellule*d;
 TypeListe donnee;
 double coeff;
 int exp;
 d->donnee.exposant=exp;
 d->donnee.coefficient=coeff;
 p=init();
 
 int h=0;
   
   cout << "Entrez un polynome: "<<endl;
   p=lire();
        // Lecture du polynôme à partir d'une chaîne de caractères
    afficher(p);
   h=degre(p);
   cout << "Le degré du polynome est:"<<h<<endl;
   supprimer_monome(p,exp);
return 0;
}

Exemple d’exécution