​ serie1

exercice 1​:

Soient deux tableaux entiers triés A[N] et b[N]

Ecrire un programme en c++ permettant de fusionner a et b dans tableau c.
a-Donnez la solution sans fonctions .
b-Donnez une solution avec function .
Solution​ ​exercice 1:
-solution question a:
#include <iostream>

using namespace std;

int main()
{ cout<<"donnez la taille de les deux tableaux :";
int n;
cin>>n;
int a[n],b[n],c[n*2];
cout<<"\n remplissage de 1er tableaux(tableaux doit etre trier decroisant ):";
for(int i=0;i<n;i++){
cout<<"\ndonnez la valeur de a["<<i+1<<"]=";
cin>>a[i];
}
cout<<"\n remplissage de 2eme tableaux( tableaux doit etre trier decroisant ):";
for(int i=0;i<n;i++){
cout<<"\ndonnez la valeur de b["<<i+1<<"]=";
cin>>b[i];
}
int i=0,j=0,k=0;
while(i<n&&j<n){
if(a[i]>b[j]){
c[k]=a[i];
i++;
k++;
}
else if(a[i]<b[j]){
c[k]=b[j];
j++;
k++;
}
else{
c[k]=b[j];
 j++;
k++;
c[k]=a[i];
i++;
k++;
}
}
for(i;i<n;i++){
c[k]=a[i];
k++;
}
for(j;j<n;j++){
c[k]=a[j];
k++;
}
cout<<"la fusion de a et b:";
for(int i=0;i<k;i++){
cout<<c[i]<<",";
}

return 0;
}

-solution question b:
#include <iostream>

using namespace std;

void remplissage(int *a,int n){
for(int i=0;i<n;i++){
cout<<"\ndonnez la valeur de tab["<<i+1<<"]=";cin>>a[i];
}
}
void fusion(int *a,int *b,int *c,int n){
int i=0,j=0,k=0;
while(i<n&&j<n){
if(a[i]>b[j]){
c[k]=a[i];
i++;
k++;
}
else if(a[i]<b[j]){
c[k]=b[j];
j++;
k++;
}
else{
 c[k]=b[j];
j++;
k++;
c[k]=a[i];
i++;
k++;
}
}
for(i;i<n;i++){
c[k]=a[i];
k++;
}
for(j;j<n;j++){
c[k]=a[j];
k++;
}
}
void affaiche(int *c,int k){
for(int i=0;i<k;i++){
cout<<c[i]<<",";
}
}
int main()
{ cout<<"donnez la taille de les deux tableaux :";
int n;
cin>>n;
int a[n],b[n],c[n*2];
cout<<"\n remplissage de 1er tableaux(tableaux doit etre trier decroisant ):";
remplissage(a,n);
cout<<"\n remplissage de 2eme tableaux( tableaux doit etre trier decroisant ):";
remplissage(b,n);
fusion(a,b,c,n);
cout<<"a=";affaiche(a,n);
cout<<"\nb=";affaiche(b,n);

cout<<"\nc(la fusion de a et b)=";affaiche(c,n*2);

return 0;
}
exercice 2:

Soit un tableau entier A[N].

Ecrire un programme c++ avec fonctions permettant d’effectuer les opération suivantes:
-afficher le plus petit et le plus grand élément de A ainsi que leurs indices respectifs
-ensuite les permuter
utiliser le transfert par référence puis le transfert par pointeur .

solution exercice 2:
-transfert par référence :

#include <iostream>

using namespace std;

void remplissage(int *a,int n){
for(int i=0;i<n;i++){
cout<<"\ndonnez la valeur de tab["<<i+1<<"]=";
cin>>a[i];
}
}
void affaichage(int *a,int n){
for(int i=0;i<n;i++){
cout<<a[i]<<"\t";
}cout<<"\n";
}
int &pluspetit(int *a,int n){
int mi=a[0], ind=0;
for(int i=1;i<n;i++){
if(mi>a[i]){
mi=a[i];
ind=i;
}
}
cout<<"\nle minimum de tableau est "<<mi<<" \n sont indice est :"<<ind+1;
return ind;
}
int &plusgrand(int *a,int n){
int ma=a[0],ind=0;
for(int i=1;i<n;i++){
if(ma<a[i]){
ma=a[i];
ind=i;
 }
}
cout<<"\nle max de tableau est "<<ma<<" \n sont indice est :"<<ind+1;
return ind;
}
void permutation(int *a,int ind1,int ind2){
int tmp=a[ind1];
a[ind1]=a[ind2];
a[ind2]=tmp;}

int main()
{
cout<<"donnez la taille de tableau :";
int n;
cin>>n;
int a[n];
remplissage(a,n);
int mi=pluspetit(a,n);
int ma=plusgrand(a,n);
cout<<"\naffaichage avant permutation entre minmum et le max :\n";
affaichage(a,n);
cout<<"affaichage apres permutation entre minmum et le max :\n";
permutation(a,mi,ma);
affaichage(a,n);

return 0;
}

