INFORMATIQUE  
 

 
 

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    

STRUCTURES  DE  DONNEES  2  
 

 
 
 

Dr  Raymond  HOUE  NGOUNA  

Dr  Agnès  LETOUZEY  
   
  

 
EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Sommaire  

SOMMAIRE  
SOMMAIRE  ...............................................................................................................................................................  3  

CHAINES  DE  CARACTERES  ............................................................................................................................................  7  

I.   CHAINES  DE  CARACTERES  .............................................................................................................................................................  7  
II.   EN  ALGORITHMIQUE  .....................................................................................................................................................................  7  
III.   EN  LANGAGE  C  ...............................................................................................................................................................................  7  
III.1.   Déclaration  .................................................................................................................................................................................................  7  
III.2.   Quelques  fonctions  ....................................................................................................................................................................................  8  
III.3.   Exemple  d’utilisation  de  chaînes  ...............................................................................................................................................................  9  
IV.   EXERCICES  ....................................................................................................................................................................................  10  
IV.1.   Exercice  1  ..................................................................................................................................................................................................  10  
IV.2.   Exercice  2  ..................................................................................................................................................................................................  10  
IV.3.   Exercice  3  ..................................................................................................................................................................................................  10  
IV.4.   Exercice  4  ...................................................................................................................................................................................................  11  

TYPES  STRUCTURES  –  STRUCTURES   .............................................................................................................................  13  

I.   EN  ALGORITHMIQUE  ...................................................................................................................................................................  13  
II.   EN  LANGAGE  C  .............................................................................................................................................................................  13  
II.1.   Déclaration  de  types  structures  .................................................................................................................................................................  13  
II.2.   Déclaration  de  variables  de  type  structuré  ..............................................................................................................................................   14  
II.3.   Utilisation  de  variables  de  type  structuré  ................................................................................................................................................   14  
II.4.   Exemple  simple  de  manipulation  de  type  structuré  en  C  .........................................................................................................................  15  
III.   EXERCICES  ....................................................................................................................................................................................  15  
III.1.   Exercice  1  (type  personne)  .......................................................................................................................................................................  15  
III.2.   Exercice  2  (football)  .................................................................................................................................................................................  16  
III.3.   Exercice  3  (véhicule)  .................................................................................................................................................................................  17  
III.4.   Exercice  4  (compréhension)  .....................................................................................................................................................................  17  
III.5.   Exercice  5  (polygones)  .............................................................................................................................................................................  18  
III.6.   Exercice  6  (rectangles)  ............................................................................................................................................................................  18  
III.7.   Exercice  7  (langage  C)  ..............................................................................................................................................................................  18  
III.8.   Exercice  8  (langage  C,  boissons)  .............................................................................................................................................................  19  
III.9.   Exercice  9  (langage  C,  nombres  complexes)  ..........................................................................................................................................  19  
III.10.   Exercice  10  (revues)  ...............................................................................................................................................................................  19  
III.11.   Exercice  11  (magasin)  .............................................................................................................................................................................  20  
III.12.   Exercice  12  (géométrie)  .........................................................................................................................................................................  20  
III.13.   Exercice  13  (cercles)  ................................................................................................................................................................................  21  

TABLEAUX  –  ALGORITHMES  DE  TRI  ET  DE  RECHERCHE  ...................................................................................................  23  

I.   QU’EST-­‐CE  QU’UN  TABLEAU  ?  .....................................................................................................................................................  23  
II.   DECLARATION  D’UN  TABLEAU  ET  ACCES  A  UN  ELEMENT  D’UN  TABLEAU  .............................................................................  24  
II.1.   En  algorithmique  .......................................................................................................................................................................................  24  
II.2.   En  langage  C  ..............................................................................................................................................................................................  24  
III.   INITIALISATION  D’UN  TABLEAU  .................................................................................................................................................  25  
III.1.   En  algorithmique  ......................................................................................................................................................................................  25  
III.2.   En  langage  C  .............................................................................................................................................................................................  25  
IV.   REMARQUES  ................................................................................................................................................................................  26  

    Page  3  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Sommaire  

V.   EXEMPLES  ....................................................................................................................................................................................  27  

V.1.   Tableaux  unidimensionnels  .......................................................................................................................................................................  27  
V.2.   Tableaux  multidimensionnels  ...................................................................................................................................................................  29  
VI.   EXERCICE  ......................................................................................................................................................................................  31  
VI.1.   Exercice    (entées  sorties,  extremas,  réarrangement  d’un  tableau)  .......................................................................................................  31  
VI.2.   Exercice  (fusion,  éclatement  de  tableaux)  ..............................................................................................................................................  31  
VI.3.   Exercice  (Compréhension)  ........................................................................................................................................................................  31  
VI.4.   Exercice  (Compréhension)  .......................................................................................................................................................................  32  
VI.5.   Exercice  (entées  sorties,  réarrangement  d’un  tableau)  .........................................................................................................................  32  
VI.6.   Exercice  (Ajout,  retraits  dans  un  tableau  trié)  ........................................................................................................................................  32  
VI.7.   Exercice  (manipulation  de  tableaux)  ......................................................................................................................................................  33  
VI.8.   Exercice    (fusion  de  tableaux  tries)  .........................................................................................................................................................  33  
VI.9.   Exercice  (polynômes)  ...............................................................................................................................................................................  33  
VI.10.   Exercice  (recherche  dans  un  tableau  de  chaînes  de  caractères)  .........................................................................................................  34  
VI.11.   Exercice  (tableaux  à  2  dimensions,  recherche  d’éléments)  .................................................................................................................  34  
VI.12.   Exercice  (tableaux  de  structures  –  compréhension)  ...........................................................................................................................  34  
VI.13.   Exercice  (tableaux  de  structures  –  dates)  ............................................................................................................................................  34  
VI.14.   Exercice  (tableaux  à  2  dimensions,  jeu  d’échecs)  ................................................................................................................................  35  
VI.15.   Exercice  (tableaux  de  structures  –  compréhension)  ...........................................................................................................................  35  
VI.16.   Exercice   ..................................................................................................................................................................................................  35  
VI.17.   Exercice  (tableaux  de  structures)  .........................................................................................................................................................  36  
VI.18.   Exercice  (tableaux  de  structures)  .........................................................................................................................................................  36  
VI.19.   Exercice  (structures  –  tableaux  de  structures  –  géométrie)  ...............................................................................................................  37  
VI.20.   Exercice  (structures  –  tableaux  de  structures  –  revue)  .......................................................................................................................  37  
VI.21.   Exercice  (structures  –  tableaux  de  structures  –  magasin)  ...................................................................................................................  38  
VI.22.   Exercice  22  (structures  –  tableaux  de  structures  –  polygones)  ...........................................................................................................  38  

MODULARITE  ......................................................................................................................................................  39  

I.   GENERALITE  ................................................................................................................................................................................  39  
I.1.   Intérêts  ........................................................................................................................................................................................................  39  
I.2.   Bibliothèques  ..............................................................................................................................................................................................  39  
I.3.   Familles  de  modules  ...................................................................................................................................................................................  39  
II.   APPELS  DE  MODULES  .................................................................................................................................................................  40  
II.1.   Eléments  d’appels  de  modules  .................................................................................................................................................................  40  
II.2.   Principe  de  communication  ......................................................................................................................................................................  42  
III.   DECLARATONS  DE  MODULES  .....................................................................................................................................................  43  
III.1.   Cas  des  modules  appartenant  a  une  bibliothèque  .................................................................................................................................  44  
III.2.   En-­‐tête  ......................................................................................................................................................................................................  44  
III.3.   Corps  .........................................................................................................................................................................................................  46  
III.4.   Exemples  ..................................................................................................................................................................................................  46  
III.5.   Où  déclarer  les  modules  ..........................................................................................................................................................................  49  
IV.   EXERCICES  ....................................................................................................................................................................................  51  
IV.1.   EXERCICE  1  .................................................................................................................................................................................................  51  
IV.2.   EXERCICE  2  .................................................................................................................................................................................................  51  
IV.3.   EXERCICE  3  ................................................................................................................................................................................................  52  
IV.4.   EXERCICE  4  ...............................................................................................................................................................................................  52  
IV.5.   EXERCICE  5  ................................................................................................................................................................................................  53  
IV.6.   EXERCICE  6  ...............................................................................................................................................................................................  54  
IV.7.   EXERCICE  7  ................................................................................................................................................................................................  54  
IV.8.   EXERCICE  8  ...............................................................................................................................................................................................  55  
IV.9.   EXERCICE  9  ...............................................................................................................................................................................................  55  

    Page  4  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Sommaire  

IV.10.   EXERCICE  10  ............................................................................................................................................................................................  55  

IV.11.   EXERCICE  11  .............................................................................................................................................................................................  56  
IV.12.   EXERCICE  12  ............................................................................................................................................................................................  57  
IV.13.   EXERCICE  13  ............................................................................................................................................................................................  58  
IV.14.   EXERCICE  14  ............................................................................................................................................................................................  59  
IV.15.   EXERCICE  15  ............................................................................................................................................................................................  60  
IV.16.   EXERCICE  16  ............................................................................................................................................................................................  61  
IV.17.   EXERCICE  17  ............................................................................................................................................................................................  62  
IV.18.   EXERCICE  18  ............................................................................................................................................................................................  63  
V.   MODULES  RECURSIFS  ................................................................................................................................................................  64  
V.1.   Remarques  sur  les  modules  récursifs  .......................................................................................................................................................  64  
V.2.   Structure  générale  d’un  module  récursif  .................................................................................................................................................  65  
V.3.   Exemples  de  sous-­‐programmes  récursifs  .................................................................................................................................................  67  
VI.   EXERCICES  ...................................................................................................................................................................................   70  
VI.1.   EXERCICE  1  ................................................................................................................................................................................................  70  
VI.2.   EXERCICE  2  ................................................................................................................................................................................................  70  
VI.3.   EXERCICE  3  ................................................................................................................................................................................................  70  
VI.4.   EXERCICE  4  ................................................................................................................................................................................................  71  
VI.5.   EXERCICE  5  .................................................................................................................................................................................................  71  
VI.6.   EXERCICE  6  ................................................................................................................................................................................................  71  
VI.7.   EXERCICE  7  .................................................................................................................................................................................................  71  
VI.8.   EXERCICE  8  ................................................................................................................................................................................................  71  
VII.   EXERCICE  GENERAL  .....................................................................................................................................................................  72  

FICHIERS  ................................................................................................................................................................  73  

I.   DECLARATION  D'UNE  VARIABLE  FICHIER  ..................................................................................................................................  73  
II.   LIEN  ET  OUVERTURE  D'UN  FICHIER  PHYSIQUE  .........................................................................................................................  73  
III.   ACCES  AUX  INFORMATIONS  CONTENUES  DANS  LES  FICHIERS  ...............................................................................................  74  
III.1.   Fichiers  binaires  ........................................................................................................................................................................................  74  
III.2.   Fichiers  texte  ............................................................................................................................................................................................  75  
III.3.   Fin  de  fichier  .............................................................................................................................................................................................  76  
III.4.   Fermeture  du  fichier  ................................................................................................................................................................................  76  
IV.   EXERCICES  ....................................................................................................................................................................................  77  
IV.1.   EXERCICE  1  ................................................................................................................................................................................................  77  
IV.2.   EXERCICE  2  ................................................................................................................................................................................................  78  
IV.3.   EXERCICE  3  ................................................................................................................................................................................................  79  
IV.4.   EXERCICE  4  ...............................................................................................................................................................................................  79  
IV.5.   EXERCICE  5  ................................................................................................................................................................................................  80  
IV.6.   EXERCICE  6  ...............................................................................................................................................................................................  80  
IV.7.   EXERCICE  7  ................................................................................................................................................................................................  81  
IV.8.   EXERCICE  8  ...............................................................................................................................................................................................  82  
IV.9.   EXERCICE  9  ...............................................................................................................................................................................................  82  

TYPES  DE  DONNEES  ABSTRAITS  .................................................................................................................................  83  

I.   GENERALITES  ..............................................................................................................................................................................  83  
I.1.   Introduction  ................................................................................................................................................................................................  83  
I.2.   Spécification  de  Feu   ...................................................................................................................................................................................  84  
I.3.   Définition  d'un  TDA  ....................................................................................................................................................................................  85  
I.4.   Spécification  d'un  TDA  ...............................................................................................................................................................................  85  
II.   TDA  PILES  ....................................................................................................................................................................................  85  

    Page  5  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Sommaire  

II.1.   Définition  ...................................................................................................................................................................................................  85  

II.2.   Spécification  d'un  TDA  Pile  .......................................................................................................................................................................  86  
II.3.   Programmation  .........................................................................................................................................................................................  87  
III.   TDA  FILES  ....................................................................................................................................................................................  89  
III.1.   Définitions  ................................................................................................................................................................................................  89  
III.2.   Spécification  d'un  TDA  File  ......................................................................................................................................................................  90  
III.3.   Programmation  ........................................................................................................................................................................................  91  
IV.   EXERCICES  ...................................................................................................................................................................................  95  
IV.1.   EXERCICE  1  ................................................................................................................................................................................................  95  
IV.2.   EXERCICE  3  ................................................................................................................................................................................................  95  
IV.3.   EXERCICE  2  ................................................................................................................................................................................................  96  
IV.4.   EXERCICE  4  ...............................................................................................................................................................................................  96  
IV.5.   EXERCICE  6  ...............................................................................................................................................................................................  96  
IV.6.   EXERCICE  8  ...............................................................................................................................................................................................  96  
IV.7.   EXERCICE  5  –  Calculatrice  élémentaire  à  pile  ..........................................................................................................................................  97  
IV.8.   EXERCICE  7  ................................................................................................................................................................................................  98  
IV.9.   EXERCICE  10  ..............................................................................................................................................................................................  98  
IV.10.   EXERCICE  11  .............................................................................................................................................................................................  98  
IV.11.   EXERCICE  13  ............................................................................................................................................................................................  98  
IV.12.   EXERCICE  9  ...........................................................................................................................................................................................  100  
IV.13.   EXERCICE  12  ...........................................................................................................................................................................................  101  
IV.14.   EXERCICE  14  ...........................................................................................................................................................................................  102  
IV.15.   EXERCICE  15  ...........................................................................................................................................................................................  103  

   

    Page  6  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Chaînes  de  caractères  

CHAINES  DE  CARACTERES  

I.   CHAINES  DE  CARACTERES  

On   appelle   chaîne   de   caractères   un   ensemble   ordonné   de   caractères   dont   le   nombre   peut   varier   au   cours   du   temps.   Il   existe   un  
mécanisme   automatique   de   mémorisation   de   ce   nombre,  il   est   toujours   possible   de   savoir,   à   n’importe   quel   instant,   la   longueur  
effective  de  la  chaîne  de  caractères.  

II.   EN  ALGORITHMIQUE  
La  déclaration  d’une  variable  chaîne  de  caractères  se  fait  de  la  façon  suivante  :  
Chaîne nom_variable
On  peut  saisir  ou  afficher  le  contenu  d’une  variable  de  type  chaîne  à  l’aide  des  instructions  saisir  et  afficher.  
On  peut  accéder  à  chaque  caractère  d’une  variable  de  type  chaîne  en  spécifiant  la  position  de  ce  caractère.  Pour  des  raisons  de  
simplicité   de   traduction   en   langage   C,   le   premier   caractère   se   trouve   en   position   0.   Il   est   aussi   possible   d’extraire   une   partie  
d’une  chaîne  de  caractères,  à  l’aide  de  la  primitive  sous-­‐chaîne.  Les  opérateurs  de  comparaison  :  =, ≠, <, ≤, >, ≥  sont  utilisables  ;  la  
relation  d’ordre  est  l’ordre  alphabétique.    L’opérateur  + permet  de  concaténer  deux  chaines  (mettre  bout  à  bout).  
Soit la déclaration suivante,
Chaîne nom
Alors
nom [ i ] :
désigne le i+1ième caractère de la chaîne nom.
sous-chaîne ( nom , i , j) :
désigne la chaîne contenue dans la chaîne nom, commençant au i+1ième caractère de nom et contenant j caractères.
long (nom ) :
indique le nombre de caractères de la chaîne nom.

III.   EN  LANGAGE  C  

III.1.   DECLARATION  
En   C++,   il   existe   un   type   permettant   de   manipuler   de   façon   simple   des   chaines   de   caractères  :   affectation,   concaténation,  
recherche  de  sous-­‐chaînes,  insertion  ou  suppression  de  sous-­‐chaines…  ce  type  est  le  type  string.  Une  variable  (ou  un  objet)  
de  type  string  contient  une  suite  de  caractères,  le  nombre  de  ces  caractères  peut  évoluer  au  cours  de  l’exécution.  
Comme   toute   autre   variable   on   peut   déclarer   seulement   ou   déclarer   et   initialiser.   Les   diverses   syntaxes   sont   illustrées   ci-­‐
dessous.    
string ch ; // déclaration seule, taille de la chaine = 0
string nombis="chats" ; // affectation de chats
string ch1("Bonjour chez vous") ; // affectation de Bonjour chez vous
string ch2(10,'*') ; // affectation d’une suite de 10 *
string ch3(nombis); // affectation de nombis

    Page  7  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Chaînes  de  caractères  

III.2.   QUELQUES  FONCTIONS  

III.2.1.   Longueur  :  
On  accède  aux  nombres  de  caractères  de  la  chaîne  par  l’intermédiaire  des  fonctions  size()  ou  length()  
cout << nombis.size() << endl; // affiche 5
cout << ch1.size() << endl ; // affiche 17
cout << ch2.length() << endl ; // affiche 10
cout << ch3.length() << endl ; // affiche 5

III.2.2.   Accès  à  un  caractère  :  

On  accède  au  caractère  d’une  chaîne  en  position  i+1  par  la  fonction at(i).  
cout << nombis.at(2) << endl; // affiche a
cout << nombis.at(nombis.size()-1) << endl ; // affiche s

III.2.3.   Saisie  au  clavier  d’une  chaîne  de  caractères  :  

On   peut   utiliser   cin   pour   une   chaîne   ne   contenant   pas   d’espace   ou   de   séparateur.   Pour   une   chaîne   contenant   des   espaces,   on  
peut  utiliser  getline(cin, ch),  il  faut  alors  faire  attention  aux  caractères  «  passer  à  la  ligne  »  qui  pourraient  rester  dans  le  
buffer  clavier.  
cout << "donnez une chaine sans espace : ";
cin >> ch; // saisie de ch
cout << ch << " contient " << ch.size() <<" caracteres\n";
 
cout << "donnez une chaine avec espace : ";
do {
getline(cin, ch); // saisie de ch, mais on peut mettre des espaces
} while (ch.size()==0);
cout << ch << " contient " << ch.size() <<" caracteres\n";

III.2.4.   Opérations  diverses  :  

 Concaténation  :  +,  +=  
 Comparaison  :  ==,  <,  >,  <=,  >=,  !=  
 Recherche   la   position   de   la   première   occurrence   de   val   (string ou char)   dans   la   chaîne   ch  :   ch.find(val).  
Retourne  une  valeur  négative  ou  supérieure  à  la  longueur  de  ch  si  val  n’est  pas  trouvé.  
 Recherche   la   position   de   la   dernière   occurrence   de   val   (string ou char)   dans   la   chaîne   ch  :   ch.rfind(val).  
Retourne  une  valeur  négative  ou  supérieure  à  la  longueur  de  ch  si  val  n’est  pas  trouvé.  
 Insertion  de  val  (string)  dans  la  chaîne  ch,  à  la  position  pos  :  ch.insert(pos,val).  
 Insertion  de  val  (char)  dans  la  chaîne  ch,  à  la  position  pos  :  ch.insert(pos,1,val).  
 Insertion  de  val  (char)  nb  fois  dans  la  chaîne  ch,  à  la  position  pos  :  ch.insert(pos,nb,val).  
 Suppression  de  nb caractères  de  la  chaîne  ch,  à  partir  de  la  position  pos  :  ch.erase(pos,nb).  
 Suppression  de  tous  les  caractères  de  la  chaîne  ch  à  partir  de  la  position  pos  :  ch.erase(pos).  
 Remplacement  des  nb  caractères  commençant  à  la  position  pos  de  la  chaîne  ch  par  la  chaîne val :  ch.replace(pos,
nb, val).  La  fin  de  la  chaine  est  décalée  si  nécessaire.  
 Remplacement   des   nb   caractères   commençant   à   la   position   pos   de   la   chaîne   ch   par   mb   fois   le   caractère   val :  
ch.replace(pos, nb, mb, val).  La  fin  de  la  chaine  est  décalée  si  nb ≠ mb.  
 Extraction   des   nb   caractères  (ou  moins  si  la   fin   de   chaîne   est   atteinte)   commençant   à   la   position  pos   de   la   chaîne   ch (ch
n’est  pas  modifiée) :  ch.substr(pos, nb).  
 

    Page  8  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Chaînes  de  caractères  

#include <string>
string nom="bonjour", nombis ;

nombis = nom ; // copie la chaîne nom dans la chaîne nombis

nombis = nom + " chez" //on ne peut ajouter qu’une chaîne constante à la fois
nombis += " vou" ;
nombis += 's' ; // on ne peut ajouter qu’un caractère à la fois

cout << nombis.find("jour") << endl ; // affiche 3

cout << nombis.find('o') << endl ; // affiche 1
cout << nombis.rfind('o') << endl ; // affiche 14
cout << nombis.rfind('a') << endl ; // affiche une valeur < 0 ou > 17
cout << nombis.find(nom) << endl ; // affiche 0

nombis.insert(7," de");

nombis.erase(7,3);
nombis.erase(7);

nombis.replace(3, 3, "soi") ;.
nombis.replace(3, 2, "ne nuit") ;

nombis = nom.substr(4, 12) ;

cout << nom.substr(3, 1) << endl; // affiche j

III.3.   EXEMPLE  D’UTILISATION  DE  CHAINES    

