Prof: Elie Hamouche

TD4 : Liste simplement chaine - Polynome

Le but de cet exercice est dimplmenter des oprations sur des polynmes par des listes
chanes.
On reprsente un ploynme par une liste chane. Chaque cellule de la liste correspond
un monme, avec son coefficient et son exposant. Par exemple, sur la figure ci-dessous,
on
reprsente la liste chane correspondant au polynme 10x^5 + 5x4 - 3x2 + 5.




Figure : liste chainne qui correspondant au polynme

crire une fonction qui prend en paramtre un polynme et rajoute un monme
la liste. Le coefficient et lexposant du monme seront passs en paramtre. On
supposera que le monme est de degr suprieur au degr du polynme pass en paramtre.

a) crire une fonction de saisie au clavier dun polynme.
b) crire une fonction daffichage dun polynme.
c) crire une fonction de destruction dun polynme.
d) crire une fonction qui recopie un polynme.
e) crire une fonction daddition de deux polynmes.
f) crire une fonction de multiplication de deux polynmes


Corrig

#include <iostream>
#include <stack>
#include <math.h>
#include <list>

using namespace std;

typedef struct monome{
int n,x;
}monome;


struct polynome{
monome m;
struct polynome *suiv;
};
class ex2{

10 5
5 4 -3 2 0 5
public:
ex2(){}
void afficherMonome(monome m){
cout<<m.x<<"x^"<<m.n;
}

void afficherPolynome(polynome* p){
polynome* pl;
pl=p;
while(pl != NULL){
afficherMonome(pl->m);
if(pl->suiv!=NULL)
cout<<"+";
else
cout<<"\n";
pl=pl->suiv;
}

}


polynome* insertMonome(polynome* anc,monome m){
polynome* nouvL;
nouvL=(polynome*)malloc(sizeof(polynome));
nouvL->m=m;
nouvL->suiv=anc;
return nouvL;
}

int longueur_liste(polynome* p)// pour rechercher la longeur de la liste
{
polynome* pl =p;
int n=0;
while(pl!=NULL){
n++;
pl=pl->suiv;
}
return n;
}
polynome* insertEnQueue(polynome* p,monome m)
{
polynome *pL,*nouvL;
nouvL=(polynome*)malloc(sizeof(polynome));
nouvL->m=m;
nouvL->suiv = NULL;
if(p==NULL)
p=nouvL;
else
{

for(pL=p;pL->suiv!=NULL;pL=pL->suiv){}
pL->suiv=nouvL;
}
return p;
}
polynome* saisirPolynome(){
polynome* l;
l=(polynome*)malloc(sizeof(polynome));
l=NULL;
monome p;
int x=0;
int n;
do
{
cout<<"donner le degre du polynome\n";
cin>>n;
} while (n < 0);

for (int i = n; i >= 0; i--)
{
cout<<"donner le coeficient de x^"<<i<<" \n";
cin>>x;
p.x=x;
p.n=i;
if (p.x!= 0)
l=insertEnQueue(l,p);
}
return l;
}

polynome* additionPoly(polynome* op1,polynome* op2){
polynome* pl1;
polynome* pl2;
polynome* res;
res=(polynome*)malloc(sizeof(polynome));
res=NULL;
pl1 = op1;
pl2 = op2;
monome m;
if(pl1==NULL && pl2!=NULL)
{
return pl2;
}
else if(pl2==NULL && pl1!=NULL)
{
return pl1;
}
else if(pl2==NULL && pl1==NULL)
{
return NULL;
}
else{
int deg=(pl1->m.n>pl2->m.n)?pl1->m.n:pl2->m.n;
for (int i=0; i<=deg;i++){
if(pl1==NULL && pl2==NULL){
break;
}
if(pl1==NULL && pl2!=NULL)
{
res=insertEnQueue(res,pl2->m);
pl2=pl2->suiv;
}
else if(pl2==NULL && pl1!=NULL)
{
res=insertEnQueue(res,pl1->m);
}
else{
if (pl1->m.n == pl2->m.n)
{
m.x = pl1->m.x+ pl2->m.x;
m.n = pl1->m.n;
pl1=pl1->suiv;
pl2=pl2->suiv;
res=insertEnQueue(res,m);
}
else if (pl1->m.n > pl2->m.n)
{
m.x=pl1->m.x;
m.n=pl1->m.n;
res=insertEnQueue(res,m);
pl1=pl1->suiv;
}
else
{
m.x=pl2->m.x;
m.n=pl2->m.n;
res=insertEnQueue(res,m);
pl2=pl2->suiv;
}
}
}
return res;
}
}

polynome* multiplicationPoly(polynome* l1, polynome* l2)//produit de deux
polynome
{
polynome* res = (polynome*)malloc(sizeof(polynome));
polynome* fres = (polynome*)malloc(sizeof(polynome));
polynome* tres = (polynome*)malloc(sizeof(polynome));
polynome* pl1=l1;
monome m;
monome m1,m2;
fres=NULL;
while(pl1!=NULL)
{
polynome* pl2=l2;
m1=pl1->m;
res=NULL;
tres=NULL;
while(pl2!=NULL){
m2=pl2->m;
m.x = m1.x * m2.x;
m.n = m1.n + m2.n;
res=insertEnQueue(res,m);
pl2=pl2->suiv;
}
tres = additionPoly(fres, res);
fres=NULL;
while (tres!=NULL)
{
fres=insertEnQueue(fres,tres->m);
tres=tres->suiv;
}
pl1=pl1->suiv;
}
return fres;
}
int polynomeToTab(polynome* p,monome* monomet)
{
int i=0;
while(p!=NULL)
{
monomet[i]=p->m;
p=p->suiv;
i++;
}
return i;
}
void tableauListe(polynome* p, list<monome>* l){
while(p!=NULL){
l->push_back(p->m);
p=p->suiv;
}
}
polynome* listePoly(list<monome> l, polynome* p){
while(l.size()>0)
{
insertEnQueue(p,l.front());
l.pop_front();
}
return p;
}
list<monome> polynomeListe(list<monome> l, polynome* p){
while(p!=NULL)
{
l.push_back(p->m);
p=p->suiv;
}
return l;
}

int checkNode(list<monome> l, monome m)
{
int res = 0;
list<monome> pl= l;
monome mn;
while (pl.size()>0)
{
mn=pl.front();
if (mn.n==m.n && mn.x==m.x)
{
res = 1;
break;
}
pl.pop_front();
}
return res;
}
list<monome> del_0(list<monome> l)
{
monome m ;
m.x = 0;
list<monome> pl;
for (int c = l.size()-1;c>=0;c--)
{
m.n = c;
if(!checkNode(l,m)){
pl.push_back(l.front());
l.pop_front();
}
}
return pl;
}

};
int main(){
ex2 o;
polynome * p1;
polynome * p2;
polynome * p3;
p1=o.saisirPolynome();
o.afficherPolynome(p1);
p2=o.saisirPolynome();
o.afficherPolynome(p2);
p3=o.additionPoly(p1,p2);
cout<<"l'addition de ses deux polynomes est : "<<endl;
o.afficherPolynome(p3);
cout<<"la multiplication de ses deux polynomes est : "<<endl;
p3=o.multiplicationPoly(p1,p2);
o.afficherPolynome(p3);
system("pause");
return 0;
}