-transfert par pointeur :

#include <iostream>

using namespace std;

void remplissage(int *a,int n){
for(int i=0;i<n;i++){
cout<<"\ndonnez la valeur de tab["<<i+1<<"]=";
cin>>a[i];
}
}
void affaichage(int *a,int n){
for(int i=0;i<n;i++){
cout<<a[i]<<"\t";
}cout<<"\n";
}
int *pluspetit(int *a,int n){
int mi=a[0], ind=0;
for(int i=1;i<n;i++){
if(mi>a[i]){
mi=a[i];
ind=i;
}
}
cout<<"\nle minimum de tableau est "<<mi<<" \n sont indice est :"<<ind+1;
return &ind;
}
int *plusgrand(int *a,int n){
int ma=a[0],ind=0;
for(int i=1;i<n;i++){
if(ma<a[i]){
ma=a[i];
ind=i;
}
}
cout<<"\nle max de tableau est "<<ma<<" \n sont indice est :"<<ind+1;
return &ind;
}
void permutation(int *a,int ind1,int ind2){
int tmp=a[ind1];
a[ind1]=a[ind2];
a[ind2]=tmp;}

int main()
{
cout<<"donnez la taille de tableau :";
int n;
cin>>n;
int a[n];
remplissage(a,n);
int mi=*(pluspetit(a,n));
int ma=*(plusgrand(a,n));
cout<<"\naffaichage avant permutation entre minmum et le max :\n";
affaichage(a,n);
cout<<"affaichage apres permutation entre minmum et le max :\n";
permutation(a,mi,ma);
affaichage(a,n);

return 0;
}
exercice 3:
soit la structure de données ​Produit ​composée des champs:code,poids et prix.
ecrire un programme c++ avec fonction permettant de déclarer deux variables M1 et M2 de
type Produit d’initialiser ces variables de les modifier et d’afficher leurs valeurs avant et
aprés la modification .utiliser les défférents modes de transfert de paramétres entre les
fonction .
-​solution exercice 3:
#include <iostream>

using namespace std;

struct prod{
int code,poids,prix;
};
void modp(prod *m){
cout<<"donnez code :";cin>>m->code;
cout<<"\ndonnez poid:";cin>>m->poids;
cout<<"\ndonnez prix:";cin>>m->prix;

}
void modref(prod &m){//transfére par ref
cout<<"donnez code :";cin>>m.code;
cout<<"\ndonnez poid:";cin>>m.poids;
cout<<"\ndonnez prix:";cin>>m.prix;

}
void affaiche(prod m){
cout<<"\ncode :"<<m.code<<" poid:"<<m.poids<<" prix:"<<m.prix;
}
int main()
{ prod m1p,m2p,m1r,m2r;
cout<<"vous devez intialiser m1 avec pointeur:";
modp(&m1p);
affaiche(m1p);
cout<<"\nvous devez intialiser m2 avec pointeur:";
modp(&m2p);
affaiche(m2p);
cout<<"\nvous devez intialiser m1 avec reffff:";
modref(m1r);
affaiche(m1r);
cout<<"\nvous devez intialiser m2 avec reff:";
modref(m2r);
affaiche(m2r);
cout<<"\n\tvous voulez modifier les valeur précedent \n";
cout<<"modifier m1 avec pointeur:";
cout<<"avant:";
affaiche(m1p);
modp(&m1p);
cout<<"\napres:";
affaiche(m1p);
cout<<"\nmodifier m2 avec pointeur:";
cout<<"avant:";
affaiche(m2p);
modp(&m2p);
cout<<"\napres:";
affaiche(m2p);
cout<<"\nmodifier m1 avec reffff:";
cout<<"avant:";
affaiche(m1r);
modref(m1r);
cout<<"\napres:";
affaiche(m1r);
cout<<"\nmodifierm2 avec reff:";
cout<<"avant:";
affaiche(m2r);
modref(m2r);
cout<<"\napres:";
affaiche(m2r);

return 0;
}
exercice 4:
donnez un programme c++ permettant de lire et trier un tableau a[n] et le affaicher
a-utiliser l’allocation statique
b-utiliser l’allocation dynamique
-solution exercice 4:
#include <iostream>
using namespace std;
void prmutatuon(int *a,int *b ){
int tmp=*a;
*a=*b;
*b=tmp;
}
void trie(int *a,int n){
for(int i=0;i<n-1;i++){
for(int j=i+1;j<n;j++)
if(a[i]>a[j]){
prmutatuon(&a[i],&a[j]);
}}
}
void remplissage(int *a,int n){
for(int i=0;i<n;i++){
cout<<"\ndonnez la valeur de tab["<<i+1<<"]=";cin>>a[i];
}
}
void affaichage(int *a,int n){
for(int i=0;i<n;i++){
cout<<a[i]<<"\t";
}cout<<"\n";
}