début #include <iostream>
using namespace std ;
#include <string>
Variables main()
Chaine verbe, conjug {
string verbe, conjug;
cout <<"Entrer un verbe du 1 groupe : ";
Afficher "Donnez un verbe du 1er groupe " cin >> verbe ;
Saisir verbe conjug=verbe;
conjug.erase(conjug.size()-2);
cout <<"je " << conjug + "e"<< endl ;
conjug ← sous-chaîne( verbe , 0, long(verbe) – 2 ) cout <<"tu " << conjug + "es" << endl ;
cout <<"il " << conjug + "e"<< endl ;
cout <<"nous " << conjug + "ons" << endl ;
Afficher " je ", conjug + "e" cout <<"vous " << conjug + "ez" << endl ;
cout <<"ils " << conjug + "ent" << endl ;
}
Afficher " tu ", conjug + "es" Modifiez  ce  programme  pour  qu’il  :  
• Vérifie  que  le  verbe  saisi  est  du  1er  groupe,  
• Traite   les   cas   particuliers   des   verbes   tels   que   les   verbes   en   –
Afficher " il ", conjug + "e"
cer,  –ger  
• Traite   les   autres   cas   particuliers   (Cf.   wiktionnaire  :  
Afficher " nous ", conjug + "ons" http://bit.ly/attCU9  ou  wikipédia  :  http://bit.ly/aoLDpF)  
 
Afficher " vous ", conjug + "ez"

Afficher " ils ", conjug + "ent"

fin

    Page  9  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Chaînes  de  caractères  

IV.   EXERCICES  

IV.1.   EXERCICE  1  
Ecrivez  un  programme  permettant  à  l'utilisateur  de  saisir  un  mot  au  clavier,  puis  affiche  le  mot  au  pluriel.  
Utilisez  les  règles  suivantes  (Cf.  espacefrancais.com:  http://bit.ly/ejEifZ):  
1. On  forme  généralement  le  pluriel  des  noms  en  ajoutant  un  s  au  singulier.  
Exemple  :  Le  chien  ¢  les  chiens.  
2. Les  noms  en  -­‐au,  -­‐eau,  -­‐eu  prennent  un  x  au  pluriel.  
Exemple  :  Un  tuyau  ¢  des  tuyaux,  le  seau  ¢  les  seaux...  
Exceptions  :  Quatre  noms  :  landau,  sarrau,  bleu,  pneu  font  exception  et  prennent  un  s  :  les  landaus,  les  sarraus,  les  bleus,  
les  pneus.  
3. Les  noms  en  -­‐ou  prennent  un  s  au  pluriel.  
Exemple  :    Le  verrou  ¢  les  verrous.  
Exceptions  :  Sept  noms:  bijou,  caillou,  chou,  genou,  hibou,  joujou,  pou  font  exception  et  prennent  x  au  pluriel.      
4. Les  noms  en  -­‐ail  prennent  un  s  au  pluriel.  
Exemple  :  Le  chandail  ¢  les  chandails.  
Exceptions  :  Sept  noms  :  bail,  corail,  émail,  soupirail,  travail,  vantail,  vitrail  font  exception  et  changent  -­‐ail  en  -­‐aux  (sans  
e).  
5. Les  noms  en  -­‐al  font  leur  pluriel  en  -­‐aux  (sans  e).  
Exemple  :  Le  cheval  ¢  les  chevaux,  le  mal  ¢  les  maux.  
Exceptions  :  Quelques  noms  :  bal,  carnaval,  chacal,  festival,  récital,  régal  font  exception  et  prennent  un  s  au  pluriel.  
Seul  idéal  fait  idéals  ou  idéaux.  
6. Les  noms  terminés  par  s,  x  ou  z  au  singulier  ne  changent  pas  au  pluriel.  
Exemple  :  le  poids  ¢  les  poids,  le  silex  ¢  les  silex,  le  nez  ¢  les  nez.  
Attention,  vous  traiterez  les  règles  au  fur  et  à  mesure,  dans  l’ordre  qui  vous  semble  le  plus  simple.  En  particulier,  vous  avez  
intérêt  à  commencer  par  la  règle  6.  

Testez  votre  programme  au  fur  et  à  mesure  de  la  prise  en  compte  des  règles.  

IV.2.   EXERCICE  2  
On   souhaite   effectuer   la   saisie   d’une   information   à   crypter.   Pour   recueillir   cette   information   on   utilise une   chaîne   de   caractères  
appelée  Phrase.    

Écrire   un   programme   permettant   la   saisie   par   l’utilisateur   d’une   chaîne   de   caractères   qui   sera   stockée   dans   la  
variable  Phrase,  puis  affiche  le  nombre  de  caractères  de  la  chaîne  saisie,  et  enfin  affiche  chaque  caractère  de  
cette  chaîne  en  les  séparant  par  des  espaces.  
On  souhaite  effectuer  un  cryptage  simple  de  l’information  contenue  dans  la  variable  Phrase.  On  supposera  ici  que  la  phrase  ne  
contient   que   des   lettres   minuscules   (de   a   à   z)   et   des   espaces.   On   transformera   chaque   caractère   de   la   manière   suivante   :   le  
caractère   ’a’   est   transformé   en   ’b’,   ’b’   est   transformé   en   ’c’,   ’c’   est   transformé   en   ’d’,   .   .   .   ,   ’z’   est   transformé   en   ’a’.   Les  
caractères  espace  (’  ’)  ne  sont  pas  transformés.  

En  enrichissant  le  programme  écrit  précédemment,  écrire  un  programme  qui  réalise  cette  transformation.  

IV.3.   EXERCICE  3  
Ecrire   un   programme   permettant   à   l'utilisateur   de   saisir   un   mot   au   clavier,   puis   affiche   si   ce   mot   est   un  
palindrome  ou  non  (un  palindrome  est  un  mot  identique  dans  les  deux  sens  de  lecture  :  ressasser,  radar,  etc.).  

    Page  10  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Chaînes  de  caractères  

IV.4.   EXERCICE  4  
Ecrire  un  programme  permettant  à  l'utilisateur  de  saisir  deux  mots  au  clavier,  puis  affiche  si  ces  deux  mots  
sont   des   anacycliques   ou   non   (un   anacyclique   est   un   mot   pouvant   se   lire   dans   les   deux   sens   :   noel   et   leon,  
ressac  et  casser,  etc.).  
   

    Page  11  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Chaînes  de  caractères  

    Page  12  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Types  structurés  –  structures  

TYPES  STRUCTURES  –  STRUCTURES  

La  conception  de  programmes  peut  exiger  l'emploi  d'informations  agrégées  ou  juxtaposées.  Ces  informations  peuvent  être  de  
natures  différentes,  c’est-­‐à-­‐dire  de  types  différents.  Pour  autant,  on  peut  souhaiter  les  regrouper  sous  un  même  nom  car  elles  
représentent   un   «  tout  ».   C’est   le   cas,   par   exemple,   d’informations   sur   une   personne   regroupant   son   nom,   son   prénom,   son  
adresse,  son  numéro  de  téléphone  …  
La   plupart   des   langages   de   programmation   structurée   permettent   la   représentation   de   tels   regroupements   qui   sont   appelés  
structures,  articles  ou  encore  enregistrements.  Un  nouveau  type  de  données  est  alors  créé.    

I.   EN  ALGORITHMIQUE  
Le  type   article  ou  structure  permet  donc  de   désigner   sous   un   même   nom   des   données   de   type   différent.    Lors  de  sa  déclaration,  
on   nommera   chacun   des   éléments   appelés   champs   de   la   structure.   L’accès   aux   éléments   d’une   variable   structurée   se   fait   par   la  
désignation   du   nom   du   champ.   Par   exemple,   on   peut   représenter   l’ensemble   des   caractéristiques   de   clients   d’une   entreprise  
par  le  type  article  suivant  :  
type structuré unclient début
Chaîne : nom
Entier : age
Réel : remise
fin
On  pourra  ensuite  déclarer  des  variables  de  type  structuré  unclient,  par  exemple,  si  monsieur  est  une  variable  de  type   unclient,  
on  effectuera  la  déclaration  suivante  :  unclient  monsieur.    
nom, age  et  remise  sont  les  champs  auxquels  on  peut  avoir  accès  simplement  en  les  nommant.  Sur  l’exemple  de  déclaration  de  
variable   précédent,   on   aura   accès   à   la   remise   concédée   au   client   monsieur   en   écrivant   monsieur.remise.   La   notation   utilisée   ici  
pour  désigner  les  champs  (point  .)  n’est  pas  la  seule  existante.  
Attention  :    
Il  ne  faut  pas  confondre  le  type  et  les  variables.  Dans  l’exemple  précédent,  unclient  est  un  nom  de  type,  qui  s’apparente  à  entier  ou  
réel  ou  …  Pour  manipuler  des  données  de  ce  nouveau  type,  il  faut  les  déclarer.  

II.   EN  LANGAGE  C  

II.1.   DECLARATION  DE  TYPES  STRUCTURES    

Les   types   structurés   permettent   donc   de   créer   un   nouveau   type   de   données   composé   de   l’agrégation   de   données  
(d’informations,  d’éléments)  de  types  différents  (ou  identiques  par  extension  !).    
L’accès  à  chacun  des  éléments  de  la  structure,  appelés  champs  ou  membres,  se  fait  par  leur  nom  au  sein  de  la  structure.  
La  forme  générale  de  déclaration  de  types  structurés  en  C  est  la  suivante  :  
struct nom_du_type_structure
{
type1 nom_champ1;
type2 nom_champ2;
…
typeN nom_champN;
} ;
Dans   cette   déclaration   struct   est   un   mot   clé   réservé   dont   la   présence   est   obligatoire   pour   identifier   les   structures   ayant  
l'étiquette   nom_du_type_structure.  Ce  mot  clé  n’est  obligatoire  que  lors  de  la  définition  du  type  structuré,  lors  de  l’utilisation  
du  type,  il  est  possible  de  l’omettre.  

    Page  13  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Types  structurés  –  structures  

Le  nouveau  type  de  données  créé  a  pour  nom  :  nom_du_type_structure.  

Généralement   les   structures   sont   déclarées   dans   la   partie   réservée   à   la   définition   de   types   située   avant   la   déclaration   du   main  
(ou   des   fonctions),   juste   après   les   directives   de   compilation   (lignes   commençant   par   #).   Elles   peuvent   aussi   être   définies  
localement  en  début  de  bloc  d'instructions  avant  la  déclaration  des  variables  locales  au  bloc.  
Chaque  champ  ou  membre  peut  avoir  comme  type  tout  type  prédéfini  ou  tout  type  défini  précédemment.  Ceci  signifie  qu'un  
ou  plusieurs  champs  d'une  structure  peuvent  être  des  structures.  Les  champs  peuvent  également  être  des  tableaux  (Cf  §  
Tableaux  –  Algorithmes  de  tri  et  de  recherche).  
Les  champs  d’une  structure  ne  peuvent  pas  être  du  type  de  la  structure  que  l’on  est  en  train  de  définir.  
Exemples  :  
struct date ou   struct  date    
{ { int jour ;
int jour, mois, annee ;  
int mois ;
} ;   int annee ;
  } ;
struct eleve struct eleve
{ ou  
{ string nom ;
string nom, prenom;   string prenom;
date naissance ; date naissance ;
float moyenne, notes ;  
float moyenne ;
int classement;   float notes ;
} ;   int classement;
  } ;
struct eleve struct eleve
{   { string nom ;
string nom, prenom;
ou   string prenom;
struct date naissance ; struct date naissance ;
float moyenne, notes ; float moyenne ;
int classement; float notes ;
} ; int classement;
} ;

II.2.   DECLARATION  DE  VARIABLES  DE  TYPE  STRUCTURE  

Etant   donné   que   nous   avons   créé   un   nouveau   type,   il   est   possible   de   l’utiliser   comme   n’importe   quel   autre   type   prédéfini   usuel  
(int, char…).  Tout  ce  qui  s’applique  aux  variables  «  classiques  »  va  donc  s’appliquer  aux  variables  de  type  structuré.    
Si  type_structure  a  été  préalablement  défini,    la  syntaxe  de  déclaration  en  C  est  la  suivante  :  
Cas  de  la  déclaration  d’une  seule  variable  
struct type_structure nom_var;
ou   type_structure  nom_var;  
Cas  de  la  déclaration  de  plusieurs  variables  
struct type_structure nom_var1, …, nom_varN ;
ou   type_structure      nom_var1,  …,  nom_varN  ;  
Cas  de  l’initialisation  au  cours  de  la  déclaration  d’une  seule  variable  
struct type_structure nom_var={valeur_champ1,…,valeur_champN};
ou   type_structure      nom_var={valeur_champ1,valeur_champ2,…,valeur_champN};  
On  peut  aussi  déclarer  la  structure  et  les  variables  simultanément  comme  le  montre  l'exemple  suivant  :  
struct eleve
{ string nom, prenom;
date naissance ;
float moyenne, notes;
int classement;
} tempo, alpha, beta ;

II.3.   UTILISATION  DE  VARIABLES  DE  TYPE  STRUCTURE  

II.3.1.   Affectation  globale  

Il  est  possible  d'affecter  tous  les  champs  d'une  variable  de  type  structuré  à  une  autre  variable  du  même  type  structuré.    

    Page  14  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Types  structurés  –  structures  

Si on déclare les deux variables suivantes : date d1, d2 = { 10, 5, 2002 } ;

On peut effectivement faire d1 = d2 ;
On peut aussi faire eleve e1, e2;
e1=e2;

II.3.2.   Saisie  et  affichage  

La  saisie  et  l'affichage  doivent  être  effectués  valeur  de  type  simple  par  valeur  de  type  simple  (champ  par  champ).

II.3.3.   Accès  aux  champs  

L’accès  aux  champs  d’une  variable  structurée  se  fait  par  l’intermédiaire  de  l’opérateur   . (point).  
Soit la variable :
struct eleve tempo ; // ou struct eleve tempo ;
tempo.moyenne
désigne le contenu du champ moyenne de la variable structurée tempo, c’est un réel ;
tempo.nom
désigne le contenu du champ nom de la variable structurée tempo, c’est une chaîne ;
tempo.naissance
désigne le contenu du champ naissance de la variable tempo, c’est une date ;
tempo.naissance.jour
désigne le contenu du champ jour de la variable tempo.naissance, c’est un entier ;
tempo.classement
désigne le contenu du champ classement de la variable tempo, c’est un entier ;
…

II.4.   EXEMPLE  SIMPLE  DE  MANIPULATION  DE  TYPE  STRUCTURE  EN  C  

#include <iostream>
using namespace std;
struct date { int j, m, an ; };
main()
{ date aujourdhui = {23, 07, 2010}, hier, demain;
// Traitement simple sur les structures
hier = demain = aujourdhui ;
hier.j = aujourdhui.j - 1 ;
demain.j = aujourdhui.j + 1 ;
cout << "\n Demain nous serons le : " << demain.j ;
cout << '/' << demain.m << '/' << demain.an ;
}

III.   EXERCICES  

III.1.   EXERCICE  1  (TYPE  PERSONNE)  

On  manipule  dans  cette  question  des  données  sur  des  personnes  représentées  par  le  type  suivant  :    
Type structuré QuelquUn Début
Chaine Nom / Nom de la personne
Caractère Situation / Personne mariée ou pacsée : M ; Autres cas : A
Entier NbE / Nombre d’enfants à charge

    Page  15  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Types  structurés  –  structures  

Fin
Le   nombre   de   parts   retenu   pour   le   calcul   de   l’impôt   sur   le   revenu   (cas   général   simplifié)   est   calculé   en   utilisant   les   règles  
suivantes  :  
 Pour  une  personne  mariée  ou  pacsée  le  nombre  de  parts  est  de  2,  dans  les  autres  situations,  le  nombre  de  parts  est  de  
1.  
 Les  deux  premiers  enfants  conduisent  à    une  demi-­‐part  supplémentaire  chacun,  les  suivants  une  part  supplémentaire.  
Ainsi,  une  personne  mariée  avec  deux  enfants  à  charge  dispose  de  3  parts,  une  personne  célibataire  avec  un  enfant  à  charge  
dispose  de  1.5  part,  une  personne  mariée  avec  trois  enfants  à  charge  dispose  de  4  parts…  

Ecrire   un   algorithme   puis   le   programme   C   qui   saisit   les   informations   associées   à   une   personne,   calcule   son  
nombre  de  parts  et  affiche  son  nom  suivi  d’un  message  indiquant  le  nombre  de  parts.  

III.2.   EXERCICE  2  (FOOTBALL)  

On   manipule   dans   cette   question   des   équipes   de   footbal   représentées   par   leur   nom,   le   nombre   de   points   obtenus   en  
championnat,  et  la  différence  de  score  cumulée  sur  l’ensemble  des  matchs  joués,  grâce  au  type  suivant  :    
Type structuré Equipe Début
Chaine Nom / Nom de l’équipe
Entier Pts / Nombre de points en championnat
Entier Diff / Différence cumulée
Fin
Une   équipe   marque   4,   2   ou   0   points   au   classement   du   championnat,   respectivement   lorsqu'elle   remporte,   fait   match   nul   ou  
perd   un   match.   En   outre     un   point   de   bonus   défensif   est   octroyé   à   toute   équipe   battue   par   un   écart   inférieur   ou   égal   à   sept  
points,  et  un  point  de  bonus  offensif  est  accordé  à  une  équipe  qui  inscrit  trois  essais  de  plus  que  son  adversaire.  
Exemple  :  Si  Tarbes  a  12  points  et  une  différence  de  -­‐5,  Pau  14  points  et  une  différence  de  -­‐1,  et  si  Pau  bat  Tarbes  18-­‐13,  Pau  ayant  
marqué  3  essais  contre  1  à  Tarbes,  alors  Tarbes  passera  à  13  points  (1  point  de  bonus  défensif)  et  sa  différence  passera  à  -­‐10  (-­‐5  +  
-­‐5),  et  Pau  passera  à  18  points  (victoire  à  4  points,  pas  de  bonus  offensif)  et  sa  différence  passera  à  +4  (-­‐1  +  +5).  

Ecrire  un  algorithme  puis  le  programme  C  qui  met  à  jour  les  informations  associées  à  deux  équipes  à  l’issue  
d’un  match  les  ayant  opposées.  Les  informations  saisies  au  clavier  seront  donc  
 nom,  nombre  de  points  et  différence  courants  des  deux  équipes  
 nombre  de  points  marqués  par  chaque  équipe  dans  le  match  
 nombre  d’essais  marqués  par  chaque  équipe  dans  le  match.  
Les  nouvelles  caractéristiques  des  deux  équipes  seront  affichées  à  l’issue  de  la  mise  à  jour.  
 

    Page  16  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Types  structurés  –  structures  

III.3.   EXERCICE  3  (VEHICULE)  

On  manipule  dans  cette  question  des  données  sur  des  véhicules  représentées  par  le  type  suivant  :    
Type structuré Vehicule Début
Chaine Marque / Nom de marque du véhicule
Réel PTAC / Poids total en charge
Entier NbP / Nombre de places
Fin
Le   permis   nécessaire   à   l’utilisation   d’un   véhicule   autre   qu’une   motocyclette   dépend   du   poids   total   autorisé   en   charge   et   du  
nombre  de    places  assises  :  
 B    :   Véhicules   dont   le   poids   total   autorisé   en   charge   (PTAC)   n'excède   pas   3   500   kg   et   comportant   au   maximum   9  
places  assises  (conducteur  compris).  
 C    :  Véhicules  isolés  de  transports  de  marchandises  dont  le  PTAC  est  supérieur  à  3  500  kg  (et  comportant  au  maximum  
9  places  assises  conducteur  compris).  
 D    :  Véhicules  isolés  de  transports  en  commun  comportant  plus  de  9  places  assises.  

Ecrire  un  algorithme  et  le  programme  C  correspondant  qui  saisit  les  informations  associées  à  un  véhicule  et  
affiche  son  nom  suivi  d’un  message  indiquant  le  permis  nécessaire  à  son  utilisation.  

III.4.   EXERCICE  4  (COMPREHENSION)  

début

Type structuré Machin Variables

début Machin b
Caractère Car Caractère d
Réel Val Réel c
Entier Nb
fin
Afficher "Donnez un caractère "
Saisir b.Car

Afficher "Donnez un réel "

Saisir b.Val

b.Nb ← 1 Donnez   les   valeurs   affichées   (en   détaillant   la  

démarche)   si   on   saisit   au   clavier   les   valeurs  
suivantes  :    
Afficher " Donnez un caractère et un réel : "
Saisir d, c r  ,    7.3  ,  h  ,  3.2  ,  r  ,  2.2  ,  r  ,  0.1  ,  x  ,  8.3  ,  *  ,  9.2.  

b.Car = d ?
non Critiquez  l’algorithme.  
 
oui
 
b.Nb ← b.Nb + 1  
 
b.Val ← b.Val + c  

non
d≠‘*’?

oui

Afficher b.Val / b.Nb

fin

   

    Page  17  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Types  structurés  –  structures  

III.5.   EXERCICE  5  (POLYGONES)  

On  manipule  dans  cette  question  des  données  sur  des  polygones  réguliers.  Un  polygone  régulier  est  un  polygone  convexe  dont  
tous  les  angles  ont  la  même  mesure  et  tous  les  côtés  la  même  longueur.  On  le  représente  par  le  type  suivant  :    
Type structuré PolyG Début
Réel Arete / dimension en mètres d’une arête
Entier NbA / Nombre d’arêtes
Fin
Soit   t   la   longueur   d'une   arête,   l'aire   a   et   le   périmètre   p d'un   polygone   régulier   à   n côtés   sont   donnés   par   les   formules  
suivantes  :  
nt 2
a= et p = nt
  4 tan(π / n)    
On  dispose  de  la  fonction  tan.  

Ecrire  un  algorithme  et  le  programme  C  correspondant  qui  saisit  les  informations  associées  à  un  polygone  et  
qui  affiche  son  aire  et  son  périmètre.  

III.6.   EXERCICE  6  (RECTANGLES)  

Nous  manipulons  dans  cette  question  des  points  et  des  rectangles.  Pour  représenter  ces  informations,  dans  notre  algorithme,  
nous  utilisons  les  types  structurés  Point  et Rectangle.    
Un   rectangle   est   représenté   par   l’abscisse   et   l’ordonnée   de   son   sommet   supérieur   gauche   (champ   CHG),   par   sa   longueur  
(champ  Lx)  et  sa  hauteur  (Champ  Ly).  Un  point  est  représenté  par  son  abscisse  (champ  X)  et  son  ordonnée  (champ  Y).  
Type structuré Point Début Type structuré Rectangle Début
Réel X Point CHG
Réel Y Réel Lx
Fin Réel Ly
Fin
 
Y  
ymax  
ymin    
Un   point   d’abscisse   x   et   d’ordonnée   y   est   à   l’intérieur   du  
xmin xmax X rectangle  décrit  sur  la  Figure  1  si  :  
 
  xmin  <  x  <  xmax   et    ymin  <    y  <  ymax  
Figure  1  :  Représentation  d’un  rectangle  par  les  abscisses  et  
 
ordonnées  de  ces  sommets.  

Ecrire   un   algorithme   et   le   programme   C   correspondant   qui   saisit   un   rectangle   et   un   point   et   qui   affiche  :   à  
l’intérieur,  à  l  ‘extérieur  ou  sur  le  bord  en  fonction  de  la  position  du  point  par  rapport  au  rectangle.  

III.7.   EXERCICE  7  (LANGAGE  C)  

En   reprenant   le   type   date   vu   dans   la   partie   cours,   faire   un   programme   permettant   de   saisir   deux   dates   et  
d’afficher  en  mois,  années  et  jours,  l'écart  entre  ces  deux  dates.  
   

    Page  18  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Types  structurés  –  structures  

III.8.   EXERCICE  8  (LANGAGE  C,  BOISSONS)  

On  dispose  du  type  structuré  suivant  :  
struct boisson
{ string nom; //nom de la boisson
float stock; //quantité en stock (en litres)
float dose, //taille en litres d'une dose vendue
float prix; //prix d'une dose de boisson
};

Ecrire  un  programme  principal  qui  :  

 déclare  2  variables  de  type  boisson  (monverre  et  sonverre),  
 saisit  les  caractéristiques  de  monverre,  
 affiche  monverre,  
 copie  monverre  dans  sonverre,  
 affiche  sonverre.  

III.9.   EXERCICE  9  (LANGAGE  C,  NOMBRES  COMPLEXES)  

Définir  un  type  structuré  pour  les  nombres  complexes  permettant  de  manipuler  ce  nombre  sous  algébrique  :   z = x + iy  et  sous  
θ
sa  forme  géométrique  :   z = re .  

Ecrire  un  programme  C  utilisant  ce  type  de  données  et  permettant  à  l'utilisateur  de  
 Saisir   2   nombres   complexes   dans   l'une   ou   l'autre   des   écritures   pour   chacun   des   nombres,   si   la   forme   algébrique  
(respectivement  géométrique)  est  saisie,  mettre  à  jour  la  forme  géométrique  (respectivement  algébrique)  par  le  calcul.  
 Faire  la  somme  de  ces  deux  nombres  complexes  et  d'afficher  le  résultat  sous  forme  algébriques  et  géométriques,  
 Faire  le  produit  de  ces  deux  nombres  complexes  et  d'afficher  le  résultat  sous  forme  algébrique  et  géométrique.  
Rappel  :    
Le  calcul  de  la  somme  est  plus  facile  en  algébrique,  celui  du  produit  en  géométrique.  
Formules  :  

r = x 2 + y2 et θ = Arctg(y / x)
x = r cos(θ ) et y = r sin(θ )
z1 + z2 = x1 + x2 + i(y1 + y2 )
z1 × z2 = r1r2 eθ1+θ2 ou z1 × z2 = x1 x2 − y1 y2 + i(x1 y2 + x2 y1 )    

III.10.   EXERCICE  10  (REVUES)  

Nous   manipulons   dans   cet   exercice   des   revues.   Pour   représenter   les   informations   nécessaires   à   cette   manipulation,   dans   notre  
algorithme,  nous  utilisons  le  type  structuré  Revue    décrit  ci-­‐dessous.    
Une   revue   est   représentée   par   son   titre   (Titre),   le   type   de   publication   (Type)  :   journalier   (365   jour   par   an,   caractère   J),  
hebdomadaire   (52   semaines   par   an,   caractère   H),   mensuel   (12   mois   par   an,   caractère   M),   trimestriel   (4   trimestre   par   an,  
caractère  T),  et  son  prix  (Prix)  au  numéro.  
Type structuré Revue Début
Chaine Titre // nom
Caractère Type // Type de publication : J, H, M ou T
Réel Prix // prix au numéro
Fin

    Page  19  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Types  structurés  –  structures  

Ecrire  un  algorithme  qui  :  

 Saisit  une  revue  en  demandant  à  l’utilisateur  son  titre,  son  type  et  son  prix  au  numéro.  
 Calcule  le  montant  d’un  abonnement  annuel  pour  la  revue  saisie  et  affiche  le  résultat.  

Traduire  cet  algorithme  en  langage  C.  

III.11.   EXERCICE  11  (MAGASIN)  

On  manipule  dans  cet  exercice  des  données  sur  des  articles  d’un  magasin  représentées  par  le  type  suivant  :    
Type structuré Article Début
Chaine Nom // Nom de l’article
Entier Nb // Nombre d’articles actuellement en stock
Réel Prix // Prix unitaire de l’article
Entier NbMin // Nombre d’articles Minimum à avoir en stock
Fin

Ecrire   un   algorithme   qui   saisit   les   informations   associées   à   un   article,   affiche   son   nom   suivi   d’un   message  
indiquant   le   coût   du   stock   de   cet   article,   puis   affiche   un   message   d’alerte   si   cet   article   doit   être  
réapprovisionné.  

Traduire  cet  algorithme  en  langage  C.  

III.12.   EXERCICE  12  (GEOMETRIE)  

On  décrit  un  point  par  le  type  structuré  suivant  :  
Type structuré Point Début
Réel x // abscisse
Réel y // ordonnée
Fin

Ecrire  un  algorithme  permettant  de  déclarer  une  variable  de  type  Point,  de  saisir  ses  champs  et  de  l'afficher.  

Traduire  cet  algorithme  en  langage  C.  

Définir   une   structure   Droite   comprenant   deux   membres   de   type   point,   puis   compléter   l'algorithme  
précédent  afin  de  déclarer,  saisir  et  afficher  une  variable  de  type  Droite.  

Compléter  le  programme  C.  

Compléter  l'algorithme  précédent  afin  de  vérifier  que  le  point  est  sur  la  droite  ou  non  et  afficher  le  résultat.  

Compléter  le  programme  C.  

Compléter  l'algorithme  afin  de  créer  deux  droites,  d’afficher  leurs  caractéristiques  puis  vérifier  si  les  droites  
sont  parallèles  ou  perpendiculaires  et  afficher  le  résultat.  

Compléter  le  programme  C.  

   

    Page  20  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Types  structurés  –  structures  

III.13.   EXERCICE  13  (CERCLES)  

Nous  manipulons  dans  cette  question  des  cercles.  Pour  représenter  ces  informations,  dans  notre  algorithme,  nous  utilisons  le  
type  structuré  Cercle    décrit  ci-­‐dessous.    
Un  cercle  est  représenté  par  l’abscisse  (abs)  et  l’ordonnée  (ord)    de  son  centre,    et  par  son  rayon  (R).  
Type structuré Cercle Début
Réel abs // abscisse du centre
Réel ord // ordonnée du centre
Réel R // rayon
Fin
Rappels  :  
Equation  d’un  cercle  :   (x  −  a)2  +  (y  −  b)2  =  r2   avec  a,  b  les  coordonnées  du  centre.    
Un  point  de  coordonnées  x,  y    est  sur  le  cercle  de  centre  a,  b  et  de  rayon  r  si    
(x  −  a)2  +  (y  −  b)2  =  r2.  

Ecrire  un  algorithme  qui  :  

 saisit  un  cercle  en  demandant  à  l’utilisateur  les  coordonnées  de  son  centre  et  la  valeur  de  son  rayon.  
 demande  à  l’utilisateur  les  coordonnées  x  et  y  d’un  point,  
 vérifie  si  le  point  est  sur  le  cercle,  et  affiche  un  message  indiquant  ce  résultat.  

Traduire  cet  algorithme  en  langage  C.  

 

    Page  21  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Types  structurés  –  structures  

    Page  22  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Tableaux  –  Algorithmes  de  tri  et  de  recherche  

TABLEAUX  –  ALGORITHMES  DE  TRI  ET  DE  

RECHERCHE  

I.   QU’EST-­‐CE  QU’UN  TABLEAU  ?  

Lors   de   la   conception   d’un   programme,   le   programmeur   peut   avoir   besoin   d’utiliser   un   grand   nombre   de   variables   de   même  
nature   (type).   Ceci   est   le   cas   lorsque,  par   exemple,   le   programme   doit   traiter   des   vecteurs   ou   des   matrices.   On   comprend   alors  
qu’il  serait  fastidieux  déclarer  et  de  manipuler  un  grand  nombre  de  variables  de  même  type.  
Les  langages  de  programmation  structurée  (Pascal,  Ada,  Fortran,  C)  offrent  des  structures  de  données  permettant  de  stocker  
un  grand  nombre  de  données  de  même  type.  Ces  structures  de  données  s’appellent  des  tableaux.  
On  appelle  tableau  un  ensemble  de  données  de  même  type  repérées  par  un  même  nom  de  variable.  Chaque  donnée  est  repérée  
par  un  indice  de  type  entier  entre  crochets,  ou  plusieurs  (on  parle  alors  de  tableau  multi-­‐indicé).  
Un   tableau   peut   être   de   dimension   1,   2   ou   plus.   Le   nombre   d’indices   nécessaires   au   repérage   d’une   donnée   détermine   la  
dimension  du  tableau.  Chaque  élément  d’un  tableau  est  une  variable  à  part  entière  et  peut  être  utilisé  comme  telle.  
Pour   un   tableau   à   une   dimension   (aussi   appelé   vecteur),   un   numéro   d’index   donne   accès   à   un   (seul)   élément.   La   Figure   2  
suivante  donne  une  représentation  graphique  d’un  tableau  de  5  éléments  de  type  réel.    
Il  est  important  de  noter  que,   dans  le  langage  C,    la  numérotation  de  l’index  commence  à  0.  Afin  de  faciliter  la  compréhension  
de  la  correspondance  entre  algorithmes  et  implantations  en  C,  nous  avons  adopté  la  convention  suivante  :  la  numérotation  de  
l’index  commence  également  à  0  en  algorithmique.  
 
VALEUR   3.24   7.31   8  .49   7.22   24.5  
           
INDICE  en  C   0   1   2   3   4  

Figure  2  :  Représentation  graphique  d’un  tableau  de  5  éléments.  

La   Figure   3   suivante   représente   un   tableau   à   2   dimensions,   qui   peut   être   vu   soit   comme   une   matrice   de   taille   4   lignes   x   5  
colonnes,   soit   comme   un   ensemble   de   4   tableaux   de   5   éléments.   On   accède   à   un   élément   d’un   tableau   à   2   dimensions   en  
utilisant  2  indices.  Par  exemple,  l’élément  d’indices  [3,  2]  peut  être  vu  comme  l’élément  de  la  matrice  situé  à  la  ligne  d’indice  3  
(4ème  ligne)  et  à  la  colonne  d’indice  2  (3ème  colonne).  Cet  élément  vaut  6.5.  Il  peut  aussi  être  vu  comme  le  3ème  élément  du  4ème  
tableau  de  5  éléments.  
    0   1   2   3   4  
             

0     0.8   4.2   6.2   17.   1.4  

1     3.3   3.2   11.   17.3   5.1  

2     1.3   4.2   6.1   11.4   1.4  

3     0.2   4.2   6.5   1.7   4.1  

Figure  3  :  Représentation  graphique  d’un  tableau  à  2  dimensions  (4x5).  

    Page  23  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Tableaux  –  Algorithmes  de  tri  et  de  recherche  

Il  n’y  a  pas  de  limite  au  nombre  de  dimensions  d’un  tableau  (dans  la  limite  de  la  taille  mémoire  disponible).  Ainsi,  l’accès  à  un  
élément  dans  un  tableau  à  n  dimensions  (où  n  est  un  entier   naturel  non  nul)  se  fait  à  l’aide  de  n  indices  (un  indice  pour  chaque  
dimension).  
L’ordre  des  indices  est  capital.  Par  exemple,  dans  le  tableau  de  dimension  2  présenté  à  la  Figure  3,  l’élément  d’indices  [2  ,  3]  vaut  
11.4  alors  que  l’élément  d’indices    [3  ,  2]  vaut  6.5.  

II.   DECLARATION   D’UN   TABLEAU   ET   ACCES   A   UN   ELEMENT   D’UN  

TABLEAU  

II.1.   EN  ALGORITHMIQUE  
Lors  de  la  déclaration  d’une  variable  de  type  tableau,  on  devra  préciser  le  type  de  ses  éléments  et  la  taille  du  tableau,  celle-­‐ci  
sera  nécessairement  CONSTANTE  et  devra  être  précisée.  On  utilisera  une  déclaration  de  la  forme  :  
réel mat [10 ; 10] , entier vect [0 .. 4], entier v [5]
Il  existe  beaucoup  d’autres  formalismes.  L’essentiel  est  que  le  type  des  éléments  composant  le  tableau,  la  taille  (en  supposant  
que  l’indice  de  début  est  0,  ou  encore  l’indice  de  début  et  de  fin  ...),  et  le  nom  du  tableau  figurent  dans  la  ligne  de  déclaration.  
L’accès   aux   éléments   du   tableau   se   fait   par   l’utilisation   d’un   (ou   plusieurs)   indice   entier   qui   doit   appartenir   au   domaine   de  
variation  précisé  dans  la  déclaration  du  tableau.  L’indice  peut  être  une  constante  entière,  une  variable  entière,  une  expression  
entière.  
Par  exemple,  soit  les  déclarations  suivantes  :  
réel vect [10]
réel mat [20 ; 10]
entiers : i, j
alors vect [i] : désigne le i+1ème réel du tableau vect,
vect [2] : désigne le 3ème réel du tableau vect,
vect [2*j + i] : désigne le (2*j + i )+1ème réel du tableau vect,
mat [i , j] : désigne le réel de la matrice mat en i+1ème ligne et j+1ème colonne.
La   taille   du   tableau   fixée   lors   de   sa   déclaration   est   sa   taille   maximum.   La   taille   effectivement   utilisée   pour   le   tableau   peut   varier  
au   cours   de   l’algorithme.   Il   n’y   a   pas   de   mécanisme   de   mémorisation   automatique   de   la   taille   effective   du   tableau.   C’est   au  
concepteur  de  l’algorithme  de  mettre  en  place  ce  mécanisme.  

II.2.   EN  LANGAGE  C  
Les  tableaux  se  déclarent  dans  les  zones  habituelles  de  déclarations  des  variables.  

II.2.1.   Tableaux  unidimensionnels  

La  syntaxe  en  C  de  déclaration  d'un  tableau  à  une  dimension  est  la  suivante  :  
type nom_tableau[taille] ;
On  déclare  ainsi  un  tableau  à  une  dimension  dont  le  nom  est  nom_tableau.  On  réserve  alors  un  espace  suffisamment  grand  
pour  que  le  tableau  nom_tableau  puisse  contenir  au  maximum  taille  (taille  de  déclaration)  éléments  de  type  type.  
L’élément  nom_tableau[0]  contient  la  première  valeur  de  type  type  du  tableau  et  l’élément  nom_tableau[taille -
1]  la  dernière  valeur  de  type  type  ;  à  condition  que  ces  valeurs  aient  été  affectées.  

II.2.2.   Tableaux  multidimensionnels  

La  syntaxe  en  C  de  déclaration  d'un  tableau  à  plusieurs  dimensions  est  la  suivante  :  
type nom_tableau[taille1][taille2]…[tailleN] ;

    Page  24  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Tableaux  –  Algorithmes  de  tri  et  de  recherche  

On  déclare  ainsi  un  tableau  à  N  dimensions.  On  réserve  alors  un  espace  suffisamment  grand  pour  que  le  tableau  nom_tableau  
puisse  contenir  au  maximum  taille1 x taille2 x … x tailleN  (tailles  de  déclaration)  éléments  de  type  type.    
L’élément  nom[0][0]…[0]  contient  la  première  valeur  de  type  type  du  tableau,  l’élément  nom[0][0]…[0][1]  contient  la  
deuxième  valeur  de  type  type  et  l’élément  nom[taille1 - 1][taille2 - 1]…[tailleN - 1]  contient  la  dernière  
valeur  de  type  type  ;  à  condition  que  ces  valeurs  aient  été  affectées.    

III.   INITIALISATION  D’UN  TABLEAU  

Un   tableau   déclaré   mais   non   initialisé   contient   des   éléments   dont   les   valeurs   sont   celles   trouvées   dans   les   cases   mémoires  
réservées   au   tableau   lors   de   l'exécution   du   programme.   Les   valeurs   des   éléments   (ou   des   cases)   du   tableau   doivent   être  
initialisées   soit   par   saisie   de   l'utilisateur,   soit   par   affectation   lors   de   l'exécution   du   programme.   Comme   toute   variable,   on   peut  
initialiser  tout  ou  partie  du  tableau  lors  de  sa  déclaration  en  donnant  une  liste  de  valeurs.  

III.1.   EN  ALGORITHMIQUE  
Pour  un  tableau  à  une  dimension  on  a  alors  la  syntaxe  suivante  :  
type nom_tableau [taille] ← {valeur0, valeur1, …, valeurk}
Si k < taille-1 les valeurs manquantes d'un tableau d'entiers ou de réels prennent la valeur 0.
On  peut  aussi  omettre  la  taille  dans  une  déclaration  avec  initialisation  la  syntaxe  est  alors  :  
type nom_tableau[ ] ← {valeur0, valeur1, …, valeurk}
La taille du tableau est alors k+1.

III.2.   EN  LANGAGE  C  

III.2.1.   Tableaux  unidimensionnels  

Pour  un  tableau  à  une  dimension  on  a  alors  la  syntaxe  en  C  :  
type nom_tableau[taille] = {valeur0, valeur1, …, valeurk};
Si k < taille-1 les valeurs manquantes d'un tableau d'entiers ou de réels prennent la valeur 0 si type est numérique
On  peut  aussi  omettre  la  taille  dans  une  déclaration  avec  initialisation  la  syntaxe  est  alors  :  
type nom_tableau[ ] = {valeur0, valeur1, …, valeurk};
La taille du tableau est alors k+1.
Exemples  d’initialisation  au  cours  de  la  déclaration  de  tableaux  à  une  dimension  :  
int a[3]={0, 1, 2};
int a[ ]={0, 1, 2}; //effectue la même initialisation
int a[7]={0, 1, 2}; //effectue les initialisations précédentes complétées par 4 valeurs nulles.

III.2.2.   Tableaux  de  structures  

Il   est   possible   de   créer   des   tableaux   de   structures.   Chaque   case   du   tableau   contient   alors   l’ensemble   des   données   de   la  
structure.  Dans  l’exemple  suivant  on  déclare  un  tableau  nommé  classe  de  30  éléments  de  type  eleve  :  
struct eleve
{ string nom, prenom;
date naissance ; eleve classe[30] ;
float moyenne, notes;  
int classement;
} ;
 
 
On  a  alors,  si  i  est  un  entier  :  

    Page  25  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Tableaux  –  Algorithmes  de  tri  et  de  recherche  

classe[i]
désigne le contenu de la case i+1 du tableau classe, variable de type eleve ;
classe[i].nom
désigne le contenu du champ nom de la variable classe[i], c’est une chaîne ;
classe[i].naissance
  désigne  le  contenu  du  champ  naissance  de  la  variable  classe[i],  de  type  date  ;  
classe[i].naissance.jour
désigne le contenu du champ jour de la variable structurée classe[i], entier ;
classe[i].classement
désigne le contenu du champ classement de la variable classe[i], c’est un entier ;

III.2.3.   Tableaux  multidimensionnels  

Pour  un  tableau  à  plusieurs  dimensions  on  a  alors  la  syntaxe  en  C  :  
type nom_tableau[taille1][taille2]…[tailleN]=
{ valeur_0_0_…_0, valeur_0_0_…_1, … , valeur_taille1-1_taille2-1_…_tailleN-1)};
ou bien :
type nom_tableau[taille1][taille2]…[tailleN]=
{{…{valeur_0_0_…_0,valeur_0_0_…_1,… , valeur_0_0_…_tailleN-1};…
{ valeur_taille1-1_taille2-1_…_0,
valeur_taille1-1_taille2-1_…_1, …,
valeur_taille1-1_taille2-1_…_tailleN-1) }…}};
On  peut  aussi  omettre  des  valeurs  et  pour  un  tableau  d'entiers  ou  de  réels  les  valeurs  manquantes  prennent  la  valeur  0.  
Exemples  d’initialisation  au  cours  de  la  déclaration  de  tableaux  à  plusieurs  dimensions  :  
float a[2][3] = { 1, 1./2., 1./3., 1./2., 1./3., 1./4. } ;
// Effectue les initialisations en donnant la valeur de tous les éléments de chaque ligne
// on obtient la matrice suivante : 1. 1./2. 1./3.
1./2. 1./3. 1./4.
float a[2][3] = { {1, 1./2., 1./3.} , {1./2., 1./3., 1./4.} } ;
// Effectue la même initialisation en utilisant des lignes séparées.
// on obtient la matrice suivante : 1. 1./2. 1./3.
1./2. 1./3. 1./4.

float a[2][3] = { 1, 1./2., , 1./2., , 1./4. } ;

// Effectue les initialisations en omettant des valeurs qui sont alors mises à zéro.
// on obtient la matrice suivante : 1. 1./2. 0
1./2. 0 1./4.

float a[2][3] = { {1, 1./2., } , {1./2., , 1./4.} } ;

// Effectue la même initialisations en utilisant des lignes séparées.
// on obtient la matrice suivante : 1. 1./2. 0
1./2. 0 1./4.

IV.   REMARQUES    
 Les   indices   doivent   avoir   une   valeur   entière   positive   ou   nulle.   Les   indices   peuvent   donc   être   des   variables   entières   ou  
encore  des  valeurs  entières  figées.  
 Les   tableaux   sont   généralement   manipulés   à   l’aide   d’instructions   de   contrôle   itératives   (en   structure   algorithmique  :  
"pour",  "tant  que",  "faire…  tant  que"  ;  en  C  :  boucles  for,  while  ou  do…while).  
 La  taille  (ou  les  tailles)  de  déclaration  du  tableau  doi(ven)t  être  connue(s)  au  moment  où  le  programme  réserve  la  place  
pour   stocker   les   valeurs   du   tableau.   Ceci   nécessite   donc   l’utilisation   de   valeur(s)   fixe(s)   ou   de   constante(s).  EN  AUCUN  CAS  LA  
TAILLE   DE   DECLARATION   NE   PEUT   ETRE   UNE   VARIABLE.   On   ne   peut   pas   avec   la   méthode   de   déclaration   présentée   ici   saisir,   par  
exemple,  au  clavier  la  ou  les  tailles  du  tableau.  Le  programmeur  doit  donc  prévoir  des  tableaux  suffisamment  grands  pour  
traiter  tous  les  cas.  Ceci  implique  que  l'utilisateur  n'utilise  pas  forcément  toutes  les  cases  du  tableau.  ON  MANIPULE  ALORS  UNE  
VARIABLE  ENTIERE  CORRESPONDANT  A  LA  TAILLE  EFFECTIVE  DU  TABLEAU.  

    Page  26  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Tableaux  –  Algorithmes  de  tri  et  de  recherche  

 Les  éléments  d’un  tableau  sont  rangés  en  mémoire  suivant  l’ordre  obtenu  en  faisant  varier  le  dernier  indice  en  premier.  
 Les   éléments   d'un   tableau   sont   stockés   dans   des   cases   mémoires   contiguës   et   donc   un   tableau   est   entièrement   déterminé  
par   l'adresse   de   son   premier   élément  ;   l’élément   suivant   est   stocké   dans   la   zone   mémoire   qui   suit   et   ainsi   de   suite.   On  
accède  à  deux  éléments  consécutifs  en  incrémentant  l’indice  désignant  le  premier.  L’élément  consécutif  à  celui  d’indice  k  
est   celui   d’indice   k+1.   L'espace   mémoire   parcouru   en   passant   de   l’indice   k   à   l’indice   k+1   correspond   à   l'espace   mémoire  
nécessaire  au  stockage  d'un  élément  du  tableau  et  donc  à  celui  du  type  type.    
 En  C,  la  valeur  des  indices  utilisés  n'est  pas  vérifiée.  La  zone  mémoire  pouvant  être  désignée  par  un  indice  trop  grand  n'est  
pas  réservée,  la  valeur  se  trouvant  dans  cette  zone  peut  tout  à  fait  appartenir  à  un  autre  programme  de  l'ordinateur,  être  
aberrante  ou,  dans  le  cas  des  tableaux  multidimensionnels,  correspondre  à  une  case  ayant  d'autres  valeurs  d'indices.  Les  
indices  négatifs  peuvent  aussi  provoquer  des  erreurs.  
 Si   on   néglige   l’élément   d'indice   0   et   qu'on   déclare   un   tableau   de   taille   n+1   alors   on   retrouve   la   notation   matricielle  
traditionnelle  où  les  indices  varient  de  1  à  n.  
 ATTENTION   !   ON   NE   PEUT   PAS   AFFECTER   DIRECTEMENT   LES   VALEURS   D'UN   TABLEAU   DANS   UN   AUTRE   TABLEAU   MEME   SI   CELUI-­‐CI   A   LES   MEMES  
TYPE,  DIMENSIONS  ET  TAILLES.  
 Le  nom  du  tableau  représente  l'adresse  en  mémoire  du  tableau  ainsi  que  celle  du  premier  élément  de  ce  même  tableau.  

V.   EXEMPLES  

V.1.   TABLEAUX  UNIDIMENSIONNELS  

V.1.1.   Calcul  de  la  somme  des  valeurs  d’un  tableau  à  1  dimension  
début

