Académique Documents
Professionnel Documents
Culture Documents
Solution Asd
Solution Asd
exercice 1:
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>
return 0;
}
exercice 2:
solution exercice 2:
-transfert par référence :
#include <iostream>
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;
}
#include <iostream>
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>
}
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>
-b
#include <iostream>
#include <stdlib.h>
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>
}
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>
}
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>
}
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>
}
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>
}
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>
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>
}
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;
}