int main()
{ int a[100];
cout<<"donnez la taille de tableau:";
int n;
cin>>n;
cout<<"\nallocation statique";
remplissage(a,n);
trie(a,n);
affaichage(a,n);
cout<<"\nallocation dynamique ";
int *ady=new int[n];
remplissage(ady,n);
trie(ady,n);
affaichage(ady,n);
return 0;
}
exercice 5:
ecrire un programme c++ permettant de permuter les valeurs minimales de deux tableaux
bidimensionnels entiers a[n][n] et b[n][n] connaissant leurs indices lignes et colonnes.
-solution exercice 5:
#include <iostream>
using namespace std;
struct indice{
int ilg,ic;};
void remplissage(int a[100][100],int n){
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
cout<<"\ndonnez la valeur de tab["<<i+1<<"]["<<j+1<<"]=";cin>>a[i][j];}}}
void affaichage(int a[100][100],int n){
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
cout<<a[i][j]<<"\t";}cout<<"\n";}}
indice pluspetit(int a[100][100],int n){
indice m;m.ilg=0;m.ic=0;int mi=a[0][0];
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(mi>a[i][j]){
mi=a[i][j];
m.ilg=i;
m.ic=j;
}}}return m;}
void permutation(int a[100][100],int b[100][100],indice ia,indice ib){
int tmp=a[ia.ilg][ia.ic];
a[ia.ilg][ia.ic]=b[ib.ilg][ib.ic];
b[ib.ilg][ib.ic]=tmp; }
int main()
{ int a[100][100],b[100][100];
cout<<"donnez la taille de matrice carée :";int n;cin>>n;
cout<<"\nremplissage de a :";
remplissage(a,n);
indice ia=pluspetit(a,n);
cout<<"\nremplissage de b:";
remplissage(b,n);
indice ib=pluspetit(b,n);
cout<<"\naffaiche de a avant :\n ";
affaichage(a,n);
cout<<"\naffaiche de b avant :\n";
affaichage(b,n);
permutation(a,b,ia,ib);
cout<<"\naffaiche de a apres :\n";affaichage(a,n);
cout<<"\naffaiche de b apres :\n";
affaichage(b,n);return 0;}
Exercice 6:
soient deux tableaux bidimensionnels entiers a[n][n] et b [n][n]
ecrire un programme c++ avec fonction permettant d’effectuer les opération suivantes :
-initialiser a et b
-calculer leur somme et leur produit
-calculer le nombre de valeurs supérieures à 50 dans a et b
-afficher le résultats
a-utiliser l’allocation statique
b-utiliser l’allocation dynamique
solution exercice 6:
a-

#include <iostream>
#include <stdlib.h>

using namespace std;

void remp(int a[100][100],int n){
for (int i=0;i<n;i++){
for(int j=0;j<n;j++){
cout<<"\ndonnez la val:";cin>>a[i][j];
}
}
}

int somme(int a[100][100],int b[100][100],int n){

int s=0;
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
s+=a[i][j]+b[i][j];
}
}
return s;
}

int produit(int a[100][100],int b[100][100],int n){

int p=1;
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
p+=a[i][j]+b[i][j];
}
}
return p;
}

int nbrsup50(int a[100][100],int b[100][100],int n){

int c=0;
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(a[i][j]>50)c++;
if(b[i][j]>50)c++;
}
}
return c;
}
int main()
{ int a[100][100],b[100][100];
cout <<"donnez la taille ";int n ;cin>>n;
cout<<"\nremplissage de a:";
remp(a,n);
cout<<"\nremplissage de b:";
remp(b,n);
system("cls");
int s=somme(a,b,n);
int p=produit(a,b,n);
int nb50=nbrsup50(a,b,n);
system("cls");
cout<<"\nleur somme:"<<s<<" leur produi:"<<p<<" nombre supr50:"<<nb50;
return 0;
}

-b
#include <iostream>
#include <stdlib.h>

using namespace std;

void remp(int **a,int n){
for (int i=0;i<n;i++){
for(int j=0;j<n;j++){
cout<<"\ndonnez la val:";cin>>a[i][j];
}
}
}
int somme(int **a,int **b,int n){
int s=0;
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
s+=a[i][j]+b[i][j];
}
}
return s;
}
int produit(int **a,int **b,int n){
int p=1;
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
p+=a[i][j]+b[i][j];
}
}
return p;
}
int nbrsup50(int **a,int **b,int n){
int c=0;
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(a[i][j]>50)c++;
if(b[i][j]>50)c++;
}
}
return c;
}