Variables
N=70
Entier a [N], i, n, s #include <iostream>
using namespace std ;
Afficher "Donnez la taille du tableau" #define N 70
Saisir n
main()
i←0
{
int a[N], i , n , s;
Saisir n et
non tous les
i <n? éléments // Saisie de la taille effective du tableau
oui de a cout << "Donner la taille utilisée : " ;
Afficher "Donnez les valeurs du tableau" cin >> n ;
Saisir a [ i ] // Saisie des éléments du tableau
for ( i = 0 ; i < n; i++)
i←i+1 {
cout<<"Entrer la valeur d’indice "<<i<<" : " ;
cin >> a[i] ;
s←0
}
// Initialisation de la somme
i←0 s = 0 ;
// Calcul de la somme
non for ( i = 0; i < n; i++ )
i <n? s += a[i] ;
oui cout << "Somme = " << s << endl ;
s←s+a[i] }

i←i+1

Afficher "Le résultat est ", s

fin

V.1.2.   Algorithme  classique  sur  les  tableaux  à  1  dimension  

    Page  27  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Tableaux  –  Algorithmes  de  tri  et  de  recherche  

début  
Algorithme  donné  Figure  4.  
Variables #include <iostream>
N = 50 using namespace std ;
Entier a [N], i, n, s, c #define N 50

Saisir n et tous les main()

éléments de a {
int n, i, c, trouve, place ;
s←0 float a[N], s = 0.0 ;

// Saisie de la taille effective du tableau

i←0 cout << "Donner la taille utilisée : " ;
cin >> n ;
non Calcul de
i <n? // Saisie des n valeurs du tableau
la for ( i = 0 ; i < n; i++)
oui moyenne {
s←s+a[i] cout<<"Entrer la valeur d’indice "<<i<<" : " ;
cin >> a[i] ;
i←i+1 }

// Calcul de la moyenne des valeurs du tableau

for ( i = 0 ; i < n ; i++ )
s←s/n s += a[i] ;
s = s / n ;
Afficher "Moyenne : ", s cout << "La moyenne est : " << s << "\n" ;
// Affichage des n valeurs du tableau
i←0 for ( i = 0 ; i < n ; i++ )
cout << " a[" << i << "] = " << a[i] << endl;
//Compte le nb de valeurs négatives dans le tableau
non c = 0 ;
i <n?
for ( i = 0; i < n ; i++ )
oui Affichage if ( a[i] < 0 )
des n c++;
Afficher a [ i ] éléments du cout << "il y a " << c << " nombres négatifs \n" ;
tableau a }
i←i+1

c←0

i←0

non
i <n?
oui Compter les
non valeurs
a[i]<0?
négatives
oui
c ←c+1

i←i+1

Afficher "Nombre de négatifs", c

fin
 

Figure  4  :  Algorithme  classique  sur  les  tableaux  à  une  dimension.  

    Page  28  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Tableaux  –  Algorithmes  de  tri  et  de  recherche  

V.2.   TABLEAUX  MULTIDIMENSIONNELS  

V.2.1.   Calcul  de  la  somme  des  valeurs  d’un  tableau  de  dimension  2  

début

Variables
NL=30, N=40
Entier a [NL,NC], i, j, nc, nl, s

Afficher "nombre de lignes, de colonnes "

Saisir nl, nc #include <iostream>
using namespace std ;
#define NL 30
i←0 #define NC 40

non main()
i < nl ? {
Saisir nl, float a[NL][NC], s ;
oui nc et tous int nc, nl, i, j ;
j←0 les
éléments // Saisie de la taille effective du tableau
de a cout << "Nombre de lignes du tableau : " ;
non cin >> nl ;
j < nc ?
cout << "Nombre de colonnes du tableau : " ;
oui cin >> nc ;
Afficher "Donnez les valeurs du tableau"
Saisir a [ i , j ] // Saisie des valeurs du tableau
for ( i = 0 ; i < nl; i++ )
for ( j = 0 ; j < nc ; j++ )
j←j+1 {
cout << "Entrer la valeur d’indice " ;
cout << i << " , " << j << " : " ;
i←i+1 cin >> a[i][j];
}

// Calcul de la somme des valeurs du tableau

s←0 s = 0;
for ( i = 0 ; i < nl; i++ )
i←0 for ( j = 0 ; j < nc ; j++ )
s += a[i][j] ;
cout << s << endl ;
non }
i < nl ?
oui
j←0

non
j < nc ?
oui
s←s+a[i,j]

j←j+1

i←i+1

Afficher "Le résultat est ", s

fin

    Page  29  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Tableaux  –  Algorithmes  de  tri  et  de  recherche  

V.2.2.   Algorithme  classique  sur  les  tableaux  multidimensionnels  (ici  deux)  

L’algorithme  ne  présente  pas  de  difficulté,  il  n’est  pas  donné.  
#include <iostream>
using namespace std ;
#define NL 25
#define NC 25
main()
{
int n1, n2 ;
int i, j, c ;
float a[NL][NC],s , somlig[NL] ;
// Saisie de la taille effective du tableau
cout << "Donner le nombre de lignes du tableau : " ;
cin >> n1 ;
cout << "Donner le nombre de colonnes du tableau : " ;
cin >> n2 ;
// Saisie des n1*n2 valeurs du tableau
for ( i = 0 ; i < n1 ; i++ )
for ( j = 0 ; j < n2 ; j++ )
{
cout << "Entrer la valeur a[" << i << "][" << j << "]" << endl ;
cin >> a[i][j] ;
}
// Calcul de la moyenne des valeurs du tableau
s = 0. ;
for ( i = 0 ; i < n1 ; i++ )
for ( j = 0 ; j < n2 ; j++ )
s += a[i][j] ;
cout << "Moyenne : " << s / ( n1 * n2 ) << endl ;
// Affichage des n1*n2 valeurs du tableau, ligne par ligne
cout << "Matrice :\n" ;
for ( i = 0 ; i < n1 ; i++ )
{
for ( j = 0 ; j < n2 ; j++ )
cout << a[i][j] << " ";
cout << endl ;
}
// Calcul de la somme des valeurs des lignes du tableau
for ( i = 0 ; i < n1 ; i++ )
{
somlig[i] = 0 ;
for ( j = 0 ; j < n2 ; j++ )
somlig[i] += a[i][j] ;
}
for ( i = 0 ; i < n1 ; i++ )
cout << "somme ligne " << i << " : " << somlig[i] << endl ;
// compte le nombre d’apparition de valeurs négatives dans le tableau
c = 0 ;
for ( i = 0 ; i < n1 ; i++ )
for ( j = 0 ; j < n2 ; j++ )
if ( a[i][j] < 0.0 ) c++;
cout << "Il y a " << c << " valeurs négatives " << endl ;
}

    Page  30  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Tableaux  –  Algorithmes  de  tri  et  de  recherche  

VI.   EXERCICE  

VI.1.   EXERCICE    (ENTEES  SORTIES,  EXTREMAS,  REARRANGEMENT  D’UN  TABLEAU)    

Ecrire   un   programme   (algorithme   et   traduction   en   C)   permettant   d’effectuer   successivement   les   actions  
suivantes  :  
a) Entrer  n  et  les  n  valeurs  d’un  tableau  T  d’entiers  avec  n<100.  
b) Afficher  n  et  les  n  valeurs  du  tableau  T.  
c) Calculer  puis  afficher    
 la  somme  de  ces  n  valeurs,    
 la  valeur  la  plus  haute,    
 la  plus  basse    
 le  nombre  de  valeurs  positives.  
d) Décaler  les  n  valeurs  du  tableau  T  vers  la  droite  par  permutation  circulaire  et  afficher  les  n  valeurs  du  nouveau  tableau  T  
obtenu.  

VI.2.   EXERCICE  (FUSION,  ECLATEMENT  DE  TABLEAUX)  

Ecrire   un   programme   (algorithme   et   traduction   en   C)   permettant   d’effectuer   successivement   les   actions  
suivantes  :  
 Entrer  n1  et  les  n1  valeurs  d’un  tableau  T1  d’entiers  avec  n1<100.  
 Entrer  n2  et  les  n2  valeurs  d’un  tableau  T2  d’entiers  avec  n2<100.  
 Construire  un  tableau  T3  contenant  les  valeurs  de  T1  puis  les  valeurs  de  T2.  
 Construire  2  tableaux  T4  et  T5  contenant  les  valeurs  positives  et  négatives  de  T3.  

VI.3.   EXERCICE  (COMPREHENSION)    

début  
 
Variables  
Entier g [12], m, p, w
 
Saisir p et tous les p
éléments de g Que  va  afficher  cet  algorithme  si  on  entre  au  clavier  les  
valeurs  :  5,  21,  17,  12,  7,  -­‐4  ?  
m←0
Que  va  afficher  cet  algorithme  si  on  entre  au  clavier  les  
non valeurs  :  4,  14,  9,  12,  3  ?  
m < p – 1 et g [ m ] > g [ m + 1 ] ?
oui
Que  fait  cet  algorithme  ?  Remplacez  les  textes  "Message  
m←m+1 un"  et  "Message  deux"  par  des  textes  adaptés.  

Modifiez  l’algorithme  pour  que  le  test  

non   g [ m ] > g [ m + 1 ]  
m=p–1?
soit  remplacé  par  le  test  :    
oui   g [ m – 1 ] > g [ m ].  
Afficher "Message un" Afficher "Message deux"  
 

fin
 

    Page  31  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Tableaux  –  Algorithmes  de  tri  et  de  recherche  

VI.4.   EXERCICE  (COMPREHENSION)    

#include <iostream>
using namesace std ;  
#define N 10
 
main()  
{ int t, m, u, d, f ;
int V[N] ;
Donnez  l’algorithme  pour  ce  programme  C.    
cout << "Donner un entire : " ;
cin >> t ; Que   va   afficher   ce   programme   si   on   entre   au   clavier  
m = 0 ;
u = t ; la  valeur  :  2345  ?  
while ( u > 0)
{ Que   va   afficher   ce   programme   si   on   entre   au   clavier  
u = u / 10 ; // division entière
m += 1 ; la  valeur  :  9  ?  
} // while u
d = t ; Que  fait  ce  programme  ?    
u = t ;
for (f = m-1 ; f >= 0 ; f--)
{ Quelles  conditions  doivent  satisfaire  les  données  lues  
u = u / 10 ; // division entière
V[f] = d – u*10 ;
au  clavier  pour  assurer  un  fonctionnement  correct  à  
d = u ; ce  programme  ?  
} // for f  
cout << t << endl ;
for (f = 0 ; f < m ; f++)  
{  
cout << V[f] << endl ;  
} // for f
}  
 

VI.5.   EXERCICE  (ENTEES  SORTIES,  REARRANGEMENT  D’UN  TABLEAU)    

Ecrire   un   programme   (algorithme   et   traduction   en   C)   permettant   d’effectuer   successivement   les   actions  
suivantes  :  
 Entrer  n  et  les  n  valeurs  d’un  tableau  T  de  réels  avec  n<50.  
 Calculer  la  moyenne  des  valeurs  de  T,  
 Créer  un  tableau  des  écarts  à  la  moyenne,  
 Afficher  les  valeurs  du  tableau  des  écarts.  
 Saisir  une  valeur  réelle  val,  
 Compter  le  nombre  de  valeurs  de  T  inférieures  à  val,  
 Créer  un  tableau  des  valeurs  inférieures  à  val  et  un  tableau  des  valeurs  supérieures  à  val,  
 Afficher  les  valeurs  de  ces  2  tableaux,  

VI.6.   EXERCICE  (AJOUT,  RETRAITS  DANS  UN  TABLEAU  TRIE)  

Ecrire   un   programme   (algorithme   et   traduction   en   C)   permettant   d’effectuer,   sur   un   tableau   T   d’entiers   de  
taille  effective  n,  au  choix  de  l’utilisateur  les  actions  :  
 Ajouter  une  valeur  x  dans  le  tableau  T  en  gardant  T  croissant  et  mettre  n  à  jour.  Attention  à  vérifier  le  dépassement  de  
taille  maximum  (10).  
 Enlever  une  valeur  x  dans  le  tableau  T  en  gardant  T  croissant  et  mettre  n  à  jour.  
 Déterminer  si  une  valeur  x  appartient  au  tableau  et  donner  l’indice  de  sa  cellule  (-­‐1  sinon).  
On  suppose  qu’initialement  le  tableau  ne  contient  pas  de  valeurs,  sa  taille  n  est  donc  initialisée  à  0.  Des  valeurs  sont  insérées  en  
utilisant  le  choix  1.  

    Page  32  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Tableaux  –  Algorithmes  de  tri  et  de  recherche  

VI.7.   EXERCICE  (MANIPULATION  DE  TABLEAUX)  

On  souhaite  affecter  des  lettres  à  des  notes  en  fonction  de  leur  appartenance  à  un  intervalle  de  valeurs  en  respectant  les  règles  
suivantes  :  
 Note    <  6  :  Lettre  ‘R’  pour  Recalé  
 6  ʺ″  Note  <  10  :  Lettre  ‘O’  pour  Oraux  de  contrôle  
 Note  ≥ 10  :  Lettre  ‘A’, ‘B’  ou  ‘C’,  le  choix  de  la  lettre  dépend  de  la  note  maximale.  Soit  NoteMax  cette  valeur,  on  crée  trois  
classes  entre  10  et  NoteMax  de  largeur  identique  et  on  affecte  ‘A’, ‘B’ ou ‘C’  en  fonction  de  la  classe  à  laquelle  la  note  
appartient.  

Ecrire  un  algorithme  qui  successivement  :  

 qui  saisit  un  tableau  de  notes  et  cherche  son  maximum,  on  connaît  le  nombre  de  notes,  
 qui  remplit  à  partir  du  tableau  des  notes  le  tableau  des  lettres,  et  compte  (en  même  temps)  le  nombre  de  chacune  des  
lettres  ;   le   nombre   de   chacune   des   lettres   peut   être   rangé   dans   un   tableau   où   la   première   case   contient   le   nombre   de  
A,  la  deuxième  le  nombre  de  B,  la  troisième  le  nombre  de  C,  la  quatrième  le  nombre  de  O,  et  la  cinquième  le  nombre  
de  R.  
 et  qui  affiche  ce  tableau  de  lettres  et  le  nombre  de  chacune  des  lettres.    
Exemple  :  
Soit  le  tableau  de  notes  suivant  :  
15.6   7.3   10.3   11.8   8.9   17.5   5.1   14.2   3.6   12.4   6.5  
La  note  maximale  est  17.5,  on  obtient  trois  classes  de  largeur  2.5.  Ce  qui  conduit  à  la  règle  suivante  :  
• 10  ʺ″  Note  <  12.5  :  Lettre  ‘C’,  
• 12.5  ʺ″  Note  <  15  :  Lettre  ‘B’,  
• 15  ʺ″  Note  ʺ″  17.5  :  Lettre  ‘A’.  
On  obtient  alors  le  tableau  des  lettres  et  le  tableau  des  comptes  suivants  :  
A   O   C   C   O   A   R   B   R   C   O  
 
2   1   3   3   2  

VI.8.   EXERCICE    (FUSION  DE  TABLEAUX  TRIES)  

Ecrire   un   programme   (algorithme   et   traduction   en   C)   permettant   d’effectuer   successivement   les   actions  
suivantes  :  
 Entrer  n1  et  les  n1  valeurs  triées  d’un  tableau  T1  d’entiers  avec  n1<100.  
 Entrer  n2  et  les  n2  valeurs  triées  d’un  tableau  T2  d’entiers  avec  n2<100.  
 Construire  un  tableau  T3  contenant  les  valeurs  de  T1  puis  les  valeurs  de  T2,  de  sorte  qu’il  soit  à  tout  moment  trié.  

VI.9.   EXERCICE  (POLYNOMES)  

Un  polynôme  à  coefficients  réels  et  dont  les  degrés  sont  positifs  ou  nuls  peut  être  représenté  à  l’aide  d’un  tableau  de  réel.  Dans  
ce  tableau  sont  rangés  les  coefficients  ordonnés  dans  l’ordre  croissant  des  degrés.  Ainsi,  le  coefficient  à  la  position  i  sera  celui  
du  degré  i  (les  degrés  commencent  à  0).  
Exemple  : Le  polynôme  3.5x5  +  10.8x2  -­‐23.47,  peut  être  représenté  par  le  tableau  :  
-­‐23.47   0   10.8   0   0   3.5  

Ecrire  un  algorithme  qui  successivement  :  

 Demande  à  l’utilisateur  le  degré  le  plus  élevé  d’un  polynôme  (au  plus  50),  
 Demande   à   l’utilisateur   les   coefficients   et   degrés   de   ce   polynôme,   seulement   pour   les   coefficients   non   nuls   et   les  
stocke  dans  un  tableau,  
 Demande  à  l’utilisateur  une  valeur  de  x,  
 Calcule  et  affiche  la  valeur  du  polynôme  en  x  (on  dispose  de  l’opération  puissance  notée  ^).  

Ecrire  le  programme  C  correspondant.  

    Page  33  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Tableaux  –  Algorithmes  de  tri  et  de  recherche  

VI.10.   EXERCICE  (RECHERCHE  DANS  UN  TABLEAU  DE  CHAINES  DE  CARACTERES)  
Ecrire   un   programme   (algorithme   et   traduction   en   C)   permettant   d’effectuer   successivement   les   actions  
suivantes  :  
 Entrer  n  mots  dans  un  tableau  T  avec  n<10.  
 Afficher  n  et  les  n  valeurs  du  tableau  T.  
 Entrer  un  mot  et  afficher  si  ce  mot  est  dans  le  tableau  ou  afficher  ‘mot  inconnu’  sinon.  

VI.11.   EXERCICE  (TABLEAUX  A  2  DIMENSIONS,  RECHERCHE  D’ELEMENTS)  

Ecrire  un  programme  (algorithme  et  traduction  en  C)  permettant  :  
 De   remplir   un   tableau   de   caractères   ayant   4   lignes   et   5   colonnes   et   représentant   une   grille   de   mots   croisés   où   les   cases  
noires  sont  symbolisées  par  des  "#".  
 D'afficher  ce  tableau.  
 De  compter  le  nombre  de  cases  noires.  
 De  repérer  si  le  mot  ENIT  est  placé  horizontalement  dans  la  grille.  

VI.12.   EXERCICE  (TABLEAUX  DE  STRUCTURES  –  COMPREHENSION)  

Le  programme  C  ci-­‐dessous  utilise  le  type  structuré  Ind.    

Indiquez  :  
 A  quoi  sert  la  boucle  while,  et  du  coup  que  faut-­‐il  préciser  à  l’utilisateur  sur  la  marche  à  suivre  dans  le  premier  affichage  
cout.  
 Quelle  valeur  doit  être  affectée  à  n  à  votre  avis,  et  à  quoi  correspond  cette  variable.  
 Que  calcule  et  affiche  la  deuxième  boucle  Pour,  en  particulier  à  quoi  correspond  cette  fois-­‐ci  le  caractère  c.  
#include <iostream>
using namespace std ; n = … ;
#define N 50 NbI = 0 ;
struct Ind NbM = 0 ;
{ string Nom ; //Nom de l’individu NbAn = 0 ;
char Car ; //Sexe : M ou F cout << c ;
int Nb ; //Nombre d’animaux domestiques for ( i=0 ; i<n ; i++ )
}; {
main() if ( Gens[i].Nom[1] == c )
{ Ind Gens[N] ; {
int i, n, NbI, NbM, NbAn ; NbI = NbI+1 ;
char c ; if ( Gens[i].Car == 'M' )
cout << " … " ; NbM += 1 ;
i = 0 ; NbAn += Gens[i].Nb ;
cin >> c ; }
do }
{ Gens[i].Car = 'c' ; cout << NbM/NbI ;
cin >> Gens[i].Nom ; cout << NbAn/NbI ;
cin >> Gens[i].Nb ; }
i = i+1 ;
cin >> c ;
} while ((c == 'M')||(c == 'F'));

VI.13.   EXERCICE  (TABLEAUX  DE  STRUCTURES  –  DATES)  

En  reprenant  le  type  date  vu  en  cours,  écrire  un  programme  principal  qui  :  
 Déclare  un  tableau  de  dates,  
 Saisit  la  première  date,    
 Remplir  le  reste  du  tableau  (sans  saisie,  chaque  case  est  le  lendemain  de  la  précédente),  
 Afficher  le  tableau.  

    Page  34  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Tableaux  –  Algorithmes  de  tri  et  de  recherche  

VI.14.   EXERCICE  (TABLEAUX  A  2  DIMENSIONS,  JEU  D’ECHECS)  

Aux  échecs  une  Dame  peut  se  déplacer,  au  coup  suivant,  sur  l'horizontale,  la  verticale  et  les  diagonales  passant  par  sa  position  
actuelle.  On  représente  un  échiquier  par  un  tableau  de  caractères  ayant  8  lignes  et  8  colonnes.  La  case  située  en  X  et  Y  contient  
la  Dame  (on  suppose  que  les  autres  cases  sont  vides).  

Ecrire  l'algorithme  et  le  programme  en  C  permettant  de  :  

 Mettre  un  'D'  dans  la  case  contenant  la  Dame,  
 Mettre  une  '*'  sur  les  cases  accessibles  à  la  Dame  au  coup  suivant,  
 Mettre  un  '+'  sur  les  autres  cases.  
 Afficher  à  l'écran  le  contenu  de  ce  tableau  en  respectant  les  lignes  et  les  colonnes.  

VI.15.   EXERCICE  (TABLEAUX  DE  STRUCTURES  –  COMPREHENSION)  

Le  programme  C  ci-­‐dessous  utilise  le  type  structuré  Equipe.    

Indiquer  :  
 Il  y  a  une  erreur  dans  les  déclarations,  laquelle  ?  
 Qu’obtient-­‐on  avec  les  valeurs  suivantes  saisies  au  clavier  ?  
4, "Biarritz", 5, 19, "Calvisano", 0, -67, "Cardiff", 10, 49, "Gloucester", 5, -1)
 Que  réalise  cet  algorithme  ?  
#include <iostream>
#include <string>
using namespace std ;
#define N 16
struct Equipe
{
string Nom ; // Nom de l’équipe
int Pts ; // Nombre de points en championnat
int Diff ; // Différence cumulée
};
main()
{ Equipe T[N] ;
int i, n, Aux ;
cin >> n ;
for ( i=0 ; i < n ;i++)
cin >> T[i].Nom >> T[i].Pts >> T[i].Diff ;
for ( i=0 ; i < n-1 ;i++)
{ for ( j=i+1 ; j < n ;j++)
{
if ( (T[i].Pts < T[j].Pts) || ( (T[i].Pts==T[j].Pts)&&(T[i].Diff < T[j].Diff) ) )
{ Aux = T[i] ;
T[i] = T[j] ;
T[j] = Aux ;
} // if ( (T[i].Pts <
} // for ( j
} // for ( i
for ( i=0 ; i < n ;i++)
cout << T[i].Nom << " " << T[i].Pts << " " << T[i].Diff << endl ;
}

VI.16.   EXERCICE    
On  considère  que  les  100  places  d'un  avion  sont  représentées  par  un  tableau  de  nombres  où  les  20  premières  places  sont  en  
classe  affaire,  les  20  suivantes  de  première  classe  et  les  60  restantes  en  classe  économique.  La  valeur  0  d'une  case  signifie  que  la  
place  est  libre  et  une  autre  valeur  signifie  qu'elle  est  réservée.  

Ecrire  le  programme  (algorithme  et  traduction  en  C)  en  C  qui  doit  :  
 mettre  les  valeurs  du  tableau  à  0,  
 permettre  à  l'utilisateur  de  réserver  ou  libérer  des  places  en  fonction  de  la  classe  et  du  numéro  de  la  place  et  ceci  tant  
qu'il  le  souhaite,  pour  cela  il  doit  disposer  de  la  liste  des  places  libres  de  la  classe  en  question.  

    Page  35  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Tableaux  –  Algorithmes  de  tri  et  de  recherche  

VI.17.   EXERCICE  (TABLEAUX  DE  STRUCTURES)  

On  souhaite  manipuler  des  données  structurées  de  type  suivant  :  
Type structuré MonType Début
Entier : code
Réel : prix
Fin
Le  champ  code  est  entier  est  représente  le  code  d’un  article  de  magasin,  il  est  strictement  positif.  
Le  champ  prix  est  réel  est  représente  le  prix  d’un  article  de  magasin.  

Ecrire  un  algorithme  qui  permet  :  

 de  saisir  un  tableau  de  données  de  type  MonType,  leur  nombre  n’est  pas  connu  ;  
 puis  de  demander  un  prix  à  l’utilisateur  ;  
 et  enfin  d’afficher  le  nombre  d’article  de  ce  prix  dans  le  tableau.  

Modifier  cet  algorithme  pour  que  l’on  puisse  demander  plusieurs  fois  le  prix  sans  nouvelle  saisie  du  tableau.  

Modifier  cet  algorithme  pour  que  l’on  puisse  en  plus  afficher  le  code  des  articles  de  ce  prix.  

VI.18.   EXERCICE  (TABLEAUX  DE  STRUCTURES)  

On  s’intéresse  à  l’activité  d’un  primeur  (marchand  de  fruits  et  légumes).  Pour  représenter  les  fruits  et  légumes  en  stock  chez  ce  
primeur  dans  l’algorithme,  nous  utilisons  un  tableau,  les  fruits  et  légumes  étant  représentés  par  le  type  Marchandise décrit  ci-­‐
dessous.  Le  champ  Nom  indique  le  nom  du  fruit  ou  légume  (orange,  courgette,  carotte  …),  le  champ  Typ  indique  s’il  s’agit  d’un  
fruit  ou  d’un  légume  (1  pour  fruit,  2  pour  légume),  le  champ  Pds  indique  le  poids  du  fruit  ou  du  légume  exprimé  en  Kg  (2.35,  15.8,  
3.33…),  le  champ  Prix,  exprimé  en  Euros,  indique  le  prix  au  Kg  du  fruit  ou  du  légume  (1.39,  0.67,  5.55…)  
Type structuré Marchandise Début
Chaine Nom
Entier Typ
Réel Pds
Réel Prix
Fin

Ecrire  un  algorithme  qui  successivement  :  

 Demande  à  l’utilisateur  de  donner  les  informations  sur  les  marchandises  du  primeur  (fruits  et  légumes)  et  range  ces  
valeurs  dans  un  tableau  ;  
 Sélectionne  dans  ce  tableau  seulement  les  fruits  ou  seulement  les  légumes  (au  choix  de  l’utilisateur).  Pour  cela,  au  lieu  
de  ranger  toute  l’information  du  fruit  ou  du  légume  (nom,  type,  poids,  prix)  dans  un  tableau,  on  rangera  seulement  
les  indices  de  ces  marchandises  ;  
 Utilise  ce  tableau  d’indices  pour  calculer  le  montant  du  stock  de  fruits  ou  de  légumes  (dans  cette  question,  on  ne  doit  
pas  faire  de  test  sur  le  type)  ;  
 Affiche  ce  montant.  
Exemple  :    
On  saisit  les  marchandises  suivantes  :  
orange,  1(fruit),  13.75,  1.49  ;  courgette,  2(légume),  12.5,  0.85  ;  carottes,  2,  17.55,  0.65  ;  pommes,  1,  15.6,  1.2  ;  bananes,  
1,  10.4,  1.15  
On  sélectionne  les  fruits,    
On  produira  donc  le  tableau  :   1   4   5  
En  effet,  l’indice  dans  le  tableau  des  marchandises  des  oranges  est  1,  celui  des  pommes  4  et  celui  des  bananes  5.  
On  affichera  ensuite  comme  montant  la  valeur  :    
51.1675  Euros  =  13.75  *  1.49  +  15.6  *  1.2  +  10.4  *  1.15  

    Page  36  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Tableaux  –  Algorithmes  de  tri  et  de  recherche  

VI.19.   EXERCICE  (STRUCTURES  –  TABLEAUX  DE  STRUCTURES  –  GEOMETRIE)  

L'exercice  proposé  vise  à  effectuer  quelques  calculs  (simples)  dans  le  domaine  de  la  géométrie  plane.  Le  choix  du  domaine  (la  
géométrie)  ne  complique  toutefois  pas  l'écriture  des  algorithmes.  On  considère  deux  points  A1  et  A2  définis  chacun  par  deux  
coordonnées.  Les  coordonnées  de  A1  sont  contenues  dans  deux  variables  (de  type  réel)  appelées  x1  et  y1  et  les  coordonnées  de  
A2   sont   contenues   dans   deux   variables   (de   type   réel)   x2   et   y2.   Cette   distance   s'écrit,   mathématiquement  :  
d(A1, A2) = (x2 − x1)2 + (y2 − y1)2 . .  On  suppose  que  l'on  peut  utiliser  la  fonction  racine  qui  calcule  la  racine  carrée  d'un  réel  
positif  ou  nul.  On  écrira  b ←  racine(a)  pour  affecter  à  la  variable  b  la  racine  carrée  de  la  valeur  de  la  variable  a.    

Ecrire  un  algorithme  puis  le  programme  C  correspondant  qui  permet  la  saisie  des  valeurs  de  x1,  y1,  x2  et  y2,  qui  
calcule  puis  affiche  pour  l'utilisateur  la  distance  entre  les  deux  points.  
On   considère   maintenant   que   les   valeurs   des   coordonnées   des   deux   points   sont   contenues   dans   un   tableau   nommé   T   à   4  
valeurs  réelles.    

Ré  écrire  l'algorithme  de  la  question  1  et  le  programme  C  correspondant  en  tenant  compte  de  ce  changement.    
Le  tableau  T  contient  désormais  un  nombre  de  points  quelconque  nommé  np  (au  moins  2  et  au  plus  50),  ce  nombre  étant  choisi  
par  l'utilisateur.    Le  tableau  T  a  donc  la  forme  suivante  :  
x1 y1 x2 y2 x3 y3 ... ... xnp ynp
On  peut  considérer  que  ce  tableau  T  représente  un  polygone  à  np  sommets.    

Écrire   un   algorithme   puis   le   programme   C   correspondant   qui   permet   de   saisir   les   valeurs   du   tableau   T   puis   de  
calculer   le   périmètre   du   polygone   ainsi   représenté.   Le   périmètre   du   polygone   est   la   somme   des   distances  
entre  deux  points  consécutifs  du  tableau.  Attention,  il  faudra  prendre  en  compte  également  la  distance  entre  
le  premier  point  et  le  dernier  point.    
Soit  le  tableau  T  de  la  question  3  et  un  point  A  décrit  par  ses  deux  coordonnées  réelles  x  et  y.    

Écrire   un   algorithme   puis   le   programme   C   correspondant   qui,   après   avoir   saisi   les   valeur   du   tableau   et   des  
coordonnées   de   A,   sélectionne   dans   T   les   points   dont   la   distance   au   point   A   est   inférieure   ou   égale   à   une  
valeur   fixée   par   l'utilisateur.   Les   points   sélectionnés   seront   stockés   dans   un   tableau   T2   dont   le   format   est  
similaire  à  celui  de  T.    

VI.20.   EXERCICE  (STRUCTURES  –  TABLEAUX  DE  STRUCTURES  –  REVUE)  

Une   revue   est   représentée   par   son   titre   (Titre),   le   type   de   publication   (Type)  :   journalier   (365   jour   par   an,   caractère   J),  
hebdomadaire   (52   semaines   par   an,   caractère   H),   mensuel   (12   mois   par   an,   caractère   M),   trimestriel   (4   trimestre   par   an,  
caractère  T),    et  son  prix  (Prix)  au  numéro.  On  représente  l'ensemble  des  revues  auxquelles  on  est  abonné  par  un  tableau  de  
revues.  On  définit  un  deuxième  tableau,  de  réels,  représentant  le  coût  de  ces  abonnements.  Ces  deux  tableaux  fonctionnent  en  
parallèle,  le  coût  de  l'abonnement  de  la  revue  de  la  4ème  cellule  (d’indice  3)  du  premier  tableau  est  stocké  dans  la  cellule  4ème  
cellule  (d’indice  3)  du  deuxième  tableau.  
Type structuré Revue Début
Chaine Titre // nom
Caractère Type // Type de publication : H, M ou T
Réel Prix // prix au numéro
Fin

Ecrire  un  algorithme  puis  un  programme  en  langage  C  qui  permet  de  :  
 Saisir  un  ensemble  de  revues,  
 Calculer  puis  stocker  dans  le  deuxième  tableau  le  coût  de  ces  revues,  
 Afficher  chaque  revue  et  le  coût  de  son  abonnement.  
 Le  coût  total  des  abonnements,  
 L'abonnement  le  moins  et  le  plus  cher,  

    Page  37  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Tableaux  –  Algorithmes  de  tri  et  de  recherche  

VI.21.   EXERCICE  (STRUCTURES  –  TABLEAUX  DE  STRUCTURES  –  MAGASIN)  

On  manipule  dans  cet  exercice  des  données  sur  des  articles  d’un  magasin  représentées  par  le  type  suivant  :    
Type structuré Article Début
Chaine Nom // Nom de l’article
Entier Nb // Nombre d’articles actuellement en stock
Réel Prix // Prix unitaire de l’article
Entier NbMin // Nombre d’articles Minimum à avoir en stock
Fin
Le  stock  du  magasin  étudié  est  représenté  par  un  tableau  d'articles.  

Ecrire  un  algorithme  qui  permet  de  saisir  le  stock  du  magasin,  de  l'afficher  puis  d'afficher  la  liste  des  articles  
devant  être  réapprovisionnés.  

Traduire  cet  algorithme  en  langage  C.  

VI.22.   EXERCICE  22  (STRUCTURES  –  TABLEAUX  DE  STRUCTURES  –  POLYGONES)  

A  partir  de  la  structure  Point,  on  crée  un  deuxième  type  de  données  structuré  Polygone  :  
Type structuré Point Début Type structuré Polygone Début
Réel x // abscisse Entier nbresommets;
Réel y // ordonnée Point sommets[100];
Fin Fin
Un  polygone  est  donc  décrit  par  l'ensemble  des  points  représentant  ses  sommets.  

Ecrire  un  algorithme  qui  permet  de  :  

 Déclarer  une  variable  de  type  Polygone,  
 Saisir  ses  caractéristiques,  
 Afficher  ses  caractéristiques.  

Traduire  cet  algorithme  en  langage  C.  

Modifiez  l’algorithme  puis  le  programme  en  langage  C  pour  qu’il  crée  un  deuxième  polygone,  translaté  d’un  
premier  polygone  selon  un  point.  Le  premier  polygone  et  le  point  devront  être  saisis  puis  affichés,  le  second  
polygone  doit  être  calculé  puis  affiche.    

Modifiez  l’algorithme  puis  le  programme  en  langage  C  pour  qu’il  crée  un  troisième  polygone  en  appliquant  à  
un  premier  polygone  une  homothétie  de  centre  O  et  de  rapport  un  réel.    

Modifiez   l’algorithme   puis   le   programme   en   langage   C   pour   qu’il   crée   un   quatrième   polygone   en   appliquant   à  
un  premier  polygone  une  homothétie  de  centre  un  point  et  de  rapport  un  réel.    