int main()
{ int a[100][100],b[100][100];
cout <<"donnez la taille ";int n ;cin>>n;
int **ad=new int *[n];
for(int i=0;i<n;i++){
ad[i]=new int [n];
}
int **bd=new int *[n];
for(int i=0;i<n;i++){
bd[i]=new int [n];
}
cout<<"\nremplissage de a:";
remp(ad,n);
cout<<"\nremplissage de b:";
remp(bd,n);
system("cls");
int ss=somme(ad,bd,n);
int pp=produit(ad,bd,n);
int nbb50=nbrsup50(ad,bd,n);
system("cls");
cout<<"\nleur somme:"<<ss<<" leur produi:"<<pp<<" nombre supr50:"<<nbb50;
return 0;
}
Exercice 7:
soient deux listes linéaires simples d’entiers, de têtes d1 et d2
1-ecrire un programme c++ avec fonctions permettant de concaténer ces deux listes
a- sans sacrifier les listes originals
b-en sacrifiant les listes originales
2- reprendre la même question avec des listes linéaires bidirectionnelles

solution exercice 7:
1-
#include <iostream>
using namespace std;
struct liste{
int info;
liste *suiv;
};
void ajoutfin(liste *&l,int x){
if(l==NULL){
l=new liste ;
l->info=x;
l->suiv=NULL;}
else if(l!=NULL){
liste *cour=l;
while(cour->suiv!=NULL){
cour=cour->suiv;}
cour->suiv=new liste ;
cour->suiv->info=x;
cour->suiv->suiv=NULL;}}
void avecsac(liste *&a,liste *b){
liste *cour=a;
while(cour->suiv!=NULL){
cour=cour->suiv;}
cour->suiv= new liste;
cour->suiv=b;}
void sanssac(liste *a,liste *b,liste *&c){
while(a!=NULL){
ajoutfin(c,a->info);
a=a->suiv;}
while(b!=NULL){
ajoutfin(c,b->info);
b=b->suiv;}}
void affaiche(liste *l){
while(l!=NULL){
cout<<"\nval:"<<l->info;
l=l->suiv;
}
}

int main()
{ liste *a=NULL,*b=NULL,*c=NULL;
int n,val;
cout <<"donnez la taille de 1er liste :";
cin>>n;
for(int i=0;i<n;i++){
cout<<"\ndonnez la valeur :";
cin>>val;
ajoutfin(a,val);

}
cout <<"donnez la taille de 2er liste :";
cin>>n;
for(int i=0;i<n;i++){
cout<<"\ndonnez la valeur :";
cin>>val;
ajoutfin(b,val);

}
affaiche(a);
cout<<"\n2eme liste :\n";
affaiche(b);
sanssac(a,b,c);
cout<<"\n 3eme liste sans sacrifice :\n";
affaiche(c);
cout<<"\n 1er liste avec sacrifice :\n";
avecsac(b,a);
affaiche(b);

return 0;
}

2-
#include <iostream>
using namespace std;
struct liste {
int info;
liste *suiv;
liste *pre;};
void affiahce(liste *l){
while(l!=NULL){
cout<<"\n val:"<<l->info;
l=l->suiv;}}
void ajoutfin(liste *&l,int x){
if(l==NULL){
l=new liste ;
l->info=x;
l->pre=NULL;
l->suiv=NULL;}
else{
liste *c=l;
while(c->suiv!=NULL){
c=c->suiv;}
c->suiv=new liste ;
c->suiv->info=x;
c->suiv->suiv=NULL;
c->suiv->pre=c;}}
void sanssacri(liste *a,liste *b,liste *&c){
while(a!=NULL){
ajoutfin(c,a->info);
a=a->suiv;}
while(b!=NULL){
ajoutfin(c,b->info);
b=b->suiv;}}
void avecsacri(liste *&a,liste *&b){
liste *c=a;
while(c->suiv!=NULL){
c=c->suiv;}
c->suiv=new liste ;
c->suiv=b;
b->pre=new liste ;
b->pre=c;}
int main()
{ liste *a=NULL,*b=NULL,*c=NULL;
int n,val;
cout<<"donnez la taille de la 1er liste :";cin>>n;
for (int i=0;i<n;i++){
cout<<"\ndonnez la val:";cin>>val;
ajoutfin(a,val);}
cout<<"donnez la taille de la 2emeliste :";cin>>n;
for (int i=0;i<n;i++){
cout<<"\ndonnez la val:";cin>>val;
ajoutfin(b,val);}
cout<<"\nla liste 1:\n";affiahce(a);
cout<<"\nla liste 2:\n";affiahce(b);
sanssacri(a,b,c);
cout<<"\nla liste 3:\n";affiahce(c);
avecsacri(a,b);
cout<<"\nla liste 1 avec sacrif:\n";affiahce(a);
return 0;}
Exercice 8:
soit une liste linéaire simple de n entiers , de tetes d1(n pair)
1-ecrire un programme c++ avec fonction permettant de partionner cette liste en deux
listes linéaires de tetes d2 et d3
a- sans sacrifier les listes originals
b-en sacrifiant les listes originales
2- reprendre la même question avec des listes linéaires bidirectionnelles
​solution exercice 8:
1-

#include <iostream>

using namespace std;

struct liste {
int info;
liste *suiv;
};
void ajoutfin(liste *&l,int x){
if(l==NULL){
l=new liste ;
l->info=x;
l->suiv=NULL;

}
else{
liste *c=l;
while(c->suiv!=NULL){
c=c->suiv;
}
c->suiv=new liste ;
c->suiv->info=x;
c->suiv->suiv=NULL;

}
}
void affaiche(liste *l){
while(l!=NULL){
cout<<"\nval:"<<l->info;
l=l->suiv;
}
}
void sanssacr(liste *a,liste *&b,liste *&c,int n){
for(int i=0;i<n/2;i++){
ajoutfin(b,a->info);
a=a->suiv;
}
for(int i=n/2;i<n;i++){
ajoutfin(c,a->info);
a=a->suiv;
}

}
void avecsacrifiant(liste *&d1,liste *&d2,int n){
liste *c=d1->suiv,*c1=d1;
d2=NULL;
for(int i=1;i<n/2;i++){
c=c->suiv;
c1=c1->suiv;
}
for(int i=n/2;i<n;i++){
ajoutfin(d2,c->info);
c=c->suiv;
}
c1->suiv=NULL;
}
int main()
{ liste *d1=NULL,*d2=NULL,*d3=NULL;
int n,val;
cout<<"donnez la taille de la liste (nombre pair) :";cin>>n;
for(int i=0;i<n;i++){
cout<<"\ndonnez la valeur :";cin>>val;
ajoutfin(d1,val);
}
cout<<"\n\t resultat sans sacrifiant \n";
cout<<"\nla liste d1 est :";
affaiche(d1);
sanssacr(d1,d2,d3,n);
cout<<"\nla liste d2 est :";
affaiche(d2);
cout<<"\nla liste d3 est :";
affaiche(d3);
cout<<"\n\t resultat avec sacrifiant \n";
avecsacrifiant(d1,d2,n);
cout<<"\nla liste d1 est :";
affaiche(d1);
cout<<"\nla liste d2 est :";
affaiche(d2);

return 0;
}
2-

#include <iostream>

using namespace std;

struct liste {
int info;
liste *suiv;
liste *pre;
};
void ajoutfin(liste *&l,int x){
if(l==NULL){
l=new liste ;
l->info=x;
l->suiv=NULL;
l->pre=NULL;

}
else{
liste *c=l;
while(c->suiv!=NULL){
c=c->suiv;
}
c->suiv=new liste ;
c->suiv->info=x;
c->suiv->suiv=NULL;
c->suiv->pre=c;

}
}
void affaiche(liste *l){
while(l!=NULL){
cout<<"\nval:"<<l->info;
l=l->suiv;
}
}
void sanssacr(liste *a,liste *&b,liste *&c,int n){
for(int i=0;i<n/2;i++){
ajoutfin(b,a->info);
a=a->suiv;
}
for(int i=n/2;i<n;i++){
ajoutfin(c,a->info);
a=a->suiv;
}
}
void avecsacrifiant(liste *&d1,liste *&d2,int n){
liste *c=d1->suiv,*c1=d1;
d2=NULL;
for(int i=1;i<n/2;i++){
c=c->suiv;
c1=c1->suiv;
}
for(int i=n/2;i<n;i++){
ajoutfin(d2,c->info);
c=c->suiv;
}
c1->suiv=NULL;
}
int main()
{ liste *d1=NULL,*d2=NULL,*d3=NULL;
int n,val;
cout<<"donnez la taille de la liste (nombre pair) :";cin>>n;
for(int i=0;i<n;i++){
cout<<"\ndonnez la valeur :";cin>>val;
ajoutfin(d1,val);
}
cout<<"\n\t resultat sans sacrifiant \n";
cout<<"\nla liste d1 est :";
affaiche(d1);
sanssacr(d1,d2,d3,n);
cout<<"\nla liste d2 est :";
affaiche(d2);
cout<<"\nla liste d3 est :";
affaiche(d3);
cout<<"\n\t resultat avec sacrifiant \n";
avecsacrifiant(d1,d2,n);
cout<<"\nla liste d1 est :";
affaiche(d1);
cout<<"\nla liste d2 est :";
affaiche(d2);

return 0;
}
 serie 2
​

exercice 1 :
ecrire une fonction c++ permettant de trier une listes linéaire simple d’entires

solution exercice 1:
#include <iostream>

using namespace std;