Modifiez   l’algorithme   puis   le   programme   en   langage   C   pour   qu’il   crée   un   cinquième   polygone   par   symétrie  
centrale  d'un  premier  polygone  par  rapport  à  un  point.    
Rappels  :  
 Le  translaté  d’un  point  M(a,  b)  par  rapport  au  point  p(x,  y)  est  le  point  M’(a’=x+a,  b’=y+b).    
 L’homothétique  de  centre  O  d’un  point  M(a,  b)  est  le  point  M’(a’=ka,  b’=kb).  
 Une  homothétie  de  centre  C(x,  y)  et  de  rapport  k  appliquée  à  un  point  M(a,  b)  donne  le  point  M’(a’,  b’)  tel  que  a’  –  x  =  
k  (a  -­‐  x)  et  b’  –  y  =  k  (b  –  y).  
 Le  symétrique  d’un  point  M(a,b)  par  rapport  au  point  p(x,y)  est  le  point  M’(a’=2x-­‐a,  b’=2y-­‐b).    
 Une  symétrie  centrale  est  une  homothétie  de  rapport  -­‐1.  

    Page  38  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     MODULARITE  

MODULARITE  

I.   GENERALITE  
L’objet   de   la   modularité   en   informatique   est   de   considérer   un   problème   complexe   en   un   arrangement   de   problèmes   plus  
simples  qui  peuvent  être  également  considérés  en  arrangement  de  problèmes  encore  plus  simples  et  ainsi  de  suite.  Les  sous-­‐
problèmes   sont   alors   rédigés   sous   la   forme   de   «  morceaux  »   de   programme   ou   d’algorithme   appelés   modules,   routines   ou  
encore  sous-­‐programmes.    
Généralement,   le   recours   à   la   notion   de   modularité   est   la   seule   manière   raisonnable   de   traiter   un   problème   complexe   en   le  
décomposant  en  arrangements  successifs  de  problèmes  plus  simples.  

I.1.   INTERETS  
La   rédaction   de   modules   est   utile   si   les   opérations   qu'ils   effectuent   sont   appelées   souvent   pour   des   paramètres   de   valeurs  
différentes.  Elle  est  encore  utile  si  elle  constitue  une  étape  logique  dans  la  décomposition  hiérarchique  en  sous  problèmes  plus  
simples   du   problème   complexe   posé   au   programmeur   (ou   groupe   de   programmeurs)   dans   le   cahier   des   charges   du  
programme.  
La   modularité   permet   en   cas   d'utilisation   répétitive   d'un   ensemble   d'actions   en   différents   points   d'un   programme   ou   par  
différents   programmes   d’économiser   de   la   mémoire   (code   présent   une   seule   fois)   et   permet   assez   souvent   une   meilleure  
lisibilité  qui  conduit  notamment  à  faciliter  le  débogage.  

I.2.   BIBLIOTHEQUES  
Les   modules   rédigés   sous   la   forme   de   «  morceaux  »   de   programme   présentant   un   caractère   suffisamment   générique   sont  
souvent  rassemblés  dans  des  bibliothèques  dans  le  but  d’être  réutilisés  par  d’autres  programmes.  Une  bibliothèque  contient  
donc  plusieurs  modules  traitant  généralement  d’une  même  famille  de  problèmes  comme  :  
• les  fonctions  mathématiques,    
• la  manipulation  de  chaînes  de  caractères,  
• la  communication  avec  l’utilisateur  (entre  le  programme,  le  clavier  et  l’écran…),  
• …  
De   nombreuses   bibliothèques   sont   généralement   jointes   aux   différents   IDE   (Integrated   Development   Environment   –  
Environnement   de   Développement   Intégré)   comme   Code::Blocks,   Visual   C++,   Borland   C++   Builder,   Eclipse…   Les   programmeurs  
ont   également   la   possibilité   de   créer   leurs   propres   bibliothèques   de   modules   qu’ils   ont   déjà   développés   toujours   dans   le   but   de  
pouvoir  réutiliser  ces  modules  dans  d’autres  programmes.  

I.3.   FAMILLES  DE  MODULES  

Trois  familles  de  modules  sont  distinguées  :  
• Les  modules  maîtres,  appelés  aussi  modules  principaux,  sont  les  modules  par  l’intermédiaire  desquels  les  programmes  
ou  algorithmes  sont  exécutés.  Ils  appellent  les  autres  modules.  Tout  programme  comporte  donc  un  module  maître.  
• Les  modules  dont  le  but  principal  est  de  réaliser  une  action  (instruction  complexe)  sont  appelés  des  procédures.  
• Les  modules  dont  le  but  principal  est  de  calculer  ou  produire  une  valeur  (quel  que  soit  son  type  :  réel,  entier,  caractère,  
booléen  ou  d’un  quelconque  type  structuré)  sont  appelés  des  fonctions.    
Toutefois  une  fonction  peut,  dans  le  cadre  de  la  production  de  la  valeur  qu’elle  doit  fournir,  réaliser  une  action.  
Dans  les  langages  C  et  C++,  tous  les  modules  sont  considérés  comme  des  fonctions  où  certaines  fonctions  ne  produisent  pas  de  
valeurs   (des   procédures   donc).   En   langage   C   et   C++,   le   main()   d’un   programme   est   un   module  ;   il   s’agit,   comme   son   nom  
l’indique  en  Anglais,  du  module  principal  (ou  maître)  appelé  aussi  fonction  principale.  

    Page  39  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     MODULARITE  

II.   APPELS  DE  MODULES  

II.1.   ELEMENTS  D’APPELS  DE  MODULES  

Lorsqu’un  module  a  besoin  d’un  autre  module  pour  mener  à  bien  la  tâche  pour  lequel  il  a  été  défini,  il  effectue  un  appel.  Nous  
distinguons  donc  le  module  appelant  qui  réalise  une  tâche  complexe  et  le  module  appelé  qui  réalise  une  sous-­‐tâche  de  cette  
tâche  complexe.  Pour  pouvoir  effectuer  un  appel  à  un  module,  il  faut  que  le  module  appelé  ait  un  nom.  
Le   module   appelé   réalise   une   sous-­‐tâche   qui   peut   être   paramétrée.   C’est-­‐à-­‐dire   que   les   actions   menées   et/ou   les   valeurs  
produites  par  le  module  appelé  dépendent  de  valeurs  de  paramètres.  
Exemples  :  
1. Cas  d’une  procédure  :  Considérons  un  module  réalisant  le  tri  dans  l’ordre  croissant  d’un  tableau  de  nombres  réels.  Ce  
module   a   besoin   du   tableau   de   nombres   réels   (et   donc   des   valeurs   qu’il   contient)   pour   effectuer   le   tri   de   ses   valeurs   et  
du  nombre  de  valeurs  effectives  contenues  dans  ce  tableau  pour  éviter  que  l’opération  de  tri  considère  des  valeurs  non  
significatives.  
2. Cas  d’une  fonction  :  Considérons  un  module  calculant  la  moyenne  des  valeurs  contenues  dans  un  tableau  de  nombres  
réels.  Ce  module  a  besoin  du  tableau  de  nombres  réels  (et  donc  des  valeurs  qu’il  contient)  pour  lequel  il  faut  calculer  la  
moyenne  et  du  nombre  de  valeurs  effectives  contenues  dans  ce  tableau.  Il  y  donc  deux  paramètres  qui  sont  un  tableau  
de   réel   et   une   valeur   entière.   La   valeur   produite   par   ce   module   pourra   être   rangée   dans   une   variable   du   module  
appelant  ou  être  exploitée  dans  une  expression  constituant  une  instruction  du  module  appelant.  Le  type  de  la  valeur  
produite  (ou  retournée)  doit  donc  être  connu.  
Les  éléments  nécessaires  à  l’appel  d’un  module  sont  donc  :  
• son  nom,  
• la  liste  ordonnée  de  ses  paramètres  et  leur  type,  
• le  type  de  la  valeur  produite  (appelée  aussi  valeur  retournée)  si  le  module  appelé  est  une  fonction.  

Un  appel  à  une  procédure  peut  être  considéré  comme  une  instruction  comme  cela  est  montré  dans  la  case  violette  de  la    

Figure  5  :  Exemple  d’appel  à  une  procédure.  

p   our   le   module   TrideTableau.   Un   appel   à   fonction   peut   être   effectué   dans   une   expression,   il   se   substitue   alors   à   n’importe  
qu’elle   valeur   du   type   produit   par   cette   fonction,  comme   cela  est   montré   dans   la   case   violette   de  la  Figure   6  pour  le  module  
MoyenneTableau.  
Par  convention,  les  noms  des  modules  appelés  lors  de  l’appel  sont  suivis  de  la  liste  des  paramètres  placés  entre  parenthèses.  Un  
module   peut   ne   pas   avoir   de   paramètre,   comme   cela   est   le   cas   en   C   et   C++   de   la   fonction   rand(),   dans   ce   cas   le   nom   du  
module  sera  tout  de  même  suivi  des  deux  parenthèses.  
 
 

    Page  40  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     MODULARITE  

 
début
 
 
 
Variables Internes  
Réel tabreel [20] ...
Entier tabsize, k main()
{
float tabreel [20]  ;
Afficher " Entrez le nombre de valeurs (<=20) : " int tabsize, k  ;
Saisir tabsize cout<<"Entrez le nombre de valeurs" ;
cout << " (<=20) :";
cin>>tabsize  ;
k!0 for (k=0  ; k<tabsize  ;k++)
{
cout<<"valeur numero " <<k<<"  : "  ;
non
k < tabsize ? cin>>tabreel[k]  ;
}
oui
TriDeTableau(tabreel, tabsize);
Afficher "valeur numéro ", k+1 ...
Saisir tabreel[k]
}

k ! k+1

 
 
 
 
TriDeTableau ( tabreel , tabsize)  
 

fin
 
 

Figure  5  :  Exemple  d’appel  à  une  procédure.  

 
 
 
 
 

    Page  41  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     MODULARITE  

début  

 
 
Variables Internes  
Réel tabreel [20], moy  
Entier tabsize, k ...
main()
{
Afficher " Entrez le nombre de valeurs (<=20) : " float tabreel [20]  ; moy
Saisir tabsize
int tabsize, k  ;
cout<<"Entrez le nombre de valeurs" ;
k!0 cout << " (<=20):";
cin>>tabsize  ;
for (k=0  ; k<tabsize  ;k++)
non
k < tabsize ? {

oui
cout<<"valeur numero " <<k<<"  : "  ;
cin>>tabreel[k]  ;
Afficher " valeur numéro ", k+1
Saisir tabreel[k] }
moy = 3*MoyenneTableau(tabreel, tabsize)/4;
cout<<"le 3/4 de la moyenne des"  ;
k ! k+1 cout <<"valeurs est " <<moy  ;
...
}

moy !3*MoyenneTableau( tabreel , tabsize)/4

 
 
Afficher " Le ¾ de la moyenne des valeurs est ", moy  
 
 
 
fin
 
Figure  6  :  Exemple  d’appel  à  une  fonction.
Attention,  l’ordre  des  paramètres  dans  la  liste  des  paramètres  est  important.  En  effet,  en  supposant  que  nous  disposons  d’un  
module   MultiplierMatrice  permettant  de  calculer  la  valeur  d’une  matrice  (le  type  matrice  ayant  été  déclaré  sous  la  forme  d’une  
structure),   tout   comme   en   mathématique,   la   valeur   calculée   par   MultiplierMatrice (A,B)   sera   différente   de   celle   calculée   par  
MultiplierMatrice (B,A).   De   même   qu’il   n’est   pas   autorisé   de   permuter   l’ordre   des   paramètres   comme   dans   le   cas   de  
MoyenneTableau  où  tabsize ne  peut  pas  être  permuté  avec  tabreel,  ces  deux  paramètres  ne  sont  pas  du  tout  de  même  type.  

II.2.   PRINCIPE  DE  COMMUNICATION  

Lors  de  l’appel  du  module  appelant  au  module  appelé,  les  étapes  suivantes  sont  réalisées  et  représentées  sur  la  Figure  7  :  
1. L’exécution  du  module  appelant  est  suspendue.  
2. Les  valeurs  des  variables,  les  valeurs  des  constantes,  ou  les  valeurs  des  expressions  placées  dans  la  liste  des  paramètres  
du  module  appelé  sont  transmises  au  module  appelé,  dans  l’ordre  où  elles  sont  placées.  
3. Les   instructions   du   module   appelé   sont   exécutées   en   utilisant   les   valeurs,   les   valeurs   des   variables,   les   valeurs   des  
constantes,  ou  les  valeurs  des  expressions  placées  dans  la  liste  de  ses  paramètres.  
4. L’exécution  des  instructions  du  module  appelé  arrive  à  son  terme.  

    Page  42  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     MODULARITE  

5. Le   module   appelé   place   les   valeurs   des   paramètres   qu’il   doit   modifier   dans   les   variables   du   module   appelant  
correspondantes  et,  si  le  module  appelé  est  une  fonction,  il  transfère  la  valeur  qu’il  a  calculée  au  module  appelant.  
6. L’exécution   du   module   appelant   reprend   avec   les   valeurs   des   variables   placées   en   paramètres   éventuellement  
modifiées   et,   si   le   module   appelé   est   une   fonction,  le   module   appelant   exploite   la   valeur   calculée   par   le   module   appelé  
(l’affecte  dans  une  variable,  évalue  l’expression  dans  laquelle  elle  figure,  l’affiche…).  
 
Module'Appelant' Module'Appelé'

temps'
1' 2'

3'

5' 4'
6'
 
Figure  7  :  Schéma  de  principe  de  communication  entre  modules.  

Lors  d’un  appel  à  un  module  les  paramètres  apparaissant  entre  les  parenthèses  sont  appelés  paramètres  effectifs  parce  qu’il  
s’agit   des   paramètres   à   partir   desquels   un   module   effectue   ses   actions.   Le   principe   de   communication   montre   que,   lors   de  
l’étape  2,  le  module  appelé  reçoit  des  valeurs  du  module  appelant.  Ces  valeurs  transmises  sont  appelées  paramètres  effectifs  
d’entrée.   Lors   de   l’étape   5,   le  module   appelé   modifie,   le   cas   échéant,  les   valeurs   de   certaines   variables   du   module   appelant  
placées  dans  la  liste  de  paramètres.  Ces  paramètres  sont  appelés   paramètres  effectifs  de  sortie.  Certains  paramètres  effectifs  
peuvent  être  à  la  fois  des  paramètres  d’entrée  et  des  paramètres  de  sortie.  Il  s’agit  alors  de  paramètres  effectifs  d’entrée-­‐sortie.  
C’est  le  cas  dans  l’exemple  de  la  Figure  5  où  le  module  TriDeTableau  utilise  la  valeur  du  tableau  de  réel  Tabreel  afin  de  le  modifier  
en  un  tableau  de  réel  trié.  Concernant  les  paramètres  effectifs  de  sortie  ou  d’entrée-­‐sortie,  lors  de  l’étape  5,  le  module  appelé  
«  cherche  »  une  zone  mémoire  pour  stocker  la  nouvelle  valeur  du  paramètre  qui  ne  peut  donc  être  qu’une  variable  (ou  une  case  
d’un  tableau  de  même  type).  Donc  lors  de  l’appel  d’un  module,  les  paramètres  effectifs  de  sortie  ou  d’entrée-­‐sortie  ne  peuvent  
être   que   des   variables   du   module   appelant.   Par   contre,   les   paramètres   effectifs   d’entrée   peuvent   être   des   valeurs,   des  
constantes,  des  expressions  ou  des  variables  correspondant  au  type  de  valeur  attendu.  
Pour  bien  utiliser  un  module  il  faut  :  
1. connaître  son  nom,  
2. savoir  ce  qu’il  fait  dans  les  grandes  lignes,  
3. connaître  la  liste  des  paramètres  et  leur  type,  
4. savoir  s’il  s’agit  de  paramètres  d’entrée,  de  sortie  ou  d’entrée-­‐sortie,  
5. savoir  à  quoi  correspondent  ces  paramètres  pour  la  tâche  réalisée  par  le  module.  
Ces  savoirs  sont  accessibles  à  l’aide  des  documentations  associées  à  l’IDE  s’il  s’agit  de  modules  appartenant  aux  bibliothèques  
fournies  avec  l’IDE,  ou  encore  grâce  aux  commentaires  associés  aux  algorithmes  ou  inclus  dans  les  programmes  pour  tout  autre  
module.  

III.   DECLARATONS  DE  MODULES  

Il  existe  deux  situations  :  soit  le  module  utilisé  existe  déjà  et  est  défini  dans  une  bibliothèque,  soit  le  module  n’existe  pas  et  il  
faut  alors  le  déclarer.  Une  déclaration  de  module  est  constituée  de  deux  éléments  qui  sont  l’en-­‐tête  et  le  corps.  

    Page  43  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     MODULARITE  

III.1.   CAS  DES  MODULES  APPARTENANT  A  UNE  BIBLIOTHEQUE  

Les   bibliothèques   sont   généralement   organisées   par   thème   (fonctions   mathématiques,   gestion   des   chaînes   de   caractères,  
gestion  du  clavier  et  de  l’écran…).    
Dans  le  cas  des  algorithmes,  il  est  rare  que  des  modules  usuels,  comme  des  fonctions  mathématiques  ou  des  modules  relatifs  au  
dialogue  avec  l’utilisateur,  soient  détaillés.  Dans  ce  cas,  il  n’y  aucune  déclaration  de  ces  modules  à  effectuer.    
Dans   le   cas   des   programmes   en   C   et   C++,   il   est   nécessaire   d’indiquer   en   tout   début   de   programme   les   bibliothèques   dans  
lesquelles  les  modules  sont  définis  à  l’aide  d’une  directive.  Ces  directives  sont  :  
 #include <unebiblistd.h>  :dans  le  cas  d’une  bibliothèque  standard  C  
 #include <unebibliostd>  :   dans   le   cas   d’une   bibliothèque   standard   C++   avec   un   compilateur   pour   lequel   il   est  
nécessaire  de  déclarer  l’espace  de  résolution  de  conflits  de  noms.  Pour  cela,  on  ajoute  l’instruction   using namespace
std ;  
 #include "unebibliperso.h":  dans  le  cas  d'une  bibliothèque  non  standard.  

III.2.   EN-­‐TETE  
L'en-­‐tête   d'un   module   est   primordial   dans   le   sens   où   celui-­‐ci   définit   une   sorte   d'interface   de   communication   entre   le   module  
appelant  et  le  module  appelé.  Cette  «  interface  »  est  constituée  de  plusieurs  éléments  :  
 un  nom  pour  appeler  le  bon  module,  
 une  liste  des  paramètres  formels  avec  pour  chacun  de  ces  paramètres  :  
o son  nom  (ce  nom  est  celui  avec  lequel  les  actions  du  module  sont  décrites  dans  le  corps  de  celui-­‐ci),  
o son   type   c'est-­‐à-­‐dire   l'ensemble   de   valeurs   que   ce   paramètre   admet   (réel,   booléen,   entier,   chaîne   de   caractères,   une  
structure  particulière…),  
o son  genre  (paramètre  d'entrée,  paramètre  de  sortie,  paramètre  d'entrée-­‐sortie),  
 s'il  s'agit  d'une  fonction,  le  type  de  la  valeur  produite  par  le  module  (réel,  booléen,  entier,  chaîne  de  caractères,  structure  
particulière…)  appelé  aussi  type  de  retour.  

III.2.1.   En  logigramme  algorithmique  

En  logigramme  algorithmique,  nous  avons  choisi  la  représentation  de  la  Figure  8  ci-­‐dessous.    
Cette  représentation  fait  apparaître  :  
 en  haut  de  la  boîte,  le  nom  du  module,  
NOMDUMODULE(  au  milieu  de  la  boîte  les  paramètres  formels  et  leur  type  ;  dans  le  cas  
où  un  paramètre  est  un  tableau  unidimensionnel  on  fait  suivre  le  nom  
Type%paramètre,%nom%paramètre%
Type%paramètre,%nom%paramètre% du   paramètre   de   "[]"   et   s'il   a   plus   d'une   dimension   de  
% "[][taille2][taille3]…[tailleN]"   où   les   tailleI   sont   des   constantes  
Type%paramètre,%nom%paramètre% entières  ou  des  valeurs  entières.  
%
Type%paramètre,%nom%paramètre%  sur   le   côté   gauche,   des   flèches   indiquant   le   genre   des   paramètres  
Type%paramètre,%nom%paramètre% formels  placés  sur  la  même  ligne  :  
o une   flèche   vers   la   droite   indique   que   le   paramètre   formel   est   un  
paramètre  d'entrée,  
Type ( o une  flèche  vers  la  gauche  indique  que  le  paramètre  formel  est  un  
paramètre  de  sortie,  
 
o une  flèche  à  double  sens  indique  que  le  paramètre  formel  est  un  
Figure  8  :  En-­‐tête  de  module  en  logigramme.   paramètre  d'entrée-­‐sortie,  
 sortant   par   le   bas   de   la   boîte   et   partant   à   gauche,   une   flèche  
indiquant   le   type   de   la   valeur   produite   lorsque   le   module   est   une  
fonction.  

    Page  44  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     MODULARITE  

III.2.2.   En  C++  

III.2.2.1. Syntaxe  
En  C++  la  syntaxe  de  l'en-­‐tête  d'un  module  est  le  suivant  :  
TypeDeRetour NomDuModule (liste des paramètres)
Où  :    
NomDuModule est le nom du module,
TypeDeRetour est
- le type de la valeur produite par le module pour une fonction
- void pour une procédure.
 
La  liste  des  paramètres  comporte  le  type,  le  nom  et  le  genre  des  paramètres  formels  :  
Pour un paramètre formel d'entrée :
typeduparametre nomduparametre
Pour un paramètre formel de sortie ou d'entrée-sortie :
typeduparametre & nomduparametre
ou typeduparametre& nomduparametre
ou typeduparametre &nomduparametre
Les paramètres sont séparés par une virgule.
 

Exemples  :  
void permuter (float& x, float& y) // permutation du contenu de 2 variables
int maximum (int a, int b) // calcul du maximum de 2 entiers
En  C++,  il  n'y  a  pas  de  différence  entre  paramètre  d'entrée-­‐sortie  et  paramètre  de  sortie.  

III.2.2.2. Cas  des  tableaux  en  C  et  C++  

Les  tableaux  ne  peuvent  pas  être  une  valeur  produite  par  une  fonction.  
Les  paramètres  formels  qui  correspondent  à  des  tableaux  ne  sont  jamais  compris  comme  des  paramètres  d'entrée  mais  sont  
explicitement  des  paramètres  d'entrée-­‐sortie  ou  de  sortie.  Il  ne  faut  pas  mettre  le  caractère  &  pour  le  préciser.  
Ainsi,   dans   le   cas   où   un   module   modifierait,   dans   ses   actions,   les   valeurs   d'un   tableau   sans   que   l'on   souhaite   répercuter   ces  
modifications   après   l'exécution   du   module,   il   faut   qu'à   l'intérieur   du   module,   il   y   ait   une   copie   du   tableau   et   que   les   actions  
modifiant  les  valeurs  du  tableau  soient  opérées  sur  cette  copie.  
Les  tableaux  figurent  comme  suit  dans  la  liste  des  paramètres  d'un  module  :  
dans le cas d'un tableau unidimensionnel :
typedesvaleurs nomdutableau []
dans le cas d'un tableau multidimensionnel où les TAILLEI sont des constantes
entières ou des valeurs entières :
typedesvaleurs nomdutableau [][TAILLE2]…[TAILLEN]
 
Exemples  d'en-­‐tête  de  module  ayant  au  moins  un  tableau  parmi  leurs  paramètres  formels  :  
float MoyenneTableau (float tcm[], int lgtcm)
void TriDeTableau (float tat[], int lg)

III.2.3.   Passages  paramètres  effectifs/paramètres  formels  

 Lors   de   l'appel   d'un   module   les   valeurs   des   paramètres   formels   d'entrée   du   module   appelé   reçoivent   les   valeurs   des  
paramètres  effectifs  d'entrée  correspondant.  On  parle  alors  de  passage  par  valeur.    
 Lors   de   l'appel   d'un   module   les   variables   représentant   les   paramètres   formels   de   sortie   du   module   appelé   sont   mis   en  
correspondance  avec  les  variables  représentants  les  paramètres  effectifs  de  sortie  correspondant.  En  fin  d’exécution,  les  

    Page  45  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     MODULARITE  

variables  représentant  ces  paramètres  de  sortie  effectifs  reçoivent  les  valeurs  des  paramètres  formels  du  module  appelé  
qui  a  dû  leur  donner  une  valeur.  On  parle  alors  de  passage  par  référence.  
 Lors   de   l'appel   d'un   module   les   valeurs   des   paramètres   formels   d'entrée-­‐sortie   du   module   appelé   reçoivent   les   valeurs   des  
paramètres  effectifs  d'entrée-­‐sortie  correspondant.  En  fin  d’exécution,  les  variables  représentant  ces  paramètres  d'entrée-­‐
sortie   effectifs   reçoivent   les   valeurs     des   paramètres   formels   du   module   appelé   (qui   a   pu   modifier   les   valeurs).   On   parle  
toujours  de  passage  par  référence.    
En  C++,  dans  le  cas  des  paramètres  d'entrée-­‐sortie  ou  de  sortie  (puisqu'il  n'y  a  pas  de  distinction)  tout  ce  passe  comme  si  le  
paramètre   effectif   du   module   appelant   était   substitué   au   paramètre   formel   du   module   appelé   (comme   si   le   module   appelé  
opérait  directement  sur  le  paramètre  effectif).  

III.3.   CORPS  

III.3.1.   Constitution  
Le  corps  d'un  module  comporte  la  séquence  d'instructions  décrivant  les  actions  du  module.  Ces  instructions  peuvent  comporter  
des  appels  à  d'autres  modules.  Cette  séquence  a  un  début  et  une  fin  et  donc,  en  C  et  C++,  elle  est  encadrée  par  "{"  et  "}".    
Les  paramètres  formels  ne  sont  pas  déclarés  dans  la  partie  «  variables  locales  »  puisqu’ils  le  sont  dans  l’en-­‐tête.    
Pour   réaliser   ses   actions,   un   module   peut   avoir   besoin   de   variables   internes   propre   au   module,   qu'il   faut   définir   et   déclarer.  
Cette  déclaration  est  effectuée  en  début  de  module.  
Le   nom   des   variables   internes   et   des   paramètres   formels   d'un   module   sont   propres   au   module,   ils   n'existent   que   lors   de  
l'exécution  de  celui-­‐ci,  et  peuvent  donc  être  les  mêmes  noms  que  ceux  d'autres  variables  ou  paramètres  d'autres  modules.  

III.3.2.   L'instruction  de  retour  

L'instruction   de   retour   que   l'on   peut   noter   Retour   en   algorithmique   et   qui   s'écrit   return   en   C   permet   de   restituer   (ou  
d’envoyer)  la  valeur  de  l'expression  située  à  sa  droite  au  le  module  appelant.  Cette  expression  doit  être  de  même  type  que  le  
type  de  retour  de  la  fonction.  
L'instruction  de  retour  est  obligatoire  s'il  s'agit  du  corps  d'une  fonction  puisqu'une  fonction  doit  produire  une  valeur.  Elle  peut  
être  présente  plusieurs  fois  dans  le  corps  de  la  fonction.  
Cette  instruction  provoque  l'arrêt  de  l'exécution  de  la  fonction,  étape  4  du  principe  de  communication  (Figure  7).    
L'instruction   de   retour   peut   également   être   utilisée   dans   une   procédure   afin   de   provoquer   l'arrêt   de   l'exécution   d'une  
procédure.   Dans   ce   cas,   elle   est   utilisée   seule   (sans   expression   à   sa   droite).   Ceci   peut   être   utilisé   pour   arrêter   l'exécution   de  
procédure  sous  certaines  conditions.  

III.4.   EXEMPLES  
Nous  proposons  dans  ce  paragraphe  des  exemples  de  modules  définis  à  l'aide  d'un  logigramme  algorithmique  et  de  code  C++.  

III.4.1.   Fonction  maximum  

Le  logigramme  et  le  code  C++  de  la  fonction   maximum  qui  produit  (ou  renvoie,  ou  retourne)  la  valeur  du  plus  grand  des  deux  
entiers  placés  en  paramètres  sont  donnés  sur  la  Figure  9.  
 

    Page  46  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     MODULARITE  

maximum&
int maximum (int a, int b)
Entier'a'
Entier'b' {
if (a < b)
Entier & return b ;

a'<'b?'
non & return a ;
}
oui &
Retour'
 
 
b & Retour'

a &
 
Figure  9  :  Fonction  Maximum.  

III.4.2.   Procédure  de  permutation  

Le   logigramme   et   le   code   C++   de   la   procédure   permuter   qui   échange   les   contenus   de   deux   variables   réelles   sont   donnés   sur  
laFigure  10.  

permuter'  

Réel%x%
Réel%y%

Variable%internes% void permuter (float&x, float&y)

%Réel%tempo% {
float tempo ;
tempo = x ;
tempo%%!%x% x = y ;
y = tempo ;
}
x%%!%y%

 
y%%!%tempo%  

fin%
 
Figure  10  :  Procédure  permuter.  

III.4.3.   Fonction  calculant  la  moyenne  d'un  tableau  de  réels  

Le   logigramme   algorithmique   et   le   code   C++   de   la   fonction   MoyenneTableau   qui   produit   (ou   renvoie,   ou   retourne)   la   valeur  
moyenne  des  lv  premières  valeurs  contenues  dans  le  tableau  de  réels  vect  sont  donnés  sur  la  Figure  11.  
 

    Page  47  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     MODULARITE  

MoyenneTableau+

Réel%vect%[%]%%
Entier%lv% float MoyenneTableau (float vect[], int lv)
{
+
Réel int k ;
float s ;
Variables%internes%
%Entier%k%
%Réel%s% s = 0. ;
for (k=0 ; k<lv ; k++)
s += vect[k] ;
s%%!%0% return s/lv ;
}

k%!%0%

non%
k%<%lv%?%

oui%

s%!%s%+%vect%[k]%

k%!%k+1%

Retour%

s+/+lv +
 
Figure  11  :  Fonction  MoyenneTableau  

III.4.4.   Procédure  de  tri  d'un  tableau  de  réels  

Le   logigramme   algorithmique   et   le   code   C++   de   la   procédure   TriDeTableau   qui   range   dans   l'ordre   croissant   les   n   premières  
valeurs  du  tableau  de  réels  tab par  l'algorithme  de  tri  à  bulle  sont  donnés  sur  la  Figure  12.  
 

    Page  48  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     MODULARITE  

TriDeTableau*

Réel#tab#[#]##
Entier#n#

Variables#internes#
#Entier#i ##
#Entier#max# ##
#Entier##fin ## void TriDeTableau (float tab[], int n)
{
int i, fin, max ;
fin# #n$1# for (fin=n-1 ; fin>=1 ; fin--)
for(i=0 ; i<fin-1 ; i++)
if (tab[i]>tab[i+1])
fin##≥#1#?#
{
oui# max = tab[i+1] ;
tab[i+1] = tab[i] ;
i# #0#
tab[i] = max ;
non# }
i#<#fin$1#?# }
oui#
non#
tab[i]#>#tab[i+1]#

oui#
max# #tab[i+1]#
tab[i+1] #tab[i]#
tab[i] #max#

i# #i+1#

fin# #fin$1#

Fin#
 
Figure  12  :  Procédure  TriDeTableau.  

III.5.   OU  DECLARER  LES  MODULES  

En  algorithmique,  il  n'y  a  pas  de  règle  précisant  l'endroit  où  doivent  être  déclarés  les  modules.  Il  suffit  de  les  joindre  au  dossier.  
En  C  et  C++,  une  possibilité  est  de  créer  une  ou  plusieurs  bibliothèques  pour  y  déclarer  des  modules.  Cependant,  ce  point  n'est  
pas   traité   dans   ce   cours.   Une   autre   possibilité,   en   C++,   est   de   déclarer   les   modules   dans   le   fichier   .cpp   contenant   la   fonction  
principale  main().   Dans   ce   cas,   les   modules   sont   déclarés   après   les   directives,   les   types   globaux,   les   constantes   et   variables  
globales  et  avant  la  fonction  principale  main()  comme  cela  est  illustré  dans  la  trame  de  programme  sur  la  Figure  13.  

    Page  49  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     MODULARITE  

#include <iostream>
using namesace std;
#include "mybib.h"
#define PI 3.1416

struct elt
{
int entier ;
float val ;
} ;
const unsigned int k=3 ;

void fonction1 (float a , char b)

{
// cette procédure…
}
float fonction2 (int j)
{
// cette fonction…
}

main ()
{
char alpha, beta ;
float x, y, z ;
/* Commentaire */
}    
Figure  13  :  Trame  d’organisation  d’un  programme  avec  fonctions  en  C.  

Toutefois,  les  modules  ne  peuvent  pas  être  déclarés  dans  n'importe  quel  ordre.  L'ordre  est  basé  sur  le  fait  qu'on  ne  peut  utiliser  
que  ce  qui  a  été  préalablement  déclaré.  
Ainsi,   en   considérant   la   situation   suivante   où   un   module   ModZ   appelle   un   module   ModY   qui   lui-­‐même   appelle   un   module   ModX  
et  un  module  ModW.  Il  faudra  d'abord  déclarer  les  modules  ModW  et  ModX  (dans  l'ordre  de  son  choix),  puis  le  module  ModY  et  
enfin  le  module  ModZ.  Ceci  explique  pourquoi  la  fonction  principale  main()est  déclarée  à  la  fin.  
 
Une  alternative  est  la  déclaration  des  prototypes  (dans  l'ordre  de  son  choix)  puis  des  modules  avec  leur  en-­‐tête  (dans  l'ordre  de  
son  choix  aussi).  
Un   prototype   est   l'en-­‐tête   d'une   fonction   suivi   d'un   ";".   Il   permet   de   définir   la   forme   de   la   fonction   avant   sa   définition.   Il   ne  
dispense   pas   de   définir   la   fonction,   et   lors   de   cette   définition   l’en-­‐tête   doit   être   présent   et   doit   correspondre   exactement   au  
prototype.  
Exemples  pour  les  modules  suivants  :  
int maximum (int a, int b);  
void permuter (float& x, float& y);
float MoyenneTableau (float vect[], int lv);
void TriDeTableau (float tab[], int n);  
ou  encore  en  les  débarrassant  des  noms  des  paramètres  formels  :  
int maximum (int, int);
void permuter (float& , float&);
float MoyenneTableau (float *, int);
void TriDeTableau (float *, int);  
Dans  le  cas  des  paramètres  formels  qui  sont  des  tableaux,  il  doit  subsister  autant  de  "*"  que  le  tableau  compte  de  dimensions.  

    Page  50  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     MODULARITE  

IV.   EXERCICES  

IV.1.   EXERCICE  1    
On  déclare  un  module  de  la  manière  suivante  :  
Fct1

Réel x
Booléen y

Réel
non
x=0?
oui
y ← vrai
y ← faux
non
x>0?
Retour oui
0
Retour
1/x
Retour
1 / ( – x)

A   quoi   sert   le   paramètre   y   ?   Que   fait   le   module   Fct1   ?   Lors   d'un   appel   à   la   fonction   Fct1,   combien   de   fois,   au  
maximum,  l'instruction  Retour  peut-­‐elle  être  exécutée  ?  

Peut-­‐on  écrire  dans  un  algorithme  les  instructions  suivantes  comprenant  un  appel  à  la  fonction  Fct1  ?  
y  ß  Fct1(2,a),  où  y  est  une  variable  de  type  Booléen  et  a  est  une  variable  de  type  Booléen  
x  ß  Fct1(x,a),  où  x  est  une  variable  de  type  Réel  et  a  est  une  variable  de  type  Booléen  
y  ß  Fct1(x,vrai),  où  x  et  y  sont  des  variables  de  type  Réel  
a  ß  (3  +  Fct1(b,c))/2,  où  a  et  b  sont  des  variables  de  type  Réel  et  c  une  variable  de  type  Booléen  
a  ß  Fct1(a+b+3,c)/2,  où  a  et  b  sont  des  variables  de  type  Réel  et  c  une  variable  de  type  Booléen  

IV.2.   EXERCICE  2  
Ecrire  une  fonction  permettant  la  saisie  d'une  matrice.  

Ecrire  une  fonction  permettant  l'affichage  d'une  matrice.  

Ecrire  une  fonction  retournant  la  trace  d'une  matrice  si  elle  est  carrée.  

Ecrire  une  fonction  calculant  la  somme  de  deux  matrices,  stockant  le  résultat  dans  une  troisième  matrice  et  
retournant  0,  si  le  calcul  n'est  pas  possible.  

Ecrire  une  fonction  calculant  le  produit  de  deux  matrices,  stockant  le  résultat  dans  une  troisième  matrice  et  
retournant  0,  si  le  calcul  n'est  pas  possible.  

Ecrire   un   programme   permettant   d'effectuer   des   opérations   sur   des   matrices   où   l'utilisateur   peut   saisir,  
resaisir,  faire  les  opérations  souhaitées,  jusqu'à  ce  qu'il  veuille  quitter  le  programme.  

    Page  51  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     MODULARITE  

IV.3.   EXERCICE  3    
On  déclare  un  module  de  la  manière  suivante  :  
Fct1

Réel A
Entier n
Réel B

Booléen
Variables Internes
entier j

non
n=0?
oui non
n>0?
B←1 oui
B←0
B←0
Retour Retour
vrai j!1 faux

non
j≤n?
oui

B←B+A

Retour
vrai

A  quoi  sert  le  paramètre  retourné  ?  Que  fait  le  module   Fct1  ?  Lors  d'un  appel  à  la  fonction   Fct1,  combien  de  
fois  au  maximum,  l'instruction  Retour  peut-­‐elle  être  exécutée  ?  

Peut-­‐on  écrire  dans  un  algorithme  les  instructions  suivantes  comprenant  un  appel  à  la  fonction  Fct1  ?  
y  ß  Fct1(2,5,a),  où  y  est  une  variable  de  type  Booléen  et  a  est  une  variable  de  type  Booléen  
a  ß  Fct1(x,k,x),  où  x  est  une  variable  de  type  Réel,  k  est  une  variable  de  type  entier  et  a  est  une  variable  de  type  Booléen  
a  ß  Fct1(x,3,5.5),  où  a  est  une  variable  de  type  Booléen,    x  est  une  variable  de  type  Réel  
c  ß  Fct1(b,3+n,a),  où  a  et  b  sont  des  variables  de  type  Réel,  n  une  variable  de  type  entier  et  c  une  variable  de  type  Booléen  
c  ß  Fct1(a+3,-­‐5,b)/2,  où  a  et  b  sont  des  variables  de  type  Réel  et  c  une  variable  de  type  Booléen  

IV.4.   EXERCICE  4  
Ecrire   une   fonction   permettant   de   trier   par   ordre   croissant   le   contenu   de   2   variables   entières   a   et   b,   et  
respectant  l’en-­‐tête  suivant  :     void tri2(int & a, int & b)

Ecrire   une   fonction   permettant   de   trier   par   ordre   croissant   le   contenu   de   3   variables   entières   a,   b   et   c,   et  
respectant  l’en-­‐tête  suivant  :     void tri3(int & a, int & b, int & c)

Utiliser  ces  fonctions  pour  écrire  un  programme  permettant  de  rentrer  les  dimensions  a1,  b1,  c1  et  a2,  b2,  c2  de  
2  boîtes  et  de  les  comparer  dimension  par  dimension  ou  globalement.  
   

    Page  52  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     MODULARITE  

IV.5.   EXERCICE  5  
On  suppose  que  l’on  dispose  de  deux  tableaux  d’entiers  ordonnés.  

Réalisez   un   module   (algorithme   et   langage   C)   qui   supprime   les   éléments   identiques   d’un   tableau   dans   un  
deuxième.  
Tableau 1 3 3 4 5 7 8 10 10 41

Résultat 3 4 5 7 8 10 41  
Exemple  d’application  de  l’algorithme  de  suppression  d’éléments  identiques  

Réalisez   un   module   (algorithme   et   langage   C)   qui   crée   l’intersection   de   deux   tableaux   ne   possédant   pas  
d’éléments  identiques.  
Tableau 1 3 4 5 7 8 10 41

Tableau 2 3 6 8 41 50

Résultat 3 8 41  
Exemple  d’application  de  l’algorithme  de  création  de  l’intersection  

Réalisez  un  module  (algorithme  et  langage  C)  qui  crée  l’union  de  deux  tableaux  ne  possédant  pas  d’éléments  
identiques.  
Tableau 1 3 4 5 7 8 10 41

Tableau 2 3 6 8 41 50

Résultat 3 4 5 6 7 8 10 41 50  
Exemple  d’application  de  l’algorithme  de  création  de  l’union  

Réalisez   un   module   (algorithme   et   langage   C)   qui   crée   la   différence   entre   deux   tableaux   qui   ne   possèdent   pas  
d’éléments  identiques  
Tableau 1 3 4 5 7 8 10 41

Tableau 2 3 6 8 41 50

Différence entre 1 et 2 4 5 7 10
Différence entre 2 et 1 6 50  
Exemple  d’application  de  l’algorithme  de  création  de  la  différence  

Réalisez  un  module  (algorithme  et  langage  C)  qui  crée  la  différence  symétrique  entre  deux  tableaux  (union  des  
différences  mutuelles  entre  les  deux  tableaux).  
Tableau 1 3 4 5 7 8 10 41

Tableau 2 3 6 8 41 50

Résultat 4 5 6 7 10 50  
Exemple  d’application  de  l’algorithme  de  création  de  la  différence  symétrique.  

Réalisez  un  module  principal  en  langage  C  qui  effectue  la  saisie  de  deux  tableaux  d’entiers,  les  trie,  supprime  
les   éléments   identiques,   affiche   les   résultats,   crée   l’union   des   deux   tableau,   l’affiche,   crée   l’intersection   des  
deux  tableaux,  l’affiche,  crée  la  différence  entre  le  tableau  1  et  le  tableau  2,  l’affiche,  crée  la  différence  entre  le  
tableau  2  et  le  tableau  1,  l’affiche,  crée  la  différence  symétrique  entre  deux  tableaux  et  l’affiche.  
   

    Page  53  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     MODULARITE  

IV.6.   EXERCICE  6  
Qu’affichera  le  programme  suivant  :  
#include <iostream>
int fct1(int tab[ ] , int ltab, int v)
{ int i ;
i=0 ; main()
while ( i < ltab ) {
{ int letab[50]={ 1, 3, 5, 7, 9, 11 , 13, 15};
if (tab[i] == v) int ldeletab, a ;
return i ;
i++ ; cout << "Un : " << fct1(letab, 8, 18) ;
} cout << endl;
return (-1) ; cout << "Deux : " << fct1(letab, 8, 7);
} cout << endl;
void fct2(int t[ ] , int &lt, int p) ldeletab = 8 ;
{ if (fct1(t, lt, p) == -1) a = 18 ;
{ fct2(letab, ldeletab, a) ;
t[lt] = p ; cout << "Trois : " << "Avec " << a ;
lt++ ; cout << " on obtient : ";
} ecrire(letab, ldeletab) ;
} a=7 ;
void ecrire(int tab[ ], int ltab) fct2(letab, ldeletab, a) ;
{ int i ; cout << "Quatre : " << "Avec " << a ;
cout << " on obtient : ";
cout << tab[0] ; ecrire(letab, ldeletab) ;
for (i=1 ; i < ltab ; i++) }
cout << " , " << tab[i] ;
cout << endl ;
}

IV.7.   EXERCICE  7  
Nous  considérons  le  type  structuré  animal  représentant  des  animaux  d’un  magasin.  Ces  animaux  possèdent  un  code  représenté  
par  l’entier  num,  un  nom  les  désignant,  un  code  du  type  de  nourriture  mangée  par  cet  animal  et  représenté  par  l’entier  eat,  et  
enfin,  un  poids  minimum  de  nourriture  à  lui  donner  par  jour  représenté  par  le  réel  pds,  ce  poids  est  exprimé  en  grammes.  
Les  types  de  nourriture  sont  au  nombre  de  NbType  et  ont  pour  code  les  entiers  de  1  à  NbType.  Un  magasin  peut  contenir  au  
maximum  250  animaux.  
Type structuré animal
début
Entier num
Chaîne nom
Entier eat
Réel pds
fin

Ecrire  les  algorithmes  (au  moins  dans  les  grandes  lignes)  et  leur  traduction  en  C  :  
1) Une  action  qui  saisit  les  caractéristiques  d’un  animal.  
2) Une  action  qui  saisit  un  tableau  d’animaux  (elle  doit  appeler  l’action  1,  on  demande  le  nombre  d’animaux  à  l’utilisateur).  
3) Une  action  qui  à  partir  du  code  du  type  de  nourriture  donné  en  paramètre  d’entrée,  calcule  le  poids  nécessaire  de  cette  
nourriture  pour  les  animaux  du  magasin.  Cette  action  ne  doit  faire  ni  saisie  au  clavier  ni  affichage  à  l’écran.  
4) Un  programme  principal  qui  :  
 Demande  à  l’utilisateur  la  valeur  du  nombre  de  type  de  nourriture  du  magasin  (valeur  de  NbType),  
 Saisit  un  tableau  d’animaux,  
 Affiche  le  poids  nécessaire  de  chaque  type  de  nourriture  pour  le  magasin  par  jour.  

    Page  54  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     MODULARITE  