struct liste {
int info;
liste *suiv;
};
void ajoutfin(liste *&l,int x){
if(l==NULL){
l=new liste ;
l->info=x;
l->suiv=NULL;

}
else{
liste *c=l;
while(c->suiv!=NULL){
c=c->suiv;
}
c->suiv=new liste ;
c->suiv->info=x;
c->suiv->suiv=NULL;

}
}
void affaiche(liste *l){
while(l!=NULL){
cout<<"\nval:"<<l->info;
l=l->suiv;
}
}
void permuter(int *a,int *b ){
int tmp=*a;
*a=*b;
*b=tmp;
}
void trie(liste *&l){
liste *c1=l;
while(c1->suiv!=NULL){
liste *c2=c1->suiv;
 while(c2!=NULL){
if(c2->info < c1->info){
permuter(&c2->info,&c1->info);
}
c2=c2->suiv;
}
c1=c1->suiv;
}

}
int main()
{ liste *a=NULL;
int n,val;
cout<<"donnez la taille de la liste :";cin>>n;
for(int i=0;i<n;i++){
cout<<"\ndonnez la valeur:";
cin>>val;
ajoutfin(a,val);
}
cout<<"\n\tla liste avant le trie \n";
affaiche(a);
trie(a);
cout<<"\n\tla liste apres le trie \n";
affaiche(a);
return 0;
}

Exercice 2:
pour représenter deux polynômes , on considère deux listes linéaires de têtes p1 et p2 , ou
chaque maillon contient un exposant et le coefficient correspondant
en supposant que les listes sont triées dans l’ordre décroissant des puissances , ecrire une
fonction c++ et sont appel pour construire la listes représentant la somme des deux
polynômes

solution exercie 2:
#include <iostream>

using namespace std;

struct liste {
int coef;
int exp;
liste *suiv;
};
void ajoutfin(liste *&l,int coef,int exp){
if(l==NULL){
l=new liste ;
 l->coef=coef;
l->exp=exp;
l->suiv=NULL;

}
else{
liste *c=l;
while(c->suiv!=NULL){
c=c->suiv;
}
c->suiv=new liste ;
c->suiv->coef=coef;
c->suiv->exp=exp;
c->suiv->suiv=NULL;

}
}
void permutation(int *ex2,int *ex1,int *c2,int *c1){
int tmp=*ex2;
*ex2=*ex1;
*ex1=tmp;
tmp=*c2;
*c2=*c1;
*c1=tmp;
}
void trie(liste *&l){
liste *c1=l;
while(c1->suiv!=NULL){
liste *c2=c1->suiv;
while(c2!=NULL){
if(c2->exp<c1->exp){
permutation(&c2->exp,&c1->exp,&c2->coef,&c2->coef);
}
c2=c2->suiv;
}
c1=c1->suiv;
}}
void affaiche(liste *l){
while(l->suiv!=NULL){
if(l->coef==0){
l=l->suiv;
}
else if(l->coef==1){
cout<<"X^"<<l->exp<<"+";
l=l->suiv;}
else{
 cout<<l->coef<<"X^"<<l->exp<<"+";
l=l->suiv;}
}
if(l->coef==0){
cout<<"\n";
}
else {
cout<<l->coef;
}}
void sommepolynome(liste *p1,liste *p2,liste *&p3){
while(p1!=NULL && p2!=NULL){
if(p1->exp >p2->exp){
ajoutfin(p3,p1->coef,p1->exp);
p1=p1->suiv;
}
else if(p1->exp <p2->exp){
ajoutfin(p3,p2->coef,p2->exp);
p2=p2->suiv;
}
else {
ajoutfin(p3,p1->coef+p2->coef,p1->exp);
p1=p1->suiv;
p2=p2->suiv;
}
}
while(p1!=NULL){
ajoutfin(p3,p1->coef,p2->exp);
p1=p1->suiv;
}
while(p2!=NULL){
ajoutfin(p3,p2->coef,p2->exp);
p2=p2->suiv;
}

int main()
{ liste *p1=NULL,*p2=NULL,*p3=NULL;
int n,coef,ex;
cout<<"\t les polynome doit etre trier d'apres exercice \n";
cout<<"donnez degrés de polynome 1 :";cin>>n;
for(int i=0;i<n+1;i++){
cout<<"\ndoonez exposant:";cin>>ex;
cout<<"\ndonnez le coeff:";cin>>coef;
ajoutfin(p1,coef,ex);
}
cout<<"\npolynome 1=";
affaiche(p1);
cout<<"\ndonnez degrés de polynome 2 :";
cin>>n;
for(int i=0;i<n+1;i++){
cout<<"\ndoonez exposant:";cin>>ex;
cout<<"\ndonnez le coeff:";cin>>coef;
ajoutfin(p2,coef,ex);
}
cout<<"\npolynome 2=";
affaiche(p2);
sommepolynome(p1,p2,p3);
cout<<"\nleur somme =";

affaiche(p3);

return 0;
}

exercice 3:
sit une linéaire l contenant la description de processus (programmes ) dans un système
multi-utilisateur ,chaque processus étant décrit par une structure comportant un id (entier ) et
une priorité (entier)
struct processus {int id ;int prior;processus *suivant};
ecrire un programme c++avec fonction permettant d’effectuer les opération suivantes :
a)construire un tableau dynamique de M listes linéaires ,compos”e chacune de n processus
b)afficher toutes les listes
c)inverser toutes les listes
d) afficher toutes les listes après l’inversion
e)supprimer à partire de la première liste du tableau ,le premier processus de priorité égale
à ‘val’ donnée donnée ,s’il existe
f)afficher la première liste après l’opération de suppression

solution exercice 3:
#include <iostream>
#include <stdlib.h>
using namespace std;
struct processus{
int id;
int prior;
processus *suiv;
};
void ajoutfin(processus *&l,int id ,int pr){
if(l==NULL){
l=new processus ;
l->id=id;
 l->prior=pr;
l->suiv=NULL;

}
else{
processus *c=l;
while(c->suiv!=NULL){
c=c->suiv;
}
c->suiv=new processus ;
c->suiv->id=id;
c->suiv->prior=pr;
c->suiv->suiv=NULL;

}
}
void affaiche(processus *l){
if(l==NULL){
cout<<"proceseuse est vide ";
}
else {
while(l!=NULL){
cout<<"\nid:"<<l->id<<" prio:"<<l->prior;
l=l->suiv;
}}
}
void ajoutdebut(processus *&l,int id,int pr){
if(l==NULL){
l=new processus;
l->id=id;
l->prior=pr;
l->suiv=NULL;
}
else{
processus *n=new processus;
n->id=id;
n->prior=pr;
n->suiv=l;
l=n;
}

}
void inversion(processus *&l){
processus *tmp=NULL;
while(l!=NULL){
ajoutdebut(tmp,l->id,l->prior);
 l=l->suiv;
}
delete []l;
l=NULL;
while(tmp!=NULL){
ajoutfin(l,tmp->id,tmp->prior);
tmp=tmp->suiv;
}

}
void suprimer(processus *&l,int val){
processus *tmp=NULL;
processus *c=l;
while(c!=NULL){
if(c->prior==val){
if(c->suiv==NULL){
c=NULL;
break;}
else{
c=c->suiv;}
}
ajoutfin(tmp,c->id,c->prior);
c=c->suiv;
}
delete []l;
l=NULL;
while(tmp!=NULL){
ajoutfin(l,tmp->id,tmp->prior);
tmp=tmp->suiv;
}
}
int main()
{
processus ** tab;
int n,m,id,pr;
cout<<"donnez nombre de les listes :";
cin>>m;
tab=new processus*[m];
for(int i=0;i<m;i++){
cout<<"\ndonnez la taille de "<<i+1<<" liste :";
cin>>n;
cout<<"\nmaintenant vous devez remplire les information de "<<i+1<<" liste \n";
tab[i]=NULL;
for(int j=0;j<n;j++){
cout<<"\n donnez id:";
cin>>id;
 cout<<"\n donnez perior:";
cin>>pr;
ajoutfin(tab[i],id,pr);

}
}
system("cls");
cout<<"\t affaichage de les liste \n";
for(int i=0;i<m;i++){
cout<<"\nla liste num:"<<i+1<<" :";
affaiche(tab[i]);

}
for(int i=0;i<m;i++){
inversion(tab[i]);

}
cout<<"\n affaichage des liste apres inversion\n";
for(int i=0;i<m;i++){
cout<<"\nla liste num:"<<i+1<<" :";
affaiche(tab[i]);

}
cout<<"\ndonnez la valeur que vous voulez suprimer de la 1er liste :";
int val;
cin>>val;
cout<<"\naffaichage avant de suprimer :\n";
affaiche(tab[0]);
suprimer(tab[0],val);
cout<<"\naffaichage apres de suprimer :\n";

affaiche(tab[0]);

return 0;
}
Exercice 4:
en utilisant une représentation par listes linéaires , ecrire un programme permettant
d’effectuer les opération suivantes :
a)construire des ensembles a et b
b)trier les ensemble a et b
c)construire d=a u b
afficher les ensembles résultant à chaque étape

solution exercice 4:
#include <iostream>
#include <stdlib.h>

using namespace std;