IV.8.   EXERCICE  8  
Ecrire  une  fonction  retournant  1  si  un  nombre  entier  n  est  premier  et  0  sinon,  et  respectant  l’en-­‐tête  suivant  :  
int premier(int n)

Utiliser  cette  fonction  pour  écrire  un  programme  permettant  d’afficher  les  nombres  premiers  inférieurs  à  100.  

IV.9.   EXERCICE  9  
Ecrire  une  fonction  permettant  la  saisie  d’un  vecteur  (tableau  à  une  dimension).  

Ecrire  une  fonction  permettant  l'affichage  d’un  vecteur.  

Ecrire   une   fonction   retournant   produit   scalaire   de   deux   vecteurs,   cette   fonction   doit   retourner     une   valeur  
permettant  de  savoir  i  le  produit  scalaire  est  valide.  

Ecrire  une  fonction  calculant  la  norme  d’un  vecteur  (on  fera  appel  à  la  fonction  écriteau  3).  

Ecrire  un  programme  permettant  de  saisir  deux  vecteurs,  de  calculer  leur  norme  et  leur  produit  scalaire.  

IV.10.   EXERCICE  10  

On  manipule  dans  cet  exercice  des  données  sur  des  articles  d’un  magasin  représentées  par  le  type  suivant  :    
Type structuré Article Début
Chaine Nom // Nom de l’article
Entier Code // Code du fournisseur
Entier Nb // Nombre d’articles actuellement en stock
Réel Prix // Prix unitaire de l’article
Fin
Nous   considérons   le   type   structuré   Article   représentant   des   articles   d’un   magasin.   Ces   articles   possèdent   un   nom   les   désignant,  
un  code  désignant  le  fournisseur  de  cet  article  et  représenté  par  l’entier  Code,  le  nombre  des  articles  de  ce  fournisseur  en  stock  
est  représenté  par  le  champ  Nb, le  prix  unitaire  de  l’article  chez  ce  fournisseur  est  représenté  par  le  champ  Prix.  
Les   fournisseurs   sont   au   nombre   de   NbFournisseur   et   ont   pour   code   les   entiers   de   1   à   NbFournisseur.   Un   magasin   peut  
contenir  au  maximum  1500  articles  différents.  

Ecrire  les  algorithmes  (au  moins  dans  les  grandes  lignes)  et  leur  traduction  en  C  :  
1) Une  action  qui  saisit  les  caractéristiques  d’un  article.  
2) Une  action  qui  saisit  un  tableau  d’articles  (elle  doit  appeler  l’action  1,  on  demande  le  nombre  d’articles  à  l’utilisateur).  
3) Une  action  qui  à  partir  du  code  du  fournisseur  donné  en  paramètre  d’entrée,  calcule  le  montant  du  stock  des  articles  de  ce  
fournisseur  en  magasin.  Cette  action  ne  doit  faire  ni  saisie  au  clavier  ni  affichage  à  l’écran.  
4) Un  programme  principal  qui  :  
 Demande  à  l’utilisateur  la  valeur  du  nombre  de  fourniseurs  du  magasin  (valeur  de  NbFournisseur),  
 Saisit  un  tableau  d’articles,  
 Affiche  le  montant  du  stock  pour  chaque  fournisseur.  
 

    Page  55  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     MODULARITE  

IV.11.   EXERCICE  11    

On   s’intéresse   ici   à   la   gestion   d’un   mannequin   virtuel   comprenant   NbArt   articulations.   Chaque   articulation   est   représentée   par  
le   type   TArt   ci-­‐dessous.   Ce   type   comprend   le   nom   de   l’articulation,   la   valeur   courante,   et   la   valeur   maximale   et   minimale  
acceptables   par   cette   articulation.   La   position   d’un   mannequin   est   donnée   par   les   valeurs   courantes   de   chacune   de   ses  
articulations.  
Le  mannequin  est  représenté  par  un  tableau  d’articulations,  un  mannequin  comprend  au  plus  50  articulations.  
Type structuré TArt
Début
Chaîne Nom // représente le nom de l’articulation
Réel q // valeur courante
Réel qmax // valeur maximale
Réel qmin // valeur minimale
Fin
On   souhaite   écrire   un   programme   qui   donne   une   indication   sur   le   confort   associé   à   une   position   du   mannequin.   On  dispose   (ne  
pas  écrire  ces  actions)  :  
• de  l’action  SaisieMan  permettant  la  saisie  des  articulations  d’un  mannequin,  et  leur  stockage  dans  le  tableau   Man  de  
taille  NbArt,  
Procédure SaisieMan ( S/ TArt Man[ ], S/ Entier NbArt )
• et  de  l’action  Position  qui  place  le  mannequin  dans  une  position  choisie  par  l’utilisateur.  
Procédure Position ( ES/ TArt Man[ ], E/ Entier NbArt )
Pour   donner   une   indication   sur   le   confort   associé   à   une   position   du   mannequin,   on   regarde   le   confort   de   chacune   de   ses  
articulations.   On   compare   la   position   courante   (q)   aux   positions   extrêmes   (qmax   et   qmin),   soit   lg = ( qmax – qmin ) / 2   la  
largeur  de  l’intervalle  :  
• La  zone  de  0  à  10%  autour  de  qmin ou  de  qmax,  c’est-­‐à-­‐dire  qmin ≤ q< qmin + lg/10  ou  qmax ≥ q > qmax - lg/10,  est  
dite  dangereuse,    
• La  zone  de  10%  à  40%  autour  de  qmin ou  de  qmax,  c’est-­‐à-­‐dire  qmin + lg/10 ≤ q < qmin + 4.lg/10  ou  qmax - lg/10 ≥ q >
qmax – 4.lg/10,  est  dite  non  recommandée,  
• La  zone  restante    est  dite  confortable.  

Ecrire  une  fonction  ou  procédure  qui  à  partir  d’une  articulation  produit  la  valeur  0  si  l’articulation  est  dans  une  
position  confortable,  1  si  elle  est  non  recommandée  et  100  si  elle  est  dangereuse.  Traduisez  là  en  C.  

Ecrire   une   fonction   ou   procédure   qui   à   partir   d’un   tableau   représentant   un   mannequin,   produit   le   score   de  
confort  de  la  position  du  mannequin.  Ce  score  est  obtenu  par  la  somme  de  la  valeur  de  chaque  articulation.  
Cette  action  doit  faire  appel  à  l’action  écrite  au  1.  Traduisez  la  en  C.  

Ecrire  un  algorithme  principal  qui  :  

a. Saisit  un  mannequin,  
b. Appelle  la  procédure  de  positionnement    du  mannequin,  effectue  le  calcul  du  score  de  confort,  et  affiche  ce  score,  
c. Recommence  l’opération  b.  

Traduisez  l’algorithme  principal  en  C.  

Ne  faire  ni  lecture  ni  affichage  dans  les  actions  écrites  au  1  et  au  2.  

    Page  56  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     MODULARITE  

IV.12.   EXERCICE  12    

On  s’intéresse  ici  à  la  gestion  de  polygones  réguliers,  et  de  nombre  polygonaux.    
Un  polygone  régulier  est  un  polygone  convexe  dont  tous  les  angles  ont  la  même  mesure  et  tous  les  côtés  la  même  longueur.  On  
le  représente  par  le  type  PolyG.  
Un   nombre   polygonal   est   un   nombre   qui   peut   être   représenté   par   un   polygone   régulier.   Les   mathématiciens   antiques   ont  
découvert  que  des  nombres  pouvaient  être  représentés  en  arrangeant  d'une  certaine  manière  des  cailloux  ou  des  graines.  Si  c  est  
1
le  nombre  de  côtés  d'un  polygone,  alors  le  nombre  c-­‐polygonal  de  rang  n  correspondant  est  :   n[(c − 2) n − (c − 4)]  (formule  1).  
2
Par  convention  1  est  le  premier  nombre  polygonal  pour  n'importe  quel  nombre  de  côtés.  
Type structuré PolyG Début
Réel Cote // Dimension en mètres d'un côté €
Entier Nbc // Nombre de côtés
Fin

Ecrire  une  fonction  C  qui  saisit  un  polygone.  

Ecrire  une  fonction  C  qui  affiche  un  polygone.  

Ecrire  une  fonction  C  qui  à  partir  d’un  polygone  et  d’un  nombre  entier  représentant  le  rang  maximum,  crée  le  
tableau  des  nombres  polygonaux  lui  correspondant,  de  rang  1,  2,  3…,  rang  maximum.  On  utilise  la  formule  1  
donnée  ci-­‐dessus  pour  le  calcul.  
Exemple  :   pour   un   polygone   à   4   côtés   (c’est-­‐à-­‐dire   un   carré),   et   pour   un   rang   maximum   de   6   on   obtient   le   tableau  
contenant  6  valeurs  :  1  ;  4  ;  9  ;  16  ;  25  ;  36.  
On  dispose  (ne  pas  écrire  ces  actions)  :  
• de  l’action  AffichTab  permettant  l’affichage  des  éléments  d’un  tableau  d’entiers,  
void AffichTab ( int t[ ], int )
• et  de  l’action  Intersection  qui  produit  l’intersection  de  deux  tableaux,  c’est-­‐à-­‐dire  le  tableau  des  éléments  communs.  
void Intersection (int t[ ], int , int u[ ], int , int r[ ], int & )

Ecrire  un  programme  principal  C  qui  :  

a. Saisit  un  rang  maximum  (inférieur  à  100),  
b. Saisit  un  polygone,  
c. Recherche  les  nombres  polygonaux  pour  ce  polygone,  
d. Saisit  un  autre  polygone,  
e. Recherche  les  nombres  polygonaux  pour  ce  polygone,  
f. Affiche  les  deux  polygones  et  les  nombres  polygonaux  communs  à  ces  deux  polygones,  
g. Recommence  l’opération  d)  (trouvez  un  critère  d’arrêt).  
Ne  faire  ni  lecture  ni  affichage  dans  l’action  écrite  au  3.  

    Page  57  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     MODULARITE  

IV.13.   EXERCICE  13  

Une   entreprise   fabriquant   des   automobiles   travaille   avec   plusieurs   fournisseurs   de   pièces.   Chaque   fournisseur   donne   au  
fabricant   un   bordereau   de   livraison   contenant   les   informations   suivantes  :   le   numéro   de   fournisseur,   le   type   de   pièce   (code  
formé   de   15   caractères)   et   le   nombre   de   pièces.   Ces   bordereaux   de   livraison   sont   représentés   par   le   type   TBord défini   ci  
dessous.  
L’entreprise   range   les   informations   sur   les   pièces   en   stock   dans   un   tableau   de   données   de   type   structuré   TPiece   décrit   ci-­‐
dessous.  Les  fournisseurs  sont  au  nombre  maximum  de  100,  les  différents  types  de  pièces  sont  au  nombre  maximum  de  2000.
Type structuré TBord Début Type structuré TPiece Début
Entier Num / Numéro du fournisseur Chaîne Code / Code de la pièce
Chaîne Code / Code de la pièce Entier Nb / Nombre de pièces
Entier Nb / Nombre de pièces Fin
Fin
On   souhaite   écrire   un   programme   qui   gère   le   stock   du   magasin.   Pour   cela   on  dispose  de   l’action   SaisieStockEnCours  
permettant   la   saisie   des   pièces   de   code   différent   stockées   dans   le   magasin,   et   rangées   dans   le   tableau   MonStock   de   taille  
NbPieces et   de   l’action AffichStockEnCours permettant   d’afficher   le   stock.   Ne   pas   écrire   ces   actions.   Les   entêtes  
de  ces  actions  sont  :  
void SaisieStockEnCours( TPiece MonStock[ ], int & NbPieces )
AffichStockEnCours( TPiece MonStock[ ], int NbPieces)

Ecrire  une  fonction  C  nommée  SaisieLivraison  permettant  de  saisir  au  clavier  un  bordereau  de  livraison.  

Ecrire   une   fonction   C   nommée   ModifStockEnCours   qui,   à   partir   du   tableau   des   pièces   en   stock   et   d’une  
livraison  modifie  le  stock  en  cours  (attention  ajout  ou  modification).  

Ecrire  un  programme  principal  C,  qui  saisit  le  tableau  du  stock  en  cours,  puis  qui  modifie  ce  tableau  de  stock  au  
fur  et  à  mesure  des  livraisons  arrivant,  et  enfin  affiche  le  contenu  du  tableau  de  stock.  Vous  ferez  appel  aux  
actions  SaisieStockEnCours,  SaisieLivraison,  ModifStockEnCours  et  AffichStockEnCours.  

Comment  pourrait-­‐on  stocker  des  informations  sur  les  fournisseurs  des  pièces  (sachant  qu’un  type  de  pièce  
peut  être  fourni  par  plusieurs  fournisseurs)  ?  Pour  cela,  Proposez  un  nouveau  type  structuré  TPiece.  
 
Remarque  :   Attention   au   passage   de   paramètres,   aucun   affichage   (écriture)   ou   saisie   (lecture)   ne   doit   être   fait   dans   l’action  
ModifStockEnCours.
Exemple  :  On  commence  par  saisir  le  tableau  du  stock  suivant  (ici  le  nombre  de  pièces  de  code  différent  est  égal  à  4)  :
 

PHAREAV   FEUXSTP   RETROG   RETROIN  

  …        
2500   420   130   5600  
Puis  on  ajoute  les  livraisons  suivantes  :  
  151   FEUXSTP   6500  
  243   CLIAVD   4250  
  164   FEUXSTP   280  
On  obtient  alors  après  chaque  livraison  saisie,  successivement  le  tableau  suivant  :  

PHAREAV   FEUXSTP   RETROG   RETROIN  

  …        
2500   6920   130   5600  
Puis  

PHAREAV   FEUXSTP   RETROG   RETROIN   CLIAVD   …        

2500   6920   130   5600   4250  
Et  enfin    

PHAREAV   FEUXSTP   RETROG   RETROIN   CLIAVD   …        

2500   7200   130   5600   4250  

    Page  58  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     MODULARITE  

IV.14.   EXERCICE  14  

On   s’intéresse   ici   à   la   gestion   d’un   magasin   comprenant  NbArt   articles,   ces   articles   sont   vendus   au   poids.   Chaque   article   est  
représenté  par  le  type  TArt  ci-­‐dessous.  Ce  type  comprend  le  nom  de  l’article,  la  valeur  courante  du  stock  en  kilo,  la  valeur  du  
prix  au  kilo  de  cet  article.  Le  magasin  est  représenté  par  un  tableau  d’articles,  un  magasin  comprend  au  plus  250  articles.  On  
souhaite  écrire  un  programme  qui  «  gère  »  un  magasin.    
Type structuré TArt Début
Chaîne Nom // représente le nom de l’article
Réel Pds // valeur courante du stock en kilos
Réel Prix // valeur du prix au kilo
Fin

Ecrire   la   fonction   C   SaisieArt   permettant   la   saisie   d  ‘un   seul   articles   d’un   magasin.   On   respectera   l’entête  :
  TArt SaisieArt()  

Ecrire   la   fonction   C   SaisieMag   permettant   la   saisie   des   articles   d’un   magasin,   et   leur   stockage   dans   le   tableau  
Mag  de  taille  NbArt.  Il  faut  appeler  la  fonction  écrite  au  1).  On  respectera  l’entête  :   void   SaisieMag(TArt
  Mag[ ], int & NbArt)

Ecrire   l’action   Peser   qui   indique   le   poids   en   kilos   d’une   quantité   d’un   article.   Cette   action   sert   à   simuler  
l’utilisation  d’une  balance  pour  obtenir  le  poids  d’un  article.  Il  suffit  de  saisir  au  clavier  le  poids  ;  On  respectera  
l’entête  : float Peser(string Name )

Ecrire   une   fonction   C   qui   à   partir   du   nom   d’un   article   fournit   sa   position   dans   le   tableau   représentant   le  
magasin  (-­‐1  s’il  n’est  pas  trouvé).  

Ecrire  une  fonction  C  qui  à  partir  de  l’indice  d’un  article  et  du  poids  d’une  quantité  de  cet  article,  produit  le  
prix  de  cette  quantité.  

Ecrire  une  algorithme  principal  qui  :  

a.
Saisit  un  magasin,  
b.
Demande  le  nom  de  l’article  au  client,  
c.
Pèse  la  quantité  achetée  par  le  client,  calcule  son  coût,  met  à  jour  le  stock  de  cet  article  dans  le  magasin,  met  à  jour  la  
note  du  client,  
d. Recommence  les  opérations  b)  et  c),  
e. Affiche  le  montant  total  dû  par  le  client.  
Exemple  :    
On  commence  par  saisir  le  magasin  suivant  (ici  le  nombre  d’articles  est  égal  à  6)  :  
Pommes Bananes Courgettes Tomates Fraises Oranges
32.5 55.3 48.25 37.95 25.0 53.5 …
2.65 1.655 1.24 2.66 6.00 2.95
Puis  pèse  les  quantités  suivantes  :   0.750  kg  d’oranges,     1.250  kg  de  tomates  
On  obtient  alors  après  chaque  achat,  successivement  le  tableau  et  montants  suivants  :  
Pommes Bananes Courgettes Tomates Fraises Oranges
32.5 55.3 48.25 37.95 25.0 52.750 …
2.65 1.655 1.24 2.66 6.00 2.95
  Montant  dû  :  0.750*2.95  =  2.21  euros  
Pommes Bananes Courgettes Tomates Fraises Oranges
32.5 55.3 48.25 36.6 25.0 52.750 …
2.65 1.655 1.24 2.66 6.00 2.95
  Montant  dû  :  2.21  +  1.250*2.66  =  5.54  euros  
On  affichera  le  montant  de  5.54  euros.  

    Page  59  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     MODULARITE  

IV.15.   EXERCICE  15  

On  s’intéresse  ici  à  la  gestion  d’un  canal  et  de  vannes  disposées  le  long  de  ce  canal.  Chaque  vanne  est  représentée  par  le  type  
TVanne  ci-­‐dessous.  Ce  type  comprend  le  nom  de  la  vanne,  le  débit  courant,  et  le  débit  maximum  et  minimum  acceptables  par  
cette  vanne.  Le  canal  est  représenté  par  un  tableau  de  vannes,  la  vanne  en  position  1  est  celle  le  plus  en  amont,  celle  en  position  
NbVannes  est  celle  le  plus  en  aval  (l’eau  s’écoule  de  l’amont  vers  l’aval).  Un  canal  comprend  au  plus  50  vannes.  
Type structuré TVanne
Début
Chaîne Nom // représente le nom de la vanne
Réel q // débit courant
Réel qmax // débit maximum
Réel qmin // débit minimum
Fin
On  souhaite  écrire  un  programme  qui  gère  les  vannes  de  ce  canal.  On  dispose  (ne  pas  écrire  ces  actions)  :  
 de  l’action   SaisieCanal  permettant  la  saisie  des  vannes  d’un  canal,  et  leur  stockage  dans  le  tableau   MCanal  de  taille  
NbVannes,  
void SaisieCanal(TVanne MCanal[ ], int & NbVannes)
 de  l’action  AffichCanal  permettant  d’afficher  les  informations  sur  les  vannes  du  canal,  
void AffichCanal(TVanne MCanal[ ], int NbVannes)
 et  de  l’action  DebitMesure  qui  donne  le  débit  mesuré  à  l’amont  de  (avant)  la  vanne  en  position  1.  
float DebitMesure()
Afin   de   gérer   un   canal,   on   souhaite   faire   en   sorte   que   le   débit   mesuré   à   l’amont   de   la   vanne   en   position   1   soit   réparti   sur   toutes  
les   vannes   du   canal   en   agissant   en   priorité   sur   les   vannes   amont   (les   premières)   mais   en   ne   dépassant   pas   leurs   limites  
minimales  et  maximales.  Pour  cela,  on  calcule  la  différence  entre  le  débit  mesuré  et  le  débit  courant  global  du  canal  (somme  
des  débits  courants  de  toutes  les  vannes  du  canal).  
 Si  on  constate  un  excédant  (différence  positive),  on  augmente  le  débit  courant  des  vannes  du  canal,  de  la  plus  amont  vers  
la  plus  aval,  jusqu’à  ce  qu’il  n’y  ait  plus  d’excédant,  et  sans  dépasser  les  débits  maximums.  
 Si  on  constate  un  manque  (différence  négative),  on  diminue  le  débit  courant  des  vannes  du  canal,  de  la  plus  amont  vers  la  
plus  aval,  jusqu’à  ce  qu’il  n’y  ait  plus  de  manque,  et  cela  sans  dépasser  les  débits  minimums.  

Ecrire  une  fonction  ou  procédure  qui  à  partir  d’un  tableau  représentant  un  canal  produit  la  valeur  du  débit  
courant  global  de  ce  canal  (i.e.  la  somme  des  débits  courants  de  toutes  les  vannes  du  canal).  

Ecrire  une  fonction  ou  procédure  qui  à  partir  d’un  tableau  représentant  un  canal,  de  la  valeur  du  débit  courant  
de  ce  canal,  et  de  la  valeur  du  débit  mesuré  à  l’amont  de  ce  canal  modifie  les  débits  courant  des  vannes  du  
canal.  Cette  action  doit  indiquer  si  tout  l’excédent  ou  tout  le  manque  ont  pu  être  absorbé.  

Ecrire  une  algorithme  principal  qui  :  

a. Saisit  un  canal,  
b. Appelle  la  fonction  de  mesure  de  débit,  effectue  la  répartition,  et  affiche  les  informations  sur  les  vannes  du  canal,  
c. Affiche  un  message  si  la  répartition  totale  n’a  pas  pu  être  effectuée,  
d. Recommence  les  opérations  b)  et  c).  
 
Exemple  :    
On  commence  par  saisir  le  canal  suivant  (ici  le  nombre  de  vannes  est  égal  à  4)  :  

Save   Gim   Ger   Gala  

0.46   1.59   0.53   0.05  
  …        
2.5   4.02   2.4   0.15  
0.2   0.205   0.05   0.001  
Puis  mesure  les  débits  suivants     5.15   2.22  
On  obtient  alors  après  chaque  mesure  de  débit,  successivement  le  tableau  suivant  :  
  5.15  -­‐  2.63  =  2.52     :  excès  à  répartir
 

    Page  60  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     MODULARITE  

Save   Gim   Ger   Gala  

2.5=0.46+2.04   2.07=1.59+0.48   0.53   0.05  
  …        
2.5   4.02   2.4   0.15  
0.2   0.205   0.05   0.001  
Et  enfin  
  2.22  -­‐  5.15  =  -­‐2.93    :  manque  à  répartir  

Save   Gim   Ger   Gala  

0.2=2.5-­‐2.3   1.44=2.07-­‐0.63   0.53   0.05  
  …        
2.5   4.02   2.4   0.15  
0.2   0.205   0.05   0.001  

IV.16.   EXERCICE  16  

Nous  nous  intéressons  ici  au  codage  d’un  contour  par  l’intermédiaire  du  code  de  Freeman.  Ce  code  permet  de  représenter  de  
façon  exacte  un  contour  fermé,  il  comprend  les  coordonnées  en  x  et  en  y  du  premier  point  du  contour  puis  la  valeur  0,  1,  2,  3,  4,  
5,  6  ou  7  du  code  représentant  la  position  du  point  suivant,  ainsi  de  suite  jusqu’au  dernier  point  du  contour.  Les  valeurs  de  code  
sont  décrites  sur  le  schéma  ci-­‐dessous.  
Ainsi  le  contour  décrit  par  la  suite  d’entiers  suivante  :  6,  4,  4,  4,  3,  4,  5,  7,  6,  7,  0,  0,  0,  0,  1,  2,  4,  3  est  celui  représenté  sur  la  figure  
ci-­‐dessous.  Il  correspond  à  la  succession  des  coordonnées  suivantes  :  (6,4)  ;  (5,4)  ;  (4,4)  ;  (3,5)  ;  (2,5)  ;  (1,4)  ;  (2,3)  ;  (2,2)  ;  (3,1)  ;  
(4,1)  ;  (5,1)  ;  (6,1)  ;  (7,1)  ;  (8,2)  ;  (8,3)  ;(7,3)  ;  (6,4).  Ainsi,  on  constate  que  :  
• si  le  code  vaut  0,  la  coordonnée  en  x  est  augmentée  de  1,  celle  en  y  est  inchangée  ;  
• si  le  code  vaut  1,  la  coordonnée  en  x  est  inchangée,  celle  en  y  est  augmentée  de  1  ;  
• si  le  code  vaut  2  les  deux  coordonnées  en  x  et  en  y  sont  augmentées  de  1…  
  Point  de  départ  :  6,4  
y  
3   2   1  

4   0  

5   6   7   0  
Code de Freeman 0   x  
Afin  de  définir  un  point,  nous  utilisons  le  type  Cord  comme  contenant  deux  entiers  représentant  l’abscisse  (x)  et  l’ordonnée  (y)  
d’un  point.  
Type structuré Cord
Début
Entier x // Entier représentant l’abscisse du point
Entier y // Entier représentant l’ordonnée du point
Fin
h
  p  