struct ensemble{
int val;
ensemble *suiv;
};
void ajoutelement(ensemble *&l,int val){
if(l==NULL){
l=new ensemble;
l->val=val;
l->suiv=NULL;
}
else{
ensemble *c=l;
while(c->suiv!=NULL){
c=c->suiv;
}
c->suiv=new ensemble;
c->suiv->val=val;
c->suiv->suiv=NULL;
}
}
void permutation(int *a,int *b){
int tmp=*a;
*a=*b;
*b=tmp;
}
void trie(ensemble *&l){
ensemble *c1=l;
ensemble *c2;
while(c1->suiv!=NULL){
c2=c1->suiv;
while(c2!=NULL){
if(c1->val<c2->val){
permutation(&c1->val,&c2->val);
 }
c2=c2->suiv; }
c1=c1->suiv; }

}
void somme(ensemble *a,ensemble *b,ensemble *&d){
while(a!=NULL&&b!=NULL){
if(a->val >b->val){
ajoutelement(d,a->val);
a=a->suiv;
}
else if(a->val <b->val){
ajoutelement(d,b->val);
b=b->suiv;
}
else {
ajoutelement(d,b->val);
b=b->suiv;
a=a->suiv;
}
}
while(a!=NULL){
ajoutelement(d,a->val);
a=a->suiv;
}
while(b!=NULL){
ajoutelement(d,b->val);
b=b->suiv;
}

}
void affaiche(ensemble *l){
cout<<"{";
while (l!=NULL){
if(l->suiv!=NULL){
cout<<l->val<<",";
}
else{
cout<<l->val;
}
l=l->suiv;
}
cout<<"}";
}
int main()
{ ensemble *a=NULL,*b=NULL,*d=NULL;
cout<<"vous devez remplire ensemble A \ndonnez nombre des element de ensemeble :";
int n,val;
cin>>n;
for(int i=0;i<n;i++){
cout<<"\ndonnez la valeur de "<<i+1<<"element:";
cin>>val;
ajoutelement(a,val);
}
system("cls");
cout<<"vous devez remplire ensemble B \ndonnez nombre des element de ensemeble :";
cin>>n;
for(int i=0;i<n;i++){
cout<<"\ndonnez la valeur de "<<i+1<<"element:";
cin>>val;
ajoutelement(b,val);
}
system("cls");
trie(a);
trie(b);
cout<<"ensemble A=";affaiche(a);
cout<<"\nensemble B=";affaiche(b);
somme(a,b,d);
cout<<"\nensemeble D(AUB)=" ;affaiche(d);

return 0;
}
Exercice 5:
ecrire un programme avec fonctions permettant d'effectuer les opération suivantes :
a)construire une pile de n entiers (n pair)
b)afficher la pile
c)partitionner la pile en deux pile de même taille p1 t p2

répondre a la question en représentant les piles par tableaux ensuit par listes linéaires .
solution exercice 5:
-avec tabelaux
#include <iostream>
#include <stdlib.h>

using namespace std;

void affaiche(int *tab,int n){
for(int i=0;i<n;i++)
{cout <<tab[i]<<"\n";
}

int main()
{
//on vas repondre au exercice avec les tableau(1er partie)apres on repondre avec liste
liniaire
cout<<"donnez la taille de la pille :";
int n,j=0;
cin>>n;
int p1[n],p2[n/2],p3[n/2];
cout<<"\n\tvous devez remplire votre pille \n";
for(int i=0;i<n;i++)
{
cout<<"\ndonnez la valeur :";
cin>>p1[i];
}
for(int i=0;i<n/2;i++){
p2[i]=p1[i];
}
for(int i=n/2;i<n;i++){
p3[j]=p1[i];
j++;
}
system("cls");
cout<<"p1:\n";
affaiche(p1,n);
cout<<"p2:\n";
affaiche(p2,n/2);
cout<<"p3:\n";
affaiche(p3,n/2);
return 0;
}

-avec liste

#include <iostream>

using namespace std;

struct pile{
int val;
pile *suiv;
};
void ajout(pile *&l,int val){
if(l==NULL){
l=new pile;
l->suiv=NULL;
l->val=val;
}
else{
pile *c=l;
while(c->suiv!=NULL){
c=c->suiv;
}
c->suiv=new pile;
c->suiv->suiv=NULL;
c->suiv->val=val;
}

}
void affaiche(pile *l){
while(l!=NULL){
cout<<l->val<<"\n";
l=l->suiv;
}
}
void ajoutpile(pile *&p1,pile *&p2,int n){
for(int i=0;i<n;i++){
ajout(p2,p1->val);
p1=p1->suiv;
}

}
void partionner(pile *p1,pile *&p2,pile *&p3,int n){
ajoutpile(p1,p2,n/2);
ajoutpile(p1,p3,n/2);

}
int main()
{ pile *p1,*p2,*p3;
p1=p2=p3=NULL;
cout<<"donnez la taille de la pile:";
int n,val;
cin>>n;
for(int i=0;i<n;i++){
cout<<"\ndonnez la valeur:";
cin>>val;
ajout(p1,val);
}
partionner(p1,p2,p3,n);
cout<<"p1:\n";
affaiche(p1);
cout<<"\np2:\n";
affaiche(p2);
cout<<"\np3:\n";
affaiche(p3);
return 0;
}