Ecrire   une   fonction   C   qui   à   partir   d’un   tableau   d’entiers   contenant   le  
code  de  Freeman  d’un  contour  produit  le  tableau  (tableau  de  valeurs  
de   type   Cord).   Le   contour   étant   fermé   l’ordre   des   points   n’a   pas   l  
d’importance,  vous  choisirez  la  solution  la  moins  coûteuse.  

Ecrire  une  ligne  d’appel  à  cette  fonction.  

    Page  61  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     MODULARITE  

IV.17.   EXERCICE  17  

Nous  considérons  le  type  structuré  cuboid  ci-­‐dessous  représentant  un  parallélépipède  rectangle  ayant  une  face  de  hauteur   h  et  
de  largeur  l  et  une  profondeur  p.  La  profondeur  est  la  dimension  la  plus  grande.  
Type structuré cuboid
début
réel h
réel l
réel p
fin

Ecrire  la  fonction  C   VerifCubo  permettant  de  vérifier  que  la  profondeur  d’un  parallélépipède  est  bien  la  plus  
grande   de   ses   dimensions,   et   de   modifier   ses   champs   de   sorte   que   p   soit   la   plus   grande   dimension,   si   ce   n’est  
pas  le  cas.    

Ecrire   l’action   VolCubo   (fonction   ou   procédure)   permettant   d’obtenir   le   volume   d’un   parallélépipède  
(h×l×p).    

Ecrire   la   fonction   C   Cubes   permettant   à   partir   d’un   tableau   de   parallélépipède     de   créer   un   tableau   ne  
contenant  que  les  cubes  (toutes  ces  faces  sont  carreés).    

Ecrire  un  programme  principal  utilisant  les  fonctions  SaisirCubo,  AfficherCubo,  VerifCubo, VolCubo,  
et  Cubes qui  :  
a. Demande  à  l’utilisateur  un  nombre  de  parallélépipède  à  saisir,  
b. Saisit  ces  parallélépipèdes  dans  un  tableau,  
c. Corrige  les  parallélépipèdes  non  correctement  saisis  (profondeur  non  correcte),  
d. Affiche  l’indice  du  parallélépipède  de  plus  grand  volume,  
e. Affiche  les  cubes.  
 
   

    Page  62  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     MODULARITE  

IV.18.   EXERCICE  18  

Une   société   dispose   de   véhicules   pour   faire   ses   tournées,   elle   a   numéroté   ces   véhicules   1,   2,   3…   Certains   véhicules   sont   de   type  
frigorifique,   le   champ   frigo   a   alors   pour   valeur   vrai.   Pour   représenter   ces   véhicules   dans   notre   algorithme,   nous   utilisons   le  
type  structuré  Camionnette décrit  ci-­‐dessous.  
Type structuré Camionnette Début
Booléen Frigo
Caractère Statut
Fin
Le  champ  Statut  permet  d’indiquer  si  un  véhicule  est  :  
 en  tournée  :  lettre  ‘T’,
 disponible  :  lettre  ‘D’,
 en  panne:  lettre  ‘P’,
 en  réparation  :  lettre  ‘R’.
On  peut  modifier  le  statut  des  véhicules  de  la  façon  suivante  :  
 Prendre   un   véhicule   disponible   pour   effectuer   une   tournée.   Attention,   certains   transports   demandent   impérativement  
l’utilisation  d’un  véhicule  frigorifique.  Le  statut  devient  alors  ‘T’;
 Prendre  un  véhicule  en  panne  pour  effectuer  des  réparations.  Le  statut  devient  alors  ‘R’;  
 Ramener  un  véhicule  après  réparations.  Le  statut  devient  alors  ‘D’;  
 Rentrer  de  tournée.  Le  statut  devient  alors  ‘D’;  
 Signaler  un  véhicule  en  panne.  Le  statut  devient  alors  ‘P’;  
On  stocke  les  véhicules  de  l’entreprise  dans  un  tableau.  

Ecrire   une   fonction   ou   procédure   qui   à   partir   du   tableau   de   variables   de   type   Camionnette,   du   numéro   du  
véhicule,   et   d’un   caractère   spécifiant   le   nouveau   statut,   met   à   jour   le   tableau.   Ne   faire   ni   lecture   ni   affichage  
dans  cette  action.  
On  dispose  du  programme  principal  suivant  :  
main( )
{
Camionnette Ent[100] ;
int nbv, j ;
char rep ;
// A compléter
cin >> nbv ;
for ( j=0 ;j<nbv ; j++){
Ent [ j ].Frigo = false ;
Ent [ j ].Statut = 'D' ;
}
// A compléter : définition des camionnettes frigorifiques
cin >> rep ;
while ( rep != 'Q' ) {
// A compléter
cin >> rep ;
}
}
 

   

    Page  63  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     MODULARITE  

V.   MODULES  RECURSIFS  
La   récursivité   est   un   concept   concernant   aussi   bien   des   structures   de   données   que   des   étapes   de   programme.   Ce   concept  
consiste   à   définir   directement   ou   indirectement   une   structure   de   données   ou   une   étape   de   programme   en   fonction   d’elle-­‐
même.  
Un   module   (fonction   ou   procédure)   récursif   est   module   qui   fait   appel   à   lui-­‐même   avec   éventuellement   des   paramètres   et/ou   des  
valeurs  de  paramètres  différents.  C'est-­‐à-­‐dire  qu'à  l'intérieur  du  corps  du  module,  il  y  a  au  moins  un  appel  à  lui-­‐même.    
Il   est   à   noter   que   la   récursivité   n'est   pas   forcément   directe.   En   effet,   un   module   peut   en   appeler   un   autre   qui   en   appelle   un  
autre…   qui   finalement   appelle   le   module   d'origine.   Cela   peut   conduire   à   de   la   récursivité   croisée.   Le   cas   élémentaire   de  
récursivité  croisée  est  celui  où  un  module  A  appelle  un  module  B  qui  appelle  à  son  tour  le  module  A.  
Dans   de   très   nombreux   cas,   l'écriture   récursive   d'un   programme   est   plus   aisée   que   l'écriture   itérative.   Toutefois,   des  
précautions  sont  à  observer.  

V.1.   REMARQUES  SUR  LES  MODULES  RECURSIFS  

L'emploi   de   modules   récursifs   comporte   le   risque   d'un   nombre   d'appels   illimité   du   module   par   lui-­‐même,   ne   fournissant   ainsi  
jamais   de   résultat   ou   bien   encore   exécutant   des   instructions   jusqu'à   ce   que   la   mémoire   soit   saturée.   La   présence   d'au   moins   un  
test   d'arrêt   dans   le   corps   d'un   sous-­‐programme   récursif   est   indispensable   ainsi   que   la   vérification   que   l’on   converge   vers   la  
condition  d’arrêt.  
En  effet,  à  chaque  appel  du  module,  une  «  copie  »  du  module  est  effectuée  en  mémoire  et  donc  l'exécution  du  sous-­‐programme  
récursif  peut  entraîner  une  saturation  de  la  mémoire  ou  encore  s'avérer  trop  lente  (problème  de  complexité).  
La   saturation   de   la   mémoire   est   un   risque   non   négligeable   car,   en   plus   de   la   «  copie  »   du   sous-­‐programme,   à   chacun   de   ses  
appels   l'environnement   du   sous-­‐programme   est   créé   avec   des   variables   locales,…   et   une   adresse   de   retour   s'il   s'agit   d'une  
fonction.  En  effet,  les  langages  permettant  l'écriture  de  modules  récursifs  utilisent  une  pile  (zone  mémoire)  dans  laquelle  ces  
données  sont  stockées  et  qui  peut  finir  par  être  saturée.  
Un   algorithme   récursif   peut   toujours   s'écrire   sous   forme   itérative   (avec   des   boucles)   mais   cela   nécessite   souvent   du  
programmeur  la  rédaction  de  séquences  d'instructions  pour  la  gestion  de  la  pile  de  données  à  préserver.  
En  revanche,  l'écriture  de  modules  récursifs  est,  dans  certains  cas,  la  seule  façon  raisonnable  de  rédiger  l'algorithme  surtout  si  
une  ou  plusieurs  structures  de  données  manipulées  sont  elles-­‐mêmes  récursives  (arbres,  listes,…).  

    Page  64  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     MODULARITE  

V.2.   STRUCTURE  GENERALE  D’UN  MODULE  RECURSIF  

V.2.1.   Fonction  

FonctionRécursive'

Type)paramètre,)nom)paramètre)
Type)paramètre,)nom)paramètre)
)
Type)paramètre,)nom)paramètre)
)
Type)paramètre,)nom)paramètre)
Type)paramètre,)nom)paramètre)

Type '
Variables)Internes)
)Type)Param)
)… ))
) ))

non)
Condition)arrêt)?)

oui)
Actions)arrêt) Actions)empilement)

Retour) Param))←)FonctionRécursive()liste)paramètres))))

Valeur'Arrêt '
Actions)dépilement)

Retour)
Valeur'dépendant'de'Param '
 

    Page  65  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     MODULARITE  

V.2.2.   Procédure  

ProcédureRécursive-

Type)paramètre,)nom)paramètre)
Type)paramètre,)nom)paramètre)
)
Type)paramètre,)nom)paramètre)
)
Type)paramètre,)nom)paramètre)
Type)paramètre,)nom)paramètre)

Variables)Internes)
)… ))
) ))

non)
Condition)arrêt)?)
oui)
Actions)arrêt) Actions)empilement)

)ProcédureRécursive)()liste)paramètres))))

Actions)dépilement)

Fin)
 
   

    Page  66  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     MODULARITE  

V.3.   EXEMPLES  DE  SOUS-­‐PROGRAMMES  RECURSIFS  

V.3.1.   Fonction  factorielle  

V.3.1.1. Ecriture  récursive  

Facto"

Entier'n' long facto(int n)

{
Entier"long " if ( n > 0 )
non'
n''>'0'?' return facto(n - 1)*((long)n) ;
oui' if ( n == 0 )
non'
n''='0'?' return 1;
Retour' return -1 ;
oui' }
n"*"Facto"("n"–"1")"
Retour'
Retour'
1 "
-1 "

V.3.1.2. Ecriture  itérative  (non  récursive)  

Factorielle*

Entier)n)

Entier**long *
long factorielle(int n)
Variables)Internes)
)Entier)i )) {
)Entier)long)f) )) int i ;
) )) long f ;
if ( n > 0 )
non) {
n))>)0)?)
f = 1 ;
oui) non)
n))=)0)?) for (i=2 ; i<=n ;i++)
f)←)1) f = f*i ;
return f ;
i)←)2)
oui) } //else inutile
if ( n == 0 )
return 1;
i)≤)n)?)
non) //else inutile
oui) return -1 ;
f)←)f)*)i) }

i)←)i)+)1)
Retour)

*
f Retour)

Retour)
1 *
-1 *
 

    Page  67  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     MODULARITE  

V.3.2.   Fonction  puissance  

La  fonction  écrite  ici  n’est  valide  que  dans  le  cas  où  la  valeur  entière  passée  en  paramètre  n'est  pas  négative.  C’est  à  l’utilisateur  
de  la  fonction  de  vérifier  cette  condition  avant  d'appeler  la  fonction.  
 
 
Pow
 
Réel x float Pow(float x, int n)
Entier n {
Réel
if ( n== 0 )
non return 1.0 ;
n =0?
// else inutile
oui non if ( n % 2 == 0 )
n %2=0?
return Pow( x, n/2 ) * Pow( x, n/2);
Retour
oui // else inutile
1 return x * Pow( x, n/2) * Pow( x, n/2);
Retour }
Pow ( x, n div 2 ) * Pow ( x, n div 2 ) Retour

x * Pow ( x, n div 2 ) * Pow ( x, n div 2 )

 
Cette  version  est  très  coûteuse  en  temps  de  calcul  car  elle  multiplie  le  nombre  d’appels  récursifs,  une  version  avec  stockage  des  
valeurs  est  plus  adaptée.  
 
 
Powb
 
Réel x  
Entier n  
 
Réel
float Powb(float x, int n)
{
Variables Internes float p ;
Réel p
if ( n== 0 )
return 1.0 ;
non // else inutile
n =0?
p = Powb( x, n/2 ) ;
oui if ( n % 2 == 0 )
p ← Powb ( x, n div 2 )
return p * p ;
Retour
non // else inutile
n %2=0? return x * p * p ;
1
}
oui
 
Retour
p*p
Retour

x*p*p
 
   

    Page  68  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     MODULARITE  

V.3.3.   Fonction   renvoyant   une   solution   s ∈ ]binf, bsup [   d'une   équation   f(x)=0   par   la  
méthode   de   dichotomie   à   une   erreur   près,   f   étant   monotone   sur   l’intervalle  
de  recherche.  

V.3.3.1. Fonctions  utiles  à  la  résolution  

F"
float F(float x)
Réel'x'
{
return x * x -2.0 ;
Réel " }
Retour'

x"*"x"–"2.0 "
 
Abs#

Réel%x% float Abs(float x)

{
if (x >= 0)
Réel # non% return x ;
x%%≥%%0%?%
else // else inutile
oui% return -1*x ;
Retour% Retour% }
x # !1#*#x #
 

V.3.3.2. Ecriture  récursive  

Cette  écriture  suppose  qu’il  existe  une  solution  sur  l’intervalle  considéré.  

Dicho&

Réel$binf$
Réel$bsup$
Réel$eps$

float Dicho(float binf, float bsup,

Réel & float eps)
$ {
Variables$Internes$
$Réel$m $$ float m ;
$ $$
$ $$ m = (binf + bsup) / 2.0 ;
m$←$($binf$+$bsup$)$/$2.0$ if ( (Abs(binf – bsup) < eps) ||
(Abs(F(m)) < eps) )
Abs$($binf$–$bsup$)$<$eps$$ non$
return m ;
ou$ // else inutile
Abs$($F(m)$)$<$eps$$?$
if ( F(m) * F(bsup) > 0 )
oui$ non$
$F$($m$)$*$F$($bsup$)$>$0$?$ return Dicho(binf, m, eps);
oui$ // else inutile
Retour$
return Dicho( m , bsup , eps );
m & }
Retour$
Dicho&(&binf&,&m&,&eps&) &
Retour$
Dicho&(&m&,&bsup&,&eps&) &
 

    Page  69  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     MODULARITE  

V.3.3.3. Ecriture  itérative  

Cette  écriture  suppose  qu’il  existe  une  solution  sur  l’intervalle  considéré.  
 

Dicho"

Réel$binf$
Réel$bsup$
Réel$eps$
float Dicho(float binf, float bsup,
"
Réel float eps)
$
{
Variables$Internes$ float m ;
$Réel$m $$
$ $$ m = (binf + bsup) / 2.0 ;
$ $$
while ((Abs(binf – bsup) >= eps) &&
m$←$($binf$+$bsup$)$/$2.0$ (Abs(F(m)) >= eps) )
{
if ( F(m) * F(bsup) > 0 )
Abs$($binf$–$bsup$)$≥$eps$$ non$
et$ bsup = m ;
Abs$($F(m)$)$≥$eps$$?$ else
oui$ binf = m ;
}
non$
$F$($m$)$*$F$($bsup$)$>$0$?$ return m ;
}
oui$
bsup$←$m$ binf$←$m$

Retour$
m "
 

VI.   EXERCICES  

VI.1.   EXERCICE  1  
Les  valeurs  calculées  par  les  suites  de  Fibonacci  sont  obtenues  par  des  relations  de  la  forme  :   f(n)= A.f(n−1)+ B.f(n−2) .  

Quels  sont  les  paramètres  nécessaires  à  une  fonction  permettant  de  calculer  f(n)  ?  

Ecrire  l'algorithme  récursif  permettant  de  calculer  f(n).  

VI.2.   EXERCICE  2  
Les  palindromes  sont  des  mots  se  lisant  aussi  bien  à  l'endroit  qu'à  l'envers  comme  :  LAVAL,  ELLE,  ETE,  KAYAK.  

Ecrire  l'entête  et  l'algorithme  d'une  fonction  récursive  booléenne  retournant  vrai  si  une  chaîne  de  caractère  
est  un  palindrome  et  faux  sinon.  Ecrire  l’appel  à  cette  fonction.  Traduire  en  langage  C  

VI.3.   EXERCICE  3  
Ecrire  une  fonction  récursive  booléenne  retournant  vrai  si  les  deux  chaînes  de  caractères  sont  dans  un  ordre  

    Page  70  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     MODULARITE  

inversé  comme  par  exemple  :  NOEL  et  LEON,  OTAN  et  NATO,  SNOB  et  BONS,  ELLES  et  SELLE…  On  appelle  un  
tel  mot  un  anacyclique.  

Traduire  en  langage  C.  Ecrire  un  programme  principal  qui  appelle  cette  fonction.  

VI.4.   EXERCICE  4  
Ecrire   l'entête   et   l'algorithme   d'une   fonction   récursive   de   recherche   dichotomique   permettant   dans   un  
tableau  d'entiers  rangés  dans  l'ordre  croissant  de  MAX  cases  de  retourner  la  place  du  nombre  recherché  ou  
une  valeur  négative  si  le  nombre  n'est  pas  dans  le  tableau.  

Traduire  en  langage  C.  Ecrire  un  programme  principal  qui  appelle  cette  fonction.  

VI.5.   EXERCICE  5  
Ecrire   une   fonction   récursive   booléenne   retournant   vrai   si   les   deux   chaînes   de   caractères   sont   des  
anagrammes.   Un   anagramme   est   un   mot   obtenu   par   la   permutation   de   ces   lettres.   Par   exemple  :   chien   et  
niche,  crane  et  ecran,  ironique  et  onirique  …  

Traduire  en  langage  C.  Ecrire  un  programme  principal  qui  appelle  cette  fonction.  

VI.6.   EXERCICE  6  
Ecrire   l'entête   et   l'algorithme   d'une   fonction   récursive   permettant   d’inverser   un   mot.   Par   exemple  :  
allumettes  donne  settemulla  …  

Traduire  en  langage  C.  Ecrire  un  programme  principal  qui  appelle  cette  fonction.  

VI.7.   EXERCICE  7  
Ecrire   l'entête   et   l'algorithme   d'une   fonction   récursive   permettant   de   calculer   la   somme   des   chiffres   d’un  
nombre  saisi  comme  une  chaîne  de  caractères.  Par  exemple  :  236714  donne  23…    

Traduire  en  langage  C.  Ecrire  un  programme  principal  qui  appelle  cette  fonction.  
 
Remarque  :  une  variable  de  type  char  peut  être  vue  comme  un  entier,  sa  valeur  entière  est  celle  de  son  code  ASCII.  Ainsi,  le  
caractère  ‘3’  a  pour  valeur  entière  51.  Les  lettres  0  à  9  sont  ordonnées.  Le  code  ASCII  de  ‘0’  vaut  48.  Si  on  souhaite  stocker  dans  
une  valeur  entière  k  le  nombre  représenté  par  un  caractère  stocké  dans  la  variable  c  il  suffit  d’écrire  :  k  =  c  –‘0’  ;  

VI.8.   EXERCICE  8  
Ecrire  l'entête  et  l'algorithme  d'une  fonction  récursive  permettant  de  dire  si  un  caractère  appartient  ou  non  à  
une  chaîne.  

Traduire  en  langage  C.  Ecrire  un  programme  principal  qui  appelle  cette  fonction.  

    Page  71  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     MODULARITE  

VII.   EXERCICE  GENERAL  

Cet  exercice  peut  être  traité  en  algorithmique  ou  en  langage  C,  ce  choix  doit  rester  le  même  tout  au  long  de  
l’exercice.  On  représente  une  tâche  d’un  emploi  du  temps  par  le  type  structuré  Tache  décrit  Figure  14  ou  Figure  
15.   Les   fonctions   de   saisie   et   d’affichage   d’une   date   et   d’affichage   d’une   tâche   sont   écrites,   le   programme  
principal  est  commencé.  Vous  aurez  à  écrire  d’autres  fonctions  et  à  compléter  le  programme  principal.  

 
Figure  14  :  Types,  fonctions  et  programme  principal  pour  l’algorithmique  

 
 
 
Figure  15  :  Types,  fonctions  et  programme  principal  pour  la  programmation  

Ecrire   une   fonction   SaisirTache   permettant   de   saisir   une   variable   de   type   Tache.   Vous   devez   faire   appel   à  
la  fonction  SaisirDate.  

Compléter   le   programme   principal   afin   de   saisir   des   tâches   tant   que   l’utilisateur   le   souhaite.   Chaque   tâche  
saisie   doit   être   stockée   dans   le   tableau   edt,   à   sa   place.   Le   tableau   edt est   classé   par   ordre   croissant   d’heure  
de  début.  Vous  devez  faire  appel  à  la  fonction  SaisirTache.  

Ecrire  une  fonction  AfficheParJour  permettant  d’afficher  toutes  les  tâches  d’une  journée.  La  date  de  cette  
journée  est  passée  en  paramètre  d’entrée.  La  fonction  peut  être  récursive.  Vous  devez  faire  appel  à  la  fonction  
AfficheTache.  

Compléter   le   programme   principal   afin   de   saisir   une   date   et   d’afficher   toutes   les   tâches   à   effectuer   ce   jour-­‐là.  
Vous  devez  faire  appel  à  la  fonction  AfficheParJour.    
 

    Page  72  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Fichiers  

FICHIERS  
Les   fichiers   sont   des   ensembles   de   données   sauvegardés   dans   la   mémoire   morte   (disque   dur,   CD,   DVD,   disquette…).   Ces  
données  sont  conservées  après  l'arrêt  et  la  fermeture  du  programme  qui  les  a  créées  (programme  fonctionnant  sur  la  mémoire  
vive).  Les  fichiers  peuvent  être  utilisés  par  le  programme  ayant  servi  à  leur  création  ou  bien  par  un  autre  programme.  
Il  existe  deux  types  de  fichiers  de  données  :  
 Les   fichiers   au   format   texte   contiennent   des   chaînes   de   caractères   lisibles   par   tout   éditeur   de   texte.   Les   données   y   sont  
stockées  sous  la  forme  de  caractères  ASCII  et  sont  des  caractères,  des  chaînes  de  caractères  ou  des  nombres.  
 Les  fichiers  binaires  contiennent  des  informations  codées  de  la  même  façon  que  dans  la  mémoire  vive  de  l'ordinateur.  
Pour  utiliser  les  informations  d'un  fichier,  il  est  nécessaire  d'utiliser  une  variable  servant  d'interface  entre  la  mémoire  vive  (où  
s'exécute  le  programme)  et  la  mémoire  morte  (où  est  stocké  le  fichier).  
En   C,   il   s'agit   d'un   pointeur   sur   un   fichier.   Cette   notion   de   pointeur   n’ayant   pas   été   étudiée,   et   les   fonctions   utilisées   étant  
complexes,   les   fichiers   seront   manipulés   en   langage   C++.   En   C++,   il   s'agit   d'une   «  variable   fichier  ».   Les   fonctions   permettant  
d'opérer  sur  les  fichiers  appartiennent  à  la  bibliothèque  fstream.  

I.   DECLARATION  D'UNE  VARIABLE  FICHIER  

La  déclaration  de  la  variable  fichier  est  effectuée  de  la  manière  suivante  :   type variable ;  
type  peut  être  :  
 fstream  pour  une  ouverture  de  fichier  indéterminée  (lecture  ou  écriture),  
 ofstream  pour  une  ouverture  de  fichier  en  écriture  seule,    
 ifstream  pour  une  ouverture  de  fichier  en  lecture  seule.  

Exemple  :  
ofstream monfichier;
fstream f;

II.   LIEN  ET  OUVERTURE  D'UN  FICHIER  PHYSIQUE  

La   variable   fichier   doit   être   liée   avec   un   fichier   physique   (mémoire   morte   de   l'ordinateur).   Ce   lien   se   fait   lors   l'ouverture   du  
fichier,  par  l'instruction  suivante  :  
variable.open(arg1,arg2);
La  fonction  open  prend  2  paramètres  d'entrée  (arg1  et   arg2)  qui  déterminent  quel  fichier  va  être  ouvert  et  la  façon  dont  il  
est  ouvert  :  
arg1  :  doit   être   de   type  chaîne   de   caractères   en   C   (donc   char *).Lorsqu’on   utilise   une   variable   de   type   string il  
est   nécessaire   d’ajouter   l’opérateur   c_str().   Dans   les   deux   cas   il   s'agit   d'une   chaîne   de   caractères  
contenant  le  chemin  d'accès  absolu  ou  relatif  au  fichier  physique  ainsi  que  son  nom.  
arg2 :  est   un   mot   machine   (un   octet)   traduisant   différentes   options.   Les   options   sont   stockées   dans   ios   par   4  
points  (::),  séparées  par  un  "ou  progressif"  noté  "|"  
où  on  utilise  les  mots  suivants  :  
 in→   ouverture  en  lecture  (implicite  pour  ifstream),  
 out→   ouverture  en  écriture  (implicite  pour  ofstream),  
 binary mode  fichier  binaire  (mode  texte  par  défaut).  

Exemples  :
ofstream monfichier;
fstream f;
string nomf = "exercice2.txt";
monfichier.open("c:\TPinfo\TP6\exemple",ios::out|ios::binary);
f.open(nomf.c_str(),ios::in);

    Page  73  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Fichiers  

III.   ACCES  AUX  INFORMATIONS  CONTENUES  DANS  LES  FICHIERS  

III.1.   FICHIERS  BINAIRES  

En  considérant  la  variable  fichier  variable  utilisée  précédemment,  les  fonctions  sont  définies  ci-­‐après.  

III.1.1.   Lecture  
variable.read(arg3,arg4); //  lecture  d'octets  du  fichier
arg3:     est   de   type   char*   et   désigne   l'adresse   du   premier   octet   (un   char   est   codé   sur   1   octet)   de   la   zone   mémoire  
dans   laquelle   on   va   stocker   les   octets   lus.   On   fait   donc   précéder   la   variable   où   on   stocke   ce   qu’on   lit   de  :  
(char*)&  
arg4  :     est  d'un  type  entier  et  correspond  au  nombre  d'octets  lus  (et  donc  à  la  taille  de  la  variable  dans  laquelle  on  stocke  
ce  qu'on  a  lu).  Ce  nombre  est  obtenu  par  la  fonction  sizeof(…).  

Exemple  :  
int k;
sonfichier.read((char*)&k, sizeof(k));

III.1.2.   Ecriture  
variable.write(arg3,arg4); //  écriture  d'octets  dans  le  fichier
arg3:     est   de   type   char*   et   désigne   l'adresse   du   premier   octet   (un   char   est   codé   sur   1   octet)   de   la   variable   dans  
laquelle   sont   stockés   les   octets   à   écrire   dans   le   fichier..   On   fait   donc   précéder   la   variable   contenant   ce   qu’on   écrit  
de  :  (char*) &  
arg4  :     est   d'un   type   entier   et   correspond   au   nombre   d'octets   à   écrire   dans   le   fichier   (et   donc   à   la   taille   de   la   variable  
qu'on  veut  écrire  dans  le  fichier).  

Exemple  :  
monfichier.write((char*)&k, sizeof(int));
Attention  :   Lorsqu’on   utilise   des   chaînes   de   caractères   et   les   fonctions   de   lecture   et   d’écriture   dans   des   fichiers   binaires,   on  
ne   peut   pas   utiliser   le   type string   car   la   fonction   sizeof   ne   peut   pas   déterminer   la   taille   de   la   chaîne,   que   les   chaînes  
soient  définies  simplement  ou  dans  un  type  structuré.  Il  faut  définir  les  variables  comme  des  tableaux  de  caractères.  

III.1.3.   Remarques  
 sizeof  est  un  opérateur  unaire  qui  renvoie  le  nombre  d'octets  de  son  opérande,  que  cet  opérande  soit  une  variable  ou  
un  type,  simple  ou  structuré.  
 sizeof(char) donne  le  nombre  d'octets  occupés  par  un  char  (1).  
 sizeof(k)  donne  le  nombre  d'octets  occupés  par  un  int  (2  ou  4  généralement).  
 Les   deux   fonctions   (read   et   write)   renvoient   un   booléen   valant   vrai   (!=0 ou true)   lorsque   l'opération   a   réussi   (on  
a   pu   lire   ou   écrire   des   données   dans   le   fichier)   ou   faux   (0 ou false)   lorsque   l'opération   a   échoué   (l'écriture   ou   la  
lecture  n'ont  pas  été  possibles).  
 La   principale   raison   de   l'impossibilité   de   lire   des   données   dans   un   fichier   binaire   est   qu'il   n'y   a   plus   rien   à   lire.   Donc,  
lorsqu'on   est   en   fin   de   fichier   (parce   qu'il   est   vide   ou   parce   qu'on   a   tout   lu),   la   fonction   read   renvoie   faux   (0 ou
false).  Un  test  sur  la  valeur  renvoyée  par  la  fonction  nous  permet  donc  de  nous  arrêter  en  fin  de  fichier  lors  de  la  lecture  
d'un  fichier.  
   

    Page  74  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Fichiers  

III.1.4.   Exemple  
struct article {
char nom[21];
int quantite;
float prix;
};
fstream fich, fach ; //déclaration  des  variables  fichier
struct article art1, art2,art;
cin>>art1.nom>>art1.quantite>>art1.prix; //saisie  des  champs  des  variables
cin>>art2.nom>>art2.quantite>>art2.prix;
fich.open("exemple.bin", ios::out |ios::binary); //ouverture  du  fichier  en  écriture
fich.write((char*)&art1,sizeof(article)); //écriture  d'un  1er  article  
fich.write((char*)&art2,sizeof(art2)); //écriture  d'un  2ème  article  
fach.open("exemple.bin", ios::in|ios::binary); //ouverture  du  même  fichier,  lecture
while (fach.read((char*)&art,sizeof(article))!=0) //lecture  puis
{ cout<<art.nom<<'\t'<<art.prix<<'\t'; //affichage  de  chaque  article  lu  
cout<<art.quantite<<'\n';
}

III.2.   FICHIERS  TEXTE  

Pour   lire   et   écrire   dans   des   fichiers   texte,   on   utilise   les   opérateurs   de   flux  <<   et   >>   (ceux   utilisés   pour   l'affichage   et   la   saisie   de  
données  avec  cout  et  cin).  

III.2.1.   Lecture  
Pour   la   lecture,   on   utilise   la   variable   fichier,   suivie   de   l'opérateur  >>   puis   des   variables   dans   lesquelles   on   stocke   ce   qu'on   a   lu  
dans  le  fichier.  
variable >>arg1>>arg2>>…>>argN;
argI  peut  être  une  variable  de  tout  type  pouvant  être  lue  avec  un  cin.  
Exemple  :  
string chaine;
int m;
f>>chaine>>m;

III.2.2.   Ecriture  
Pour  l'écriture,  on  utilise  la  variable  fichier,  suivie  de  l'opérateur  <<  puis  des  variables  à  écrire  dans  le  fichier.  
variable <<arg1<<arg2<<…<<argN;
argI  peut  être  une  variable,  une  valeur  ou  une  expression  de  tout  type  pouvant  être  affichée  avec  un  cout.  
Exemple  :  
g<<"On peut écrire dans le fichier\n";
g<<12<<" + "<<19<<" = "<<12+19;

III.2.3.   Remarques  :  
 Dans   le   cas   où   des   chaînes   de   caractères   sont   utilisées   pour   l'habillage   du   fichier   (comme   les   " + "   et   " = "   dans  
l’exemple   ci-­‐dessus),   ces   chaînes   non   porteuses   d'informations   utiles   pour   le   programme   doivent   quand   même   être   lues   et  
stockées   dans   des   variables   dont   le   contenu,   bien   sûr,   ne   sera   pas   utilisé.   Elles   ne   serviront   qu'à   la   progression   dans   le  
fichier  texte.  Les  espaces  sont  considérés  comme  des  séparateurs  (à  éviter,  ou  à  lire).  Par  exemple,  il  faut  6  lectures  dans  
une  chaîne  de  caractères  pour  «  absorber  »  le"On peut écrire dans le fichier".  

    Page  75  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Fichiers  

 La  fonction   setw(nb),  avec   nb  une  variable  de  type  entier  ou  un  nombre,  permet  de  formater  le  nombre  de  caractères  
pris  en  compte  avec  les  opérateurs  de  flux  <<  et  >>.  Cette  fonction  appartient  à  la  bibliothèque  iomanip.  
 setw(nb)  permet  d'afficher,  de  lire  ou  d'écrire  une  variable  sur  nb  caractères,  des  espaces  étant  ajoutés  avant  la  valeur  
de  la  variable  pour  combler  les  caractères  manquants  (alignement  à  droite).  

Exemple  :  
cout << setw(4) << 10 ; //  affiche  2  espaces  et  la  valeur  10   VV10
cout << setw(4) << 245 ; //  affiche  1  espace  et  la  valeur  245   V245
 Comme  pour  les  fichiers  binaires,  il  est  possible  de  savoir  si  la  lecture  et  l'écriture  ont  échoué.  En  cas  de  réussite,  la  variable  
fichier  elle-­‐même  vaut  vrai  (!=0 ou true),  sinon  elle  vaut  faux  (0 ou false).  Pour  tester  la  fin  de  fichier,  on  doit  
donc  tester  la  variable  elle-­‐même.  

III.2.4.   Exemple  :  
struct article {
char nom[21];
int quantite;
float prix;
};
fstream fich, fach ; //déclaration  des  variables  fichier
struct article art1, art2,art;
cin>>art1.nom>>art1.quantite>>art1.prix; //saisie  des  champs  des  variables
cin>>art2.nom>>art2.quantite>>art2.prix;
fich.open("exemple.txt", ios::out);
fich<<setw(21)<<art1.nom<<setw(5)<<art1.quantite ;
fich <<setw(8)<<art1.prix<<'\n';
fach.open("exemple.txt", ios::in);
while(1)
{ fach>>setw(21)>>art1.nomfach>>setw(5)>>art1.quantite ;
fach >>setw(8)>>art1.prix;
if (fach==0) break; //si  la  lecture  a  échoué,on  sort  de  la  boucle,  sinon  on  affiche  
cout<<art1.nom<<'\t'<<art1.prix<<'\t'<<art1.quantite<<'\n';
}

III.3.   FIN  DE  FICHIER  

On  peut  savoir  si  on  est  en  fin  de  fichier  par  l'une  des  2  méthodes  vues  précédemment  :  
  variable.read(arg3,arg4)  renvoie  faux  pour  les  fichiers  binaires    
ou  variable  vaut  faux  pour  les  fichiers  texte.  
On  peut  aussi  utiliser  la  fonction  eof(end  of  file).  
variable.eof()  renvoie  vrai  (!=0)  si  on  est  en  fin  de  fichier,  faux  (0)  sinon.  
Exemple  
fstream h;
int k;

h.open("tests.txt", ios::in);
h>>k;
if(h.eof() != 0) cout << "Fin de fichier atteinte\n";
else cout << "Valeur lue : " << k << "\n" ;

III.4.   FERMETURE  DU  FICHIER  

La  variable  fichier  est  liée  à  un  fichier  physique  au  moment  de  l'ouverture  du  fichier  (fonction   open),  ce  lien  est  détruit  et  le  
fichier  fermé  par  la  fonction  close().  
variable.close();

    Page  76  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Fichiers  

III.4.1.   Exemples  
g.close();
monfichier.close();
f.close();
sonfichier.close();

IV.   EXERCICES  

IV.1.   EXERCICE  1  
On  souhaite  informatiser  la  gestion  d'un  magasin  comportant  des  articles  représentés  par  :  
 un  code,  entier  positif  de  quatre  chiffres  ;  
 un  nom  d'au  maximum  20  caractères  ;  
 un  prix  ;  
 un   stock   de   type   Appro,   dont   le   champ   val   correspond   au   stock   actuel   de   l'article,   et   le   champ   min   au   stock   minimal   en  
dessous  duquel  il  faut  réapprovisionner  le  magasin.  
La  structuration  des  données  est  la  suivante  :  
struct Appro { struct Article {
int val; int code;
int min; char nom[26];
}; float prix;
Appro stock;
};
Exemple  de  données  :  
3000   vélo   7   3   299,99  
2514   pompe   1   20   6,49  
4001   poignée   20   5   6,09  
8475   compteur   0   4   21,95  
8745   selle   1   6   39,99  

Utilisation  d’un  fichier  binaire  

 Saisir   plusieurs   articles   au   clavier   et   les   stocker   dans   un   fichier   binaire   d'articles.   On   arrêtera   la   saisie   lorsque   le   code  
proposé  par  l'utilisateur  sera  égal  à  0  (zéro).  
 Afficher  ensuite  les  informations  contenues  dans  le  fichier  à  l'écran.  
N'oubliez  pas  de  fermer  les  fichiers  en  fin  de  programme.  

Utilisation  d’un  fichier  texte  

 Ecrire   un   programme   qui   demande   le   nom   d'un   fichier   binaire   créé   précédemment   et   écrit   les   données   lues   dans   un   fichier  
texte  au  lieu  de  les  afficher  à  l'écran.  
 Regardez  le  contenu  du  fichier  texte  à  l'aide  d'un  éditeur  de  texte  par  exemple.  

Utilisation  d’un  fichier  texte  et  d’un  fichier  binaire  

 Ecrire  un  programme  qui  demande  le  nom  d'un  fichier  texte  contenant  des  informations  sur  des  articles  d'un  magasin  (vous  
pouvez  le  créer  avec  un  éditeur  de  texte).  
 Créer  un  fichier  binaire  dans  lequel  ne  figurent  que  les  articles  devant  être  réapprovisionnés.  
 Vérifiez  le  contenu  du  fichier  binaire  à  l'aide  du  programme  écrit  à  la  question  précédente  (Utilisation  d’un  fichier  texte).  
 

Remarque  :  il  est  nécessaire  d’utiliser  la  fonction  setw(… )  dans  les  deux  dernières  questions.  
   

    Page  77  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Fichiers  

IV.2.   EXERCICE  2  
Soit  le  programme  suivant  :   void fonction3 (string r1, objet r2[ ], int r3)
#include <iostream> { fstream W;
#include <string> int k;
#include <fstream> W.open(r1.c_str(), ios::out);
#include <iomanip> for (k=0; k<r3; k++)
using namespace std; {
struct objet W << r2[k].ch1 << " " << r2[k].ch2 << endl;
{ string ch1; }
float ch2; W.close();
}; }
void fonction1(string p1,objet p2[ ],int&p3) void fonction4 (string v1, string v2)
{ fstream D; { fstream A, B;
p3=0; char x[30];
D.open(p1.c_str(), ios::in); float y;
D >> p2[p3].ch1; A.open(v1.c_str(), ios::in);
while(!D.eof()) B.open(v2.c_str(), ios::out);
{ A >> x;
D >> p2[p3].ch2; while ( !A.eof() )
p3++; { A >> y;
D >> p2[p3].ch1; B << x << " " << y << endl;
} A >> x;
D.close(); }
} A.close();
void fonction2 (objet g1[ ], int & g2) B.close();
{ int k, j, m; }
k=0; main ()
while (k<g2) { objet Tab[100];
{ j=k+1; int n, i;
while (j<g2)
{ if (g1[k].ch1 == g1[j].ch1) fonction1 ("UN", Tab, n) ;
{ cout<<"-----------> reponse 1 : "<<n<<endl ;
g1[k].ch2 += g1[j].ch2; cout<<"-----------> reponse 2 : "<<endl ;
for (m=j; m<g2-1; m++) for (i=0 ; i<n ; i++)
{ g1[m] = g1[m+1]; cout<<" "<<Tab[i].ch1<<", "<<Tab[i].ch2<<endl;
} fonction2 (Tab, n) ;
g2--; cout<<"----------> reponse 3 : "<<n<< endl ;
} cout<<"-----------> reponse 4 : "<<endl ;
j++; for (i=0 ; i<n ; i++)
} cout<<" "<<Tab[i].ch1<<", "<<Tab[i].ch2<<endl;
k++; fonction3 ("ANOMMER", Tab, n) ;
} fonction4 ("ANOMMER","UN") ;
} }

Le  fichier  UN  a  le  contenu  suivant  :    

pierre 21.34
jacques 23.45
pierre 12.3
anne 10.3
pierre 32.43
anne 21.95

Donnez  l’affichage  suivant  reponse  1  et  reponse  2.  Que  fait  la  fonction  fonction1  ?  

Donnez  l’affichage  suivant  reponse  3  et  reponse  4.  Que  fait  la  fonction  fonction2  ?  

Que   contient   le   fichier ANOMMER après   l’appel   à   la   fonction fonction3 ?   Que   fait   la   fonction  
fonction3  ?  

Que  contiennent  les  fichiers  ANOMMER et  UN  après  l’appel  à  la  fonction  fonction4 ?  Que  fait  la  fonction  
fonction4  ?  

L’appel   à   la   fonction   fonction4   n’était   pas   nécessaire,   dire   comment   modifier   le   programme   pour   qu’il  
donne  le  même  résultat  sans  utiliser  la  fonction  fonction4.  

    Page  78  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Fichiers  

IV.3.   EXERCICE  3  
On  manipule  dans  cette  question  des  outils  de  coupe  dans  un  atelier.  Un  outil  est  représenté  par  son  nom,  son  code,  sa  durée  
de  vie  et  sa  durée  d’utilisation.  Les  durées  sont  exprimées  en  minutes.  Un  booléen  indique  si  l’outil  est  (valeur  vrai)  ou  n’est  pas  
utilisable   (valeur   faux,   l’outil   est   usé,   cassé…).   L’atelier   est   représenté   par   un   tableau   d’outils.   On   dispose   du   type   structuré  
outil  :    
struct outil
{ char nom[26];
int code ;
int dvie ;
int dutil ;
bool ok ;
};

Ecrire  la  fonction  RecupAtelier  qui  produit  un  tableau  d’outils  (atel)  à  partir  d’un  fichier  texte  spécifié  par  
son  nom  (nomfich),  le  tableau  contient  alors  nbo  valeurs  :  
void RecupAtelier(string nomfich , outil atel[], int & nbo)

Ecrire  la  fonction  AChanger  qui  stocke  dans  un  fichier  binaire  tous  les  outils  à  changer.  

Ecrire  la  fonction  Affiche  qui  affiche  le  contenu  d’un  fichier  binaire  d’outils  à  l’écran.  

Ecrire  la  fonction  MiseAJour  qui  modifie  la  durée  d’utilisation  d’un  outil  en  fonction  de  la  durée  d’une  tâche.  
L’outil   sera   désigné   par   son   code   et   recherché   dans   le   tableau   représentant   l’atelier.   Aucune   saisie,   aucun  
affichage  ne  doit  être  fait  dans  cette  fonction.  Le  champ  ok pourra  être  modifié.  

Ecrire  la  fonction  Stocke  qui  stocke  le  contenu  d’un  tableau  d’outils  dans  un  fichier  texte.  

Ecrire  un  programme  principal  main  qui  :  

 Produit  le  tableau  d’outils  contenu  dans  le  fichier  Tour.txt  (appel  à  RecupAtelier),  
 Demande  à  l’utilisateur  le  code  d’un  outil  et  la  durée  d’une  tâche  puis  met  à  jour  cet  outil  (appel  à  MiseAJour),  
 Crée  le  fichier  Modif.bin  contenant  les  outils  à  changer  (appel  à  AChanger),  
 Affiche  à  l’écran  le  contenu  du  fichier  Modif.bin  (appel  à  Affiche),  
 Stocke  le  tableau  modifié  dans  le  fichier  texte  Outils.txt (appel  à  Stocke).  
N’oubliez  pas  de  déclarer  les  variables  nécessaires  au  programme  principal.  

IV.4.   EXERCICE  4  
Soit  la  fonction  ci-­‐contre  :   void fonction ()
Le  fichier  un  a  le  contenu  suivant  :     { fstream f, g, h;
int i;
9 12 7 21 14 6 -15 -30 28   f.open("un", ios::in);
Les  fichiers  deux et trois sont  vides.     g.open("deux", ios::out|ios::binary);
h.open("trois", ios::out);
f>>i;
while(!f.eof()) {
if(i%2==0) g.write((char*)&i, sizeof(int));
else h<<i<<' ';
f>>i;
}
f.close();
g.close();
h.close();
}

Que  contiendront  les  fichiers  un,  deux  et  trois  après  l'exécution  de  la  fonction  fonction  ?  

Que  fait  la  fonction  fonction  ?  

    Page  79  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Fichiers  

IV.5.   EXERCICE  5  
Soit  le  programme  C  suivant  manipulant  des  fichiers  :  
#include <fstream>
#include <iomanip>
struct MonType
{ int nb ;
float v ;
} ;
void main(void)
{ fstream f1,f2,f3;
MonType val;
f1.open("MonF1", ios::binary | ios::in);
f2.open("MonF2", ios::binary | ios::in);
f3.open("MonF3", ios::out);
while ( f1.read( (char *) &val , sizeof(MonType) ) != 0)
{ f3 << val.nb << " , " << val.v << "\n";
}
while (f2.read( (char *) &val , sizeof(MonType) ) != 0)
{ f3 << val.nb << " , " << val.v << "\n";
}
f1.close();
f2.close();
f3.close();
}

Combien  de  fichiers  ce  programme  manipule-­‐t-­‐il  ?  Précisez  pour  chacun  des  fichiers  son  type,  son  nom  sur  le  
disque,  s’il  est  crée,  modifié  ou  lu.  

Que  fait  ce  programme  ?  

IV.6.   EXERCICE  6  
Soient  le  type  structuré  et  les  2  fonctions  suivants  :  
struct exemple void A(string B, exemple C[], int &D)
{ int un; { fstream E;
float deux; exemple F;
char trois; int G, H;
}; E.open(B.c_str(), ios::in);
void I(string J, exemple K[], int L) while (! E.eof()) //ou while (E.eof()==false)
{ fstream M; { E>>F.un>>F.deux>>F.trois;
int N; G=0;
while (F.deux>C[G].deux && G<D) G++;
M.open(J.c_str(), ios::out); if(G<D)
for(N=0;N<L;N++) { for(H=D;H>G;H--) C[H]=C[H-1];
{ M<<' '<<K[N].trois; C[G]=F;
M<<' '<<K[N].un; }
M<<' '<<K[N].deux; else C[D]=F;
} D++;
M.close(); }
} E.close();
}
Nous   disposons   de   2   fichiers  :   "examen.txt"   contenant   les   données   de   la   Figure   16   et   "probleme.txt",   pour   l'instant  
vide.  Le  programme  étudié  comporte  les  2  variables  suivantes  :  
 Un  tableau  de  50  cellules,  appelé  DS,  contenant  les  données  de  type  exemple  de  la  Figure  17,  
 Un  entier  nb  valant  4,  indiquant  le  nombre  de  cellules  du  tableau  DS  occupées,  
ainsi  que  les  2  instructions  suivantes  :  
1) I("probleme.txt", DS, nb);
2) A("examen.txt", DS, nb);

Représentez  le  contenu  du  fichier  probleme.txt,  à  l'issue  de  l'exécution  de  la  première  instruction.  

    Page  80  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Fichiers  

Que  fait  la  fonction  I  ?    

Représentez  le  fichier  examen.txt,  tableau  DS  et  la  variable  nb  après  l'exécution  la  deuxième  instruction.    

Que  fait  la  fonction  A  ?  

29 -4.3 W 21 115.6 G
Figure  16  -­‐  contenu  de  examen.txt  
113 218 1 38
-18.1 2.3 17.5 38.8 …
R F Q A
Figure  17  –  tableau  DS  

IV.7.   EXERCICE  7  
On  dispose  du  début  de  programme  suivant,  qui  vise  à  gérer  des  fichiers  contenant  des  modèles  d’appareil  photo  numérique  
(APN),   ces   modèles   étant   décrits   par   le   type   photo   composé   de   la   marque,   du   nom   du   modèle,   du   type   d’appareil   (‘C’   pour  
appareil  compact  ou  ‘R’  pour  appareil  reflex)  et  le  prix  en  euros.  

De  quel  type  sont  les  fichiers  f1  et  f2  manipulés  par  la  fonction  FPhoto ?  Que  réalise  cette  fonction  ?  

On  dispose  des  trois  fichiers  textes  suivants.  Avec  lequel/lesquels  de  ces  fichiers  le  programme  fonctionnera-­‐t-­‐
il  correctement  ?  Justifiez  votre  réponse.  
 
#include<iostream> void FPhoto()
using namespace std; { fstream f1, f2;
#include <iomanip> string nomf1, nomf2;
#include <fstream> photo P;
#include <string> cout << "\nNom du fichier 1 \n";
cin >> nomf1;
struct photo f1.open(nomf1.c_str(), ios::in);
{ cout << "\nNom du fichier 2 \n";
char marque[20] ; cin >> nomf2;
char modele[20] ; f2.open(nomf2.c_str(), ios::out | ios::binary);
char type ; while (1)
float prix ; { f1 >> P.marque;
}; if (f1==0) break;
f1 >> P.modele >> P.type >> P.prix;
void Affiche(photo P) Affiche(P);
{ f2.write((char*)&P,sizeof(photo));
cout <<"\n"<<setw(20)<<P.marque; }
cout <<setw(20)<<P.modele; f1.close();
cout <<" ("<< P.type<<")"; f2.close();
cout <<setw(10)<<"prix : "; cout << "\n\n";
cout <<P.prix<<"\t euros"; }
} main()
{ FPhoto();
}
Fichier photo1.txt
Canon EOS550D R 730.99 Samsung ES74 C 120.33 Nikon D700 R 2100.27
Fichier photo2.txt Fichier photo3.txt
Canon EOS550D R 730.99 Canon EOS550D
Samsung ES74 C 120.33 R 730.99
Nikon D700 R 2100.27 Samsung ES74
C 120.33
Nikon D700
R 2100.27

    Page  81  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Fichiers  

IV.8.   EXERCICE  8  
On  manipule  dans  cette  question  divers  achats  effectués  dans  un  magasin.  Pour  chaque  type  d'article,  on  note  sur  un  ticket  le  
prix  unitaire  de  l’article  (champ   Prix  du  type   TypeTicket)  et  le  nombre  d'articles  de  ce  type  achetés  par  le  client  (champ  
Nb  du  type  TypeTicket).    
On  a  rangé  dans  un  fichier  binaire  nommé  "Jour.bin"  plusieurs  tickets.    
On  dispose  du  type  structuré  TypeTicket:    
struct TypeTicket
{
float Prix ;
int Nb ;
};

Ecrire  la  fonction  CoutTotal  qui  calcule  le  montant  total  des  achats.  On  doit  parcourir  le  fichier  binaire  et  ne  
faire  ni  lecture  au  clavier  ni  affichage  à  l'écran.  

IV.9.   EXERCICE  9  
On  manipule  dans  cette  question  divers  achats  effectués  dans  un  magasin.  Pour  chaque  type  d'article,  on  note  On  représente  
un   individu   par   le   type   structuré   Individu   décrit   sur   la   Figure   18.   Les   fonctions   de   saisie   et   d’affichage   d’un   individu   sont   écrites,  
le  programme  principal  est  commencé.  Vous  aurez  à  écrire  une  autre  fonction  et  à  compléter  le  programme  principal.  
#include <iostream>
#include <string> void Affich(Individu x)
#include <fstream> {
using namespace std; cout << x.Nom << " a " << x.Age << " ans,";
struct Individu if (x.S == 'F') cout << " elle est ";
{ else cout << " il est ";
char Nom[30]; if (x.Majeur) cout << "majeur";
char S; else cout << "mineur";
int Age; if (x.S == 'F') cout << "e";
bool Majeur; cout << endl;
}; }
Individu Saisie( )
{
Individu x; main ()
cout << "Nom : "; {
cin >> x.Nom; Individu Population[100];
cout << "Age : "; int NbIndiv, i;
cin >> x.Age;
cout << "Sexe : "; // A completer : saisie
cin >> x.S; // A completer : stockage dans fichier indiv.res
return x; // A completer : affichage
}
Figure  18  –  Types,  fonctions  et  programme  principal  pour  la  programmation  

Ecrire   une   fonction   Stockage   permettant,   d’affecter   le   champ   Majeur   de   chaque   individu   contenu   dans   un  
tableau  d’individus  à   true  ou  à   false  en  fonction  de  son  âge,  et  de  stocker  dans  un  fichier  binaire  ce  tableau  
d’individus.  

Compléter  le  programme  principal  afin  de  saisir  des  individus  dans  le  tableau  Population  (appel  à  Saisie)  puis  
d’appeler  la  fonction  Stockage,  et  enfin  d’afficher  les  individus  du  tableau  (appel  à  Affich).  
 
 

    Page  82  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Types  de  Données  Abstraits  

TYPES  DE  DONNEES  ABSTRAITS  

I.   GENERALITES  

I.1.   INTRODUCTION  
Supposons  que  l’on  travaille  sur  un  projet  de  gestion  de  trafic  sur  une  voirie  pour  lequel  la  représentation  de  
feux   tricolores   est   nécessaire.   Dans   le   cahier   des   charges   de   ce   projet   il   est   stipulé   qu'un   feu   tricolore   est  
toujours  allumé,  il  ne  peut  donc  être  qu’au  vert,  à  l’orange  ou  au  rouge  (la  situation  où  il  est  éteint  n'est  pas  
envisagée).  De  plus,  l'orange  clignotant  n'existe  pas.    
 
Les  actions  possibles  sur  un  feu  sont  :  
 Passer_Vert  :  met  le  feu  au  vert,  
 Passer_Orange  :  met  le  feu  à  l'orange,  
 Passer_Rouge  :  met  le  feu  au  rouge.  
 
On  peut  avoir  besoin  de  savoir  si  le  feu  est  au  rouge  ou  au  vert.  S'il  n'est  ni  l'un  ni  l'autre,  il  est  donc  orange.  Pour  cela,  on  définit  
deux  tests  :  
 Est_Vert  :  qui  produit  la  valeur  vrai  si  le  feu  est  au  vert  et  la  valeur  faux  sinon,  
 Est_Rouge  :  qui  produit  la  valeur  vrai  si  le  feu  est  au  rouge  et  la  valeur  faux  sinon,  
Le  feu  ne  peut  passer  que  du  vert  à  l’orange,  de  l’orange  au  rouge  et  du  rouge  au  vert.  Lors  de  sa  première  utilisation,  il  est  
forcé  au  rouge.  
 
De   par   leur   définition,   les   actions   et   tests   sont   liés   par   des   relations   (le   test   Est_Rouge   précèdera   toujours   Passer_Vert).   De  
même,   certaines   combinaisons   d'actions   et   de   tests   sont   impossibles   (Passer_Vert   et   Passer_Rouge   ne   peuvent   pas   se  
succéder).  
Il   est   alors   possible   de   résumer   ce   qui   définit   un   feu   tricolore   par   la   spécification   décrite   page   suivante   dans   laquelle   les  
opérations  possibles  et  impossibles  sont  précisées.  
 
Nous   venons   ainsi   de   définir   un   Type   de   Donnée   Abstrait   (TDA)   qui   est   "feu   tricolore"   qui  peut   être   spécifié   différemment   sans  
que  les  données  du  problème  de  gestion  de  trafic  ne  soient  modifiées.  La  définition,  la  spécification  et  l'implémentation  du   TDA  
Feu  Tricolore  sont  indépendantes  du  projet  de  gestion  du  trafic  et  peuvent  être  modifiées  sans  impact  sur  le  projet.  

    Page  83  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Types  de  Données  Abstraits  

I.2.   SPECIFICATION  DE  FEU  

Types  associés       //On  précise  ici  les  types  (sauf  feu)  utilisés  par  les  opérations    
  Booléen  
 
Opérations         //  On  précise  ici  les  opérations  utilisées  par  le  type  feu  
  Fonction  Feu  Créer_Feu  (  )  
    Fonction  n’ayant  pas  d’opérande  et  créant  un  feu  
  Procédure  Détruire_Feu  (ES/  Feu)  
    Action  détruisant  un  feu  existant  
  Procédure  Passer_Vert  (ES/  Feu)    
    Action  mettant  le  feu  au  vert  
  Procédure  Passer_Orange  (ES/  Feu)    
    Action  mettant  le  feu  à  l’orange  
  Procédure  Passer_Rouge  (ES/  Feu)    
    Action  mettant  le  feu  au  rouge  
  Fonction  Booléen  Est_Vert  (E/  Feu)  
    Fonction  retournant  vrai  si    le  feu  est  au  vert,  faux  sinon  
  Fonction  Booléen  Est_Rouge  (E/  Feu)  
    Fonction  retournant  vrai  si    le  feu  est  au  rouge,  faux  sinon  
 
Relations     //  On  précise  ici  les  relations  entre  les  opérations  utilisées  par  le  type  feu  
  Détruire_Feu(Créer_Feu(  ))  =  action  nulle         (cela  ne  fait  rien)  
  Passer_Rouge(Créer_Feu(  ))  =  Créer_Feu(  )  
  Est_Vert(Créer_Feu(  ))  =  faux  
  Est_Rouge(Créer_Feu(  ))  =  vrai  
  ∀  x  :  Passer_Vert(x)  ;  Est_Vert(x)  =  vrai  
  ∀  x  :  Passer_Rouge(x)  ;  Est_Vert(x)  =  faux  
  ∀  x  :  Passer_Orange(x)  ;  Est_Vert(x)  =  faux  
  ∀  x  :  Passer_Vert(x)  ;  Est_Rouge(x)  =  faux  
  ∀  x  :  Passer_Rouge(x)  ;  Est_Rouge()  =  vrai  
  ∀  x  :  Passer_Orange(x)  ;  Est_Rouge()  =  faux  
 
Exceptions  
  Passer_Orange(Créer_Feu(  ))  est  illégal  
  ∀  x  :  Passer_Orange(x)  ;  Passer_Vert(x)  est  illégal  
  ∀  x  :  Passer_Rouge(x)  ;    Passer_Orange(x)  est  illégal  
  ∀  x  :  Passer_Vert(x)  ;  Passer_Rouge(x)  est  illégal  
  Si  Est_Rouge(x)  =  faux  et  Est_Vert(x)  =  faux  alors  Passer_Vert(x)  est  illégal  
  Si  Est_Rouge(x)  =  vrai  alors  Passer_Orange(x)  est  illégal  
  Si  Est_Vert(x)  =  vrai  alors  Passer_Rouge(x)  est  illégal  
  le  signe  ∀  signifie  quel  que  soit  
 
Les  opérations  suivantes  ne  sont  pas  insérées  dans  le  TDA  Feu  car  ce  sont  des  actions  possibles  qui  ne  donnent  pas  lieu  à  des  
relations  spécifiques  :  
  Passer_Vert(Créer_Feu(  ))  est  légal  
  ∀x  :  Passer_Rouge(x)  ;  Passer_Vert(x)  est  légal  
  ∀x  :  Passer_Vert(x)  ;  Passer_Orange(x)  est  légal  
  ∀x  :  Passer_Orange(x)  ;  Passer_Rouge(x)  est  légal  

    Page  84  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Types  de  Données  Abstraits  

I.3.   DEFINITION  D'UN  TDA  

Lorsque  l’on  conçoit  un  algorithme,  on  souhaite  rester  le  plus  indépendant  possible  d’une  implémentation  particulière  de  façon  
à   raisonner   à   différents   niveaux   d’abstraction   et   de   façon   à   pouvoir   réutiliser   l’algorithme.   La   représentation   des   données  
utilisées  n’est  pas  figée.  Il  est  seulement  nécessaire  de  disposer  d’une  description  :  
 du  type  des  données,    
 des  opérations  de  base  que  l’on  peut  réaliser  sur  ces  données,  
 des  relations  entre  ces  opérations.  
Cette  description  est  appelée  Type  de  Données  Abstrait  (TDA).  
Lorsque   l'on   définit   un   TDA,   il   est   impératif   de   définir   ce   que   font   les   opérations   associées   à   ce   TDA   ainsi   que   les   relations   entre  
les   opérations.   Il   existe   divers   formalismes,  ce   n’est   pas   l’objet   de   ce   chapitre.   Nous  utiliserons   dans   la   suite   de   ce   document  
cette  notion  pour  décrire  les  données  abstraites  que  nous  manipulerons  telles    que  les  piles  ou  les  files.  

I.4.   SPECIFICATION  D'UN  TDA  

La  spécification  d'un  TDA  comporte  plusieurs  parties  :  
 La  première  partie  est  consacrée  aux  types  de  données  associés  au  TDA  spécifié.  Ce  sont  les  types  de  données  (autres  que  
le  TDA  spécifié)  utilisés  en  entrée  ou  produits  par  les  opérations  définies  sur  le  TDA  qu'on  spécifie.  Ces  types  de  données  
peuvent  comporter  d’autres  TDA  (spécifiés  par  ailleurs).  
 La  deuxième  partie  est  dédiée  à  la  spécification  de  chacune  des  opérations  utilisées  par  le  TDA.  On  précise  alors  les  types  
des   données   en   entrée   et   en   sortie   des   opérations.   On   spécifie   le   rôle   de   l’opération.   Plusieurs   notations   peuvent   être  
employées   pour   cette   définition,   nous   proposons   cellei   utilisée   dans   les   chapitres   précédents   pour   les   procédures   et  
Fonctions.  
 La   troisième   partie   concerne   la   description   des   relations   entre   les   opérations   également   appelées   "axiomes".   Les  
notations   utilisables   sont   variées   certaines   sont   mathématiques   d'autres   textuelles   mais   quoi   qu'il   en   soit   cette  
spécification  des  opérations  et  des  axiomes  ne  doit  pas  comporter  d'ambiguïtés.  
 La   quatrième   partie   est   destinée   à   la   définition   des   exceptions   c'est-­‐à-­‐dire   des   opérations   qui   ne   peuvent   pas   être  
effectuées  lorsque  certaines  valeurs  du  jeu  d'opérandes  sont  utilisées.  
Les   piles   et   les   files   sont   des   structures   de   stockage   d'éléments   ayant   une   gestion   de   leur   contenu   prédéfinie.   Elles   servent  
notamment   à   gérer   des   éléments   en   attente   de   leur   utilisation.   Les   éléments   y   sont   inscrits   puis   retirés   selon   un   mode   bien  
défini  mais  toujours  un  par  un.  La  suite  du  cours  est  consacrée  à  leur  description,  définition  et  implémentation.  

II.   TDA  PILES  

II.1.   DEFINITION  
Les  éléments  contenus  dans  une  pile  sont  dits  "empilés".  Ils  sont  ajoutés  en  sommet  de  pile  et  retirés  à  
partir  du  sommet  de  la  pile,  comme  dans  une  pile  d'assiette  où,  pour  accéder  à  l'assiette  du  bas,  il  faut  
retirer  toutes  les  assiettes  posées  dessus  afin  de  ne  pas  les  casser.  La  gestion  des  piles  est  de  type  LIFO  
("Last  In  First  Out"  :  dernier  entré  premier  sorti).  
Les  actions  principales  menées  sur  les  piles  sont  :    
 l'initialisation  d'une  pile,  
 l'ajout  d'un  élément,  
 le  retrait  d'un  élément,  
 la  vérification  que  la  pile  est  vide,  
 l'accès  au  sommet  de  la  pile.  
D'autres  opérations  peuvent  être  définies  sur  une  pile.  

    Page  85  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Types  de  Données  Abstraits  

Description  des  cinq  opérations  précédentes  :  

 Initialisation  d'une  pile  :  Init  
Cette  action  permet  d'initialiser  une  pile.  Elle  ne  contient  alors  aucun  élément  et  pourra  par  la  suite  contenir  des  éléments.  
 Ajouter  un  élément  :  Ajouter  
Cette  action  permet  d'ajouter  un  élément  au  sommet  d'une  pile.  Le  détail  de  cette  opération  est  montré  sur  la  Figure  19.  
 Retrait  d'un  élément  :  Retrait  
Cette  action  permet  de  retirer  l'élément  situé  au  sommet  de  la  pile.  Le  détail  de  cette  opération  est  montré  sur  la  Figure  19.  
 Vérification  que  la  pile  est  vide  :  Vide  
Cette  action  produit  la  valeur  booléenne  vrai  si  la  pile  ne  contient  pas  d'élément  et  faux  sinon.  
 Accès  au  sommet  de  la  pile  :  Sommet  
Cette  action  produit  l'élément  placé  en  sommet  de  pile  sans  le  retirer.  
 

Elément( Ajouter( Retirer( Elément(

Elément( Elément(

Elément( Elément(

 
Figure  19  :  Illustration  d'une  pile.  

La  spécification  du  TDA  Pile  qui  découle  de  ce  qui  vient  d'être  décrit  est  la  suivante.  

II.2.   SPECIFICATION  D'UN  TDA  PILE  

Types  associés    
  Elément  
  Booléen  
 
Opérations  
  Procédure  Init  (ES/  Pile)  
    Fonction  initialisant  une  pile  
  Procédure  Ajouter  (E/  Elément,  ES/  Pile)  
    Action  ajoutant  l’élément  spécifié  à  la  pile.  La  pile  est  modifiée.  
  Fonction  Elément  Retirer  (  ES/  Pile)  
  Fonction  enlevant  l’élément  au  sommet  de  la  pile.  La  valeur  de  cet  élément  est  retournée,  la  pile  est  modifiée.  
  Fonction  Booléen  Vide  (E/  Pile)  
    Fonction  retournant  vrai  si  la  pile  est  vide,  faux  sinon  
  Fonction  Elément  Sommet  (E/  Pile)  
    Fonction  retournant  la  valeur  de  l’élément  au  sommet  de  la  pile  spécifiée  
 
 
 

    Page  86  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Types  de  Données  Abstraits  

Relations     Le  signe  ∀  signifie  quel  que  soit  

  ∀  p  :  Init(p)  ;  Vide(p)  =  vrai  
  ∀  (x,  p)  :  Ajouter(  x,  p)  ;  Vide(p)  =  faux  
  ∀  (x,  p)  :  Ajouter(  x,  p  )  ;  Sommet(p)  =  x  
  ∀  (x,  p)  :  Ajouter(  x,  p  )  ;  Retirer(p)  =  x  :  p  n’est  pas  modifiée  
  ∀  (p)  :  Ajouter(Retirer(p)  ,  p  )  :    p  n’est  pas  modifié  
 
Exceptions       Le  signe  ∀  signifie  quel  que  soit  
  ∀  p  :  si  Vide(p)  alors  Retirer(p)  est  illégal  
  ∀  p  :  si  Vide(p)  alors  Sommet(p)  est  illégal  

II.3.   PROGRAMMATION  
Une  pile  est  représentée  par  :  
• L'ensemble  de  ses  éléments,  dans  l'ordre  de  leur  ajout,  
• Un  repère  sur  l'élément  du  sommet,  les  autres  éléments  étant  dessous.  

II.3.1.   Type  de  données  

En  langage  C,  on  va  donc  représenter  une  pile  par  une  structure  contenant  :  
 Un  tableau  d'éléments,    
 L'indice  du  sommet.  
Les  éléments  peuvent  être  de  type  classique  (int, float, char…)  ou  de  type  structuré  (date, eleve…).  Afin  qu'ils  soient  
toujours  du  même  type,  on  renomme  leur  type  en   Element.  L'indice  du  sommet  est  en  fait  l'indice  du  premier  emplacement  
libre.    
L'action  de  renommer  un  type  se  fait  par  le  mot  clef  typedef,  suivi  de  l'ancien  nom  puis  du  nouveau.  
typedef type nom; va renommer type en nom.
Exemples  :  
  typedef char caractere;   //  le  type  prédéfini  char  va  maintenant  s'appeler  caractere  
  caractere c='A';   //  la  variable  c  est  un  char  et  contient  la  lettre  A  
  typedef eleve etudiant;   //   le   type   structuré   eleve   que   l'on   a   défini   nous   même   est   maintenant   appelé  
etudiant.  
 
Notre  pile  devra  donc  toujours  commencer  par  renommer  son  contenu  en  élément  :  
typedef type Element;  
 
La  structure  décrivant  la  pile  sera  toujours  la  même,  quel  que  soit  le  contenu  de  la  pile  :  
struct Pile
{
Element Elt[NMAX];
int Sommet;
};
Exemple  :  
#define NMAX 20
typedef float element;
struct Pile
{
Element Elt[NMAX];
int Sommet;
};

    Page  87  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Types  de  Données  Abstraits  

0 1 2 3 4 5 6 7
Elt 0.6 -2.7 16.9 2.8 3.1
Sommet
Figure  20.  Implémentation  d'une  pile  de  réels.  

II.3.2.   Opérations  
Les  différentes  opérations  étudiées  précédemment  doivent  être  programmées.  Du  fait  du  choix  d'un  tableau  pour  stocker  les  
éléments   de   la   pile,   notre   pile   peut   être   pleine,   car   la   taille   du   tableau   est   finie.   Il   faudra   programmer   une   autre   opération  
testant  si  la  pile  est  pleine.  
Les   opérations   effectuées   sur   la   pile   sont   des   fonctions.   Elles   sont   indépendantes   du   type   de   données   réellement   contenues  
dans  la  pile.  

II.3.2.1. Fonction  vérifiant  si  la  pile  est  vide  

bool Vide (Pile P)
{
return P.Sommet == 0 ;
}

II.3.2.2. Fonction  vérifiant  si  la  pile  est  pleine     //  Nécessaire  pour  la  traduction  
bool Full (Pile P)
{
return (P.Sommet==NMAX) ;
}

  0 1 2 3 4 5 6 7
Retrait     Elt 0.6 -2.7 16.9 2.8 3.1
d'un  élément   sommet sommet
  3.1
 
  0 1 2 3 4 5 6 7
Ajout     Elt 0.6 -2.7 16.9 2.8 14.8
d'un  élément   sommet sommet
  14.8

Figure  21.  Retrait  et  Ajout  d'un  élément  dans  une  pile  de  réels.  

II.3.2.3. Fonction  d'ajout  d'un  élément  dans  la  pile  (voir  Figure  21)  
void Ajouter (Element nouveau, Pile & P)
{
P.Elt[P.Sommet]=nouveau ;
(P.Sommet)++ ;
}

    Page  88  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Types  de  Données  Abstraits  

II.3.2.4. Fonction  de  sortie  d'un  élément  de  lapile  (voir  Figure  21)  
Element Retirer(Pile & P)
{ (P.Sommet)-- ;
return P.Elt[P.Sommet] ;
}

II.3.2.5. Fonction  de  réinitialisation  de  la  pile  

void Init(Pile & P)
{ P.Sommet=0;
}

II.3.2.6. Fonction  d'accès  à  l'élément  du  sommet  de  la  pile  :  

Element Sommet(Pile P)
{ return P.Elt[P.Sommet-1] ;
}

II.3.3.   Relations  et  Exceptions  

Il  n'est  pas  possible  de  programmer  les  relations  entre  les  opérations  ainsi  que  les  exceptions.  
Attention,  
 On  doit  vérifier  que  la  pile  est  non  vide  avant  d’appeler  les  fonctions  Sommet  et  Retirer.  
 On  doit  vérifier  que  la  pile  n’est  pas  pleine  avant  d’appeler  la  fonction  Ajouter.  

III.   TDA  FILES  

III.1.   DEFINITIONS  
La  gestion  des  files  est  de  type  FIFO  ("First  In  First  Out"  :  premier  entré  premier  sorti).  Les  éléments  sont  entrés  en  queue  de  file  
et  sortis  en  tête  de  file.  Ce  TDA  correspond  à  une  file  d'attente  à  une  caisse  de  supermarché.  
Les  actions  principales  menées  sur  les  files  sont  :    
 l'initialisation  d'une  file,  
 l'ajout  d'un  élément,  
 le  retrait  d'un  élément,  
 la  vérification  que  la  file  est  vide,  
 l'accès  à  la  tête.  
D'autres  opérations  peuvent  être  définies  sur  une  file.  
Description  des  cinq  opérations  précédentes  :  
 Initialisation  d'une  file  :  Init  
Cette  action  permet  d'initialiser  une  file.  Elle  ne  contient  alors  aucun  élément  et  pourra  par  la  suite  contenir  des  éléments.  
 Ajouter  un  élément  :  Ajouter  
Cette  action  permet  d'ajouter  un  élément  en  queue  d'une  file.  Le  détail  de  cette  opération  est  montré  sur  la  Figure  22.  
 Retrait  d'un  élément  :  Retirer  
Cette  action  permet  de  retirer  l'élément  placé  en  tête  d'une  file.  Le  détail  de  cette  opération  est  montré  sur  la   Figure  22  
 Vérification  que  la  file  est  vide  :  Vide  
Cette  action  produit  la  valeur  booléenne  vrai  si  la  file  ne  contient  pas  d'élément  et  faux  sinon.  
 Accès  à  la  tête  :  Tete
Cette  action  produit  l'élément  placé  en  tête  de  file  sans  le  retirer.  
 

    Page  89  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Types  de  Données  Abstraits  

Elément(

Ajou
ter(
Fin( Elém
( ent
(
Elém
( e nt(
Elément(
Elém
( e nt( (
Elém
( e nt( (
Tête e tirer
( R
 
Figure  22.  Illustration  d'une  file.  

La  spécification  du  TDA  File  qui  découle  de  ce  qui  vient  d'être  décrit  est  la  suivante.  

III.2.   SPECIFICATION  D'UN  TDA  FILE  

Types  associés    
  Elément  
  Booléen  
 
Opérations  
  Procédure  Init  (  ES/  File  )  
    Action  initialisant  une  file  
  Procédure  Ajouter  (E/  Elément,  ES/  File)  
    Action  ajoutant  l’élément  spécifié  à  la  file.  La  file  est  modifiée.  
  Fonction  Elément  Retirer  (  ES/  File)  
  Fonction  enlevant  l’élément  en  tête  de  la  file.  La  valeur  de  cet  élément  est  retournée,  la  file  est  modifiée.  
  Fonction  Booléen  Vide(E/  File)  
    Fonction  retournant  vrai  si  la  file  est  vide,  faux  sinon  
  Fonction  Elément  Tete(E/  File)  
    Fonction  retournant  la  valeur  de  l’élément  en  tête  de  la  file  spécifiée  
 
Relations     Le  signe  ∀  signifie  quel  que  soit  
  ∀  f  :  Init(f)  ;  Vide(f)  =  vrai  
  ∀  (x,  f)  :  Ajouter(  x,  f)  ;  Vide(f)  =  faux  
  ∀  (x,  f)  et  Vide(f)=faux  :  Ajouter(  x,  f  )  :  Tete(f)  n’est  pas  modifiée  
  ∀  (x,  f)  et  Vide(f)=vrai  :  Ajouter(  x,  f  )  ;  Tete(f)  =  x  
  ∀  (x,  f)  et  Vide(f)=vrai  :  Ajouter(x,  f)  ;  Retirer(f)  :  f  est  toujours  vide  
 
Exceptions     Le  signe  ∀  signifie  quel  que  soit  
  ∀  f  :  si  Vide(f)  alors  Retirer(f)  est  illégal  
  ∀  f  :  si  Vide(f)  alors  Tete(f)  est  illégal  

    Page  90  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Types  de  Données  Abstraits  

III.3.   PROGRAMMATION  

III.3.1.   Introduction  
Pour  représenter  une  file,  on  a  besoin  de  :  
 L'ensemble  des  éléments  de  la  file,  dans  l'ordre  de  leur  ajout,    
 Un  repère  sur  le  début  de  la  file  d'où  sont  retirés  les  éléments,  
 Un  repère  sur  la  fin  de  la  file  où  sont  ajoutés  les  éléments.  
Si   l'on   représente   l'ensemble   des   éléments   par   un   tableau,   la   file   va   alors   ressembler   à   la   partie   gauche   de   la   Figure   23.  
Lorsqu'on  ajoute  un  élément  dans  la  file,  la  fin  de  la  file  est  décalée  (voir  partie  droite  de  la  Figure  23).  
0 1 2 3 4 5 0 1 2 3 4 5
E1 E2 E3 E4 E1 E2 E3 E4 E5
                         

Début         Fin       Début           Fin  

Figure  23.  Implémentation  d'une  file.  

Si  l'on  retire  maintenant  un  élément  de  la  file  (l'élément  E1  qui  est  position  d'être  retiré),  deux  possibilités  s'offrent  à  nous  :  
 Retirer   l'élément   puis   décaler   toute   la   file   afin   que   le   prochain   élément   à   retirer   soit   toujours   à   la   même   position   dans   le  
tableau  (voir  Figure  24  partie  gauche).  Ce  fonctionnement  correspond  à  une  file  d'attente  en  caisse  de  supermarché  où  le  
prochain  client  s'avance  jusqu'à  la  caisse  et  les  suivants  se  déplacent.  
 Retirer   l'élément   puis   décaler   le   début   de   la   file   afin   qu'il   indique   le   prochain   élément   à   retirer   (voir  Figure   24   partie   droite).  
Ce   fonctionnement   correspond   à   un   contrôle   de   papiers   de   véhicule   en   bord   de   route,   où   le   gendarme   se   déplace   d'une  
voiture  à  l'autre,  dans  l'ordre  de  leur  arrivée.  
0 1 2 3 4 5 0 1 2 3 4 5
E2 E3 E4 E5 E2 E3 E4 E5
                         

Début         Fin         Début         Fin  

Figure  24.  Retrait  d'un  élément  d'une  file.  

Le  fonctionnement  de  la  partie  gauche  de  la  Figure  24  correspond  à  une  file  linéaire.  Le  fonctionnement  de  la  partie  droite  de  la  
Figure  24  correspond  à  une  file  circulaire  (car  la  file  va  avancer  dans  le  tableau  jusqu'à  arriver  au  bout  et  revenir  au  début).    

III.3.2.   Files  linéaires  

III.3.2.1. Représentation  
Les  éléments  de  la  file  étant  toujours  retirés  de  la  même  case,  une  file  est  représentée  par  :  
 un  tableau  d'éléments,  
 l'indice  de  la  fin  de  la  file.  
Le  contenu  de  la  file  sera  toujours  de  type  Element  ;  l'indice  de  fin  est  l'indice  du  premier  emplacement  libre.  
typedef type Element;  
struct File
{
Element Elt[NMAX];
int Fin;
};
   

    Page  91  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Types  de  Données  Abstraits  

Exemple  :  
#define NMAX 20
typedef float Element;
struct File
{ Element Elt[NMAX];
int Fin;
};
0 1 2 3 4 5 6 7
Elt 4.7 -9.1 18.5 -14.6 1.2
Fin

Figure  25.  Implémentation  d'une  file  linéaire  de  réels.  

III.3.2.2. Opérations  
Tout  comme  pour  le  TDA  pile,  les  éléments  étant  stockés  dans  un  tableau,  un  test  de  file  pleine  doit  être  programmé.  

File  vide  
bool EstVide (File F)
{ return ( F.Fin == 0 ) ;
}

File  pleine             //  Nécessaire  pour  la  traduction  

bool Full (File F)
{ return ( F.Fin == NMAX ) ;
}
  0 1 2 3 4 5 6 7
Retrait     Elt 4.7 -9.1 18.5 -14.6 1.2
d'un  élément   Fin Fin
  4.7
 
  0 1 2 3 4 5 6 7
Ajout     Elt -9.1 18.5 -14.6 1.2 27.8
d'un  élément   Fin Fin
  27.8

Figure  26.  Retrait  et  Ajout  d'un  élément  dans  une  file  linéaire  de  réels.  

Ajout  d'un  élément  dans  la  file  (voir  Figure  26)  

void Ajouter (Element nouveau, File & F)
{ F.Elt[F.Fin]=nouveau ;
(F.Fin)++ ;
}

Sortie  d'un  élément  de  la  file  (voir  Figure  26)  

Element Retirer (File & F)
{ Element oldhead ;
int k ;
oldhead = F.Elt[0] ;
for (k=0 ; k<F.Fin-1 ; k++) F.Elt[k] = F.Elt[k+1] ;
(F.Fin)-- ;
return oldhead ;
}

    Page  92  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Types  de  Données  Abstraits  

Accès  à  l'élément  de  début  

Element Tete (File F)
{
return F.Elt[0] ;
}

Réinitialisation  de  la  file  

void Init(File & F)
{
F.Fin = 0;
}

III.3.3.   Files  circulaires  

III.3.3.1. Représentation  
Afin  d'éviter  le  décalage  de  tous  les  éléments  de  la  file  à  chaque  retrait,  on  fait  varier  le  début  de  la  file  dans  le  tableau.  
La  file  est  alors  composée  de  :  
 un  tableau  d'éléments,  
 un  indice  de  fin,  
 un  indice  de  début.  
L'indice  de  fin  est  en  fait  l'indice  du  premier  emplacement  libre  ;  l'indice  de  début  est  l'indice  du  prochain  élément  qui  sortira.  
Lorsque  la  fin  ou  le  début  de  la  file  arrive  à  la  dernière  case  du  tableau,  on  retourne  à  la  première  case  du  tableau  (ainsi  la  file  
avance  et  tourne  en  rond  dans  le  tableau).  
typedef type Element;  
struct File
{
Element Elt[NMAX];
int Debut;
int Fin;
};  
Exemple  :  
#define NMAX 20
typedef float Element;
struct File
{
Element Elt[NMAX];
int Fin, Debut;
};

0 1 2 3 4 5 6 7
Elt -9.1 18.5 -14.6 1.2
Debut Fin

Figure  27.  Implémentation  d'une  file  circulaire  de  réels.  

III.3.3.2. Opérations  
Le  tableau  impose  de  tester  si  la  file  est  pleine  ou  pas.  En  outre,  la  file  se  décalant  dans  le  tableau,  il  est  nécessaire  de  conserver  
une  case  vide  entre  le  début  et  la  fin  de  la  file,  afin  de  différencier  la  file  vide  de  la  file  pleine  (le  cas  où  le  début  rejoint  la  fin  doit  
être  différent  du  cas  où  la  fin  rejoint  le  début).    

    Page  93  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Types  de  Données  Abstraits  

File  vide  
bool vide (File F)
{ return ( F.Fin == F.Debut ) ;
}
0 1 2 3 4 5 6
Cas  1   elements 18.5 -14.6 1.2 27.8 4.7 -9.1
  fin debut
0 1 2 3 4 5 6
Cas  2   elements 4.7 -9.1 18.5 -14.6 1.2 27.8
  debut fin
0 1 2 3 4 5 6
Cas  3   elements 4.7 -9.1 18.5 -14.6 1.2 27.8
  fin debut

Figure  28.  Exemples  de  files  circulaires  de  réels  pleines.  

File  pleine             //  Nécessaire  pour  la  traduction  

bool Full(File F)
{ return ( F.Debut == (F.Fin+1)%NMAX ) ;
}
  0 1 2 3 4 5 6 7
Ajout  d'un  élément   elements -9.1 18.5 -14.6 1.2 4.7
Cas  1   debut fin fin
  4.7
 
  0 1 2 3 4 5 6 7
Ajout  d'un  élément   elements 18.5 -14.6 1.2 -9.1 27.8
Cas  2   fin debut fin
  27.8

Figure  29.  Ajout  d'un  élément  dans  une  file  circulaire  de  réels.  

Ajout  d'un  élément  dans  la  file  (voir  Figure  29)  

void Ajouter (Element nouveau, File & F)
{
F.Elt[F.Fin]=nouveau;
F.Fin=(F.Fin+1)%NMAX;
}

Accès  à  l'élément  de  début  

Element Tete (File F)
{
return F.Elt[F.Debut] ;
}

Réinitialisation  de  la  file  

void Init(File & F)
{
F.Fin = F.Debut = 0 ;
}

    Page  94  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Types  de  Données  Abstraits  

  0 1 2 3 4 5 6 7
Retrait  d'un  élément   elements 4.7 -9.1 18.5 -14.6 1.2
Cas  1   debut debut fin
  4.7
 
  0 1 2 3 4 5 6 7
Retrait  d'un  élément   elements 1.2 27.8 -9.1 -14.6 18.5
Cas  2   debut fin debut
  18.5

Figure  30.  Retrait  d'un  élément  dans  une  file  circulaire  de  réels.  

Retrait  d'un  élément  de  la  file  (voir  Figure  30)  

Element Retirer (File & F)
{ Element oldhead ;
oldhead = F.Elt[F.Debut] ;
F.Debut=(F.Debut+1)%NMAX ;
return oldhead ;
}

III.3.4.   Relations  et  Exceptions  

Il  n'est  pas  possible  de  programmer  les  relations  entre  les  opérations  ainsi  que  les  exceptions.  Attention,  
 On  doit  vérifier  que  la  file  est  non  vide  avant  d’appeler  les  fonctions  Tete  et  Retirer.  
 On  doit  vérifier  que  la  file  n’est  pas  pleine  avant  d’appeler  la  fonction  Ajouter.  

IV.   EXERCICES  

IV.1.   EXERCICE  1  
Définir  un  TDA  représentant  une  pièce  de  monnaie  ne  pouvant  pas  être  posée  sur  la  tranche  :  

Définissez  les  opérations  (dire  textuellement  ce  qu'elles  font).  

Quels  sont  les  types  associés  à  ce  TDA  ?  

Spécifiez  le  TDA  pièce  de  monnaie.  

IV.2.   EXERCICE  3  
Ecrire  une  fonction  permettant  de  donner  le  rang  d'un  élément  donné  dans  une  pile.  

Ecrire  une  fonction  permettant  de  compter  le  nombre  d'éléments  contenu  dans  une  pile.  

Ecrire  une  fonction  permettant  de  donner  le  rang  d'un  élément  donné  dans  une  file.  

Ecrire  une  fonction  permettant  de  compter  le  nombre  d'éléments  contenu  dans  une  file.  

    Page  95  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Types  de  Données  Abstraits  

IV.3.   EXERCICE  2  
A  partir  du  TDA  feu  tricolore  du  cours,  écrire  l'algorithme  de  l'opération  Changer_Couleur  qui  fait  passer  du  
vert  à  l'orange,  de  l'orange  au  rouge  ou  du  rouge  au  vert.  

On  suppose  maintenant  que  dans  le  projet  de  gestion  de  trafic,  la  seule  action  possible  sur  le  feu  est  l’action  
Changer_Couleur  qui  met  le  feu  au  vert  s’il  était  rouge,  à  l’orange  s’il  était  vert  et  au  rouge  s’il  était  orange.  
Les  actions  Passer_Orange,  Passer_Rouge  et  Passer_Vert  ne  sont  plus  accessibles.  Réécrire  le  TDA  feu  tricolore  
du  cours.  

Que  se  produit-­‐il  pour  les  exceptions  ?    

Ecrire   les   algorithmes   des   actions   Forcer_Vert,   Forcer_Rouge   et   Forcer_Orange   avec   cette   nouvelle  
spécification.    

IV.4.   EXERCICE  4  
Ecrire  une  fonction  itérative  permettant  d’afficher  les  éléments  d’une  pile  dans  l’ordre  de  parcours.  

Ecrire  une  fonction  itérative  permettant  d’afficher  les  éléments  d’une  file  dans  l’ordre  de  parcours.  

IV.5.   EXERCICE  6  
Un  logiciel  de  planification  envoie  des  tâches  à  réaliser  sur  différents  postes  de  travail.  Chaque  poste  de  travail  comporte   deux  
opérateurs.   Chaque   tâche   envoyée   à   un   poste   comporte   donc   le   numéro   de   l'opérateur   et   la   durée   de   la   tâche.   Les   tâches   sont  
mises  en  file  d'attente  sur  le  poste  de  travail  où  elles  seront  dispatchées  sur  l'un  ou  l'autre  des  opérateurs  lors  du  traitement  de  
la  liste  de  tâches.  Nous  gérons  un  poste  de  travail  comportant  2  opérateurs.    Il  y  a  donc  trois  files  de  tâches  :  
 La  file  des  tâches  à  traiter,  
 La  file  des  tâches  à  réaliser  par  l'opérateur  1,  
 La  file  des  tâches  à  réaliser  par  l'opérateur  2.  

Ecrivez  un  algorithme  puis  un  programme  en  langage  C  effectuant  les  actions  suivantes  :  
1) Création  et  déclaration  du  type  des  données  stockées  dans  la  file,  
2) Déclaration  et  initialisation  des  3  variables  de  type  File  nécessaires  (linéaire  ou  circulaire,  au  choix),  
3) Saisie  des  tâches  du  poste  de  travail  pour  la  journée  (en  remplacement  de  l'envoi  des  tâches  par  le  planificateur),  
4) Lecture  de  chaque  tâche  et  affectation  à  l'opérateur  (retrait  puis  ajout  dans  2  files),  
5) Affichage  des  tâches  de  l'opérateur  1  et  de  sa  durée  totale  de  travail,  
6) Affichage  des  tâches  et  de  la  durée  de  travail  de  l'opérateur  2.  

IV.6.   EXERCICE  8  
Ecrire  une  fonction  récursive  permettant  d’afficher  les  éléments  d’une  pile  dans  l’ordre  de  parcours.  

Ecrire  une  fonction  récursive  permettant  d’afficher  les  éléments  d’une  file  dans  l’ordre  de  parcours.  

Ecrire  une  fonction  récursive  permettant  d’afficher  les  éléments  d’une  pile  dans  l’ordre  inverse  de  parcours.  

Ecrire  une  fonction  récursive  permettant  d’afficher  les  éléments  d’une  pile  dans  l’ordre  inverse  de  parcours.  

    Page  96  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Types  de  Données  Abstraits  

IV.7.   EXERCICE  5  –  CALCULATRICE  ELEMENTAIRE  A  PILE  

On  souhaite  écrire  un  programme  permettant  de  calculer  une  expression  algébrique  obtenue  en  rentrant  d’abord  les  nombres  
puis   l’opération   sans   utiliser   de   parenthèses.   Par   exemple,   (4+8)/3   devient       4   8   +   3   /   .   Le   programme   doit   permettre   à   l’aide  
d’une  boucle  :  
 à  l’utilisateur  de  rentrer    
o soit  ‘v’  pour  saisir  un  nombre  réel    
o soit  ‘+’,  ‘-­‐‘,  ‘*’,  ‘/’  pour  une  opération,    
o soit  ‘r’  pour  afficher  la  dernière  valeur  calculée  ou  rentrée,    
o soit  ‘q’  pour  arrêter  le  programme,    
o soit  ‘e’  pour  effacer  les  données  et  recommencer  un  calcul.    
 si  l’utilisateur  a  rentré  un  nombre  celui-­‐ci  sera  stocké  dans  un  TDA  du  type  PILE    
 si   l’utilisateur   a   rentré   une   opération   alors   les   2   dernières   valeurs   du   tableau   sont   extraites   de   la   pile   et   le   résultat   de  
l’opération  désirée  ajouté  dans  la  pile.  
Exemple  :    
Pour  calculer  4/8  et  afficher  le  résultat  on  rentre  :        v  4  v  8  /  r  
Pour  calculer  (4+8)/3  et  afficher  le  résultat  on  rentre  :        v  4  v  8  +  v  3  /  r  
Pour  calculer  4*8*3  et  afficher  le  résultat  on  rentre  :        v  4  v  8  v  3  *  *  r  

Complétez  le  programme  ci-­‐dessous  permettant  de  réaliser  cette  calculatrice  :  

1) Créez  la  pile  et  ses  opérations.  
2) Dans  le  programme  principal  :  
a. écrivez  une  boucle  proposant  de  rentrer  un  caractère  parmi  ‘v’,  ‘+’,  ‘-­‐‘,  ‘*’,  ‘/’,’q’,  ‘r’,  ‘e’.    
b. programmez  les  instructions  à  effectuer  pour  chaque  choix  ci-­‐dessus.  
 
#include <iostream>
using namespace std ;
#define NMAX 10
//A compléter
int menu()
{ char choix;
cout<<"\n\n v : Ajouter une valeur a la pile";
cout<<"\n +,*,-,/ : Effectuer un calcul avec cette operande ";
cout<<"\n r : Afficher la derniere valeur calculee";
cout<<"\n e : Effacer la pile";
cout<<"\n q : Quitter";
cout<<"\nEntrez votre choix : ";
cin>>choix;
return choix;
}
main ()
{ char action='o';
//A compléter
cout<<"*** PROGRAMME DE CALCULATRICE ELEMANTAIRE A PILE ***\n";
while(action != 'q')
{ action = menu();
system("cls"); // efface l'affichage de la console
switch (action)
{ case 'v': // A COMPLETER
break;
…
case '/': // A COMPLETER
break;
default : // A COMPLETER
break;
}
}
}

    Page  97  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Types  de  Données  Abstraits  

IV.8.   EXERCICE  7  
On  considère  le  type  structuré  UneVoiture  défini  ci-­‐dessous.  
Type structuré UneVoiture
Début
Chaîne modele
Entier km
Entier annee
Fin

Ecrire  une  action  truc1  (procédure  ou  fonction)  qui,  à  partir  d’un  tableau  de  UneVoiture  (type  décrit  ci-­‐dessus)  
fournit   une   pile   contenant   l’ensemble   des   UneVoiture   du   tableau   dont   le   kilométrage   est   compris   entre   deux  
valeurs   spécifiées.   Cette   action   doit   fournir   le   nombre   de   UneVoiture   contenues   dans   la   pile   (c’est-­‐à-­‐dire   le  
nombre  de  UneVoiture  dont  le  kilométrage  est  compris  entre  les  valeurs  spécifiées).  

Quelle(s)   modification(s)   sont   à   apporter   à   cette   action   si   le   critère   de   recherche   est   l’année   du   véhicule  
(indiquez  uniquement  les  lignes  modifiées)  ?  L’action  ainsi  modifiée  est  appelée  truc2.  

Ecrivez  un  algorithme  permettant  :  

a. La  saisie  par  un  utilisateur  d’un  ensemble  de  voitures  dans  un  tableau  de  type  UneVoiture  (le  nombre  maximum  
de  voitures  à  saisir  et  le  nombre  effectif  de  voitures  saisies  ne  sont  pas  forcément  identiques)  ;  
b. La  saisie  par  l’utilisateur  de  deux  bornes  de  recherche  pour  le  kilométrage  ;  
c. La  recherche  des  voitures  dont  le  kilométrage  est  compris  entre  ces  deux  bornes  (les  véhicules  correspondant  
au  critère  de  recherche  seront  stockés  dans  une  pile)  ;  
d. L’affichage  d’un  message  indiquant  si  des  voitures  correspondant  aux  critères  de  recherche  ont  été  trouvées  ;  
e. La  saisie  par  l’utilisateur  de  deux  bornes  de  recherche  pour  l’année  ;  
f. La  recherche  des  voitures  dont  l’année  est  comprise  entre  ces  bornes  (les  véhicules  correspondant  au  critère  de  
recherche  sont  stockés  dans  une  autre  pile)  ;  
g. L’affichage  d’un  message  indiquant  si  des  voitures  correspondant  aux  critères  de  recherche  ont  été  trouvées.  

IV.9.   EXERCICE  10  

Écrire   une   fonction   permettant   de   comparer   une   pile   et   une   file.   Si   la   pile   contient,   de   son   sommet   vers   sa  
base,   les   mêmes   éléments   que   la   file,   de   sa   tête   vers   sa   fin,   dans   le   même   ordre,   on   retournera   la   valeur   vrai  ;  
sinon,  on  retournera  faux.  

Donnez  une  version  itérative  ET  une  version  récursive.  

IV.10.   EXERCICE  11  

Ecrire  la  fonction  récursive  Produit  qui  calcule  le  produit  des  éléments  d’une  pile.  Le  type  Element  est  assimilé  
au  type  réel.  

IV.11.   EXERCICE  13  

On  considère  les  actions  Act1  et Act2 et  le  programme  principal  sur  la  Figure  31.  Ils  utilisent  les  TDA  File  et  Pile  vus  en  cours.  Le  
type  Elément  est  ici  assimilable  au  type  Entier.  

    Page  98  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Types  de  Données  Abstraits  

Act1 début

File A
Elément B Variables Internes
Pile C Entiers m, j, f, d, r
File k
Pile t
Variables Internes
Elément x
Init ( k )

Saisir m
Init ( C )

non j!1
non Vide(A) ?
non
oui j≤m?
oui
x ← Retirer ( A )
Saisir f
non
x≠B? Ajouter ( f, k )
oui
j ← j +1
Ajouter ( x , C )

Saisir d

non
Fin d>0?
 
  oui
r ← Act2 ( k , d )
Act2

File A
Afficher r
Elément B

Act1 ( k , d , t )
Entier non
non Vide( A ) ? j!1

oui non
j≤r?
non
Tete( A ) ≠ B ? oui
oui Afficher Retirer ( t )
Retirer ( A ) Retirer ( A )
j ← j +1

Retour Retour
1 + Act2 ( A , B ) Act2 ( A , B )
Retour Saisir d
0

  Fin
 
Figure  31  –  Procédure  Act1,  fonction  Act2  et  programme  principal.  

On  lance  le  programme  principal  et  on  donne  les  valeurs  successives  suivantes  pour  m,  f  puis  d  :  
    {  5,  3,  8,  3,  4,  9,  4,  3,  -­‐1  }.  

Donnez  la  file  k  obtenue  après  le  pour.    

Quelles  valeurs  seront  écrites  à  l’écran  ?  Détaillez  et  justifiez  vos  réponses  en  donnant  par  exemple  le  contenu  
des  files  et  piles  au  fur  et  à  mesure  de  l’exécution.    

Que  font  les  actions  Act1  et  Act2  ?    

    Page  99  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Types  de  Données  Abstraits  

IV.12.   EXERCICE  9  
Ecrire   une   fonction   qui   compte   le   nombre   de   valeurs   égales   à   val   dans   un   tableau   t   de   nb   entiers.   Cette  
fonction  ne  doit  faire  ni  saisie  (lecture)  ni  affichage  (écriture).  L’entête  de  cette  fonction  est  la  suivante:  
int compte ( int t [ ], int nb, int val)
Pour  les  questions  suivantes,  on  utilise  le  TDA  Pile  défini  dans  le  cours.  On  considère  que  le  type  élément  est  assimilé  au  type  
Entier.  

Ecrire   un   module   (une   fonction   ou   une   procédure)   récursif   qui   permet   d’afficher   les   éléments   (entiers)  
contenus  dans  une  pile.  

Ecrire  un  module  (une  fonction  ou  une  procédure)  qui  à  partir  d’un  tableau  d’entiers  et  d’une  valeur  crée  
une   pile   contenant   les   éléments   du   tableau   différents   de   cette   valeur.   Ce   module   ne   doit   faire   ni   saisie  
(lecture)  ni  affichage  (écriture).  
On  suppose  déjà  écrit  le  début  de  programme  C  suivant  :  
#include <iostream>
using namespace std ;
main()
{ int Tab[40], n, i ;
// A compléter
cout << " Entrer le nombre d’éléments à saisir " ;
cin >> n ;
for ( i=0 ; i<n ; i++ ) cin >> Tab[i] ;
// A compléter
}

Complétez  ce  programme  pour  qu’il  permette  :  

a. De  saisir  une  valeur  entière,  
b. De  créer  la  pile  contenant  les  valeurs  du  tableau  différents  de  celle  saisie.  Pour  cela  vous  ferez  appel  au  module  
écrit  au  3.  
c. D'afficher  le  nombre  de  valeurs  contenues  dans  la  pile.  Pour  cela  vous  ferez  appel  au  module  écrit  au  1.  
d. D'afficher  les  éléments  de  la  pile  crée.  Pour  cela  vous  ferez  appel  au  module  écrit  au  2.  
   

    Page  100  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Types  de  Données  Abstraits  

IV.13.   EXERCICE  12  

Dans  cette  question,  nous  manipulons  des  files  et  piles  d’entiers.  Soient  les  actions  de  la  Figure  32.  

Quel   est   le   contenu   des   piles   Z1   et   Z2   après   l’instruction   suivante   ExoA ( F1 , 9, Z1, Z2 ) ?   Détaillez   votre  
réponse.  Combien  d’appels  à  ExoA et  à  ExoB sont-­‐ils  effectués  ?  

Quel  est  le  contenu  des  listes  Z3  et  Z4  après  l’instruction  suivante  ExoA ( F1 , 41, Z3, Z4 ) ?  Détaillez.    

Quel  est  le  contenu  des  listes  Z5  et  Z6  après  l’instruction  suivante  ExoA ( F1 , 3, Z5, Z6 ) ?  Détaillez.    

Que  font  les  actions  ExoA  et  ExoB ?  Sont-­‐elles  récursives  ?  

Modifier  la  procédure   ExoA  ou  la  procédure   ExoB  ou  les  deux,  pour  que  l’ordre  de  traitement  des  éléments  
des  piles  soit  le  même  que  celui  des  éléments  de  la  file  initiale.  
ExoA ExoB

File A File R
Entier v
Pile B Pile K
Pile C

Init ( K )
Variables Internes
Entier x non
non Vide ( R ) ?

non oui
Vide ( A ) ?
Ajouter ( Tete( R ) , K )
oui non
Tete ( A ) = v ?
Init ( B ) Retirer ( R )
oui x ← Retirer ( A )

Init ( C ) ExoB ( A , C ) ExoA ( A , v , B , C )

Init ( B ) Fin
Ajouter ( x , B )  

Fin

 
Figure  32  –  File  F1.  

   

    Page  101  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Types  de  Données  Abstraits  

IV.14.   EXERCICE  14  

On  considère  les  actions  Compte, Aff  et Range et  le  programme  principal  sur  la      Figure  33.  Ils  utilisent  les  TDA  File  
et   Pile   vus   en   cours.   Les   piles   contiennent   des   valeurs   de   type   Elément   défini   sur   la       Figure   33.   Les   files  
contiennent  des  réels.
On  lance  le  programme  principal  et  on  donne  les  valeurs  successives  suivantes  :  
  {  5,  "tube",  2,  2.90,  "plat",  1,  3.24,  "tige",  2,  4.21,  "axe",  2,  12.85,  "cube",  1,  14.78  }.  

Donnez  la  pile  A  obtenue  après  le  pour.  

Donnez  la  file  R  obtenue  après  l’instruction  R  ß  Range ( A , 2 )  

Quelles  valeurs  seront  écrites  à  l’écran  ?  Détaillez  et  justifiez  vos  réponses.  

Que  font  les  actions  Aff,  Compte  et  range  ?  Précisez  pour  chacune  si  elle  est  récursive  ou  itérative.  

Compte début
Type structuré Elément
début
File R
chaîne Code Variables
Entier Type Elément Val
Réel
Réel Tps Entier n, j
Fin Réel r
Variables Internes
Pile A
Réel Inter
File R

non
non Vide (R) ? Init ( A )
oui

Inter ! Retirer ( R ) Saisir n

Range

Pile A j!1
Entier T Retour
Inter + Compte ( R ) non
File Retour j≤n?
0 oui
Variables Internes
Elément E Saisir Val.Code
File F Saisir Val.Type
Aff Saisir Val.Tps
Init ( F )
File X
Ajouter ( Val, A )
non
non Vide (A) ?
Variables Internes j ! j +1
oui Réel V
E ! Retirer ( A )

non R ! Range ( A , 2 )
E.Type = T ? non Vide (X) ?

oui oui Aff ( R )

Ajouter (E.Tps, F ) V ! Retirer( X )

r ! Compte( R )
Afficher V
Afficher r

Retour
F Fin Fin

 
   Figure  33  –  Procédure  Aff,  fonctions  Range  et  Compte,  et  programme  principal.  

    Page  102  sur  103  

EC  TC  P324  -­‐  ALGORITHMIQUE  ET    STRUCTURES  DE  DONNEES  2     Types  de  Données  Abstraits  

IV.15.   EXERCICE  15  

On   considère   l’action   Prepare   et   le   programme   principal   sur   la   Erreur  !   Source   du   renvoi   introuvable..   Ils  
utilisent  le  TDA  File  vu  en  cours.  
Les  Files  contiennent  des  valeurs  de  type  Elément  défini  sur  la  Erreur  !  Source  du  renvoi  introuvable..  

Type structuré Elément

début
chaîne Code
int Prio
fin

Prepare

début File A
Element T

Variables Internes
Elément X, V
File K Variables Internes
File F

Init ( K )
Init ( F )
Saisir X.Code

non
T.Prio = 0 ?
X.Code ≠ "stop" ? oui
oui non
non Vide (A) ?
Saisir X.Prio
oui

Prepare ( K , X ) Ajouter ( Retirer ( A ) , F )

Saisir X.Code

Ajouter ( T , A ) Ajouter(T , A )

non Vide (K) ? non

non Vide (F) ?
oui
oui
V ← Retirer ( K )
Ajouter ( Retirer ( F ) , A )

Afficher V.Code

Fin Fin
 
Figure  34  –  Procédure  Prepare  et  programme  principal.  

On  lance  le  programme  principal  et  on  donne  les  valeurs  successives  suivantes  :  
{ "Salles", 1,
"Riley", 4,
"Stewart", 0,
"Hedlund", 2,
"stop" }.

Donnez  l’évolution  de  la  file  K  au  fur  et  à  mesure  des  saisies.  

Quelles  valeurs  seront  écrites  à  l’écran  ?  

Que  fait  l’action  Prepare  ?    

    Page  103  sur  103