See discussions, stats, and author profiles for this publication at: https://www.researchgate.

net/publication/340897902

Algorithmique et programmation en C : Cours avec 200 exercices corrigés

Book · April 2020

CITATIONS READS

0 11,784

1 author:

Djelloul Bouchiha
Ctr univ Naama, EEDIS Labo, UDL-SBA
77 PUBLICATIONS   283 CITATIONS   

SEE PROFILE

Some of the authors of this publication are also working on these related projects:

Re-engineering Web Application towards Web Semantic View project

Service-Oriented Computing View project

All content following this page was uploaded by Djelloul Bouchiha on 12 November 2021.

The user has requested enhancement of the downloaded file.



 




 




!








 



 



 











 
 



















 









 


 






 

 





 





 







 



























 
 

 

 






 


 

 

 




 




 !







"
 
# 
$

%


&




' %

( 
)*
$

%


#

#
*)+,-
$










  

 
.
/
 
#'01"1
 
.
2,2,
"
 
# 
$

%


&




' %

( 
$OJRULWKPLTXHHWSURJUDPPDWLRQHQ&
&RXUVDYHFH[HUFLFHVFRUULJpV

WĂƌ
3URI'MHOORXO%28&+,+$

EdZhE/sZ^/d/ZͲ^>,/,DͲED
sK>hd/KEZzE'/EZ/E'E/^dZ/hd/E&KZDd/KE^z^dD^>KZdKZz
;/^Ϳh>Ͳ^
ĚũĞůůŽƵů͘ďŽƵĐŚŝŚĂΛƵŶŝǀͲƐďĂ͘Ěnj͖ďŽƵĐŚŝŚĂ͘ĚũΛŐŵĂŝů͘ĐŽŵ


dĂďůĞĚĞƐŵĂƚŝğƌĞƐ
ǀĂŶƚͲƉƌŽƉŽƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϵ

ŚĂƉŝƚƌĞϭ͗/ŶƚƌŽĚƵĐƚŝŽŶ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϬ
ϭ͘ƌĞĨŚŝƐƚŽƌŝƋƵĞƐƵƌů[ŝŶĨŽƌŵĂƚŝƋƵĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϬ
ϭ͘ϭ͘ĠĨŝŶŝƚŝŽŶ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϬ
ϭ͘Ϯ͘WĂƌƚŝĞƐĚĞů[ŝŶĨŽƌŵĂƚŝƋƵĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϬ
ϭ͘ϯ͘>[ŽƌĚŝŶĂƚĞƵƌ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϬ
ϭ͘ϯ͘ϭ͘ĠĨŝŶŝƚŝŽŶ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϬ
ϭ͘ϯ͘Ϯ͘,ŝƐƚŽƌŝƋƵĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϬ
ϭ͘ϯ͘ϯ͘ŽŵƉŽƐĂŶƚĞƐĚ[ƵŶŽƌĚŝŶĂƚĞƵƌ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϬ
ϭ͘ϰ͘hŶŝƚĠƐĚĞŵĞƐƵƌĞĚĞůĂŵĠŵŽŝƌĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϮ
ϭ͘ϰ͘ϭ͘^ƚƌƵĐƚƵƌĞĚƵĚŝƐƋƵĞĚƵƌ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϮ
ϭ͘ϰ͘Ϯ͘dĂŝůůĞƐĚĞƋƵĞůƋƵĞƐŵĠŵŽŝƌĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϯ
ϭ͘ϱ͘>ĂƌĞůĂƚŝŽŶ,ŽŵŵĞͬDĂĐŚŝŶĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϰ
ϭ͘ϱ͘ϭ͘^LJƐƚğŵĞĚ[ĞdžƉůŽŝƚĂƚŝŽŶ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϰ
ϭ͘ϱ͘Ϯ͘&ŝĐŚŝĞƌĞƚƌĠƉĞƌƚŽŝƌĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϱ
Ϯ͘/ŶƚƌŽĚƵĐƚŝŽŶăů[ĂůŐŽƌŝƚŚŵŝƋƵĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϱ
Ϯ͘ϭ͘ZĠƐŽůƵƚŝŽŶĚ[ƵŶƉƌŽďůğŵĞƉĂƌŽƌĚŝŶĂƚĞƵƌ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϱ
Ϯ͘Ϯ͘EŽƚŝŽŶĚ[ĂůŐŽƌŝƚŚŵĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϱ
Ϯ͘ϯ͘džĞŵƉůĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϱ
ϯ͘džĞƌĐŝĐĞƐĐŽƌƌŝŐĠƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϭ
ϯ͘ϭ͘džĞƌĐŝĐĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϭ
ϯ͘Ϯ͘ŽƌƌŝŐĠƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϮϮ

ŚĂƉŝƚƌĞϮ͗>ĞƐĂůŐŽƌŝƚŚŵĞƐƐĠƋƵĞŶƚŝĞůƐƐŝŵƉůĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϰ
ϭ͘WĂƌƚŝĞƐĚ[ƵŶĂůŐŽƌŝƚŚŵĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϰ
Ϯ͘>ĞƐĚŽŶŶĠĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϰ
ϯ͘>ĞƐƚLJƉĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϱ
ϰ͘KƉĠƌĂƚŝŽŶƐĚĞďĂƐĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϲ
ϰ͘ϭ͘>[ĂĨĨĞĐƚĂƚŝŽŶ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϲ
ϰ͘Ϯ͘>ĞƐĞŶƚƌĠĞƐͬƐŽƌƚŝĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϳ
ϱ͘ŽŶƐƚƌƵĐƚŝŽŶĚ[ƵŶĂůŐŽƌŝƚŚŵĞƐŝŵƉůĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϳ
ϲ͘ZĞƉƌĠƐĞŶƚĂƚŝŽŶĚ[ƵŶĂůŐŽƌŝƚŚŵĞƉĂƌƵŶŽƌŐĂŶŝŐƌĂŵŵĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϴ
ϳ͘dƌĂĚƵĐƚŝŽŶĞŶůĂŶŐĂŐĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϴ
ϳ͘ϭ͘džĞŵƉůĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϴ
ϳ͘Ϯ͘DĂŶŝƉƵůĂƚŝŽŶĚĞƐŶŽŵďƌĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϵ
ϳ͘ϯ͘DĂŶŝƉƵůĂƚŝŽŶĚĞƐĐĂƌĂĐƚğƌĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϯϬ
 ϳ͘ϰ͘DĂŶŝƉƵůĂƚŝŽŶĚĞƐůĠĞŶƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϯϮ
ϳ͘ϱ͘KƉĠƌĂƚĞƵƌƐĞŶ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϯϮ
ϳ͘ϲ͘ƵƚƌĞƐƉŽƐƐŝďŝůŝƚĠƐĞƚƌğŐůĞƐĞŶ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϯϱ
ϴ͘džĞƌĐŝĐĞƐĐŽƌƌŝŐĠƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϰϮ
ϴ͘ϭ͘džĞƌĐŝĐĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϰϮ
ϴ͘Ϯ͘ŽƌƌŝŐĠƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϰϲ

ŚĂƉŝƚƌĞϯ͗>ĞƐƐƚƌƵĐƚƵƌĞƐĐŽŶĚŝƚŝŽŶŶĞůůĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϱϴ
ϭ͘/ŶƚƌŽĚƵĐƚŝŽŶ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϱϴ
Ϯ͘^ƚƌƵĐƚƵƌĞĐŽŶĚŝƚŝŽŶŶĞůůĞƐŝŵƉůĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϱϴ
ϯ͘^ƚƌƵĐƚƵƌĞĐŽŶĚŝƚŝŽŶŶĞůůĞĐŽŵƉŽƐĠĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϱϵ
ϰ͘^ƚƌƵĐƚƵƌĞĐŽŶĚŝƚŝŽŶŶĞůůĞŵƵůƚŝƉůĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϲϬ
ϱ͘>ĞďƌĂŶĐŚĞŵĞŶƚ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϲϮ
ϲ͘džĞƌĐŝĐĞƐĐŽƌƌŝŐĠƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϲϯ
ϲ͘ϭ͘džĞƌĐŝĐĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϲϯ
ϲ͘Ϯ͘ŽƌƌŝŐĠƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϲϰ

ŚĂƉŝƚƌĞϰ͗>ĞƐďŽƵĐůĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϳϯ
ϭ͘/ŶƚƌŽĚƵĐƚŝŽŶ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϳϯ
Ϯ͘>ĂďŽƵĐůĞdĂŶƚƋƵĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϳϯ
ϯ͘>ĂďŽƵĐůĞZĠƉĠƚĞƌ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϳϰ
ϰ͘>ĂďŽƵĐůĞWŽƵƌ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϳϱ
ϱ͘>ĞƐďŽƵĐůĞƐŝŵďƌŝƋƵĠĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϳϳ
ϲ͘džĞƌĐŝĐĞƐĐŽƌƌŝŐĠƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϳϴ
ϲ͘ϭ͘džĞƌĐŝĐĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϳϴ
ϲ͘Ϯ͘ŽƌƌŝŐĠƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϴϬ

ŚĂƉŝƚƌĞϱ͗>ĞƐƚĂďůĞĂƵdžĞƚůĞƐĐŚĂŠŶĞƐĚĞĐĂƌĂĐƚğƌĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϵϯ
ϭ͘/ŶƚƌŽĚƵĐƚŝŽŶ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϵϯ
Ϯ͘>ĞƚLJƉĞƚĂďůĞĂƵ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϵϯ
Ϯ͘ϭ͘DĂŶŝƉƵůĂƚŝŽŶĚ[ƵŶƚĂďůĞĂƵ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϵϰ
Ϯ͘Ϯ͘dƌŝĚ[ƵŶƚĂďůĞĂƵ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϬϬ
Ϯ͘ϯ͘dĂďůĞĂƵăĚĞƵdžĚŝŵĞŶƐŝŽŶƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϬϮ
ϯ͘>ĞƐĐŚĂŠŶĞƐĚĞĐĂƌĂĐƚğƌĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϬϯ
ϯ͘ϭ͘ĠĐůĂƌĂƚŝŽŶĚ[ƵŶĞĐŚĂŠŶĞĚĞĐĂƌĂĐƚğƌĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϬϯ
ϯ͘Ϯ͘DĂŶŝƉƵůĂƚŝŽŶĚĞƐĐŚĂŠŶĞƐĚĞĐĂƌĂĐƚğƌĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϬϯ
ϯ͘ϯ͘dĂďůĞĂƵĚĞĐŚĂŠŶĞƐĚĞĐĂƌĂĐƚğƌĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϬϳ
ϰ͘džĞƌĐŝĐĞƐĐŽƌƌŝŐĠƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϬϳ
ϰ͘ϭ͘džĞƌĐŝĐĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϬϳ
ϰ͘Ϯ͘ŽƌƌŝŐĠƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϭϭ
ŚĂƉŝƚƌĞϲ͗>ĞƐƐŽƵƐͲƉƌŽŐƌĂŵŵĞƐ͗WƌŽĐĠĚƵƌĞƐĞƚ&ŽŶĐƚŝŽŶƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϮϲ
ϭ͘/ŶƚƌŽĚƵĐƚŝŽŶ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϮϲ
Ϯ͘>ĞƐƐŽƵƐͲƉƌŽŐƌĂŵŵĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϮϴ
ϯ͘>ĞƐǀĂƌŝĂďůĞƐůŽĐĂůĞƐĞƚůĞƐǀĂƌŝĂďůĞƐŐůŽďĂůĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϯϰ
ϰ͘>ĞƉĂƐƐĂŐĞĚĞƐƉĂƌĂŵğƚƌĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϯϳ
ϱ͘>ĂƌĠĐƵƌƐŝǀŝƚĠ;ƌĠĐƵƌƐŝŽŶͿ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϰϮ
ϱ͘ϭ͘ĠĨŝŶŝƚŝŽŶ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϰϮ
ϱ͘Ϯ͘džĞŵƉůĞ;ĂůĐƵůĚĞůĂĨĂĐƚŽƌŝĞůůĞͿ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϰϮ
ϲ͘džĞƌĐŝĐĞƐĐŽƌƌŝŐĠƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϰϰ
ϲ͘ϭ͘džĞƌĐŝĐĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϰϰ
ϲ͘Ϯ͘ŽƌƌŝŐĠƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϰϴ

ŚĂƉŝƚƌĞϳ͗>ĞƐƚLJƉĞƐƉĞƌƐŽŶŶĂůŝƐĠƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϲϭ
ϭ͘/ŶƚƌŽĚƵĐƚŝŽŶ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϲϭ
Ϯ͘ĠĨŝŶŝƚŝŽŶĚĞƐƚLJƉĞƐĞŶ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϲϭ
ϯ͘>ĞƚLJƉĞƐƚƌƵĐƚƵƌĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϲϭ
ϰ͘>ĞƚLJƉĞƵŶŝŽŶ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϲϰ
ϱ͘>ĞƚLJƉĞĠŶƵŵĠƌĂƚŝŽŶ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϲϲ
ϲ͘džĞƌĐŝĐĞƐĐŽƌƌŝŐĠƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϲϴ
ϲ͘ϭ͘džĞƌĐŝĐĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϲϴ
ϲ͘Ϯ͘ŽƌƌŝŐĠƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϳϭ

ŚĂƉŝƚƌĞϴ͗>ĞƐĨŝĐŚŝĞƌƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϴϯ
ϭ͘/ŶƚƌŽĚƵĐƚŝŽŶ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϴϯ
Ϯ͘>ĞƐĨŝĐŚŝĞƌƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϴϯ
Ϯ͘ϭ͘>ĂƐƚƌƵĐƚƵƌĞ&/>͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϴϯ
Ϯ͘Ϯ͘KƵǀĞƌƚƵƌĞĚ[ƵŶĨŝĐŚŝĞƌ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϴϰ
Ϯ͘ϯ͘&ĞƌŵĞƚƵƌĞĚ[ƵŶĨŝĐŚŝĞƌ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϴϱ
Ϯ͘ϰ͘ĐĐğƐĂƵĨŝĐŚŝĞƌ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϴϲ
Ϯ͘ϰ͘ϭ͘>ĞĐƚƵƌĞͬĠĐƌŝƚƵƌĞŶŽŶͲĨŽƌŵĂƚĠĞƐĞŶŵŽĚĞĐĂƌĂĐƚğƌĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϴϲ
Ϯ͘ϰ͘Ϯ͘>ĞĐƚƵƌĞͬĠĐƌŝƚƵƌĞŶŽŶͲĨŽƌŵĂƚĠĞƐĞŶŵŽĚĞĐŚĂŠŶĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϴϳ
Ϯ͘ϰ͘ϯ͘>ĞĐƚƵƌĞͬĠĐƌŝƚƵƌĞĨŽƌŵĂƚĠĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϴϴ
Ϯ͘ϰ͘ϰ͘>ĞĐƚƵƌĞͬĠĐƌŝƚƵƌĞƉĂƌďůŽĐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϴϵ
Ϯ͘ϰ͘ϱ͘ĐĐğƐĚŝƌĞĐƚ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϵϬ
ϯ͘džĞƌĐŝĐĞƐĐŽƌƌŝŐĠƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϵϭ
ϯ͘ϭ͘džĞƌĐŝĐĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϵϭ
ϯ͘Ϯ͘ŽƌƌŝŐĠƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϭϵϯ

ŚĂƉŝƚƌĞϵ͗>ĞƐůŝƐƚĞƐĐŚĂŠŶĠĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϮϬϱ
ϭ͘/ŶƚƌŽĚƵĐƚŝŽŶ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϮϬϱ
 Ϯ͘>ĞƐƉŽŝŶƚĞƵƌƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϮϬϱ
ϯ͘'ĞƐƚŝŽŶĚLJŶĂŵŝƋƵĞĚĞůĂŵĠŵŽŝƌĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϮϬϲ
ϰ͘>ĞƐůŝƐƚĞƐĐŚĂŠŶĠĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϮϬϴ
ϱ͘KƉĠƌĂƚŝŽŶƐƐƵƌůĞƐůŝƐƚĞƐĐŚĂŠŶĠĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϮϭϬ
ϱ͘ϭ͘ƌĠĞƌĞƚƌĞŵƉůŝƌƵŶĞůŝƐƚĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϮϭϬ
ϱ͘Ϯ͘ĨĨŝĐŚĞƌůĞƐĠůĠŵĞŶƚƐĚĞůĂůŝƐƚĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϮϭϮ
ϱ͘ϯ͘ũŽƵƚĞƌƵŶĠůĠŵĞŶƚĂƵĚĠďƵƚĚĞůĂůŝƐƚĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϭϯ
ϱ͘ϰ͘/ŶƐĠƌĞƌƵŶĠůĠŵĞŶƚĚĂŶƐůĂůŝƐƚĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϭϰ
ϱ͘ϱ͘^ƵƉƉƌŝŵĞƌůĂƚġƚĞĚĞůĂůŝƐƚĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϭϱ
ϱ͘ϲ͘^ƵƉƉƌŝŵĞƌƵŶĠůĠŵĞŶƚĚĞůĂůŝƐƚĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϭϲ
ϲ͘>ĞƐůŝƐƚĞƐĚŽƵďůĞŵĞŶƚĐŚĂŠŶĠĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϭϳ
ϳ͘>ĞƐůŝƐƚĞƐĐŚĂŠŶĠĞƐƉĂƌƚŝĐƵůŝğƌĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϮϮϬ
ϳ͘ϭ͘>ĞƐƉŝůĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϮϮϬ
ϳ͘ϭ͘ϭ͘WƌŝŵŝƚŝǀĞƐĚ[ĂĐĐğƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϮϮϭ
ϳ͘ϭ͘Ϯ͘ZĞƉƌĠƐĞŶƚĂƚŝŽŶĚ[ƵŶĞƉŝůĞƉĂƌƵŶĞůŝƐƚĞĚŽƵďůĞŵĞŶƚĐŚĂŠŶĠĞ͘͘ϮϮϭ
ϳ͘Ϯ͘>ĞƐĨŝůĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϮϮϮ
ϳ͘Ϯ͘ϭ͘ĐĐğƐăƵŶĞĨŝůĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϮϮϯ
ϳ͘Ϯ͘Ϯ͘ZĞƉƌĠƐĞŶƚĂƚŝŽŶĚ[ƵŶĞĨŝůĞƉĂƌƵŶĞůŝƐƚĞĚŽƵďůĞŵĞŶƚĐŚĂŠŶĠĞ͘͘ϮϮϯ
ϴ͘džĞƌĐŝĐĞƐĐŽƌƌŝŐĠƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϮϮϯ
ϴ͘ϭ͘džĞƌĐŝĐĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϮϮϯ
ϴ͘Ϯ͘ŽƌƌŝŐĠƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϯϰ

ŚĂƉŝƚƌĞϭϬ͗>ĞƐĂƌďƌĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϱϰ
ϭ͘/ŶƚƌŽĚƵĐƚŝŽŶ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϱϰ
Ϯ͘ĠĨŝŶŝƚŝŽŶƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϱϰ
ϯ͘ƌďƌĞďŝŶĂŝƌĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϱϱ
ϯ͘ϭ͘ĠĨŝŶŝƚŝŽŶ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϱϱ
ϯ͘Ϯ͘WĂƐƐĂŐĞĚ[ƵŶĂƌďƌĞŶͲĂŝƌĞăƵŶĂƌďƌĞďŝŶĂŝƌĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϱϱ
ϯ͘ϯ͘ZĞƉƌĠƐĞŶƚĂƚŝŽŶĐŚĂŠŶĠĞĚ[ƵŶĂƌďƌĞďŝŶĂŝƌĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϱϱ
ϯ͘ϰ͘WĂƌĐŽƵƌƐĚ[ƵŶĂƌďƌĞďŝŶĂŝƌĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϱϳ
ϯ͘ϰ͘ϭ͘WĂƌĐŽƵƌƐƉƌĠĨŝdžĠ;ƉƌĠŽƌĚƌĞŽƵZ'Ϳ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϱϳ
ϯ͘ϰ͘Ϯ͘WĂƌĐŽƵƌƐŝŶĨŝdžĠ;ƉƌŽũĞĐƚŝĨ͕ƐLJŵĠƚƌŝƋƵĞŽƵĞŶĐŽƌĞ'ZͿ͘͘͘͘͘͘͘͘͘͘͘͘Ϯϱϴ
ϯ͘ϰ͘ϯ͘WĂƌĐŽƵƌƐƉŽƐƚĨŝdžĠ;ŽƌĚƌĞƚĞƌŵŝŶĂůŽƵ'ZͿ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϱϴ
ϯ͘ϱ͘ƌďƌĞƐďŝŶĂŝƌĞƐƉĂƌƚŝĐƵůŝĞƌƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϱϴ
ϯ͘ϱ͘ϭ͘ƌďƌĞďŝŶĂŝƌĞĐŽŵƉůĞƚ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϱϴ
ϯ͘ϱ͘Ϯ͘ƌďƌĞĚĠŐĠŶĠƌĠ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϱϵ
ϯ͘ϱ͘ϯ͘ƌďƌĞďŝŶĂŝƌĞŽƌĚŽŶŶĠ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϱϵ
ϰ͘džĞƌĐŝĐĞƐĐŽƌƌŝŐĠƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϱϵ
ϰ͘ϭ͘džĞƌĐŝĐĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϱϵ
ϰ͘Ϯ͘ŽƌƌŝŐĠƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϮϲϮ

ŚĂƉŝƚƌĞϭϭ͗>ĞƐŐƌĂƉŚĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϲϵ
ϭ͘/ŶƚƌŽĚƵĐƚŝŽŶ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϲϵ
Ϯ͘ĠĨŝŶŝƚŝŽŶƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϲϵ
ϯ͘ZĞƉƌĠƐĞŶƚĂƚŝŽŶĚ[ƵŶŐƌĂƉŚĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϲϵ
ϯ͘ϭ͘>ŝƐƚĞĚ[ĂĚũĂĐĞŶĐĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϲϵ
ϯ͘Ϯ͘DĂƚƌŝĐĞĚ[ĂĚũĂĐĞŶĐĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϮϳϬ
ϰ͘WĂƌĐŽƵƌƐĚ[ƵŶŐƌĂƉŚĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϳϭ
ϰ͘ϭ͘WĂƌĐŽƵƌƐĞŶůĂƌŐĞƵƌĚ[ĂďŽƌĚ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϳϭ
ϰ͘Ϯ͘WĂƌĐŽƵƌƐĞŶƉƌŽĨŽŶĚĞƵƌĚ[ĂďŽƌĚ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϳϭ
ϱ͘džĞƌĐŝĐĞƐĐŽƌƌŝŐĠƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϮϳϮ
ϱ͘ϭ͘džĞƌĐŝĐĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϮϳϮ
ϱ͘Ϯ͘ŽƌƌŝŐĠƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϳϯ

ZĠĨĠƌĞŶĐĞƐďŝďůŝŽŐƌĂƉŚŝƋƵĞƐĂĚĚŝƚŝŽŶŶĞůůĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϮϴϬ

/Ey͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϴϭ



Avant-propos


Ce livre est destiné aux étudiants de la première année Licence Mathématiques

et Informatique, et à tous ceux qui souhaitent acquérir des bases solides en
algorithmique et en structures de données. Les algorithmes de ce livre sont
traduits en langage C.
Proposant un apprentissage progressif, ce livre s¶appuie largement sur notre
expérience d¶enseignement de la matière "Algorithmique et structures de
données" pendant plusieurs années. A la fin de chaque chapitre, il y a un
ensemble d¶exercices corrigés. Après avoir lu et compris le cours, l¶étudiant est
conseillé d¶essayer de résoudre les exercices par lui-même avant de consulter la
correction. L¶étudiant ne doit pas oublier qu¶un même problème peut être
résolu par différents algorithmes.
L¶auteur de ce livre sera très reconnaissant de recevoir toute remarque ou
suggestion.

ϵ

Introduction .

Chapitre 1 : Introduction

1. Bref historique sur l¶informatique

1.1. Définition
Le mot informatique vient de deux mots : information et automatique.
L¶informatique est le traitement automatique de l¶information.
Traitement : c¶est la création, la suppression, la modification et le stockage.
Automatique : en utilisant une machine.
Information : il faut distinguer entre donnée et information.
x Donnée : c¶est un élément brut, par exemple, 5, jaune, dimanche, ahmed...
x Information : c¶est une donnée interprétée, par exemple, 5 est un nombre.
1.2. Parties de l¶informatique
L¶étude de l¶informatique nous ramène à étudier deux parties :
 HARDWARE : c¶est la partie physique (matériel) dans un ordinateur, par
exemple, circuits intégrés, câbles électriques, disques magnétiques, etc.
 SOFTWARE : c¶est la partie programme (logiciel) dans un ordinateur, par
exemple, système d¶exploitation, programmes d¶application, etc.
1.3. L¶ordinateur
1.3.1. Définition
C¶est une machine capable de traiter de l¶information.
1.3.2. Historique
On peut dire que la deuxième guerre mondiale a donné naissance aux premiers
ordinateurs :
x Les Z2 et Z3 de l¶allemand Zuse ont été prêts en 1939 et 1941.
x Ensuite, la série des "Automatic Sequence Controlled Computer Mark"
conçue par Howard Aiken. Le Mark I fonctionnera en 1944.
x L¶ENIAC (Electronic Numerical Integrator Analyser and Computer)
(1946) de Prosper Eckert et John Mauchly, souvent référencé comme le
premier ordinateur. Il pesait 30 tonnes occupant une superficie de 160
mètres carrés et une hauteur de 3 mètres.
x Ensuite, la 2de génération d¶ordinateurs où on a utilisé les transistors, les
disques magnétiques, etc.
x En 1963, on a utilisé les circuits intégrés (3e génération).
x Les unités centrales réalisées sous de très faibles volumes ont été
largement diffusées en 1976.
1.3.3. Composantes d¶un ordinateur
Un PC (Personal Computer) est constitué principalement de trois parties :
A.Unité centrale : elle contient :
a. La carte mère : elle regroupe les composantes de l¶ordinateur.
ϭϬ
Introduction .

b. Le processeur : c¶est le cerveau de l¶ordinateur, constitué à son tour

d¶une UC (unité de commandes) et d¶une UAL (unité arithmétique et
logique).
Toute action ou activité faite par l¶ordinateur, son ordre provient de l¶UC.
L¶UAL permet de calculer les résultats des expressions arithmétiques et
logiques.
Les expressions arithmétiques : elles servent à effectuer des calculs dont les
résultats sont de type numérique. Ces expressions comportent :
x Des opérandes de type numérique.
x Des opérateurs :  (addition),  (soustraction), (multiplication), 
(division), etc.
x Des fonctions mathématiques : OQ, VLQ, DUFWJ, etc.
Exemple :  .
L¶ordre de priorité entre opérations est le suivant:
x Les fonctions mathématiques.
x La multiplication et la division.
x L¶addition et la soustraction.
On peut utiliser les parenthèses pour clarifier, ou pour changer l¶ordre de
priorité. Par exemple,      permet d¶effectuer l¶addition avant la
multiplication.
Dans le cas d¶égalité de priorité, les opérations sont effectuées de gauche à
droite.
Les expressions logiques : elles servent à effectuer des calculs dont les
résultats sont de type logique (booléen), en utilisant les opérateurs 121, (7 et 28
triés par ordre de priorité. En effet, les parenthèses changent l¶ordre de priorité.
Les opérandes logiques peuvent prendre deux valeurs : 95$, ou )$8;. Une
expression logique implique éventuellement des opérateurs de comparaison, à
savoir !, ! , ,  , , !.
Remarque : Le symbole ! est utilisé dans ce cours pour indiquer la différence
().
Les équations logiques sont les suivantes :
121 (7 95$, )$8; 28 95$, )$8;
95$, )$8; 95$, 95$, )$8; 95$, 95$, 95$,
)$8; 95$, )$8; )$8; )$8; )$8; 95$, )$8;
Exemple !(7 95$,.
c. La mémoire : permet le stockage des informations. Il existe deux types
de mémoire :
1. La mémoire centrale : comporte (1) la RAM (Random Access
Memory) où les informations sont stockées pendant le traitement ;
ϭϭ
Introduction .

(2) la ROM (Read Only Memory) qui stocke le BIOS (Basic Input
Output System), le programme de démarrage de l¶ordinateur.
2. La mémoire auxiliaire : elle permet le stockage permanent des
informations. La mémoire auxiliaire peut être un disque dur, un
CD-ROM, une clé USB, etc.
d. En plus, d¶autres dispositifs, tels que le lecteur CD-ROM, les câbles,
les nappes, etc.
B.L¶écran : permet de sortir (afficher) les informations à l¶utilisateur.
C.Le clavier : permet d¶entrer (acquérir) les informations à la machine.
Un PC peut être accompagné d¶un ensemble de périphériques pour faciliter son
utilisation et augmenter son efficacité. Il existe : la souris, l¶imprimante, le
scanner, le graveur, etc.
1.4. Unités de mesure de la mémoire
L¶unité de mesure de la mémoire est l¶octet, noté O (en anglais byte). 1 octet
correspond à un caractère. 1 octet = 8 bit. Un bit est soit 0, soit 1. Par exemple,
le caractère 'A', dont le code ASCII est 65, est stocké 01000001.
Remarques :
S ASCII (American Standard Code for Information Interchange) : est une
norme d¶encodage informatique des caractères alphanumériques de
l¶alphabet latin.
S La représentation du 0 et 1 dépend du support de stockage.
 Dans la RAM, le 0 et 1 sont représentés par une charge électrique :
chargé (1) ou non chargé (0).
 Dans un support magnétique, ça dépend du sens de la magnétisation.
Par exemple, dans un disque dur, les secteurs sont divisés en îlots
d¶aluminium. Pour écrire un 1, il faut que deux îlots placés à côté l¶un
de l¶autre aient un sens magnétique différent. Sinon, on écrit un 0.
 Dans un CD-ROM, c¶est l¶alvéole qui définit l¶information. On
nomme creux le fond de l¶alvéole, et on nomme plat les espaces entre
les alvéoles. Le passage d¶un creux à un plat (ou l¶inverse) représente
un 1. Le reste représente un 0.
S Contrairement au disque dur, un CD-ROM n¶a qu¶une seule piste
organisée en spirale.
1.4.1. Structure du disque dur
Le disque dur est constitué d¶un ensemble de disques superposés à double-face,
i.e. les données sont stockées sur les deux côtés de chaque disque. Un disque ne
peut être utilisé qu¶après un formatage de bas niveau qui consiste à le
subdiviser en pistes. Une piste contient un ensemble de secteurs. Un secteur
contient 512 O. Un ensemble de pistes superposées est appelé cylindre.

ϭϮ

Introduction .

džĞĚĞƌŽƚĂƚŝŽŶ dġƚĞĚĞ>ͬ
ŝƐƋƵĞ
ŚĂƌŝŽƚ

^šŒµšµŒ[µv]‹µµŒ

^ĞĐƚĞƵƌ

ŝƐƋƵĞ
WŝƐƚĞ;ϬͿ

^šŒµšµŒ[µv]‹µ
On a les règles :
1 Kilo-octet (KO) = 1024 O = (210) O
1 Méga-octet (MO) = 1024 KO = (1024)2 O
1 Giga-octet (GO) = 1024 MO = (1024)2 KO = (1024)3 O
1 Téra-octet (TO) = 1024 GO
1 Péta-octet (PO) = 1024 TO
1.4.2. Tailles de quelques mémoires
Voici les tailles de quelques mémoires :
x Disque dur : 320 GO, 500 GO, 1 TO, etc.
x RAM : 512 MO, 1 GO, 2 GO, etc.
x CD-ROM : 700 MO.
x DVD : 4,7 GO.
x Clé USB : 256 MO, 512 MO, 1 GO, 4 GO, etc.
Remarques :
x Un CD-ROM de l¶anglais « Compact Disc Read Only Memory »
signifie « disque compact en lecture seule ».
x Un DVD de l¶anglais « Digital Versatile Disc » signifie « disque
numérique polyvalent ».
Exercice : Quel est le nombre de CD-ROM nécessaires pour stocker le contenu
d¶un DVD plein.
Solution : On utilise la règle de trois (règle de proportionnalité) pour résoudre
ce problème.
ϭϯ

Introduction .

'9':*2
*2:02
*2:;
1024 * 4,7
X 4812,8MO
1
'9':02
1 CD-520:02
1:02
4812,8
N 6,8 | 7CDROM
700
Pour stocker le contenu d¶un DVD plein, on aura besoin de 7 CD-ROM.
1.5. La relation Homme/Machine
L¶utilisateur ne peut utiliser un ordinateur qu¶à travers un système
d¶exploitation.
hƚŝůŝƐĂƚĞƵƌ

WŒ}PŒuu[‰‰o]š]}v

^ǐšu[Ɖo}]šš]}v ^K&dtZ

/K^

DĂĐŚŝŶĞ ,ZtZ

1.5.1. Système d¶exploitation

C¶est un ensemble de programmes permettant la gestion de l¶ordinateur
(gestion de la mémoire, gestion des fichiers, etc.). Il joue le rôle d¶un
intermédiaire entre l¶utilisateur et la machine.
Exemples :
 MS DOS (Microsoft Disk Operating System) : un système d¶exploitation
produit par Microsoft de Bill Gates, basé sur les commandes (saisies au
clavier), telles que dir, md, rd, etc.
 Windows : un système d¶exploitation graphique (la souris est souvent
utilisée pour la manipulation) produit par Microsoft.
Il existe d¶autres systèmes d¶exploitation produits par d¶autres sociétés, tels que
l¶Unix, Solaris, OS2, etc.
ϭϰ

Introduction .

1.5.2. Fichier et répertoire

Un fichier est un ensemble d¶informations stockées sur un support physique
(disque dur, disquette, RAM, etc.). Un fichier peut être un texte, une image, un
fichier son, etc.
Un fichier possède un nom, une extension indiquant son type, une taille, date et
heure de création ou de modification.
Un répertoire est une partie d¶un support de stockage qui contient des fichiers
et éventuellement d¶autres sous-répertoires. L¶objectif de la création des
répertoires est l¶organisation.
Exemple : Un fichier Révolution.doc, qui existe dans le sous-répertoire
Histoire, qui à son tour existe dans le répertoire Ouvrage, qui se trouve dans le
disque dur, est référencé par le chemin C:\Ouvrage\Histoire\Révolution.doc.
2. Introduction à l¶algorithmique
2.1. Résolution d¶un problème par ordinateur
Pour résoudre un problème à l¶aide d¶un ordinateur, il faut :
1. Analyser ce problème : définir les entrées et les sorties.
2. Déterminer la méthode de résolution : déterminer la suite des opérations à
effectuer pour résoudre le problème. Plusieurs méthodes peuvent être
trouvées ; il faut choisir la plus efficace.
3. Formuler l¶algorithme définitif : représenter la méthode de résolution par
un algorithme écrit en un langage algorithmique, appelé aussi langage de
description d¶algorithme (LDA), ou encore pseudo-code.
4. Traduire l¶algorithme en un langage de programmation adapté.
2.2. Notion d¶algorithme
Le mot algorithme provient du nom du célèbre mathématicien arabe :
Mohamed Ibn Moussa El Khawarizmi (780-850).
Un algorithme est une suite d¶opérations élémentaires exécutées dans un ordre
donné pour résoudre un problème ou accomplir une tâche. En tant que science,
on parle de l¶algorithmique.
2.3. Exemple
Soit le problème de calcul de la somme de deux nombres. Ce problème peut
être résolu de la manière suivante :
A. Analyse
S Entrées : valeur1 et valeur2.
S Sortie : la somme des deux valeurs.
B. Solution
Le calcul de la somme consiste à:
1. Avoir les deux valeurs (lire valeur1 et valeur2).
2. Additionner les deux valeurs.
3. Afficher le résultat (Ecrire la somme).
ϭϱ

Introduction .

Cette forme de représentation d¶un algorithme est dite Enumération des étapes.
C. Ecriture en LDA
En informatique, on utilise un langage de description d¶algorithme (LDA) pour
écrire un algorithme. Ainsi, l¶algorithme ci-dessus devient :
$OJRULWKPH6RPPH
9DULDEOHV
(QWLHUYDOHXUYDOHXUVRP
'pEXW
/LUHYDOHXUYDOHXU
VRP&YDOHXUYDOHXU
(FULUHVRP
)LQ
Comme illustré dans l¶exemple précédent :
S Un algorithme commence par le mot $OJRULWKPH, suivi de son nom.
Généralement, le nom de l¶algorithme indique sa fonction.
S Le mot 9DULDEOHV précède la liste des variables manipulées dans
l¶algorithme et leurs types. Les variables du même type sont séparées par
des virgules (). Deux déclarations différentes sont séparées par un point-
virgule ().
S Les opérations de l¶algorithme sont prises entre les mots 'pEXW et )LQ
indiquant le début et la fin de l¶algorithme. Ces opérations sont séparées
par des points-virgules.
S Le mot /LUH permet la lecture à partir du clavier. Le mot (FULUH permet
l¶affichage à l¶écran.
S Le symbole & correspond à l¶opération d¶affection. Le symbole  est utilisé
pour indiquer l¶addition.
D¶autres mots et symboles utilisés dans notre langage algorithmique seront
découverts dans le reste de ce cours.
Remarque : Le LDA varie d¶un document à un autre. Par exemple, le symbole
d¶affectation, représenté dans notre cours par &, peut être représenté dans un
autre document par .
Un algorithme doit être :
x Lisible : clair et facile à comprendre.
x De haut niveau : indépendant du langage de programmation et du système
d¶exploitation.
x Précis : non ambigu.
x Concis : réduire le nombre d¶opérations ainsi que l¶espace occupé en mémoire.
x Structuré : organisé.
D. Ecriture en langage de programmation
Pour être exécuté sur un ordinateur, un algorithme doit être traduit en un
langage compréhensible par la machine, i.e. un langage de programmation, tel
que Pascal, C, Java, etc.
ϭϲ

Introduction .

Ainsi, l¶algorithme de calcul de la somme, traduit en langage Pascal, donne :

SURJUDP6RPPH
YDUYDOHXUYDOHXUVRPLQWHJHU
EHJLQ
UHDGYDOHXUYDOHXU
VRP YDOHXUYDOHXU
ZULWHVRP
HQG
La traduction en langage C donne le programme :
LQFOXGHVWGLRK!
PDLQ
^
LQWYDOHXUYDOHXUVRP
VFDQIGG YDOHXU YDOHXU
VRP YDOHXUYDOHXU
SULQWIGVRP
`
Si l¶utilisateur introduit  et  pour les deux variables (YDOHXU et YDOHXU)
lors de l¶exécution du programme, alors le résultat d¶affichage sera : 
Il est possible d¶améliorer le programme de calcul de la somme de la manière
suivante:
LQFOXGHVWGLRK!
PDLQ
^
LQWYDOHXUYDOHXUVRP
SULQWI(QWUH]ODSUHPLqUHYDOHXU
VFDQIG YDOHXU
SULQWI(QWUH]ODGHX[LqPHYDOHXU
VFDQIG YDOHXU
VRP YDOHXUYDOHXU
SULQWIΗ>ĂƐŽŵŵĞĚĞйĚĞƚйĚĞƐƚ͗йĚΗ͕ǀĂůĞƵƌϭ͕ǀĂůĞƵƌϮ͕ƐŽŵ
`
Le résultat d¶exécution du programme précédent, si l¶utilisateur introduit  et 
pour YDOHXU et YDOHXU, est le suivant :
(QWUH]ODSUHPLqUHYDOHXU
(QWUH]ODGHX[LqPHYDOHXU
/DVRPPHGHHWHVW
Un programme est donc le résultat de la traduction d¶un algorithme en un
langage de programmation, i.e. un langage formel compréhensible par la
machine.
Dans le reste de ce cours, tous les algorithmes seront traduits en C. Ce langage
a été conçu en 1972 par Denis Ritchie pour écrire le système d¶exploitation
Unix.
Dans le programme C précédent, nous avons :
xL¶en-tête PDLQ indique que ce qui va être écrit par la suite est le
programme principal. En LDA, ça correspond à $OJRULWKPH.
ϭϳ

Introduction .

xLes deux accolades ^` correspondent respectivement à 'pEXW et )LQ dans

un algorithme.
xLQW est utilisé pour déclarer des entiers.
xL¶affectation est exprimée en C par . On note ici qu¶il y a une grande
différence entre l¶égalité en mathématiques qui vise généralement une
comparaison entre deux valeurs, et l¶affectation en algorithmique qui vise à
attribuer une valeur à une variable. L¶opérateur d¶égalité est représenté en C
par le symbole .
xLa fonction VFDQI permet la lecture à partir du clavier. La fonction SULQWI
permet l¶affichage à l¶écran. Les deux fonctions appartiennent à la
bibliothèque VWGLRK incorporée au programme grâce à la directive de pré-
compilation LQFOXGH.
Avant d¶avancer dans ce cours, nous allons monter pas à pas un programme C :
Exemple 1 :
LQFOXGHVWGLRK!
PDLQ
^
SULQWIERQMRXU
`
SULQWI permet d¶afficher une chaîne de caractères mise entre deux guillemets
doubles. Ainsi, le programme de l¶exemple 1 affiche : ERQMRXU
Exemple 2 :
LQFOXGHVWGLRK!
PDLQ
^
SULQWIERQMRXU?Q
SULQWIPRQVLHXU
`
?Q indique le retour à la ligne suivante. Ainsi, le programme de l¶exemple 2
affiche :
ERQMRXU
PRQVLHXU
Sans le ?Q, le programme affichera : ERQMRXUPRQVLHXU
Notons aussi que la fonction SXWV affiche une chaîne de caractères et passe à la
ligne suivante. Ainsi, SULQWIERQMRXU?Q est équivalente à
SXWVERQMRXU.
Voici encore d¶autres possibilités de représentation de caractères spéciaux :
Notation en C Signification
?D Cloche ou bip
?E Retour arrière
?I Saut de page
?Q Saut de ligne
ϭϴ

Introduction .

?U Retour chariot

?W Tabulation horizontale
?Y Tabulation verticale
?? ?
?


? 
?" "
? caractère QXOO
?2QQ QQ en octal
?;QQ QQ en hexadécimal
 
Exemple 3 :
LQFOXGHVWGLRK!
PDLQ
^
LQW[
[ 
SULQWIYDOHXUG[
`
En général, la fonction SULQWI peut avoir plusieurs arguments. Le premier
argument, mis entre deux guillemets doubles, indique le format, i.e. un guide
qui montre comment afficher les arguments suivants, s¶ils existent. Le caractère
 signifie que ce qui vient par la suite est un code de format. Le reste des
arguments correspond aux valeurs à afficher.
Le G dans le programme précédent sera remplacé par la valeur de [ en
décimal. Ainsi, le programme affiche : YDOHXU
Dans le format transmis en premier argument de SULQWI, tout ce qui n¶est pas
code de format est affiché tel quel. Si nous avions, par exemple, SULQWIM¶DL
GDQV[au lieu de SULQWIYDOHXUG[, ceci affiche : M¶DLDQV
Notons aussi qu¶il est possible en C de déclarer et d¶initialiser une variable au
même temps (LQW[ ). La valeur d¶une variable, juste après sa création, est
inconnue. Pour éviter tout problème, il faut initialiser la variable quand on la
déclare, ou bien juste après sa déclaration. L¶initialisation consiste donc à
donner à une variable une première valeur (valeur initiale).
D¶autres formats sont aussi possibles : G pour décimal, I pour IORDW (réel) et F
pour caractère. L¶instruction SULQWIFGGI
$

$

affiche : $. Notons ici qu¶un caractère est mis entre deux
guillemets simples.
Exemple 4 :
LQFOXGHVWGLRK!
PDLQ
^
ϭϵ

Introduction .

LQW[\]
[ 
\ 
] [\
SULQWI/DVRPPHGHGHWGHVWG[\]
`
Dans cet exemple, le programmeur a déclaré trois variables entières [, \ et ]. Il
a initialisé le [ à  et le \ à . Il a ensuite affecté le résultat d¶addition de [ et \
à ].
Ainsi, le programme de l¶exemple 4 affiche : /DVRPPHGHHWHVW
On aurait pu remplacer l¶instruction SULQWIΗ>Ă ƐŽŵŵĞ ĚĞ йĚ Ğƚ йĚ ĞƐƚ͗ йĚ Η͕ dž͕ LJ͕ nj
par SULQWIΗ>ĂƐŽŵŵĞĚĞйĚĞƚйĚĞƐƚ͗йĚΗ͕dž͕LJ͕džнLJ. Comme ça, on aurait pu éviter
la déclaration de la variable ] et l¶affectation ] [\.
Exemple 5 :
LQFOXGHVWGLRK!
PDLQ
^
LQW[\
VFDQIGG [ \
SULQWIYDOHXU GHWYDOHXU G[\
`
De même que pour la fonction SULQWI, la fonction VFDQI possède en argument
un format exprimé sous forme d¶une chaîne de caractères, ici GG, ce qui
correspond à deux valeurs entières. Nous trouvons par la suite une liste
d¶arguments correspondant à des adresses, précisant dans quelles variables on
souhaite placer ces valeurs, ici [ et \.
L¶opérateur (le et commercial) signifie adresse de. Sans cet opérateur, le
compilateur ne détectera aucune erreur, mais les données lues au clavier seront
rangées dans des emplacements aléatoires.
On note aussi que, pour la fonction VFDQI, les données tapées au clavier ne
seront validées qu¶après avoir tapé la touche Entrée.
Il est aussi possible de séparer la saisie de deux nombres par un espace, et
valider le tout par la touche Entrée à la fin. Maintenant, si on sépare les deux
formats dans VFDQI par un caractère bien précis, ceci nous oblige à le saisir
pour séparer les deux nombres, comme c¶est le cas dans VFDQIG G [
\, où la saisie des deux valeurs doit être séparée par le caractère

.
Remarques et définitions :
1. Dans un algorithme, on parle d¶opérations. Dans un programme, on dit
instructions. Un programme est donc une suite d¶instructions.
2. Il faut aussi distinguer entre les opérations arithmétiques et logiques
effectuées en utilisant les opérateurs (, , , DQG, RU, etc.), et les
opérations d¶un algorithme (affectation, lecture, écriture, etc.).
ϮϬ

Introduction .

3. Langage machine ou code machine ou code binaire : instructions codées

en binaire et directement exécutées au niveau du CPU (Central Processing
Unit, ou le micro-processeur) sans traduction.
4. Compilateur : c¶est un logiciel qui transforme un programme écrit en un
langage de programmation (code source) en un programme dont les
instructions sont écrites en langage machine (code binaire ou fichier
exécutable). Lors de la compilation, des erreurs peuvent surgir ; il faut les
corriger avant d¶exécuter le programme.
5. On distingue en particulier deux types de problèmes (erreurs de
compilation) qui peuvent être signalés par le compilateur : [Error] et
[Warning]. [Error] signale un problème grave qui doit être corrigé pour
que le programme s¶exécute. [Warning] signale un cas pouvant entraîner
un comportement inattendu, mais n¶empêche pas l¶exécution du
programme.
6. Une erreur d¶exécution se produit quand le programme n¶a pas le
comportement attendu lors de son exécution. Elle n¶est pas détectée par le
compilateur, mais par le programmeur lui-même. Par exemple, l¶absence
du dans VFDQI, pour lire un entier, provoque une erreur d¶exécution.
7. Le langage le plus facile à convertir en code machine est l¶assembleur.
L¶assembleur est un langage de programmation dont les instructions
correspondent au langage machine (c¶est-à-dire aux instructions
élémentaires du CPU), mais sont écrites en abréviations textuelles plutôt
qu¶en code binaire.
3. Exercices corrigés
3.1. Exercices
Exercice 1 :
1. Calculez l¶expression arithmétique suivante :
± ±
2. Calculez l¶expression logique suivante :
28)$8;(795$,28 
Exercice 2 :
Question 1 : Est-ce qu¶il est possible de graver le contenu d¶un disque dur de
30 GO dans 44 CDROM ? Justifiez votre réponse.
Question 2 : Combien de CDROM faut-il pour copier le contenu d¶une clé USB
de 4 GO ?
Question 3 : Quel est le nombre de caractères qui peuvent se trouver dans un
disque dur de 4 GO ?
Question 4 : Quel est le nombre de cylindres qui existent dans un disque dur de
20 GO, en supposant que le disque dur contient 10 disques superposés à
double-face, et il existe 32 secteurs par piste ?

Ϯϭ

Introduction .

3.2. Corrigés
Solution 1 :
1. Calcul de l¶expression arithmétique :
± ± 1 ±
2 ±
1 ±
6±
 11
 2
2. Calcul de l¶expression logique :
28)$8;(795$,28 
 VRAI28)$8;(795$,28 
 VRAI(795$,28 
95$,(795$,286 
95$,(795$,28FAUX
95$,(7VRAI
VRAI
Solution 2 :
Réponse 1 :
Taille du disque dur en MO :
*2:02
*2:;
X = (1024 * 30)/1 = 30720 MO
Taille des CDROM en MO :
1 CDROM :02
&'520:;
X = (700 * 44)/1 = 30800 MO
La taille des CDROM est supérieure à la taille du disque dur (30800 > 30720),
alors la réponse est : OUI, il est possible de graver le contenu d¶un disque dur
de 30 GO dans 44 CDROM.
Réponse 2 :
Taille de la clé USB en MO
*2:02
*2:;
X = (1024 * 4) / 1 = 4096 MO
Nbr de CDROM pour copier le contenu de la clé USB
&'520:02
;&'520:02
;   § 6 CDROM
On a besoin de 6 CDROM pour copier le contenu d¶une clé USB de 4 GO.

ϮϮ
Introduction .

Réponse 3 :
On a : FDUDFWqUH:RFWHW
*2:02 2 KO = (1024)3 O
!*2:3 caractères
*2:;
3
X = 4 *1024 = 4294967296 caractères
1
Théoriquement, il est possible de stocker l¶équivalent de 4294967296
caractères dans un disque dur de 4 GO.
Réponse 4 :
Taille du cylindre en O
On a : SLVWH:VHFWHXUV
On a : VHFWHXU:2
VHFWHXUV:;
X = (512*32)/1 = 16384 O
!SLVWH: O
On a aussi : F\OLQGUH:10 pistes * 2 = 10 * 16384 * 2 = 327680 O
Taille du disque dur en O
*2:02 2 KO = (1024)3 O
*2:;
3
X = 20 *1024 = 21474836480 O
1
Nbr de cylindres/disque dur
On a : F\OLQGUH:327680 O
;:21474836480 O
X = 21474836480 * 1 = 65536 cylindres
327680
Le disque dur contient 65536 cylindres.

Ϯϯ

Les algorithmes séquentiels simples .

Chapitre 2 : Les algorithmes séquentiels simples

1. Parties d¶un algorithme

Un algorithme contient deux parties:
x La partie données (déclaration) : contient les variables et les constantes.
x La partie traitement (code, opérations ou corps de l¶algorithme) : elle
correspond au processus de calcul.
2. Les données
Les données sont les objets manipulés dans un algorithme.
Dans un algorithme, toute donnée utilisée doit être déclarée. Les données
peuvent être des variables ou des constantes.
Les variables : Une variable correspond à un objet dont la valeur peut varier au
cours de déroulement de l¶algorithme. Une variable est caractérisée par :
x Un nom (identificateur) qui doit être explicite, i.e. indique le rôle de la
variable dans l¶algorithme.
x Un type : indique les valeurs qui peuvent être prises par la variable.
x Une valeur : indique la grandeur prise par la variable à un moment donné.
Sur le plan technique, une variable correspond à une case mémoire
(emplacement de mémoire) avec : le non de la variable est l¶adresse de la case
mémoire, le type indique la taille (le nombre d¶octets) de la case, et la valeur
représente le contenu de la case. C¶est le compilateur qui fait alors le lien entre
l¶identificateur d¶une variable et son adresse en mémoire.
Les constantes : Une constante est un cas particulier de la variable. Il s¶agit
d¶une variable dont la valeur est inchangeable dans l¶algorithme tout entier.
Exemple :
$OJRULWKPHFDOFXOBVXUIDFH
&RQVWDQWHV
3, 
9DULDEOHV
5pHO UD\RQVXUIDFH
'pEXW
«

En C :
GHILQH 3, 
PDLQ
^
IORDW UD\RQVXUIDFH
«

Une constante est donc introduite en C par la directive de pré-compilation

GHILQH suivie du nom de la constante, et enfin sa valeur. Lors de la pré-
Ϯϰ
Les algorithmes séquentiels simples .

compilation, chaque fois où la constante figure dans le code source, elle sera
remplacée par sa valeur.
Les variables et la constante du programme précédent peuvent être représentées
en mémoire comme suit :
  ĚƌĞƐƐĞƐ DĠŵŽŝƌĞ
ŵĠŵŽŝƌĞ
   
  ϭϰϰϱϵ 
W/ ^ ϭϰϰϲϬ ϯ͘ϭϰ
  ϭϰϰϲϭ 
ƌĂLJŽŶ ^ ϭϰϰϲϮ 
ƐƵƌĨĂĐĞ ^ ϭϰϰϲϯ 
  ϭϰϰϲϰ 
  YXX 
En fait, cette représentation n¶est pas tout à fait exacte, car réellement la
mémoire est constituée d¶un ensemble d¶octets, chacun est identifié par une
adresse. La case mémoire correspondant à une variable est constituée d¶un
ensemble d¶octets selon son type. L¶adresse d¶une variable est l¶adresse du
premier octet de l¶espace mémoire réservé (alloué) à la variable.
On note aussi qu¶il n¶y a pas de place allouée en mémoire pour une constante
introduite par GHILQH. Le nom de la constante (3,) sera remplacé par 
tout au long du programme. Pour déclarer des constantes typées, on utilise le
mot clé FRQVW. Dans ce cas-là, un espace mémoire sera réservé à la constante
selon son type. Par exemple : FRQVWIORDW3, 
3. Les types
Le type correspond au genre ou la nature de la variable que l¶on souhaite
utiliser. Il indique donc les valeurs qui peuvent être prises par cette variable.
La déclaration d¶une variable consiste à l¶associer à un type. Chaque type
donné peut être manipulé par un ensemble d¶opérations.
Il existe des types simples et des types structurés.
Les types simples (scalaires) : Un type simple est un type de données
décrivant une information atomique, i.e. constituée d¶une seule valeur. A leur
tour, les types simples peuvent être classés en deux catégories :
1.Types numériques :
S (QWLHU : Par exemple : , . Les opérateurs de manipulation des
entiers sont :
x Les opérateurs arithmétiques classiques : , , , .
x Le modulo , avec QS donne le reste de la division de Q par S.
x Les opérateurs de comparaison classiques : , !, , etc.
S 5pHO : Par exemple : , . Les opérateurs de manipulation des
réels sont :

Ϯϱ

Les algorithmes séquentiels simples .

x Les opérateurs arithmétiques classiques : , , , .

x Les opérateurs de comparaison classiques : , !, , etc.
2.Types symboliques :
S %RROpHQ : comporte les deux valeurs 95$, et )$8;. Les opérateurs de
manipulation des booléens sont : 121, (7, 28.
S &DUDFWqUH : comporte les données alphanumériques, symboliques,
signes de ponctuation, etc., contenant un seul caractère, par exemple

D
,
"
,

,

. Notons qu¶un caractère se met entre deux guillemets
simples. Les opérateurs de manipulation des caractères sont les
opérateurs de comparaison : !, , , etc. Le résultat de la comparaison
dépend du code ASCII des caractères comparés.
Les types structurés (complexes) : Un type structuré est un type de données
décrivant une information composite, i.e. constituée de plusieurs valeurs, elles-
mêmes de types simples ou structurés. Parmi ces types on cite : le type tableau,
le type chaîne de caractères et le type structure qui seront vus ultérieurement.
4. Opérations de base
La partie traitement d¶un algorithme implique un ensemble d¶opérations qui
peuvent être :
 Opérations de base ou encore élémentaires qui permettent une exécution
séquentielle d¶un algorithme.
 Structures de contrôle qui permettent le saut dans un algorithme.
Les opérations de base sont l¶affectation et les opérations d¶entrée/sortie.
4.1. L¶affectation
L¶opération la plus importante en algorithmique est l¶affectation (assignation)
qui se note & ( en C), et qui consiste à attribuer ou affecter à une variable une
valeur appartenant à son domaine de définition (son type). La valeur affectée
est souvent le résultat d¶un calcul d¶une expression arithmétique ou une
expression logique.
Exemple : En C :
$OJRULWKPHFDOFXOV LQFOXGHVWGLRK!
« PDLQ
'pEXW ^«
;& ; 
<&;  < ; 
=&< = <
=&=± = =±
+&!(7 + ! 
« «
L¶exemple est lu comme suit : La variable ; reçoit la valeur  ; La variable <
reçoit la valeur de ; multipliée par  ; La variable = reçoit la valeur de < ; La
variable = reçoit la valeur courante (actuelle) de = moins  ; La variable + reçoit
la valeur 95$,.
Ϯϲ

Les algorithmes séquentiels simples .

Remarque : Comme en C il n¶y a pas de type booléen, + va prendre dans ce

programme la valeur 1.
4.2. Les entrées/sorties
Les échanges d¶information entre l¶utilisateur et la machine sont appelés
opérations d¶entrée-sortie. Les opérations d¶entrée-sortie sont :
x /LUH : qui récupère la valeur tapée au clavier et l¶affecte à l¶espace
mémoire désigné par la variable entre parenthèses. En C, c¶est VFDQI.
x (FULUH : qui récupère la valeur située à l¶espace mémoire désigné par la
variable entre parenthèses, et affiche cette valeur à l¶écran. En C, c¶est
SULQWI.
Une chaîne de caractères : est une suite de plusieurs caractères, permettant de
représenter des mots ou des phrases. Une chaîne de caractères doit être mise
entre deux guillemets doubles pour la distinguer d¶un identificateur de variable.
Par exemple, (FULUHERQMRXU, en C SULQWIERQMRXU, permet
d¶afficher le mot ERQMRXU à l¶écran.
5. Construction d¶un algorithme simple
La construction d¶un algorithme consiste à lui donner un nom, identifier les
variables et les constantes et écrire le corps de l¶algorithme.
Le corps de l¶algorithme est constitué d¶une séquence d¶opérations mises entre
'pEXW et )LQ et séparées par des points-virgules (). Le corps de l¶algorithme
peut contenir des opérations de lecture, écriture, affection, etc. Pour éclaircir
l¶algorithme, son corps peut contenir des commentaires mis entre  « .
Exemple :
L¶algorithme de calcul de la surface d¶un cercle représenté par énumération des
étapes est le suivant :
1.Saisir le rayon du cercle (lire le rayon).
2.Calculer la surface par l¶expression :  UD\RQ2.
3.Afficher le résultat (écrire la surface).
En utilisant un langage algorithmique, on obtient :
$OJRULWKPH&DOFXOB6XUIDFH
 &DOFXOGHODVXUIDFHG¶XQFHUFOH 
&RQVWDQWHV
3, 
9DULDEOHV
5pHOUD\RQVXUIDFH
'pEXW
(FULUH'RQQH]ODYDOHXUGXUD\RQ
/LUHUD\RQ
VXUIDFH&3, UD\RQ UD\RQ
(FULUHVXUIDFH
)LQ


Ϯϳ

Les algorithmes séquentiels simples .

6. Représentation d¶un algorithme par un organigramme

Un algorithme peut être représenté aussi par un organigramme facilitant sa
compréhension. Un organigramme est une représentation graphique
(diagramme) de la solution d¶un problème. Pour cela, on utilise les symboles
géométriques suivants :
Un rectangle aux coins
ĠďƵƚͬ&ŝŶ arrondis représente 'pEXW ou )LQ de
l¶algorithme.
Un parallélogramme représente une
>ŝƌĞͬĐƌŝƌĞ
opération d¶entrée/sortie.
Un rectangle représente un traitement
yVz=í (une affectation par exemple).
Un losange représente un test d¶une
KƵŝ EŽŶ condition pour une décision ou une
ŽŶĚŝƚŝŽŶ
sélection.
Un lien orienté ou non représente une
OLDLVRQHQWUHGHX[Q°XGVHWLQGLTXHDXVVL
l¶ordonnancement des opérations.
L¶algorithme de calcul de la surface peut être représenté par l¶organigramme
suivant :
ĠďƵƚ

ĐƌŝƌĞ;ΗŽŶŶĞnjůĂǀĂůĞƵƌĚƵƌĂLJŽŶ͗ΗͿ͖

>ŝƌĞ;ƌĂLJŽŶͿ͖

µŒ(VW/ŽŒÇ}vŽŒÇ}v͖

ĐƌŝƌĞ;ƐƵƌĨĂĐĞͿ͖

&ŝŶ

7. Traduction en langage C
7.1. Exemple
La traduction de l¶algorithme de calcul de la surface en un programme C sera
comme suit :
LQFOXGHVWGLRK!
GHILQHSL 
PDLQ
 &DOFXOGHODVXUIDFHG¶XQFHUFOH 
Ϯϴ
Les algorithmes séquentiels simples .

^
IORDWUD\RQVXUIDFH
SULQWI'RQQH]ODYDOHXUGXUD\RQ?Q
VFDQII UD\RQ
VXUIDFH SL UD\RQ UD\RQ
SULQWIIVXUIDFH
`
7.2. Manipulation des nombres
Les entiers :
Le langage C comprend principalement trois types d¶entiers, différenciés par la
quantité d¶espace mémoire utilisée pour représenter la valeur numérique
considérée :
x VKRUW : 2 octets
x LQW : en général 2 octets, parfois 4 ou plus (ça dépend du compilateur)
x ORQJ : 4 octets
De plus, deux modificateurs peuvent être appliqués à ces types :
x XQVLJQHG : entiers naturels (positifs). Tous les bits sont utilisés pour
représenter le nombre.
x VLJQHG : entiers relatifs (positifs ou négatifs). Le bit de poids fort (à
gauche) représente le signe du nombre (0 représente un signe +, et 1
représente un signe -). Le reste des bits représente le nombre.
Si on ne précise pas le modificateur, le type est VLJQHG par défaut.
Voici un tableau explicatif :
Nombre de valeurs Intervalle de
Type Octets Modificateur
possibles définition
XQVLJQHG [0, 216 í@
VKRUW 2 216 = 22×8 = 65536
VLJQHG >í15, 215 í@
XQVLJQHG [0, 232 í@
ORQJ 4 24×8 = 4294967296
VLJQHG >í31, 231 í@
Les réels :
Les nombres réels sont des nombres à virgule flottante, pouvant s¶écrire sous la
forme : ± Mantisse E ± Exposant, avec Nombre réel = ± Mantisse * 10 ±Exposant
En C, un nombre réel exprimé en notation scientifique à virgule flottante (avec
le format H) prend la forme ([[[[[[[H“[[[)
Exemple : Le nombre réel (IORDW en C) , s¶écrit avec le format H
comme suit : H
En langage C, on trouve trois types de réels :
Type Octets Signe Mantisse Exposant Intervalle de définition
IORDW 4 1 bit 23 bits 8 bits [1,5 × 10í45 ; 3,4 × 1038]
GRXEOH 8 1 bit 52 bits 11 bits [5 × 10í324 ; 1,7 × 10308]
ORQJ
10 1 bit 64 bits 15 bits [3,4 × 10í4932 ; 1,1 × 104932]
GRXEOH
Ϯϵ

Les algorithmes séquentiels simples .

Remarque : Les informations de cette section peuvent nous aider à calculer la

complexité spatiale de quelques programmes. La complexité spatiale est le coût
en espace d¶un programme, i.e., indique combien d¶espace mémoire ce
programme occupe. Nous avons aussi la complexité temporelle qui correspond
au coût en temps d¶un programme, i.e., indique combien d¶instructions ce
programme comporte.
Exemple : Soit le programme C suivant :
LQFOXGHVWGLRK!
PDLQ
^
IORDW[
VKRUW\]
[ SULQWII?Q[
[ SULQWII?Q[
[ SULQWII?Q[
[ SULQWII?Q[
[ SULQWIH?Q[
[ SULQWIH?Q[
[ SULQWIH?Q[
[ SULQWIH?Q[
[ SULQWIH?Q[ 
`
Le programme affiche :

Notons que le format I nous a permis d¶afficher un nombre avec deux
chiffres après la virgule avec ajustement. Si on l¶affiche en notation scientifique
à virgule flottante, il y aura aussi un ajustement.
La complexité spatiale du programme = 4 + 2 + 2 = 8 octets.
La complexité temporelle du programme = 18 instructions.
7.3. Manipulation des caractères
Un caractère (lettre, ponctuation, symbole, etc.) est déclaré en langage C par le
mot clé FKDU. Une variable de type caractère occupe 1 octet en mémoire.
Chaque caractère possède un code ASCII. La table ASCII est un tableau de 256

ϯϬ

Les algorithmes séquentiels simples .

caractères numérotés de 0 à 255. A titre d¶exemple, les lettres majuscules de

$
à
=
sont codées dans l¶ordre par les codes 65 à 90.
Quelques fonctions de manipulation des caractères :
En langage C, il existe une fonction nommée SXWFKDU permettant d¶afficher un
seul caractère.
Exemple :
LQFOXGHVWGLRK!
PDLQ
^
FKDU[
H

SXWFKDU[
`
Le programme affiche : H
Maintenant, la fonction JHWFKDU permet de lire un caractère :
Exemple :
LQFOXGHVWGLRK!
PDLQ
^
FKDU[ JHWFKDU
SULQWIF[
`
Ce programme permet d¶affecter un caractère lu à partir du clavier à la variable
[ grâce à la fonction JHWFKDU, et de l¶afficher ensuite à l¶écran.
Remarques :
S SXWFKDU et JHWFKDU ne peuvent être exécutées que si on ajoute la directive
de pré-compilation LQFOXGH permettant d¶incorporer au programme,
avant la compilation, le fichier VWGLRK là où les deux fonctions sont
définies.
S Pour la fonction JHWFKDU, le caractère tapé au clavier ne sera validé
qu¶après avoir tapé la touche Entrée.
S Chaque caractère doit être mis entre deux guillemets simples pour le
distinguer d¶un identificateur.
S Il est possible de comparer les caractères selon l¶ordre du code ASCII.
Ainsi, 
$
!
%
 retourne  ()$8; en algorithmique).
S Puisque chaque caractère correspond à un code ASCII, une variable de
type FKDU peut être manipulée comme un nombre. Ainsi, l¶instruction
FKDU F 
$
est équivalente à FKDU F  . De même, l¶instruction
LQWL 
$
est équivalente à LQWL .
S Il ne faut pas confondre le caractère

ayant le code ASCII 54, et le
nombre  représentant lui-même le code ASCII d¶un autre caractère.

ϯϭ

Les algorithmes séquentiels simples .

7.4. Manipulation des booléens

Il n¶existe pas de type booléen à proprement parler en C. A la place, on utilise
des entiers :
S La valeur zéro représente la valeur )$8;.
S Une valeur non-nulle représente la valeur 95$,.
Remarque :
Dans d¶autres langages, tels que Pascal, le type booléen existe explicitement.
Par exemple, soit le programme Pascal suivant :
SURJUDPH[HPSOH
YDUEERROHDQ
EHJLQ
E 
$
!
%

ZULWHOQE
HQG
Ce programme affiche :)$/6(
Son équivalent en C est :
LQFOXGHVWGLRK!
PDLQ
^
LQWE
E 
$
!
%

SULQWIGE
`
Ce programme affiche : 
7.5. Opérateurs en C
Opérateurs arithmétiques :
Le tableau suivant montre des opérateurs arithmétiques en C :
Opérateur Description Type Priorité Associativité
 identité unaire 14 DàG
 opposé unaire 14 DàG
 addition binaire 12 GàD
 soustraction binaire 12 GàD
 multiplication binaire 13 GàD
Division (si les deux
 opérandes sont des entiers, il binaire 13 GàD
s¶agit d¶une division entière)
modulo : reste de la division
 entière (les deux opérandes binaire 13 GàD
doivent être des entiers)
Les deux premiers opérateurs (identité et opposé) sont dits unaires, portant sur
un seul opérande. Les autres opérateurs sont dits binaires, portant sur deux
opérandes.
Les opérateurs en C sont classés selon 16 niveaux de priorité : le plus haut
niveau étant 15 ; le plus bas niveau est donc 0.
ϯϮ

Les algorithmes séquentiels simples .

Le sens d¶associativité indique si les expressions contenant plusieurs opérateurs

de même priorité doivent être évaluées en considérant les opérandes de gauche
à droite (GàD) ou de droite à gauche (DàG).
Les parenthèses peuvent être utilisées pour améliorer la lisibilité de
l¶expression, ou pour changer l¶ordre de priorité.
Ces opérateurs s¶appliquent à des valeurs numériques (y compris les caractères
qui sont représentés par leurs codes ASCII) et renvoient un résultat lui aussi
numérique.
Exemples :
S   est équivalente à  , car les opérateurs et  ont la même
priorité, et l¶ordre d¶évaluation de l¶expression est donc déterminé par leur
sens d¶associativité (GàD).
S   est équivalente à  , pour les mêmes raisons.
Opérateurs de comparaison (relationnels) :
Les opérateurs de comparaison prennent comme opérandes des expressions
numériques, et produisent un résultat booléen, i.e. 95$, ou )$8;. Comme il n¶y
a pas de type booléen en C, alors, si le résultat de la comparaison est :
S )$8;, alors l¶expression retourne .
S 95$,, alors l¶expression retourne .
Opérateur Description Priorité Associativité
 égal 9 GàD
  différent 9 GàD
 strictement inférieur 10 GàD
  inférieur ou égal 10 GàD
! strictement supérieur 10 GàD
!  supérieur ou égal 10 GàD
Exemples :
S ! est une expression de type LQW dont la valeur est  ()$8;).
S ! est une expression de type LQW dont la valeur est  (95$,).
Attention ! Il ne faut pas confondre l¶opérateur d¶affectation ( ) et celui
d¶égalité ( ), car le symbole utilisé en mathématiques pour l¶égalité est utilisé
en C pour l¶affectation. Cette erreur (eg. mettre au lieu de ) est difficile à
détecter, car elle ne donne pas lieu à une erreur de compilation ; elle provoque
plutôt une erreur d¶exécution.
Opérateurs logiques :
Les opérateurs logiques sont supposés s¶appliquer à des valeurs booléennes
(95$, et )$8;) et renvoyer un résultat lui aussi booléen.
Puisqu¶il n¶y a pas de type booléen en C, et qu¶on représente 95$, et )$8; par
des entiers, alors ces opérateurs :
S s¶appliquent à des valeurs entières :
ϯϯ

Les algorithmes séquentiels simples .

  représente )$8;,
 une valeur non-nulle représente 95$,.
S et renvoient une valeur entière :
  pour un résultat = )$8;,
  pour un résultat = 95$,.
Opérateur Description Priorité Associativité
 non (ou négation) 14 DàG
 et (conjonction) 5 GàD
__ ou (disjonction) 4 GàD
Exemples :
S !  ! est une expression de type LQW dont la valeur est 
()$8;).
S ! __ ! est une expression de type LQW dont la valeur est 
(95$,).
S ! __  retourne  (95$,). La valeur non-nulle  correspond à
95$,.
S !__ __ retourne encore  (95$,). Cette expression
va correspondre à 95$,__95$, )$8;__)$8;, qui va être calculée
de la manière suivante : 95$, __ 95$,  )$8; __ )$8;  95$, __
)$8;__)$8; 95$,__)$8; 95$,.
Remarques :
S L¶opérateur (7 est appliqué tant qu¶on ne rencontre pas d¶opérande )$8;
(auquel cas la valeur de l¶expression est )$8;). Par exemple, pour   
  , on évalue seulement la partie rouge de l¶expression, car
dès qu¶on rencontre le , on sait que l¶expression est fausse sans avoir
besoin d¶en connaitre la suite.
S L¶opérateur 28 est appliqué tant qu¶on ne rencontre pas d¶opérande 95$,
(auquel cas la valeur de l¶expression est 95$,). Par exemple, pour __ 
__  __ , là-aussi, on évalue seulement la partie rouge de l¶expression,
car dès qu¶on rencontre le , on sait que l¶expression est vraie sans avoir
besoin d¶en connaitre la suite.
Opérateurs bit-à-bit
Sachant que toutes les données (entier, réel, caractère, etc.) sont stockées dans
la mémoire d¶un ordinateur en binaire, ces opérateurs permettent de travailler
directement sur la représentation binaire des données, bit par bit.
Opérateur Description Priorité Associativité
a complément à un 14 DàG
 et bit-à-bit 8 GàD
A ou exclusif bit-à-bit 7 GàD
_ ou bit-à-bit 6 GàD
ϯϰ

Les algorithmes séquentiels simples .

!! décalage à droite 11 GàD

 décalage à gauche 11 GàD
Le complément à un d¶un nombre binaire est la transformation obtenue en
remplaçant tous ses  par des , et tous ses  par des .
et bit-à-bit : 0 0=0, 0 1=0, 1 0=0, 1 1=1.
ou exclusif (;25) bit-à-bit : 0A0=0, 0A1=1, 1A0=1, 1A1=0.
ou bit-à-bit : 0_0=0, 0_1=1, 1_0=1, 1_1=1.
Le décalage à droite se fait en supprimant le bit de poids faible (à droite), et en
ajoutant un 0 à gauche.
Le décalage à gauche se fait en supprimant le bit de poids fort (à gauche), et en
ajoutant un 0 à droite.
7.6. Autres possibilités et règles en C
Dans ce qui suit, nous citons quelques possibilités offertes par le langage C, et
quelques règles qui doivent être respectées lors de l¶écriture d¶un programme C :
L¶opérateur sizeof :
L¶opérateur VL]HRIW permet de connaitre l¶espace mémoire occupé par une
valeur de type W spécifié. Ainsi, VL]HRIIORDW retourne . Il peut aussi être
appliqué directement à une expression, pour obtenir l¶espace qu¶elle occupe en
mémoire.
Dépassement de capacité :
Si jamais, lors d¶un calcul, la valeur manipulée sort de l¶intervalle prévu, on dit
qu¶il y a un dépassement de capacité.
XQVLJQHG VKRUW[ 
 est représenté en binaire , ce qui va dépasser les 2
octets réservés à un XQVLJQHGVKRUW. La valeur affectée à [ sera . Notons
que cette erreur n¶empêche pas l¶exécution du programme, mais pourra donner
des résultats erronés.
Identificateurs et mots-clés :
Un identificateur est un nom donné à un élément de programmation : fonction,
variable, constante, etc. Il doit être significatif, i.e. indique le rôle de l¶élément
dans le programme.
Un identificateur doit être unique. Il doit être constitué de lettres (minuscules
et/ou majuscules), des chiffres et/ou le caractère tiret-bas (aussi appelé
underscore : B). Il ne doit pas contenir des signes diacritiques sur les lettres
(accents, trémas, tilde, etc.). Il ne doit pas dépasser 127 caractères. Le premier
caractère doit être une lettre.
Remarque : Le compilateur C fait la distinction entre les lettres minuscules et
les lettres majuscules. Par exemple, les deux identificateurs YDO et 9$/ sont
considérés différents.
ϯϱ

Les algorithmes séquentiels simples .

Les mots clés (ou mots réservés) du langage C, tels que PDLQ, SULQWI, VFDQI,
FRQVW, etc. ne doivent pas être utilisés comme identificateurs.
Commentaires et lisibilité :
Un commentaire est un texte exprimé en langage naturel, et dont le but est
d¶expliquer le fonctionnement du programme à un programmeur. Ce texte est
ignoré par le compilateur.
En C, un commentaire est délimité par  et , et peut occuper plusieurs
lignes. On peut aussi faire des commentaires d¶une seule ligne en insérant  en
début de la ligne.
Exemple :
 &HSURJUDPPHFDOFXOHODVXUIDFH
G¶XQUHFWDQJOH 

9RLFLODSUHPLqUHPpWKRGH


Les commentaires améliorent la lisibilité du code.

La lisibilité du code source est la propriété d¶un code source à être facilement
compris par une personne qui ne l¶a pas forcément écrit.
Un autre moyen pour améliorer la lisibilité du code est l¶indentation.
L¶indentation est un décalage introduit en début de ligne pour aligner
horizontalement certaines lignes du code source.
Exemple : Aligner les accolades, aligner les instructions appartenant au même
EORF«
Constantes symboliques vs. Constantes littérale :
Une constante définie par le mot clé FRQVW, ou par la directive GHILQH est dite
symbolique. Elle permet d¶associer un identificateur à une valeur qui ne change
pas au cours d¶exécution du programme.
Une constante littérale ne possède pas de nom, il s¶agit simplement d¶une
valeur donnée explicitement dans le code source. On distingue :
S Les constates numériques :
 Constantes entières, par exemple : 
 Les constantes réelles sont exprimées en utilisant un point décimal, par
exemple :  ou 
S et les constantes textuelles :
 Constantes caractères, par exemple
$

 Constantes chaîne de caractères, par exemple ERQMRXU

Conversions :
Dans une instruction d¶affectation, le type de l¶expression à droite doit
correspondre au type de la variable de destination à gauche.
La partie gauche d¶une affectation est souvent dite lvalue, pour left value en
anglais.
ϯϲ

Les algorithmes séquentiels simples .

Pour une souplesse de programmation, le langage C offre des possibilités de

conversion.
Grâce à cette conversion, l¶expression (à droite) va être calculée, même si les
types de ses opérandes sont différents ; et l¶affectation sera effectuée même si
le type du résultat (à droite) est différent au type de la lvalue.
La conversion est l¶action de changer le type de données d¶une expression. Elle
peut être implicite ou explicite.
La conversion implicite est effectuée automatiquement sans aucune
intervention du programmeur. Le compilateur la déduit du code source. Cela se
fait comme suit :
 Le type du résultat d¶une expression étant imposé par celui des opérandes
ayant le type le plus fort, sachant que l¶ordre de force décroissante
s¶établit ainsi : ORQJGRXEOH, GRXEOH, IORDW, XQVLJQHG ORQJ, ORQJ,
XQVLJQHGLQW, LQW.
Les opérandes de type (XQVLJQHG) FKDU ou (XQVLJQHG) VKRUW sont
systématiquement convertis en (XQVLJQHG) LQW.
 Le résultat obtenu après calcul va être converti au type de la lvalue de
l¶affectation.
Exemple 1 :
LQFOXGHVWGLRK!
PDLQ
^
IORDWD E
LQW[\ 
[ D
SULQWI[ G?Q[
E D\
SULQWIE IE
`
Dans la première affectation ([ D), la valeur de D sera convertie en entier
pour pouvoir l¶affecter à [. [ aura la valeur . Dans ce cas-là, il y a eu une perte
de précision ou dégradation de l¶information (la partie décimale du nombre réel
a été perdue). Dans la deuxième affectation ( E D\), la valeur de \ sera
convertie en réel (car c¶est le type de D), et le résultat réel sera affecté à E.
Ce programme affiche donc :
[ 
E 
Passant maintenant à la conversion explicite qui est une conversion demandée
par le programmeur grâce à l¶opérateur de transtypage, appelé aussi cast.
Format général : W\SHH[SUHVVLRQ
Exemple 2 :
LQFOXGHVWGLRK!
ϯϳ

Les algorithmes séquentiels simples .

PDLQ
^
LQW[ UHVXOWDW
IORDW\ 
UHVXOWDW [LQW\
SULQWIPRGXOR GUHVXOWDW
`
Dans cet exemple, nous avons converti un réel en entier pour pouvoir appliquer
l¶opérateur modulo, et le programme affiche ainsi : PRGXOR 
Exemple 3 :
LQFOXGHVWGLRK!
PDLQ
^
LQW[ \ 
IORDWUHVXOWDW
UHVXOWDW [IORDW\
SULQWIUHVXOWDW IUHVXOWDW
`
La conversion explicite nous a permis d¶obtenir un résultat réel , au
lieu de  si on enlève la conversion.
Exemple 4 :
LQFOXGHVWGLRK!
PDLQ
^
IORDWVXUIDFH 
SULQWII?QVXUIDFH
VXUIDFH 
SULQWIIVXUIDFH
`
 et  sont deux constantes entières ; c¶est pourquoi le premier opérateur  a
permis d¶effectuer une division entière. Le résultat étant converti en réel et
affecté à surface.
 est une constante réelle ; c¶est pourquoi, le deuxième opérateur  a permis
d¶effectuer une division entre réels après avoir converti la constante  en réel.
Le programme de l¶exemple 4 affiche donc :


Attention ! Le calcul de la valeur (résultat) d¶une expression se fait selon
l¶ordre de priorité entre opérateurs. Dans une expression, chaque fois qu¶on
calcule le résultat d¶une opération entre deux opérandes, on applique les règles
de conversion déjà vues. C¶est pourquoi, l¶expression   donne un
résultat peut être inattendu ( ). Puisqu¶il y a une égalité de priorité
entre  et , la division entière s¶effectuera avant la multiplication, ce qui
donne  . A la différence de   qui donnera ; ce
ϯϴ

Les algorithmes séquentiels simples .

même résultat correct peut être obtenu avec    ou   ou
IORDW , etc.
On remarque aussi que la conversion des réels en nombres entiers supprime la
partie décimale (troncature).
L¶opérateur
En C, l¶affectation est un opérateur. Il possède une associativité de droite à
gauche (DàG).
N L  est équivalente à N L . On affecte le  à L, puis la valeur
de l¶expression L , qui est , sera affectée à N.
[ \ ]  est équivalente à [ \ ] . Donc,  sera affecté d¶abord à
], puis la valeur de l¶expression ]  (qui est aussi ) sera affectée à \, et ainsi
de suite.
Il ne faut pas confondre l¶opérateur d¶affectation avec l¶opérateur d¶égalité .
[ \  est équivalente à [ \ , car le sens d¶associativité de est de
GàD. On teste donc d¶abord si [ et \ sont égaux, puis on compare l¶entier
résultant de ce test avec la valeur .
Fonctions mathématiques :
La bibliothèque PDWKK contient les fonctions de calcul scientifique : SRZ
(puissance), VTUW (racine carrée), FRV, VLQ, WDQ, etc.
Entrées et sorties formatées :
Les deux fonctions VFDQI et SULQWI ont besoin d¶un argument spécifiant le
format. Il s¶agit d¶une chaîne de caractères qui indique éventuellement la
position et le format d¶affichage des autres arguments grâce au caractère .
Le caractère  est une balise de positionnement suivie d¶une spécification de
traduction dont le format général est :
>LQGLFDWHXU@>ODUJHXU@>SUHFLVLRQ@>PRGLILFDWLRQ@W\SH.
Tous les champs notés entre crochets sont optionnels. Le type est obligatoire.
Voici les différentes possibilités de type :
Type Signification
F Caractère
V Chaîne de caractères
G Nombre entier en décimal
H Nombre réel sous la forme mantisse/exposant [-]m.nnnnnne[+|-]xx
( Nombre réel sous la forme mantisse/exposant en majuscule [-]m.nnnnnne[+|-]xx
I Nombre réel sous la forme [-]mmm.nnnnnn
J Nombre réel sous la forme la plus courte entre les types %e et %f
* Nombre réel sous la forme la plus courte entre les types %E et %f
R Nombre entier en octal
S Pointeur ou adresse de la valeur numérique
X Nombre entier non signé en décimal
[ Nombre entier en hexadécimal

ϯϵ

Les algorithmes séquentiels simples .

; Nombre entier en hexadécimal ; lettres affichées en majuscules

Exemple :
LQFOXGHVWGLRK!
PDLQ
^
IORDW[ 
SULQWII[
`
Le programme affiche : 
Pour afficher un réel en spécifiant le nombre de chiffres après la virgule avec
ajustement, le format est "I.
Par exemple : SULQWII[ affiche : 
SULQWIIV avec V entier, ou SULQWIGV avec V réel, dans les deux
cas, il n¶aura pas d¶erreur de compilation, mais on aura un résultat d¶affichage
inattendu.
L¶opérateur d¶incrémentation :
Notation : 
Priorité : la même que pour l¶opérateur unaire identité ().
Dans un programme C, L est équivalente à L L.
L peut figurer dans une expression comme le montre l¶exemple suivant :
LQFOXGHVWGLRK!
PDLQ
^
LQWL 
LQWQ L
LQWN L
SULQWIL GQ GN GLQN
`
L incrémente la valeur de L d¶une unité. Cependant, cette incrémentation ne
sera tenue en compte que dans l¶instruction suivante.
Le programme affiche : L Q N 
Dans le cas où l¶opérateur  précède la variable, alors l¶incrémentation sera
effectuée immédiatement dans l¶opération en cours. Ainsi, dans
l¶exemple suivant :
LQFOXGHVWGLRK!
PDLQ
^
LQWL 
LQWQ L
LQWN L
SULQWIL GQ GN GLQN
`
Le programme affiche : L Q N 
ϰϬ

Les algorithmes séquentiels simples .

Avec le même esprit, agit l¶opérateur .

Instruction expression :
En langage C, la notion d¶instruction et d¶expression sont étroitement liées. On
parle souvent de instruction expression.
L
L 
N L 
Les deux premières ont l¶allure d¶une instruction d¶affectation. Dans les deux
cas il y a l¶évaluation d¶une expression. La valeur de l¶expression (L ), i.e.
, est affectée à N. La dernière affectation elle aussi agit comme une expression,
et retourne une valeur () qui pourra être utilisée ultérieurement.
Opérateurs d¶affectation élargie :
Le langage C permet de condenser les affectations de la forme :
OYDOXH OYDOXH2SpUDWHXUH[SUHVVLRQ
en
OYDOXH2SpUDWHXU H[SUHVVLRQ
Par exemple : L L est équivalente L .
Ceci est valable aussi pour , , , , ainsi que les opérateurs de manipulation
des bits.
L¶opérateur conditionnel :
Soit par exemple :
6LD!EPD[&DVLQRQPD[&E
Ceci peut être écrit en C :
PD[ D!E"DE
Déclaration d¶une variable :
En langage C, il est possible de déclarer une variable n¶importe où dans un
programme. La règle à respecter est qu¶on ne peut utiliser une variable qu¶après
sa déclaration, comme c¶est le cas pour la variable \ dans l¶exemple suivant :
LQFOXGHVWGLRK!
PDLQ
^
LQW[
[ 
LQW\'pFODUDWLRQGH\DXPLOLHXGXSURJUDPPH
\ [
SULQWIGG[\
`
Il faut aussi tenir compte de la portée d¶une variable, i.e. le bloc d¶instructions
là où la variable peut être utilisée. Dans l¶exemple suivant, la variable \ ne peut
être utilisée que dans le bloc d¶instructions défini entre ^ et `, et non pas
ailleurs.
LQFOXGHVWGLRK!
PDLQ
ϰϭ

Les algorithmes séquentiels simples .

^
LQW[
[ 
^'pEXWGXEORFGDQVOHTXHOODYDULDEOH\SHXWrWUHXWLOLVpH
LQW\
\ [
SULQWIGG[\
`)LQGXEORF
`
8. Exercices corrigés
8.1. Exercices
Exercice 1 :
Qu¶affiche l¶algorithme suivant ?
$OJRULWKPHFDOFXOBGRXEOH
9DULDEOHV
HQWLHUYDOGEO
'pEXW
YDO&
GEO&YDO 
(FULUHYDO
(FULUHGEO
)LQ
Exercice 2 :
Ecrire un algorithme permettant de lire deux nombres a et b, de calculer et
d¶afficher leur moyenne. Traduire l¶algorithme en C. Ensuite, représentez
l¶algorithme par un organigramme. Déroulez l¶algorithme dans le cas où
l¶utilisateur donne pour a la valeur 7, et pour b la valeur 19.
Note : Le déroulement d¶un algorithme (simulation ou trace d¶un algorithme)
consiste à décrire le changement des variables (sur le plan technique, l¶état de
la mémoire) au cours d¶exécution des opérations de l¶algorithme, dans un
tableau appelé tableau de situation.
Exercice 3 :
Ecrire un algorithme permettant de lire trois nombres, de calculer et d¶afficher
leur somme, leur produit et leur moyenne. Traduire l¶algorithme en C.
Exercice 4 :
Ecrire un algorithme qui demande un nombre à l¶utilisateur, puis calcule et
affiche le carré, le double et le triple de ce nombre. Traduire l¶algorithme en C.
Exercice 5 :
Ecrire un algorithme qui lit le prix HT (Hors Taxe) d¶un article, le nombre
d¶articles et le taux de TVA (la Taxe sur la Valeur Ajoutée), et qui fournit le
prix total TTC (Toutes Taxes Comprises) correspondant. Traduire l¶algorithme
en C.

ϰϮ

Les algorithmes séquentiels simples .

Exercice 6 :
Ecrire un algorithme permettant de lire le rayon R d¶une sphère, de calculer et
d¶afficher son aire = 4 pi R2 et son volume = 4/3 pi R3. Traduire l¶algorithme
en C.
Exercice 7 :
Ecrire un algorithme permettant de lire au clavier les longueurs des trois côtés
a, b et c d¶un triangle. L¶algorithme doit calculer et afficher le périmètre et
l¶aire du triangle. Périmètre = p = a + b + c, et Aire = (p/2 * (p/2-a) * (p/2-b)
* (p/2-c))1/2. Traduire l¶algorithme en C.
Exercice 8 :
Ecrire un algorithme permettant de lire au clavier le rayon R d¶un cercle et un
angle a (en degrés). L¶algorithme doit calculer et afficher l¶aire du secteur
circulaire (= pi R2 a / 360). Traduire l¶algorithme en C.
Exercice 9 :
Pour convertir des degrés Fahrenheit en degrés Celsius, on a la formule
suivante : &§ )-32), où F est la température en degrés Fahrenheit, et
C est la température correspondante en degrés Celsius.
xEcrire un algorithme qui convertit une température entrée au clavier,
exprimée en degrés Fahrenheit, et affiche une valeur approchée de la même
température en degrés Celsius. Les températures seront exprimées par des
nombres réels. Traduire l¶algorithme en C.
xMême question pour la conversion inverse : de degrés Celsius en degrés
Fahrenheit.
Exercice 10 :
Soit la fonction mathématique f définie par f(x)=(2x+3)(3x2+2).
Ecrire un algorithme qui calcule l¶image par f d¶un nombre saisi au clavier.
Traduire l¶algorithme en C.
Exercice 11 :
Une bille de plomb est lâchée du haut d¶un immeuble et tombe en chute libre.
Au bout d¶un temps t (exprimé en secondes), la bille est descendue d¶une
hauteur h (en mètres) : h=1/2 *g * t2, avec g = 9.81
x Ecrire un algorithme qui calcule la hauteur descendue au bout d¶un temps
t saisi au clavier. Traduire l¶algorithme en C.
x Ecrire un programme C qui calcule la durée totale de la chute connaissant
la hauteur total h de l¶immeuble saisi au clavier. On pourra utiliser la
fonction VTUW de la bibliothèque PDWKK qui calcule la racine carrée d¶un
nombre.
Exercice 12 :
Ecrire un algorithme permettant de saisir deux nombres, de les permuter puis
les afficher. Traduire l¶algorithme en C.
ϰϯ

Les algorithmes séquentiels simples .

Note : La permutation de deux variables consiste à échanger (intervertir) leurs

valeurs.
Exercice 13 :
Par un algorithme, exprimez un nombre de secondes sous forme d¶heures,
minutes et secondes. La seule donnée est le nombre total de secondes que nous
appellerons nsec; les résultats consistent en trois nombres h, m, s. Traduire
l¶algorithme en C.
Exercice 14 :
Les exercices de 14 à 17 utilisent les déclarations suivantes en langage C :
FKDUF 
$
F 
'

LQWQ S 
ORQJT 
IORDW[ 
Donnez le type et la valeur de chacune des expressions suivantes :
x QT
x Q[
x QS T
x QS Q
Exercice 15 :
Donnez le type et la valeur de l¶expression : F[
Exercice 16 :
Donnez le type et la valeur de chacune des expressions suivantes :
x QS
x Q! S
x Q!T
x T Q!S
x F!F
x F!Q
x F!QFS
x F!Q FS
Exercice 17 :
Donnez le type et la valeur de chacune des expressions suivantes :
x F!F__FF
x T Q
x T Q
x [ T 
Exercice 18 :
Qu¶affiche le programme C suivant ?
LQFOXGHVWGLRK!
PDLQ
^
LQWQ S T

ϰϰ

Les algorithmes séquentiels simples .

Q 
S
T QS
SULQWIGT
`
Exercice 19 :
xEssayez de mieux présenter le programme C suivant :
LQFOXGHVWGLRK!PDLQ^LQW
QVFDQIG
Q
SULQWI
GDSRXUGRXEOHG

Q 
Q`
xQue se passe t-il si on enlève la déclaration LQWQ ?
xQue se passe t-il si on remplace l¶identificateur Q par LI ?
Exercice 20 :
Qu¶affiche le programme C suivant ?
LQFOXGHVWGLRK!
PDLQ
^
XQVLJQHGVKRUWD E 
SULQWIGGDE!!
`
Exercice 21 :
Qu¶affiche le programme C suivant ?
LQFOXGHVWGLRK!
PDLQ
^
LQWQ S 
SULQWIGGG?QQ SQ_SQAS
SULQWIGGG?QQ!!Q!!Q
SULQWIGGGaQaQ!!aQ
`
Exercice 22 :
Ecrire un programme C qui affiche le code ASCII d¶un caractère saisi au
clavier.
Exercice 23 :
Ecrire un programme C qui :
xlit deux entiers n1 et n2 au clavier ;
xaffiche la partie entière de leur quotient ;
xaffiche la partie fractionnaire frac de leur quotient ;
xlit un nombre réel l au clavier ;

ϰϱ

Les algorithmes séquentiels simples .

 calcule la partie entière du produit de l par frac modulo 256, puis convertit
le résultat en caractère ;
 affiche le caractère obtenu.
Tester votre programme pour n1=1321, n2=500, l=500.
8.2. Corrigés
Solution 1 :
L’algorithme affiche :
231
462
Solution 2 :
Algorithme :
Algorithme Moyenne
Variables
Réel a,b, moy ;
Début
Ecrire("Donnez la première valeur :") ;
Lire(a) ;
Ecrire("Donnez la deuxième valeur :") ;
Lire(b) ;
moy ← (a + b) / 2 ;
Ecrire("Moyenne = ", moy) ;
Fin
Programme C :
#include <stdio.h>
main()
{
float a, b, moy;
printf("Donnez la première valeur :\n");
scanf("%f",&a);
printf("Donnez la deuxième valeur :\n");
scanf("%f",&b);
moy = (a + b) / 2 ;
printf("Moyenne = %f", moy);
}

46
Les algorithmes séquentiels simples .

Organigramme :
ĠďƵƚ

ĐƌŝƌĞ;ΗŽŶŶĞnjůĂƉƌĞŵŝğƌĞǀĂůĞƵƌ͗ΗͿ͖

>ŝƌĞ;ĂͿ͖

ĐƌŝƌĞ;ΗŽŶŶĞnjůĂĚĞƵdžŝğŵĞǀĂůĞƵƌ͗ΗͿ͖

>ŝƌĞ;ďͿ͖

u}ÇV~=lî͖

ĐƌŝƌĞ;ΗDŽLJĞŶŶĞсΗ͕ŵŽLJͿ͖

&ŝŶ

Déroulement de l¶algorithme :
Pour le déroulement de l¶algorithme dans le cas de a=7 et b=19, on va noter les
opérations comme suit :
Opération Notation
(FULUH'RQQH]ODSUHPLqUHYDOHXU 1
/LUHD 2
(FULUH'RQQH]ODGHX[LqPHYDOHXU 3
/LUHE 4
PR\&DE 5
(FULUH0R\HQQH PR\ 6
Le tableau suivant (tableau de situation) correspond au schéma d¶évolution
d¶état des variables, opération par opération :
Variable D E PR\
Affichage
Opération (effectué par l¶opération Ecrire)
     'RQQH]ODSUHPLqUHYDOHXU
     
     'RQQH]ODGHX[LqPHYDOHXU
     
     
     0R\HQQH 
Solution 3 :
Algorithme :
ϰϳ

Les algorithmes séquentiels simples .

$OJRULWKPHFDOFXOV
9DULDEOHV
5pHOVRPPHSURGXLWPR\HQQHQEQEQE
'pEXW
(FULUH'RQQH]WURLVQRPEUHV
/LUHQEQEQE
VRPPH&QEQEQE
SURGXLW&QE QE QE
PR\HQQH&VRPPH
(FULUH/DVRPPHGHFHVWURLVQRPEUHVHVWVRPPH
(FULUH/HSURGXLWGHFHVWURLVQRPEUHVHVWSURGXLW
(FULUH/DPR\HQQHGHFHVWURLVQRPEUHVHVWPR\HQQH
)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ
^
IORDWVRPPHSURGXLWPR\HQQHQEQEQE
SULQWI'RQQH]WURLVQRPEUHV?Q
VFDQIIII QE QE QE
VRPPH QEQEQE
SURGXLW QE QE QE
PR\HQQH VRPPH
SULQWI/DVRPPHGHFHVWURLVQRPEUHVHVWI?QVRPPH
SULQWI/HSURGXLWGHFHVWURLVQRPEUHVHVWI?QSURGXLW
SULQWI/DPR\HQQHGHFHVWURLVQRPEUHVHVWI?QPR\HQQH
`
Solution 4 :
Algorithme :
$OJRULWKPHFDUUHBGRXEOHBWULSOH
9DULDEOHV
(QWLHUQEFGW
'pEXW
(FULUH(QWUH]XQQRPEUH
/LUHQE
F&QE QE
G& QE
W& QE
(FULUH/HFDUUp F
(FULUH/HGRXEOH G
(FULUH/HWULSOH W
)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ
^
LQWQEFGW
SULQWI'RQQH]XQQRPEUH?Q

ϰϴ

Les algorithmes séquentiels simples .

VFDQIG QE
F QE QE
G QE 
W QE 
SULQWI/HFDUUp G?QF
SULQWI/HGRXEOH G?QG
SULQWI/HWULSOH G?QW
`
Solution 5 :
Algorithme :
$OJRULWKPHIDFWXUH
9DULDEOHV
5pHOSXWYDWWF
(QWLHUQE
'pEXW
(FULUH'RQQH]OHSUL[XQLWDLUHKRUVWD[HV
/LUHSX
(FULUH'RQQH]OHQRPEUHG¶DUWLFOHV
/LUHQE
(FULUH'RQQH]OHWDX[GH79$
/LUHWYD
WWF&QE SXQE SX WYD
(FULUH/HSUL[WRXWHVWD[HVHVWWWF
)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ
^
IORDWSXWYDWWF
LQWQE
SULQWI'RQQH]OHSUL[XQLWDLUHKRUVWD[HV
VFDQII SX
SULQWI'RQQH]OHQRPEUHG
DUWLFOHV
VFDQIG QE
SULQWI'RQQH]OHWDX[GH79$
VFDQII WYD
WWF QE SXQE SX WYD
SULQWI/HSUL[WRXWHVWD[HVHVWIWWF
`
Solution 6 :
Algorithme :
$OJRULWKPHVSKHUH
&RQVWDQWHV
SL 
9DULDEOHV
5pHO5$LUH9RO
'pEXW
(FULUH,QWURGXLVH]ODYDOHXUGXUD\RQ
ϰϵ

Les algorithmes séquentiels simples .

/LUH5
$LUH& SL 5 5
9RO& SL 5 5 5
(FULUH$LUH $LUH
(FULUH9ROXPH 9RO
)LQ
Programme C :
LQFOXGHVWGLRK!
GHILQHSL
PDLQ
^
IORDW5$LUH9RO
SULQWI,QWURGXLVH]ODYDOHXUGXUD\RQ
VFDQII 5
$LUH  SL 5 5
9RO  SL 5 5 5
SULQWI$LUH I?Q$LUH
SULQWI9ROXPH I9RO
`
Solution 7 :
Algorithme :
$OJRULWKPHWULDQJOH
9DULDEOHV
5pHODEF3HULP$LUHS
'pEXW
(FULUH'RQQH]ODORQJXHXUGXF{WpD
/LUHD
(FULUH'RQQH]ODORQJXHXUGXF{WpE
/LUHE
(FULUH'RQQH]ODORQJXHXUGXF{WpF
/LUHF
3HULP&DEF
S&3HULP
$LUH&S SD SE SFA
(FULUH3pULPqWUH 3HULP
(FULUH$LUH $LUH
)LQ
Programme C :
LQFOXGHVWGLRK!
LQFOXGHPDWKK!
PDLQ
^
IORDWDEF3HULP$LUHS
SULQWI'RQQH]ODORQJXHXUGXF{WpD
VFDQII D
SULQWI'RQQH]ODORQJXHXUGXF{WpE
VFDQII E
SULQWI'RQQH]ODORQJXHXUGXF{WpF

ϱϬ

Les algorithmes séquentiels simples .

VFDQII F

3HULP DEF
S 3HULP
$LUH VTUWS SD SE SF
SULQWI3pULPqWUH I?Q3HULP
SULQWI$LUH I$LUH
`
Solution 8 :
Algorithme :
$OJRULWKPHVHFWHXU
&RQVWDQWHV
SL 
9DULDEOHV
5pHO5$QJOH$LUH
'pEXW
(FULUH,QWURGXLVH]OHUD\RQ
/LUH5
(FULUH,QWURGXLVH]O
DQJOHHQGHJUpV
/LUH$QJOH
$LUH&SL 5 5 $QJOH
(FULUH$LUH $LUH
)LQ
Programme C :
LQFOXGHVWGLRK!
GHILQHSL
PDLQ
^
IORDW5$QJOH$LUH
SULQWI,QWURGXLVH]OHUD\RQ
VFDQII 5
SULQWI,QWURGXLVH]O
DQJOHHQGHJUpV
VFDQII $QJOH
$LUH SL 5 5 $QJOH
SULQWI$LUH I$LUH
`
Solution 9 :
Algorithme :
$OJRULWKPH&RQYHUVLRQB)BWRB&
9DULDEOHV
5pHO&)
'pEXW
(FULUH'RQQH]ODWHPSpUDWXUHHQGHJUpV)DKUHQKHLW
/LUH)
&& )
(FULUH/DWHPSpUDWXUHHQGHJUpV&HOVLXV &
)LQ
Programme en C :
LQFOXGHVWGLRK!
ϱϭ

Les algorithmes séquentiels simples .

PDLQ
^
IORDW&)
SULQWI'RQQH]ODWHPSpUDWXUHHQGHJUpV)DKUHQKHLW
VFDQII )
&  )
SULQWI/DWHPSpUDWXUHHQGHJUpV&HOVLXV I&
`
Programme en C pour la conversion inverse :
LQFOXGHVWGLRK!
PDLQ
^
IORDW&)
SULQWI'RQQH]ODWHPSpUDWXUHHQGHJUpV&HOVLXV
VFDQII &
) &
SULQWI/DWHPSpUDWXUHHQGHJUpV)DKUHQKHLW I)
`
Solution 10 :
Algorithme :
$OJRULWKPHIFW
9DULDEOHV
5pHO[I[
'pEXW
(FULUH(QWUH]XQQRPEUH
/LUH[
I[& [ [ [
(FULUH)[ I[
)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ
^
IORDW[I[
SULQWI(QWUH]XQQRPEUH
VFDQII [
I[  [ [ [
SULQWI)I I[I[
`
Solution 11 :
Algorithme :
$OJRULWKPH&DOFXOBKDXWHXU
9DULDEOHV
5pHOKW
'pEXW
(FULUH(QWUH]XQHGXUpH
/LUHW
K&ò  W W
ϱϮ

Les algorithmes séquentiels simples .

(FULUH+DXWHXU K

)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ
^
IORDWKW
SULQWI(QWUH]XQHGXUpH
VFDQII W
K   W W
SULQWI+DXWHXU IK
`
Programme C : calcul du temps en fonction de la hauteur
LQFOXGHVWGLRK!
LQFOXGHPDWKK!
PDLQ
^
IORDWKW
SULQWI(QWUH]XQHKDXWHXU
VFDQII K
W VTUW K
SULQWI7HPSV IW
`
Solution 12 :
Permutation en utilisant une variable intermédiaire :
Algorithme :
$OJRULWKPH3HUPXWHU
9DULDEOHV
(QWLHU[\]
'pEXW
(FULUH'RQQH]ODYDOHXUGH[
/LUH[
(FULUH'RQQH]ODYDOHXUGH\
/LUH\
]&[
[&\
\&]
(FULUH$SUqVSHUPXWDWLRQ
(FULUH[ [
(FULUH\ \
)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ
^
LQW[\]
SULQWI'RQQH]ODYDOHXUGH[
VFDQIG [
ϱϯ

Les algorithmes séquentiels simples .

SULQWI'RQQH]ODYDOHXUGH\

VFDQIG \
] [
[ \
\ ]
SULQWI$SUqVSHUPXWDWLRQ?Q
SULQWI[ G?Q[
SULQWI\ G\
`
Permutation sans variable intermédiaire :
Algorithme :
$OJRULWKPH3HUPXWHU
9DULDEOHV
(QWLHU[\
'pEXW
(FULUH'RQQH]ODYDOHXUGH[
/LUH[
(FULUH'RQQH]ODYDOHXUGH\
/LUH\
[&[\
\&[±\
[&[±\
(FULUH$SUqVSHUPXWDWLRQ
(FULUH[ [
(FULUH\ \
)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ
^
LQW[\
SULQWI'RQQH]ODYDOHXUGH[
VFDQIG [
SULQWI'RQQH]ODYDOHXUGH\
VFDQIG \
[ [\
\ [\
[ [\
SULQWI$SUqVSHUPXWDWLRQ?Q
SULQWI[ G?Q[
SULQWI\ G\
`
Solution 13 :
Algorithme :
$OJRULWKPHFRQYHUVLRQ
9DULDEOHV
(QWLHUQVHFKPV
'pEXW
ϱϰ

Les algorithmes séquentiels simples .

(FULUH,QWURGXLVH]OHQRPEUHGHVHFRQGHV

/LUHQVHF
V&QVHF
P&QVHF
K&QVHF
ĐƌŝƌĞ;ŶƐĞĐ͕ΗƐĞĐŽŶĚĞ;ƐͿǀĂƵƚ͗Η͕Ś͕ΗŚĞƵƌĞ;ƐͿ͕Η͕ŵ͕ΗŵŝŶƵƚĞ;ƐͿ͕ĞƚΗ͕Ɛ͕ΗƐĞĐŽŶĚĞ;ƐͿΗͿ͖
)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ
^
LQWQVHFKPV
SULQWI,QWURGXLVH]OHQRPEUHGHVHFRQGHV
VFDQIG QVHF
K QVHF
P QVHF
V QVHF
ƉƌŝŶƚĨ;ΗйĚƐĞĐŽŶĚĞ;ƐͿǀĂƵƚ͗йĚŚĞƵƌĞ;ƐͿйĚŵŝŶƵƚĞ;ƐͿ͕ĞƚйĚƐĞĐŽŶĚĞ;ƐͿΗ͕ŶƐĞĐ͕Ś͕ŵ͕ƐͿ͖
`
Solution 14 :
Le type et la valeur de chacune des expressions suivantes :
x QT Type :ORQJ, valeur :
x Q[ Type :IORDW, valeur :
x QS T Type :ORQJ, valeur :
x QS Q Type :LQW, valeur :
Solution 15 :
Le type et la valeur de l¶expression suivante :
F[Type :IORDW, valeur : 
Solution 16 :
Le type et la valeur de chacune des expressions suivantes :
x QS Type :LQW, valeur : 
x Q! SType :LQW, valeur : 
x Q!T Type :LQW, valeur : 
x T Q!SType :ORQJ, valeur : 
x F!FType :LQW, valeur : 
x F!QType :LQW, valeur : 
x F!QFS Type :LQW, valeur : 
x F!Q FSType :LQW, valeur : 
Solution 17 :
Le type et la valeur de chacune des expressions suivantes :
x F!F__FFType :LQW, valeur : 
x T QType :LQW, valeur : 
x T QType :LQW, valeur : 
ϱϱ

Les algorithmes séquentiels simples .

x [ T  Type :IORDW, valeur : 

Solution 18 :
Le programme affiche :
Solution 19 :
x Mieux présenter le programme C :
LQFOXGHVWGLRK!
PDLQ
^
LQWQ
VFDQI Q
SULQWIGDSRXUGRXEOHGQ Q
`
x Si on enlève la déclarationLQWQ, une erreur de compilation surgit : Q
XQGHFODUHG.
x Si on remplace l¶identificateurQ par LI, une erreur de compilation
surgit refusant d¶utiliser LI comme identificateur, car LI est un mot
clé.
Solution 20 :
Le programme C affiche :
Solution 21 :
Le programme C affiche :



Solution 22 :
Programme C :
LQFOXGHVWGLRK!
PDLQ
^
FKDUF
SULQWI7DSH]XQFDUDFWqUH
VFDQIF F
SULQWI/HFRGH$6&,,GXFDUDFWqUHFHVWGFF
`
Solution 23 :
Programme C :
LQFOXGHVWGLRK!
PDLQ
^
LQWQQTXRWLHQW
IORDWIUDFO
FKDUF
SULQWI'RQQH]GHX[HQWLHUV?Q
VFDQIGG Q Q

ϱϲ

Les algorithmes séquentiels simples .

TXRWLHQW QQ
SULQWI3DUWLHHQWLqUHGXTXRWLHQWG?QTXRWLHQW
IUDF QIORDWQTXRWLHQW
SULQWI3DUWLHIUDFWLRQQDLUHGXTXRWLHQWI?QIUDF
SULQWI'RQQH]XQQRPEUH
VFDQII O
F LQWO IUDF
SULQWI/HFDUDFWqUHREWHQXHVWFF
`
Avec Q , Q , O , le programme affiche :
'RQQH]GHX[HQWLHUV


3DUWLHHQWLqUHGXTXRWLHQW
3DUWLHIUDFWLRQQDLUHGXTXRWLHQW
'RQQH]XQQRPEUH
/HFDUDFWqUHREWHQXHVW$

ϱϳ

Les structures conditionnelles .

Chapitre 3 : Les structures conditionnelles

1. Introduction
Les algorithmes vus précédemment sont exécutés séquentiellement. Les
ruptures des séquences peuvent être effectuées par des structures de contrôle
classées en deux catégories : les structures conditionnelles et les boucles. Les
structures conditionnelles (simples, composées et multiples) sont aussi appelées
structures alternatives, structures de choix ou les tests.
2. Structure conditionnelle simple
Format général : 6L&RQGLWLRQ6pTXHQFH!
Cette opération est lue comme suit : Si la condition est vérifiée (95$,), alors la
séquence d¶opérations s¶exécute.
La condition est une expression logique qui retourne la valeur 95$, ou )$8;.
L¶expression peut être simple (condition simple) ou composée (plusieurs
conditions composées avec des opérateurs logiques (7, 28 et 121).
La séquence peut contenir une ou plusieurs opérations. Si la séquence contient
plusieurs opérations, alors elles sont séparées par des points-virgules et mises
entre GpEXW et ILQ. Si la séquence contient une seule opération, alors les mots
GpEXW et ILQ ne sont pas obligatoires.
La structure conditionnelle simple peut être représentée dans un organigramme
comme suit :

EKE Kh/
;ŽŶĚŝƚŝŽŶͿ

^ĠƋƵĞŶĐĞ

Voyons les exemples suivants :

x 6L;!(FULUH;
On affiche la valeur de ; si elle est supérieure à .
x 6L;!GpEXW(FULUH;<&;ILQ
On affiche la valeur de ; et on affecte la valeur de ; à <, si ; est
supérieure à .
x 6L;!(7;(FULUH;
On affiche la valeur de ; si elle est prise entre  et .
x 6L;!6L;(FULUH;
Cet exemple est équivalent à l¶exemple précédent, sauf que cette fois-ci
on utilise des tests imbriqués.
x 6L;6L;!(FULUH[
ϱϴ

Les structures conditionnelles .

Dans cet exemple, la valeur de ; n¶est jamais affichée, car il n¶y a aucun
cas qui satisfait la condition.
En C, la structure conditionnelle simple s¶écrit sous la forme :
LI&RQGLWLRQ%ORF!
Exemple : LI;!SULQWIG;
Remarques :
xDans un programme C, on utilise le terme bloc au lieu de séquence. Le bloc
est constitué donc d¶une ou plusieurs instructions.
xLa condition est obligatoirement mise entre  et . Chaque instruction du
bloc doit se terminer par un point-virgule ().
xSi le bloc contient plus d¶une instruction, alors les deux accolades ^ et `
sont obligatoires pour délimiter la suite d¶instructions. Les accolades sont
facultatives s¶il n¶y a qu¶une seule instruction.
xSi on met un point-virgule juste après la condition, le compilateur considère
que le bloc de LI est constitué d¶XQH VHXOH LQVWUXFWLRQ ULHQ« 3DU
exemple : LI[!SULQWIERQMRXU
ici, le SULQWI ne se trouve pas dans le LI, mais à l¶extérieur, et par
conséquent, il sera exécuté quelle que soit la valeur de [.
xComme il n¶y a pas de type booléen en C, alors une expression non nulle
(différente de ) est considérée comme vraie. Une expression nulle (égale à
) est considérée comme fausse.
3. Structure conditionnelle composée
Format général : 6LFRQGLWLRQ6pTXHQFH!6LQRQ6pTXHQFH!
Cette opération est lue comme suit : Si la condition est vérifiée ( 95$,), alors les
opérations de la 6pTXHQFH sont exécutées. Dans le cas contraire, ce sont les
opérations de la 6pTXHQFH qui vont être exécutées.
Les mots GpEXW et ILQ sont utilisés pour délimiter une séquence de plusieurs
opérations.
La structure conditionnelle composée peut être représentée dans un
organigramme comme suit :
EKE Kh/
;ŽŶĚŝƚŝŽŶͿ
^ĠƋƵĞŶĐĞϮ ^ĠƋƵĞŶĐĞϭ

Soit l¶exemple suivant :

6L;!(FULUH;
6LQRQ(FULUHYDOHXUQRQDFFHSWpH

ϱϵ

Les structures conditionnelles .

Dans cet exemple, la valeur de ; est affichée si elle est supérieure à , sinon
on affiche le message : YDOHXUQRQDFFHSWpH
En C, on aura :
LI[!SULQWIG[
HOVHSULQWIYDOHXUQRQDFFHSWpH
Remarques :
 Si nous avions une suite d¶instructions dans un bloc, alors on aurait dû
utiliser les deux accolades ^ et `.
 Le HOVH se rapporte toujours au LI« le plus proche. Pour casser ce rapport,
il est possible d¶utiliser ^ et `. Par exemple, dans le cas de :
LI[!^LI[SULQWIG[`
HOVHSULQWIYDOHXUQRQDFFHSWpH
le HOVH suit le premier LI et non pas le deuxième.
4. Structure conditionnelle multiple
La structure conditionnelle multiple, appelée aussi l¶alternative classifiée ou le
choix multiple, permet de comparer un objet (expression) à toute une série de
valeurs, et d¶exécuter une séquence d¶opérations parmi plusieurs, en fonction
de la valeur effective de l¶objet. Une séquence par défaut peut être prévue dans
le cas où l¶objet n¶est égal à aucune des valeurs énumérées.
Chaque séquence est étiquetée par une valeur. Pour que cette séquence soit
choisie, il faut que sa valeur soit équivalente à l¶expression. La structure
conditionnelle multiple se présente comme suit :
6HORQH[SUHVVLRQ
GpEXW
FDV9DOHXU6pTXHQFH!
FDV9DOHXU6pTXHQFH!
«
FDV9DOHXUQ6pTXHQFHQ!
'pIDXW6pTXHQFHSDUGpIDXW!
ILQ
Ceci est équivalent à :
6LH[SUHVVLRQ 9DOHXU6pTXHQFH!
6LQRQ6LH[SUHVVLRQ 9DOHXU6pTXHQFH!
«
6LQRQ6LH[SUHVVLRQ 9DOHXUQ6pTXHQFHQ!
6LQRQ6pTXHQFHSDUGpIDXW!
La structure conditionnelle multiple peut être représentée dans un
organigramme comme suit :

ϲϬ

Les structures conditionnelles .

;ŽŶĚŝƚŝŽŶϭͿ Kh/ ^ĠƋƵĞŶĐĞϭ

EKE

;ŽŶĚŝƚŝŽŶϮͿ Kh/ ^ĠƋƵĞŶĐĞϮ

EKE

EKE ;ŽŶĚŝƚŝŽŶŶͿ Kh/ ^ĠƋƵĞŶĐĞŶ

^ĠƋƵĞŶĐĞƉĂƌĚĠĨĂƵƚ

Dans l¶exemple suivant, la valeur de ; est affichée en lettres, si elle est égale à
 ou , sinon on affiche un message :
6HORQ;
GpEXW
FDV9DOHXU(FULUH8Q
FDV9DOHXU(FULUH'HX[
'pIDXW(FULUH9DOHXUVXSjGHX[RXLQIjXQ
ILQ
Remarques :
- Dans l¶opération de choix multiple, l¶ordre de présentation ne change rien.
- Le cas défaut est facultatif.
En C, ça s¶écrit :
VZLWFK;
^
FDVHSULQWI8QEUHDN
FDVHSULQWI'HX[EUHDN
GHIDXOWSULQWI9DOHXUVXSjGHX[RXLQIjXQ
`
Ou bien :
VZLWFK;
^
FDVH^SULQWI8QEUHDN`
FDVH^SULQWI'HX[EUHDN`
GHIDXOW^SULQWI9DOHXUVXSjGHX[RXLQIjXQ`
`
Remarques :
- En langage C, l¶expression et les valeurs à choisir doivent être de type LQW
ou FKDU.

ϲϭ

Les structures conditionnelles .

- L¶instruction EUHDN termine l¶exécution de l¶instruction englobante

(VZLWFK) dans laquelle elle apparaît. En cas d¶oubli de EUHDN, les
instructions des cas suivants seront aussi exécutées.
Par exemple, en l¶absence de EUHDN, et pour ; , l¶instruction :
VZLWFK;
^
FDVHSULQWI8Q
FDVHSULQWI'HX[
GHIDXOWSULQWI9DOHXUVXSjGHX[RXLQIjXQ
`
affiche : 'HX[9DOHXUVXSjGHX[RXLQIjXQ
Maintenant, pour l¶exemple :
VZLWFK;
^
FDVH
FDVHSULQWIG;EUHDN
GHIDXOWSULQWI9DOHXUVXSjGHX[RXLQIjXQ
`
Le traitement est le même (l¶affichage de la valeur de ;) pour ;égale à
ou ; égale à.
- Pour une souplesse de programmation, il est possible de mettre :
GHILQHYDO
«
VZLWFKQ
^«
FDVHYDO±«
FDVHYDO«
FDVHYDO«
«`
Une modification de YDO se résume à une seule intervention au niveau de
la directive GHILQH.
- Si vous dupliquez les cas, par exemple :
VZLWFK;
^
FDVHSULQWIERQMRXUEUHDN
FDVHSULQWIPHUFLEUHDN
GHIDXOWSULQWI9DOHXUVXSjGHX[RXLQIjXQ
`
Vous aurez une erreur de compilation de la forme duplicate case value.
5. Le branchement
Il est possible d¶effectuer un saut direct vers une opération en utilisant une
opération de branchement de la forme DOOHUjpWLTXHWWH!.
Exemple :
$OJRULWKPHDIILFKHUBQEUBSRVLWLI
9DULDEOHV
(QWLHU,
ϲϮ

Les structures conditionnelles .

'pEXW
/LUH,
6L,DOOHUjHWLT
(FULUH,
HWLT(FULUH0HUFL
)LQ
En C, ça s¶écrit :
LQFOXGHVWGLRK!
PDLQ
^
LQW,
VFDQIG ,
LI,JRWRHWLT
SULQWIG?Q,
HWLTSULQWI0HUFL
`
On note qu¶il est déconseillé d¶utiliser l¶instruction de branchement, et cela
pour réduire la complexité des programmes en termes de temps.
6. Exercices corrigés
6.1. Exercices
Exercice 1 :
Ecrire un algorithme qui demande un nombre à l¶utilisateur, et l¶informe
ensuite si ce nombre est positif ou négatif. Si le nombre vaut zéro, on le
considère positif. Représenter l¶algorithme par un organigramme, ensuite le
traduire en C.
Exercice 2 :
Ecrire un algorithme qui affiche la valeur absolue d¶un nombre réel lu à partir
du clavier. Traduire l¶algorithme en C.
Exercice 3 :
Ecrire un algorithme qui compare deux nombres réels lus à partir du clavier.
Traduire l¶algorithme en C.
Exercice 4 :
Ecrire un algorithme qui permet de dire si un nombre lu à partir du clavier est
pair ou impair. Traduire l¶algorithme en C.
Exercice 5 :
Ecrire un algorithme qui affiche le résultat d¶un étudiant (accepté ou rejeté) à
une matière, sachant que cette matière est évaluée par une note d¶oral
(coefficient 1) et une note d¶écrit (coefficient 2). La moyenne obtenue doit être
supérieure ou égale à 10 pour valider la matière. Traduire l¶algorithme en C.
Exercice 6 :
Ecrire un algorithme permettant de déterminer le plus grand de trois nombres
réels lus à partir du clavier. Traduire l¶algorithme en C.
ϲϯ

Les structures conditionnelles .

Exercice 7 :
Ecrire un algorithme qui demande deux nombres à l¶utilisateur, et l¶informe
ensuite si le produit est positif, négatif ou nul. Attention ! On ne doit pas
calculer le produit. Traduire l¶algorithme en C.
Exercice 8 :
Ecrire un algorithme qui permet de calculer les racines de l¶équation du second
degré suivante : ax2 + bx+ c = 0. Comme entrées, l¶utilisateur doit introduire
les facteurs a, b et c. Traduire l¶algorithme en C.
Exercice 9 :
Ecrire un algorithme qui demande d¶entrer un nombre entre 1 et 7, et donne le
QRP GX MRXU FRUUHVSRQGDQW VDPHGL GLPDQFKH« HQ XWLOLVDQW OD VWUXFWXUH
conditionnelle multiple. Traduire l¶algorithme en C.
Exercice 10 :
Ecrire un algorithme permettant à partir d¶un menu affiché, d¶effectuer la
somme, le produit ou la moyenne de trois nombres. Nous appelons menu,
l¶association d¶un numéro séquentiel aux différents choix proposés par un
programme. Traduire l¶algorithme en C.
Exercice 11 :
Ecrire un algorithme permettant de déterminer si l¶année A est bissextile. On
doit savoir que si A n¶est pas divisible par 4, l¶année n¶est pas bissextile. Si A
est divisible par 4, l¶année est bissextile, sauf si A est divisible par 100 et non
pas par 400. Traduire l¶algorithme en C. Tester votre programme pour les
années 111, 1984, 1900 et 800.
Exercice 12 :
Ecrire un algorithme permettant d¶effectuer la transformation des coordonnées
cartésiennes (x,y) en coordonnées polaires (r,t). Cette transformation se fait par
les formules :
x r2 = x2+y2
x Si x = 0 alors : t = pi/2 si y > 0 ; t = - pi/2 si y < 0 ; t n¶existe pas si y = 0.
x Sinon t = arctg (y/x) auquel il faut ajouter pi si x<0.
Traduire l¶algorithme en C.
6.2. Corrigés
Solution 1 :
Algorithme :
$OJRULWKPHSRVLWLIBQHJDWLI
9DULDEOHV
(QWLHUQ
'pEXW
(FULUH(QWUH]XQQRPEUH
/LUHQ
6LQ! (FULUH&HQRPEUHHVWSRVLWLI

ϲϰ

Les structures conditionnelles .

6LQRQ(FULUH&HQRPEUHHVWQpJDWLI

)LQ
Organigramme :
ĠďƵƚ

ĐƌŝƌĞ;ΗŶƚƌĞnjƵŶŶŽŵďƌĞ͗ΗͿ͖

>ŝƌĞ;ŶͿ͖

Kh/ EŽŶ
ŶхсϬ

ĐƌŝƌĞ;ΗĞŶŽŵďƌĞ ĐƌŝƌĞ;ΗĞŶŽŵďƌĞ
ĞƐƚƉŽƐŝƚŝĨ͘ΗͿ͖ ĞƐƚŶĠŐĂƚŝĨ͘ΗͿ͖

&ŝŶ

Programme C :
LQFOXGHVWGLRK!
PDLQ
^
LQWQ
SULQWI(QWUH]XQQRPEUH
VFDQIG Q
LIQ! SULQWI&HQRPEUHHVWSRVLWLI
HOVHSULQWI&HQRPEUHHVWQpJDWLI
`
Solution 2 :
Algorithme :
$OJRULWKPHYDOHXUBDEVROXH
9DULDEOHV
5pHO;9DOBDEV
'pEXW
(FULUH(QWUH]XQQRPEUH
/LUH;
9DOBDEV&;
6L9DOBDEV9DOBDEV&9DOBDEV
(FULUH/DYDOHXUDEVROXHGH;HVW9DOBDEV
)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ
^
IORDW;9DOBDEV
SULQWI(QWUH]XQQRPEUH
ϲϱ

Les structures conditionnelles .

VFDQII ;

9DOBDEV ;
LI9DOBDEV9DOBDEV 9DOBDEV
SULQWI/DYDOHXUDEVROXHGHIHVWI;9DOBDEV
`
Solution 3 :
Algorithme :
$OJRULWKPHFRPSDUDLVRQ
9DULDEOHV
5pHO;<
'pEXW
(FULUH(QWUH]GHX[QRPEUHV;HW<
/LUH;<
6L; <(FULUH; <
6LQRQ6L;!<(FULUH;HVWVXSpULHXUj<
6LQRQ(FULUH;HVWLQIpULHXUj<
)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ
^
IORDW;<
SULQWI(QWUH]GHX[QRPEUHV;HW<?Q
VFDQIII ; <
LI; <SULQWII I;<
HOVHLI;!<SULQWIIHVWVXSpULHXUjI;<
HOVHSULQWIIHVWLQIpULHXUjI;<
`
Solution 4 :
Algorithme :
$OJRULWKPHSDLUBLPSDLU
9DULDEOHV
(QWLHU;
'pEXW
(FULUH(QWUH]XQQRPEUH
/LUH;
6L; (FULUH;HVWXQQRPEUHSDLU
6LQRQ(FULUH;HVWQRPEUHLPSDLU
)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ
^
LQW;
SULQWI(QWUH]XQQRPEUH
VFDQIG ;
LI; SULQWIGHVWXQQRPEUHSDLU;
HOVHSULQWIGHVWXQQRPEUHLPSDLU;
ϲϲ

Les structures conditionnelles .

`
Solution 5 :
Algorithme :
$OJRULWKPHHYDOXDWLRQ
9DULDEOHV
5pHOQHQRPR\
'pEXW
(FULUH(QWUH]ODQRWHGHO
H[DPHQpFULW
/LUHQH
(FULUH(QWUH]ODQRWHGHO
H[DPHQRUDO
/LUHQR
PR\& QHQR
6LPR\! (FULUHDFFHSWp
6LQRQ(FULUHUHMHWp
)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ
^
IORDWQHQRPR\
SULQWI(QWUH]ODQRWHGHO
H[DPHQpFULW
VFDQII QH
SULQWI(QWUH]ODQRWHGHO
H[DPHQRUDO
VFDQII QR
PR\  QHQR
LIPR\! SULQWIDFFHSWp
HOVHSULQWIUHMHWp
`
Solution 6 :
Algorithme :
$OJRULWKPHSOXVBJUDQG
9DULDEOHV
5pHO[\]SJ
'pEXW
(FULUH(QWUH]WURLVQRPEUHV
/LUH[\]
6L[! \HW[! ]SJ&[
6LQRQ6L\! ]SJ&\
6LQRQSJ&]
(FULUH/HSOXVJUDQGGHVWURLVQRPEUHVHVWSJ
)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ
^
IORDW[\]SJ
SULQWI(QWUH]WURLVQRPEUHV?Q
VFDQIIII [ \ ]
ϲϳ

Les structures conditionnelles .

LI[! \ [! ]SJ [

HOVHLI\! ]SJ \
HOVHSJ ]
SULQWI/HSOXVJUDQGGHVWURLVQRPEUHVHVWISJ
`
Solution 7 :
Algorithme :
$OJRULWKPHUHVXOWDWBSURGXLW
9DULDEOHV
(QWLHUPQ
'pEXW
(FULUH(QWUH]GHX[QRPEUHV
/LUHPQ
6LP 28Q 
(FULUH/HSURGXLWGHPHWQHVWQXO
6LQRQ6LP!(7Q!28P(7Q
(FULUH/HSURGXLWGHPHWQHVWSRVLWLI
6LQRQ(FULUH/HSURGXLWGHPHWQHVWQpJDWLI
)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ
^
LQWPQ
SULQWI(QWUH]GHX[QRPEUHV?Q
VFDQIGG P Q
LIP __Q 
SULQWI/HSURGXLWGHGHWGHVWQXOPQ
HOVHLIP! Q!__P Q
SULQWI/HSURGXLWGHGHWGHVWSRVLWLIPQ
HOVHSULQWI/HSURGXLWGHGHWGHVWQpJDWLIPQ
`
Solution 8 :
Algorithme :
$OJRULWKPH(TBGHBGHJUH
9DULDEOHV
5pHODEFG[[[
'pEXW
(FULUH(QWUH]OHVYDOHXUVDEHWFGHO
pTXDWLRQ
/LUHDEF
G&E E D F
6LG!GpEXW
[&E±¾(  D
[&E¾(  D
(FULUH/
pTXDWLRQSRVVqGHGHX[UDFLQHV
(FULUH[ [[ [
ILQ

ϲϴ

Les structures conditionnelles .

6LQRQ6LG GpEXW
[&E D
(FULUH/
pTXDWLRQSRVVqGHXQHUDFLQH
(FULUH[ [
ILQ
6LQRQ(FULUH/
pTXDWLRQQHSRVVqGHSDVGHUDFLQHV
)LQ
Programme C :
LQFOXGHVWGLRK!
LQFOXGHPDWKK!
PDLQ
^
IORDWDEFG[[[
SULQWI(QWUH]OHVYDOHXUVDEHWFGHO
pTXDWLRQ?Q
VFDQIIII D E F
G E E D F
LIG!^
[ EVTUWG D
[ EVTUWG D
SULQWI/
pTXDWLRQSRVVqGHGHX[UDFLQHV?Q
SULQWI[ I[ I[[
`
HOVHLIG ^
[ E D
SULQWI/
pTXDWLRQSRVVqGHXQHUDFLQH?Q
SULQWI[ I[
`
HOVHSULQWI/
pTXDWLRQQHSRVVqGHSDVGHUDFLQHV
`
Solution 9 :
Algorithme :
$OJRULWKPHMRXU
9DULDEOHV
(QWLHUQR
'pEXW
(FULUH(QWUH]OHQXPpURGXMRXU6DPHGL'LPDQFKH«
/LUHQR
6HORQQR
GpEXW
FDV(FULUH6DPHGL
FDV(FULUH'LPDQFKH
FDV(FULUH/XQGL
FDV(FULUH0DUGL
FDV(FULUH0HUFUHGL
FDV(FULUH-HXGL
FDV(FULUH9HQGUHGL
'pIDXW(FULUH1XPpURQRQDFFHSWp
ILQ
)LQ
ϲϵ

Les structures conditionnelles .

Programme C :
LQFOXGHVWGLRK!
PDLQ
^
LQWQR
SULQWI(QWUH]OHQXPpURGXMRXU6DPHGL'LPDQFKH«
VFDQIG QR
VZLWFKQR
^
FDVHSULQWI6DPHGLEUHDN
FDVHSULQWI'LPDQFKHEUHDN
FDVHSULQWI/XQGLEUHDN
FDVHSULQWI0DUGLEUHDN
FDVHSULQWI0HUFUHGLEUHDN
FDVHSULQWI-HXGLEUHDN
FDVHSULQWI9HQGUHGLEUHDN
GHIDXOWSULQWI1XPpURQRQDFFHSWp
`
`
Solution 10 :
Algorithme :
$OJRULWKPHPHQX
9DULDEOHV
5pHOQEQEQE
(QWLHU&KRL[
'pEXW
(FULUH(QWUH]WURLVQRPEUHV
/LUHQEQEQE
 $IILFKDJHGXPHQXHWVDLVLHGXFKRL[ 
(FULUHSRXUODPXOWLSOLFDWLRQ
(FULUHSRXUODVRPPH
(FULUHSRXUODPR\HQQH
(FULUH9RWUHFKRL[
/LUHFKRL[
6HORQFKRL[
GpEXW
FDVĐƌŝƌĞ;Η>ĞƉƌŽĚƵŝƚĚĞƐƚƌŽŝƐŶŽŵďƌĞƐĞƐƚ͗Η͕ŶďϭΎŶďϮΎŶďϯͿ͖
FDVĐƌŝƌĞ;Η>ĂƐŽŵŵĞĚĞƐƚƌŽŝƐŶŽŵďƌĞƐĞƐƚ͗Η͕ŶďϭнŶďϮнŶďϯͿ͖
FDVĐƌŝƌĞ;Η>ĂŵŽLJĞŶŶĞĚĞƐƚƌŽŝƐŶŽŵďƌĞƐĞƐƚ͗Η͕;ŶďϭнŶďϮнŶďϯͿͬϯͿ͖
'pIDXW(FULUH&KRL[LQFRUUHFW
ILQ
)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ
^
IORDWQEQEQE
LQW&KRL[

ϳϬ

Les structures conditionnelles .

SULQWI(QWUH]WURLVQRPEUHV?Q

VFDQIIII QE QE QE
 $IILFKDJHGXPHQXHWVDLVLHGXFKRL[ 
SULQWISRXUODPXOWLSOLFDWLRQ?Q
SULQWISRXUODVRPPH?Q
SULQWISRXUODPR\HQQH?Q
SULQWI9RWUHFKRL[
VFDQIG &KRL[
VZLWFK&KRL[
^
FDVHƉƌŝŶƚĨ;Η>ĞƉƌŽĚƵŝƚĚĞƐƚƌŽŝƐŶŽŵďƌĞƐĞƐƚ͗йĨΗ͕ŶďϭΎŶďϮΎŶďϯͿ͖ďƌĞĂŬ͖
FDVHƉƌŝŶƚĨ;Η>ĂƐŽŵŵĞĚĞƐƚƌŽŝƐŶŽŵďƌĞƐĞƐƚ͗йĨΗ͕ŶďϭнŶďϮнŶďϯͿ͖ďƌĞĂŬ͖
FDVHƉƌŝŶƚĨ;Η>ĂŵŽLJĞŶŶĞĚĞƐƚƌŽŝƐŶŽŵďƌĞƐĞƐƚ͗йĨΗ͕;ŶďϭнŶďϮнŶďϯͿͬϯͿ͖
ďƌĞĂŬ͖
GHIDXOWSULQWI&KRL[LQFRUUHFW
`
`
Solution 11 :
Algorithme :
$OJRULWKPHELVVH[WLOH
9DULDEOHV
(QWLHU$
'pEXW
(FULUH,QWURGXLVH]O
DQQpH
/LUH$
6L121$ 
(FULUH/
DQQpH$Q
HVWSDVELVVH[WLOH
6LQRQ6L$ (7121$ 
(FULUH/
DQQpH$Q
HVWSDVELVVH[WLOH
6LQRQ(FULUH/
DQQpH$HVWELVVH[WLOH
)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ
^
LQW$
SULQWI,QWURGXLVH]O
DQQpH
VFDQIG $
LI$ 
SULQWI/
DQQpHGQ
HVWSDVELVVH[WLOH$
HOVHLI$  $ 
SULQWI/
DQQpHGQ
HVWSDVELVVH[WLOH$
HOVHSULQWI/
DQQpHGHVWELVVH[WLOH$
`
Après test :
On a obtenu :  Q
HVW SDV ELVVH[WLOH;  HVW ELVVH[WLOH;
Q
HVWSDVELVVH[WLOH; etHVWELVVH[WLOH

ϳϭ

Les structures conditionnelles .

Solution 12 :
Algorithme :
$OJRULWKPH&DUWHVLHQB3RODLUH
&RQVWDQWHV
3L 
9DULDEOHV
5pHO[\UW
'pEXW
(FULUH,QWURGXLVH]O
DEVFLVVH[
/LUH[
(FULUH,QWURGXLVH]O
RUGRQQpH\
/LUH\
U&¥6 $ E 7 $ 
6L[ 
6L\!(FULUHU UHWW SL
6LQRQ6L\(FULUHU UHWW SL
6LQRQ(FULUHU UHWWQ
H[LVWHSDV
6LQRQGpEXW
W&DUFWJ\[
6L[W&WSL
(FULUHU UHWW W
ILQ
)LQ
Programme C :
LQFOXGHVWGLRK!
LQFOXGHPDWKK!
GHILQH3L
PDLQ
^
IORDW[\UW
SULQWI,QWURGXLVH]O
DEVFLVVH[
VFDQII [
SULQWI,QWURGXLVH]O
RUGRQQpH\
VFDQII \
U VTUWSRZ[SRZ\
LI[ LI\!SULQWIU IHWW IU3L
HOVHLI\SULQWIU IHWW IU3L
HOVHSULQWIU IHWWQ
H[LVWHSDVU
HOVH^
W DWDQ\[
LI[W W3L
SULQWIU IHWW IUW
`
`

ϳϮ

Les boucles .

Chapitre 4 : Les boucles

1. Introduction
Lorsqu¶on veut répéter une opération ou une suite d¶opérations plusieurs fois
dans un algorithme, il est possible d¶utiliser des structures répétitives
(itératives) appelées les boucles. Il existe trois types de boucles : 7DQWTXH,
5pSpWHU et 3RXU.
2. La boucle Tant que
Format général : 7DQWTXH&RQGLWLRQ6pTXHQFH!
Cette structure permet la répétition d¶une séquence d¶opérations tant que la
condition est satisfaite (= 95$,). Quand la condition devient fausse, la boucle
est terminée.
La condition est une expression logique. Il faut alors que cette expression
puisse changer de valeur (avoir la valeur )$8;) pour sortir de la boucle et éviter
le cas de la boucle infinie.
La séquence est une ou plusieurs opérations. Pour plusieurs opérations, le
GpEXW et ILQ sont obligatoires. Dans le cas d¶une seule opération, le GpEXW et
ILQ sont optionnels.
La boucle 7DQWTXH est représentée dans un organigramme comme suit :
EKE Kh/
;ŽŶĚŝƚŝŽŶͿ
^ĠƋƵĞŶĐĞ

L¶exemple suivant permet d¶afficher les valeurs de  à  :

L&
7DQWTXHL GpEXW
(FULUHL
L&L
ILQ
En C, la boucle 7DQWTXH s¶exprime comme suit :
L 
ZKLOHL ^
SULQWIG?QL
L L
`
Remarques :
x En langage C, dans une instruction ZKLOH, la condition doit être délimitée
par  et . Chaque instruction du bloc doit se terminer par un point-virgule
().

ϳϯ

Les boucles .

x Si le bloc contient plusieurs instructions, alors elles sont obligatoirement

délimitées par ^ et `. Si ce bloc contient une seule instruction, les
accolades sont facultatives.
x Condition vraie veut dire que la valeur de l¶expression est non nulle.
Condition fausse veut dire que la valeur de l¶expression est .
3. La boucle Répéter
Format général : 5pSpWHU6pTXHQFH!-XVTX¶j&RQGLWLRQ
Cette structure permet la répétition d¶une ou plusieurs opérations jusqu¶à ce
qu¶une condition soit vérifiée (= 95$,). Pour éviter la boucle infinie, il faut que
la condition puisse changer de valeur (avoir la valeur 95$,).
La boucle 5pSpWHU peut être représentée dans un organigramme comme suit :

^ĠƋƵĞŶĐĞ
EKE
Kh/
;ŽŶĚŝƚŝŽŶͿ

Reprenons l¶exemple permettant d¶afficher les valeurs de  à  :

L&
5pSpWHU
GpEXW
(FULUHL
L&L
ILQ
-XVTX¶jL!
Le tableau suivant récapitule les différences entre les boucles 7DQW TXH et
5pSpWHU :
Condition Condition
Boucle Nombre d¶exécutions
d¶exécution pour quitter
n¶est pas connu d¶avance, mais elle
Condition = Condition = peut ne jamais être exécutée si la
dĂŶƚƋƵĞ
95$, )$8;
condition = )$8; dès le départ.
Condition = Condition = n¶est pas connu d¶avance, mais elle
ZĠƉĠƚĞƌ
)$8; 95$, est exécutée au moins une fois.
Remarques :
xPour la boucle 7DQWTXH et 5pSpWHU, on utilise souvent une variable, dite
indice, initialisée à une valeur initiale avant d¶exécuter la boucle. A
l¶intérieur de la boucle, l¶indice sera incrémenté (en ajoutant une valeur à la
valeur courante), ou décrémenté (en diminuant la valeur courante) pour
atteindre la condition d¶arrêt de la boucle.

ϳϰ

Les boucles .

xUne itération est la réalisation d¶un cycle complet de boucle. Ceci inclut le
test de la condition et l¶exécution de la séquence. Ceci est valable pour
toutes les boucles.
xEn C, il n¶existe pas une boucle 5pSpWHU proprement dite. Il existe une
instruction qui fait presque le même travail. Il s¶agit de l¶instruction GR«
ZKLOH«, mais en réalité, c¶est un simple échange de position entre le bloc
d¶instructions et la condition de la boucle ZKLOH (7DQWTXH), permettant
ainsi l¶exécution du bloc d¶instructions au moins une seule fois, sauf que la
condition d¶arrêt est la même que la boucle ZKLOH, i.e. condition = )DX[.
L¶exemple précédent devient ainsi :
L 
GR^
SULQWIG?QL
L L
`ZKLOHL 
4. La boucle Pour
Format général :
3RXU 2SpUDWLRQ GH GpSDUW  &RQGLWLRQ  3DV GH SURJUHVVLRQ
6pTXHQFH!
Avec :
1. Opération de départ : c¶est une opération exécutée une seule fois au début
de la boucle. On peut mettre plusieurs opérations séparées par des virgules.
Il s¶agit généralement d¶une ou plusieurs initialisations.
2. Condition : c¶est une condition testée avant d¶exécuter la séquence. Si la
condition est vérifiée (=95$,), on exécute la séquence. Si la condition n¶est
pas vérifiée, on quitte la boucle sans exécuter la séquence.
3. Pas de progression, indiqué par une opération (ou plusieurs opérations
séparées par des virgules) exécutée(s) après l¶exécution de la séquence.
Après avoir exécuté l¶opération ou les opérations correspondant au Pas de
progression, on revient à l¶étape 2 (tester la Condition). Le Pas de
progression doit donc nous ramener à une Condition ayant la valeur )$8;
pour qu¶on puisse quitter la boucle. Généralement, il s¶agit de la
modification de la variable (ou des variables) initialisée(s) dans l¶étape 1
(Opération de départ).
Le format le plus utilisé de la boucle 3RXU est le suivant :
3RXU FRPSWHXU & YDOBLQLWLDOH FRPSWHXU   YDOBILQDOH
FRPSWHXU&FRPSWHXULQFUpPHQW6pTXHQFH!

Ou bien :
3RXU FRPSWHXU & YDOBLQLWLDOH FRPSWHXU !  YDOBILQDOH
FRPSWHXU&FRPSWHXUGpFUpPHQW6pTXHQFH!
Cette structure permet de répéter l¶exécution d¶une séquence d¶opérations pour
toutes les valeurs d¶une variable de contrôle (FRPSWHXU) à partir d¶une valeur
ϳϱ

Les boucles .

initiale (YDOBLQLWLDOH) à une valeur finale (YDOBILQDOH). Après chaque

exécution de la séquence, la variable de contrôle est incrémentée d¶une unité
(LQFUpPHQW), ou décrémentée d¶une unité (GpFUpPHQW). Quand la variable de
contrôle dépasse la valeur finale, on quitte la boucle sans exécuter la séquence
de la boucle.
Remarques :
 La variable de contrôle est de type (QWLHU.
 Dans la séquence d¶une boucle 3RXU, le compteur (variable de contrôle)
peut être utilisé, mais il ne doit jamais être modifié à l¶intérieur de la
boucle.
 La valeur initiale, la valeur finale et l¶incrément peuvent être des
expressions numériques.
La boucle 3RXU peut être représentée dans un organigramme comme suit :

KƉĠƌĂƚŝŽŶĚĞĚĠƉĂƌƚ

EKE Kh/
;ŽŶĚŝƚŝŽŶͿ
^ĠƋƵĞŶĐĞ

WĂƐĚĞƉƌŽŐƌĞƐƐŝŽŶ

Gardons le même exemple permettant d¶afficher les valeurs de  à  :

3RXUL&L L&L(FULUHL
En C, la boucle 3RXU s¶exprime comme suit :
IRUL L L LSULQWIG?QL
Ou bien : IRUL L L SULQWIG?QL
Ou même : IRUL L LSULQWIG?QL
Remarques :
 En langage C, si le bloc d¶instructions de la boucle IRU contient plusieurs
instructions, alors elles sont obligatoirement délimitées par ^ et `. Si ce
bloc contient une seule instruction, alors les accolades sont facultatives.
 Après avoir quitté la boucle IRUL  L  L %ORF! la
variable L aura la valeur .
 En langage C, le format général suivant peut être utilisé :
IRU,QVWUXFWLRQ GH GpSDUW!  &RQGLWLRQ ! 3DV GH
SURJUHVVLRQ!%ORF!
avec (1) ,QVWUXFWLRQGHGpSDUW! (généralement une initialisation) est
exécutée une seule fois au début de la boucle ; (2) la &RQGLWLRQ est
évaluée au début de chaque itération ; (3) Une modification indiquant un
3DVGHSURJUHVVLRQ est exécutée à la fin de chaque itération.
ϳϲ

Les boucles .

 L¶instruction EUHDN sert à interrompre le déroulement de la boucle, en

passant à l¶instruction qui suit cette boucle. Par exemple, la boucle :
IRUL L L^
 LIL EUHDN
 SULQWIGL
`
affiche : 
On note ici qu¶après avoir quitté la boucle, la variable L aura la valeur .
 L¶instruction FRQWLQXH permet de passer au tour de boucle suivant. Par
exemple, la boucle :
IRUL L L^
 LIL FRQWLQXH
 SULQWIGL
`
affiche : 
 Il est possible d¶initialiser/modifier plusieurs variables dans la boucle IRU
en même temps. Ces initialisations/modifications sont séparées par des
virgules. Par exemple, IRU[ \ [\[\%ORF! permet
de répéter le bloc d¶instructions cinq fois.
 L¶instruction IRU%ORF! est une boucle infinie dont on ne pourra
sortir que par une instruction EUHDN.
5. Les boucles imbriquées
Les boucles peuvent être imbriquées les unes dans les autres. Une boucle 7DQW
TXH peut contenir une autre boucle 7DQWTXH, une autre boucle 5pSpWHU, ou
une autre boucle 3RXU, et vice versa. De plus, une boucle peut contenir une
autre boucle, qui elle-même peut contenir une autre boucle, et ainsi de suite.
L¶algorithme suivant permet d¶afficher les tables de multiplication de  jusqu¶à
 :
$OJRULWKPHERXFOHVBLPEULTXHHV
9DULDEOHV
 (QWLHULM
'pEXW
3RXUL&L L&LGpEXW
M&
7DQWTXHM GpEXW
(FULUHL M L M
M&M
)LQ
)LQ
L¶organigramme correspondant à l¶algorithme précèdent est le suivant :

ϳϳ

Les boucles .

ĠďƵƚ

]Ví͖

EKE Kh/
ŝфсϭϬ
iVí͖
&ŝŶ

ũфсϭϬ Kh/
EKE
ĐƌŝƌĞ;ŝ͕ΗΎΗ͕ũ͕ΗсΗ͕ŝΎũͿ͖
]V]=í͖

ũVi=í͖

Programme C :
LQFOXGHVWGLRK!
PDLQ
^
LQWLM
IRUL L L^
M 
ZKLOHM ^
SULQWIG G G?QLML M
M M
`
`
`
6. Exercices corrigés
6.1. Exercices
Exercice 1 :
Ecrire des algorithmes permettant de calculer la somme de la suite des nombres
   « Q (n est un entier positif lu à partir du clavier) en utilisant les
boucles 7DQW TXH, 5pSpWHU et 3RXU. Représentez chaque algorithme par
l¶organigramme correspondant.
Exercice 2 :
Ecrire un algorithme qui calcule la factorielle d¶un nombre entier n strictement
positif, sachant que : Q    « Q, et que 0! = 1. Traduire l¶algorithme en
C.
Exercice 3 :
Ecrire un algorithme qui calcule la nième puissance entière d¶un entier x par
multiplications successives du nombre par lui-même. Traduire l¶algorithme en
C.
ϳϴ

Les boucles .

Exercice 4 :
Ecrire un algorithme qui demande à l¶utilisateur un nombre compris entre 1 et 3
jusqu¶à ce que la réponse convienne. Traduire l¶algorithme en C.
Exercice 5 :
Ecrire un algorithme qui demande un nombre de départ, et qui ensuite affiche
les dix nombres suivants. Traduire l¶algorithme en C.
Exercice 6 :
Ecrire un algorithme qui demande un nombre de départ, et qui ensuite écrit la
table de multiplication de ce nombre. Traduire l¶algorithme en C.
Exercice 7 :
Etant donnés deux nombres entiers m et n positifs non nuls. Ecrire un
algorithme permettant de déterminer le PGCD (plus grand diviseur commun)
de m et n. Traduire l¶algorithme en C.
Note : Le PGCD peut être calculer en utilisant l¶algorithme itératif d¶Euclide
qui prend d¶abord le reste de la division de m par n, puis le reste de la division
de n par ce premier reste, etc., jusqu¶à ce qu¶on trouve un reste nul. Le dernier
diviseur utilisé sera le PGCD de m et n.
Exercice 8 :
Ecrire un algorithme permettant de saisir une série de nombres entiers positifs.
On termine la saisie par un nombre négatif qui ne sera pas tenu en compte lors
des calculs. Puis, on propose indéfiniment (en boucle) à l¶utilisateur, par
l¶intermédiaire d¶une sorte de menu à choix multiple, d¶afficher la valeur
minimale, la valeur maximale, la somme ou la moyenne des nombres entrés, ou
encore de quitter le programme. Traduire l¶algorithme en C.
Exercice 9 :
Ecrire un algorithme permettant de lire la suite des prix des achats d¶un client
(en dinars entiers positifs). La suite se termine par un zéro. L¶algorithme doit
permettre de calculer la somme qu¶il doit, lire la somme qu¶il paye, et simuler
la remise de la monnaie en affichant les textes « 10 DA », « 5 DA » et « 1 DA »
autant de fois qu¶il y a de coupures de chaque sorte à rendre. Traduire
l¶algorithme en C.
Exercice 10 :
Ecrire un algorithme qui calcule itérativement le nième terme de la suite de
Fibonacci définie comme suit : Si n = 0 alors Fn = 0 ; Si n = 1 alors Fn = 1 ; Si
n >1 alors Fn = Fn-1+Fn-2.
Traduire l¶algorithme en C.
Exercice 11 :
Ecrire un programme C permettant d¶afficher un triangle rempli d¶étoiles,
s¶étendant sur un nombre de lignes lu à partir du clavier, et se présentant
comme dans cet exemple :
ϳϵ

Les boucles .

'RQQH]OHQRPEUHGHOLJQHV





Exercice 12 :
1. Que fait le programme C suivant ?
LQFOXGHVWGLRK!
PDLQ
^
 LQW[
ZKLOH^
 VFDQIG [
 LI[ EUHDN
`
`
2. Que devient-il si on enlève l¶instruction EUHDN ?
3. Que se passe t-il si on remplace ZKLOH par ZKLOH ?
6.2. Corrigés
Solution 1 :
Algorithmes :
Algorithme Tant que :
$OJRULWKPHVRPPHBVXLWH
9DULDEOHV
(QWLHULQVRPPH
'pEXW
(FULUH'RQQH]XQQRPEUH
/LUHQ
6LQ!GpEXW
VRPPH&
L&
7DQWTXHL QGpEXW
VRPPH&VRPPHL
L&L
ILQ
(FULUH/DVRPPHGHODVXLWH VRPPH
ILQ
6LQRQ(FULUH/HQRPEUHGRLWrWUHSRVLWLI
)LQ
Algorithme Répéter :
$OJRULWKPHVRPPHBVXLWH
9DULDEOHV
(QWLHULQVRPPH
'pEXW
(FULUH'RQQH]XQQRPEUH
/LUHQ
ϴϬ

Les boucles .

6LQ!GpEXW

VRPPH&
L&
5pSpWHU
GpEXW
VRPPH&VRPPHL
L&L
ILQ
MXVTX¶jL!Q
(FULUH/DVRPPHGHODVXLWH VRPPH
)LQ
6LQRQ(FULUH/HQRPEUHGRLWrWUHSRVLWLI
)LQ
Algorithme Pour :
$OJRULWKPHVRPPHBVXLWH
9DULDEOHV
(QWLHULQVRPPH
'pEXW
(FULUH'RQQH]XQQRPEUH
/LUHQ
6LQ!GpEXW
VRPPH&
3RXUL&L QL&LVRPPH&VRPPHL
(FULUH/DVRPPHGHODVXLWH VRPPH
ILQ
6LQRQ(FULUH/HQRPEUHGRLWrWUHSRVLWLI
)LQ

ϴϭ

Les boucles .

Organigrammes :
Organigramme Tant que :
ĠďƵƚ

ĐƌŝƌĞ;ΗŽŶŶĞnjƵŶŶŽŵďƌĞ͗ΗͿ͖

>ŝƌĞ;ŶͿ͖

Kh/ EŽŶ
ŶхϬ

}uuVì͖

]Ví͖ ĐƌŝƌĞ;Η>ĞŶŽŵďƌĞĚŽŝƚġƚƌĞ
ƉŽƐŝƚŝĨ͘ΗͿ͖
Kh/ EŽŶ
ŝфсŶ

}uuV}uu=]͖ ĐƌŝƌĞ;Η>ĂƐŽŵŵĞĚĞ
ůĂƐƵŝƚĞсΗ͕ƐŽŵŵĞͿ͖
]V]=í͖

&ŝŶ


ϴϮ

Les boucles .

Organigramme Répéter :
ĠďƵƚ

ĐƌŝƌĞ;ΗŽŶŶĞnjƵŶŶŽŵďƌĞ͗ΗͿ͖

>ŝƌĞ;ŶͿ͖

Kh/ EŽŶ
ŶхϬ

}uuVì͖

]Ví ĐƌŝƌĞ;Η>ĞŶŽŵďƌĞĚŽŝƚġƚƌĞ
ƉŽƐŝƚŝĨ͘ΗͿ͖

}uuV}uu=]͖

]V]=í͖

EŽŶ Kh/
ŝхŶ

ĐƌŝƌĞ;Η>ĂƐŽŵŵĞĚĞůĂƐƵŝƚĞ
сΗ͕ƐŽŵŵĞͿ͖

&ŝŶ


ϴϯ

Les boucles .

Organigramme Pour :
ĠďƵƚ

ĐƌŝƌĞ;ΗŽŶŶĞnjƵŶŶŽŵďƌĞ͗ΗͿ͖

>ŝƌĞ;ŶͿ͖

Kh/ EŽŶ
ŶхϬ

}uuVì͖
ĐƌŝƌĞ;Η>ĞŶŽŵďƌĞĚŽŝƚġƚƌĞ
]Ví͖ ƉŽƐŝƚŝĨ͘ΗͿ͖

Kh/ EKE
ŝфсŶ

}uuV}uu=]͖
ĐƌŝƌĞ;Η>ĂƐŽŵŵĞĚĞůĂ
]V]=í͖ ƐƵŝƚĞсΗ͕ƐŽŵŵĞͿ͖

&ŝŶ

Solution 2 :
Algorithme :
$OJRULWKPHIDFWRULHOOH
9DULDEOHV
(QWLHULQIDFWRULHOOH
'pEXW
(FULUH(QWH]XQQRPEUH
/LUHQ
6LQ
(FULUH/DIDFWRULHOOHG
XQQRPEUHQpJDWLIQ
H[LVWHSDV
6LQRQGpEXW
IDFWRULHOOH&
3RXUL&L QL&LIDFWRULHOOH&IDFWRULHOOH L
(FULUH/DIDFWRULHOOHGHQ IDFWRULHOOH
ILQ
)LQ
Programme C :
LQFOXGHVWGLRK!
ϴϰ

Les boucles .

PDLQ
^
LQWLQIDFWRULHOOH
SULQWI(QWH]XQQRPEUH
VFDQIG Q
LIQ
SULQWI/DIDFWRULHOOHG
XQQRPEUHQpJDWLIQ
H[LVWHSDV
HOVH^
IDFWRULHOOH 
IRUL L QLIDFWRULHOOH IDFWRULHOOH L
SULQWI/DIDFWRULHOOHGHG GQIDFWRULHOOH
`
`
Solution 3 :
Algorithme :
$OJRULWKPHSXLVVDQFH
9DULDEOHV
(QWLHUQL
5pHO[SXLVV
'pEXW
(FULUHĂůĐƵůĚĞůĂƉƵŝƐƐĂŶĐĞŶŝğŵĞĚƵƌĠĞůdžƉĂƌŵƵůƚŝƉůŝĐĂƚŝŽŶƐƐƵĐĐĞƐƐŝǀĞƐ͘
(FULUH,QWURGXLVH]OHQRPEUHUpHO[
/LUH[
(FULUH,QWURGXLVH]O
H[SRVDQWGH[HQWLHUSRVLWLI
/LUHQ
SXLVV&
L&
7DQWTXHL QGpEXW
SXLVV&SXLVV [
L&L
ILQ
(FULUH/DSXLVVDQFHQLqPHGH[HVWSXLVV
)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ
^
LQWQL
IORDW[SXLVV
SULQWIĂůĐƵůĚĞůĂƉƵŝƐƐĂŶĐĞŶŝğŵĞĚƵƌĠĞůdžƉĂƌŵƵůƚŝƉůŝĐĂƚŝŽŶƐƐƵĐĐĞƐƐŝǀĞƐ͘?Q
SULQWI,QWURGXLVH]OHQRPEUHUpHO[
VFDQII [
SULQWI,QWURGXLVH]O
H[SRVDQWGH[HQWLHUSRVLWLI
VFDQIG Q
SXLVV 
L 
ZKLOHL Q^
SXLVV SXLVV [
L L
ϴϱ

Les boucles .

`
SULQWI/DSXLVVDQFHGLqPHGHIHVWIQ[SXLVV
`
Solution 4 :
Algorithme :
$OJRULWKPHYDOHXUBB
9DULDEOHV
(QWLHUQ
'pEXW
5pSpWHU
GpEXW
(FULUH(QWUH]XQQRPEUHHQWUHHW
/LUHQ
6LQ28Q!
(FULUH6DLVLHHUURQpH5HFRPPHQFH]
6LQRQ(FULUH1RPEUHDFFHSWp
ILQ
-XVTX¶jQ! (7Q 
)LQ
Programme C :
Comme il n¶existe pas une structure qui correspond exactement à la boucle
5pSpWHUen C, nous allons utiliser l¶instruction GR«ZKLOH«comme suit :
LQFOXGHVWGLRK!
PDLQ
^
LQWQ
GR^
SULQWI(QWUH]XQQRPEUHHQWUHHW?Q
VFDQIG Q
LIQ__Q!
SULQWI6DLVLHHUURQpH5HFRPPHQFH]?Q
HOVHSULQWI1RPEUHDFFHSWp
`
ZKLOHQ__Q!
`
Solution 5 :
Algorithme :
$OJRULWKPHDIILFKHUBBVXLYDQWV
9DULDEOHV
(QWLHUQL
'pEXW
(FULUH(QWUH]XQQRPEUH
/LUHQ
(FULUH/HVQRPEUHVVXLYDQWVVRQW
3RXUL&QL QL&L(FULUHL
)LQ
Programme C :
ϴϲ

Les boucles .

LQFOXGHVWGLRK!
PDLQ
^
LQWQL
SULQWI(QWUH]XQQRPEUH
VFDQIG Q
SULQWI/HVQRPEUHVVXLYDQWVVRQW?Q
IRUL QL QLSULQWIG?QL
`
Solution 6 :
Algorithme :
$OJRULWKPHWDEOHBPXOWLSOLFDWLRQ
9DULDEOHV
(QWLHUQL
'pEXW
(FULUH(QWUH]XQQRPEUH
/LUHQ
(FULUH/DWDEOHGHPXOWLSOLFDWLRQGHQHVW
3RXUL&L L&L(FULUHQ
[
L
 
Q L
)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ
^
LQWQL
SULQWI(QWUH]XQQRPEUH
VFDQIG Q
SULQWI/DWDEOHGHPXOWLSOLFDWLRQGHGHVW?QQ
IRUL L LSULQWIG[G G?QQLQ L
`
Solution 7 :
Algorithme :
$OJRULWKPH3OXVB*UDQGB'LYLVHXUB&RPPXQ
9DULDEOHV
(QWLHUPQDEU3*&'
'pEXW
(FULUHΗEŽƵƐĂůůŽŶƐĐĂůĐƵůĞƌůĞW'ĚĞĚĞƵdžŶŽŵďƌĞƐĞŶƚŝĞƌƐ͘Η
(FULUH,QWURGXLVH]OHSUHPLHUQRPEUH
/LUHP
(FULUH,QWURGXLVH]OHGHX[LqPHQRPEUH
/LUHQ
D&P
E&Q
U&DE
7DQWTXH121U GpEXW
D&E
E&U
U&DE
ϴϳ

Les boucles .

ILQ
3*&'&E
(FULUH/H3*&'GHPHWQHVW3*&'
)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ
^
LQWPQDEU3*&'
SULQWIΗEŽƵƐĂůůŽŶƐĐĂůĐƵůĞƌůĞW'ĚĞĚĞƵdžŶŽŵďƌĞƐĞŶƚŝĞƌƐ͘ͰŶΗ
SULQWI,QWURGXLVH]OHSUHPLHUQRPEUH
VFDQIG P
SULQWI,QWURGXLVH]OHGHX[LqPHQRPEUH
VFDQIG Q
D P
E Q
U DE
ZKLOHU ^
D E
E U
U DE
`
3*&' E
SULQWI/H3*&'GHGHWGHVWGPQ3*&'
`
Solution 8 :
Algorithme :
$OJRULWKPHFDOFXOVBPHQX
9DULDEOHV
(QWLHULFKRL[
5pHOVQPR\HQQHPLQLPXPPD[LPXP
'pEXW
(FULUH(QWUH]VXFFHVVLYHPHQWGHVQRPEUHVSRVLWLIV
(FULUH(QWUH]XQQRPEUHQpJDWLISRXUILQLU
/LUHQ
6LQ! GpEXW
V&Q
PLQLPXP&Q
PD[LPXP&Q
L&
5pSpWHU
GpEXW
/LUHQ
6LQ! GpEXW
6LQPLQLPXPPLQLPXP&Q
6LQ!PD[LPXPPD[LPXP&Q
V&VQ
L&L
ILQ
ϴϴ

Les boucles .

ILQ
MXVTX¶jQ
PR\HQQH&VL
5pSpWHU
GpEXW
(FULUH&KRLVLVVH]HQWUH
(FULUHPLQLPXP
(FULUHPD[LPXP
(FULUHVRPPH
(FULUHPR\HQQH
(FULUHVWRS
(FULUH(QWUH]YRWUHFKRL[
/LUHFKRL[
&DVFKRL[
GpEXW
(FULUH/HPLQLPXPHVWPLQLPXP
(FULUH/HPD[LPXPHVWPD[LPXP
(FULUH/DVRPPHHVWV
(FULUH/DPR\HQQHHVWPR\HQQH

'pIDXW(FULUH&KRL[QRQDFFHSWp
ILQ
ILQ
-XVTX¶jFKRL[ 
ILQ
)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ
^
LQWLFKRL[
IORDWVQPR\HQQHPLQLPXPPD[LPXP
SULQWI(QWUH]VXFFHVVLYHPHQWGHVQRPEUHVSRVLWLIV?Q
SULQWI(QWUH]XQQRPEUHQpJDWLISRXUILQLU?Q
VFDQII Q
LIQ! ^
V Q
PLQLPXP Q
PD[LPXP Q
L 
GR
^
VFDQII Q
LIQ! ^
LIQPLQLPXPPLQLPXP Q
LIQ!PD[LPXPPD[LPXP Q
V VQ
L L
`

ϴϵ

Les boucles .

`
ZKLOHQ! 
PR\HQQH VL
GR
^
SULQWI&KRLVLVVH]HQWUH?Q
SULQWIPLQLPXP?Q
SULQWIPD[LPXP?Q
SULQWIVRPPH?Q
SULQWIPR\HQQH?Q
SULQWIVWRS?Q
SULQWI(QWUH]YRWUHFKRL[
VFDQIG FKRL[
VZLWFKFKRL[
^
FDVHSULQWI/HPLQLPXPHVWI?QPLQLPXP
EUHDN
FDVHSULQWI/HPD[LPXPHVWI?QPD[LPXP
EUHDN
FDVHSULQWI/DVRPPHHVWI?QVEUHDN
FDVHSULQWI/DPR\HQQHHVWI?QPR\HQQH
EUHDN
FDVHEUHDN
GHIDXOWSULQWI&KRL[QRQDFFHSWp?Q
`
`
ZKLOHFKRL[ 
`
`
Solution 9 :
Algorithme :
$OJRULWKPH$FKDW
9DULDEOHV
(QWLHUSUL[VRPPH05HVWH1E'1E'1E'
'pEXW
VRPPH&
(FULUH'RQQH]OHVSUL[HWWHUPLQH]SDUXQ
5pSpWHU
GpEXW
(FULUH(QWUH]XQSUL[
/LUHSUL[
6LSUL[!VRPPH&VRPPHSUL[
ILQ
-XVTX
jSUL[ 
(FULUH9RXVGHYH]VRPPH'$
(FULUH0RQWDQWYHUVp
/LUH0
5HVWH&0±VRPPH

ϵϬ

Les boucles .

1E'&5HVWH
1E'&5HVWH
1E'&5HVWH
(FULUH5HPLVHGHODPRQQDLH
(FULUH3LqFHVGH'$1E'
(FULUH3LqFHVGH'$1E'
(FULUH3LqFHVGH'1E'
)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ
^
LQWSUL[VRPPH05HVWH1E'1E'1E'
VRPPH 
SULQWI'RQQH]OHVSUL[HWWHUPLQH]SDUXQ?Q
GR
^
SULQWI(QWUH]XQSUL[
VFDQIG SUL[
LISUL[!VRPPH VRPPHSUL[
`
ZKLOHSUL[ 
SULQWI9RXVGHYH]G'$?QVRPPH
SULQWI0RQWDQWYHUVp
VFDQIG 0
5HVWH 0VRPPH
1E' 5HVWH
1E' 5HVWH
1E' 5HVWH
SULQWI5HPLVHGHODPRQQDLH?Q
SULQWI3LqFHVGH'$G?Q1E'
SULQWI3LqFHVGH'$G?Q1E'
SULQWI3LqFHVGH'G?Q1E'
`
Solution 10 :
Algorithme :
$OJRULWKPHILERQDFFL
9DULDEOHV
(QWLHUQILERSUHGSUHGL
'pEXW
(FULUH'RQQH]XQHQWLHU
/LUHQ
6LQ ILER&
6LQRQ6LQ ILER&
6LQRQ6LQ!GpEXW
SUHG&
SUHG&
3RXUL&L QL&LGpEXW
ILER&SUHGSUHG
ϵϭ

Les boucles .

SUHG&SUHG
SUHG&ILER
ILQ
ILQ
(FULUH)LERQDFFLQ ILER
)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ
^
LQWQILERSUHGSUHGL
SULQWI'RQQH]XQHQWLHU
VFDQIG Q
LIQ ILER 
HOVHLIQ ILER 
HOVHLIQ!^
SUHG 
SUHG 
IRUL L QL^
ILER SUHGSUHG
SUHG SUHG
SUHG ILER
`
`
SULQWI)LERQDFFLG GQILER
`
Solution 11 :
Programme C :
LQFOXGHVWGLRK!
PDLQ
^
LQWQLM
SULQWI'RQQH]OHQRPEUHGHOLJQHV
VFDQIG Q
IRUL L QL^
IRUM M LMSULQWI 
SULQWI?Q
`
`
Solution 12 :
1. Le programme permet de lire une série de valeurs, jusqu¶à introduire la
valeur 1.
2. Boucle infinie.
3. Le bloc n¶est jamais exécuté.


ϵϮ

Les tableaux et les chaînes de caractères .

Chapitre 5 : Les tableaux et les chaînes de caractères

1. Introduction
Les types présentés jusqu¶à maintenant sont des types simples. Il existe d¶autres
types dits structurés (complexes). Un type structuré est tout type défini à base
d¶autres types. Commençant par le type qu¶on juge le plus important des types
structurés, à savoir le type tableau.
2. Le type tableau
Un tableau est une structure de données homogène composée d¶un ensemble
d¶éléments de même type de données.
Format général : W\SHBGRQQpHV1RPBWDE>WDLOOHBWDE@
Un tableau possède un nom (1RPBWDE). Il est aussi caractérisé par sa taille, i.e.
le nombre d¶éléments ou encore le nombre de cases (WDLOOHBWDE). Le type des
éléments du tableau est indiqué par W\SHBGRQQpHV.
Par exemple, pour déclarer un tableau 1RWH de dix éléments réels, on met :
5pHO1RWH>@
Cet exemple nous a permis de substituer la déclaration de 10 variables 1RWH,
1RWH « 1RWH de type 5pHO par une seule structure, à savoir le tableau
1RWH.
En C, on écrit : IORDW1RWH>@
La capacité d¶un tableau (le nombre d¶éléments que peut contenir un tableau)
ne peut pas être changée au cours d¶exécution d¶un programme. Il faut donc
que la taille du tableau soit suffisamment grande pour la manipulation. Pour
une souplesse de programmation, on peut utiliser la déclaration suivante :
GHILQHWDLOOHBWDE 
PDLQ 
^
IORDW1RWH>WDLOOHBWDE@
«
Remarques :
S Les cases d¶un tableau sont numérotées de  à WDLOOHBWDE en langage
C.
S Le nom du tableau désigne l¶adresse où débute le tableau en mémoire, i.e.
1RWH est équivalent à 1RWH>@.
S Le nom du tableau ne peut pas figurer à gauche d¶une affectation (lvalue).
S Si vous utilisez le tableau hors de ses limites, il n¶y aura pas d¶erreur de
compilation. On appelle ça, débordement ou dépassement de tableau. C¶est
l¶un des bugs de la programmation en C.
S Pour la manipulation des tableaux, on utilise fréquemment les boucles.

ϵϯ

Les tableaux et les chaînes de caractères .

S Il est possible d¶omettre la dimension du tableau. Celle-ci étant déterminée

par le nombre de valeurs énumérées dans l¶initialisation. Par exemple,
IORDW 1RWH>@  ^ ` indique que le tableau contient deux
éléments.
2.1. Manipulation d¶un tableau
Un tableau peut être représenté par un ensemble de cases contigües. Le tableau
1RWH, avec 10 éléments, peut être représenté comme suit :
Ϭ
ϭ
Ϯ
ϯ
ϰ
ϱ
ϲ
ϳ
ϴ
ϵ
Un élément du tableau est accessible par sa position (indice) dans le tableau. Le
tableau 1RWH est un tableau à une seule dimension, là où chaque élément est
accessible par un seul indice. Par exemple, 1RWH>@& permet d¶affecter
la valeur  à la première case du tableau. Le tableau 1RWH devient:
Ϭ Ϭ͘Ϯϱ
ϭ 
Ϯ 
ϯ 
ϰ 
ϱ 
ϲ 
ϳ 
ϴ 
ϵ 

L¶indice peut être exprimé directement comme un nombre en clair. Il peut aussi
correspondre à une valeur d¶une variable ou à une expression calculée.

ϵϰ

Les tableaux et les chaînes de caractères .

Soit par exemple : En C :

$OJRULWKPHH[HBWDE PDLQ
9DULDEOHV ^
(QWLHU7>@ LQW7>@
(QWLHU; LQW;
'pEXW ; 
;& 7>@ 
7>@& 7>;@ 
7>;@& 7>;@ 
7>;@& `
)LQ
Après l¶exécution des opérations de l¶algorithme, le tableau 7 peut être
représenté comme suit :
Ϭ ϳ
ϭ ϰ
Ϯ ϭϴ
ϯ
ϰ 
Une représentation plus proche à la réalité est la suivante : (Voir encore la
section 2 du chapitre 2)
ĚƌĞƐƐĞƐŵĠŵŽŝƌĞ

Ϭϵϵϴ

d Ϭϵϵϵ ϭϬϬϬ
d΀Ϭ΁ ϭϬϬϬ ϳ
d΀ϭ΁ ϭϬϬϭ ϰ
d΀Ϯ΁ ϭϬϬϮ ϭϴ
d΀ϯ΁ ϭϬϬϯ

d΀ϰ΁ ϭϬϬϰ

ϭϬϬϱ

Avec, le contenu de la case 7 correspond à 7>@ qui est égale à ; le nom
du tableau 7 est donc un pointeur vers le premier élément (contient son
adresse).

ϵϱ

Les tableaux et les chaînes de caractères .

Remarques :
xEn C, l¶indice peut être aussi de type caractère, compte tenu des règles de
conversion implicite. Par exemple, 7>
$
@ est équivalent à 7>@.
xLorsqu¶on applique VL]HRI à une variable de type tableau, l¶opérateur
renvoie l¶espace mémoire total que ce tableau occupe, i.e. son nombre
d¶éléments multiplié par l¶espace mémoire occupé par un seul élément.
Exercice 1 : (Création, initialisation et édition d¶un tableau)
Problème : Ecrire un algorithme permettant de créer un tableau de dix entiers,
d¶initialiser ses éléments à , ensuite de les afficher. Traduire l¶algorithme en
C.
Solution :
$OJRULWKPHLQLWBWDE
9DULDEOHV
(QWLHU7>@
(QWLHUL
'pEXW
3RXUL&L L&L7>L@&
3RXUL&L L&L(FULUH7>L@
)LQ
Le programme C :
LQFOXGHVWGLRK!
PDLQ
^
LQW7>@
LQWL
IRUL L L7>L@ 
IRUL L LSULQWIG?Q7>L@
`
Ou bien :
LQFOXGHVWGLRK!
PDLQ
^
LQW7>@ ^`L
IRUL L LSULQWIG?Q7>L@
`
Exercice 2 : (Création, lecture et affichage d¶un tableau)
Problème : Ecrire un algorithme permettant de créer un tableau de dix entiers,
de lire ses éléments à partir du clavier, ensuite de les afficher. Traduire
l¶algorithme en C.
Solution :
$OJRULWKPHOLUHBWDE
9DULDEOHV
(QWLHU7>@
(QWLHUL
'pEXW
ϵϲ

Les tableaux et les chaînes de caractères .

3RXUL&L L&L/LUH7>L@

3RXUL&L L&L(FULUH7>L@
)LQ
Le programme C :
LQFOXGHVWGLRK!
PDLQ
^
LQW7>@
LQWL
IRUL L LVFDQIG 7>L@
IRUL L LSULQWIG?Q7>L@
`
Exercice 3 : (Recherche dans un tableau)
Problème : Ecrire un algorithme permettant la recherche d¶un nombre lu à
partir du clavier dans un tableau de dix réels. Traduire l¶algorithme en C.
Solution : Il existe plusieurs stratégies pour la recherche dans un tableau. Nous
en verrons deux : la recherche en utilisant la technique de Flag, et la recherche
dichotomique.
Technique de Flag : Le Flag, en anglais, veut dire drapeau. Dans cette première
méthode, on a une variable booléenne initialisée à )$8; (drapeau baissé), et qui
aura la valeur 95$, dès qu¶un événement attendu se produit (drapeau levé). La
technique de Flag peut être utilisée dans le problème de recherche et dans
n¶importe quel problème pareil.
La recherche dichotomique : La dichotomie (« couper en deux » en grec). La
recherche dichotomique exige que les éléments du tableau soient ordonnés
préalablement. Elle consiste à comparer le nombre à rechercher avec le nombre
qui se trouve au milieu du tableau. S¶ils sont égaux, on arrête la recherche et on
déclare que l¶élément existe. Sinon, si le nombre recherché est inférieur, on
devra continuer la recherche dorénavant dans la première moitié. Sinon, on
devra le rechercher dans la deuxième moitié. A partir de là, on prend la moitié
du tableau qui nous reste, et on recommence la recherche. La recherche s¶arrête
quand il ne reste plus de place là où rechercher, et on déclare que le nombre
recherché n¶existe pas dans le tableau.
Algorithme de la recherche en utilisant la technique de Flag :
$OJRULWKPH5HFKHUFKHB)ODJ
9DULDEOHV
5pHO120%5(6>@
5pHO1%5
%RROpHQ)ODJ
(QWLHUL
'pEXW
(FULUH(QWUH]OHVpOpPHQWVGXWDEOHDX
3RXUL&L L&L/LUH120%5(6>L@
(FULUH(QWUH]OHQRPEUHjUHFKHUFKHU
ϵϳ

Les tableaux et les chaînes de caractères .

/LUH1%5

)ODJ&)$8;
3RXUL&L L&L6L120%5(6>L@ 1%5)ODJ&95$,
6L)ODJ(FULUH1%5IDLWSDUWLHGXWDEOHDX
6LQRQ(FULUH1%5QHIDLWSDVSDUWLHGXWDEOHDX
)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ
^
IORDW120%5(6>@
IORDW1%5
LQW)ODJ
LQWL
SULQWI(QWUH]OHVpOpPHQWVGXWDEOHDX?Q
IRUL L LVFDQII 120%5(6>L@
SULQWI(QWUH]OHQRPEUHjUHFKHUFKHU
VFDQII 1%5
)ODJ 
IRUL L LLI120%5(6>L@ 1%5)ODJ 
LI)ODJSULQWIIIDLWSDUWLHGXWDEOHDX1%5
HOVHSULQWIIQHIDLWSDVSDUWLHGXWDEOHDX1%5
`
L¶inconvénient du programme précédent est que la recherche continue jusqu¶au
dernier élément, même si l¶élément recherché a été trouvé auparavant. Un
programme optimisé est donc le suivant :
LQFOXGHVWGLRK!
PDLQ
^
IORDW120%5(6>@
IORDW1%5
LQW)ODJ
LQWL
SULQWI(QWUH]OHVpOpPHQWVGXWDEOHDX?Q
IRUL L LVFDQII 120%5(6>L@
SULQWI(QWUH]OHQRPEUHjUHFKHUFKHU
VFDQII 1%5
)ODJ 
L 
ZKLOHL  )ODJ
LI120%5(6>L@ 1%5)ODJ 
HOVHL
LI)ODJSULQWIIIDLWSDUWLHGXWDEOHDX1%5
HOVHSULQWIIQHIDLWSDVSDUWLHGXWDEOHDX1%5
`
Algorithme de la recherche dichotomique :
$OJRULWKPH5HFKHUFKHBGLFKRWRPLTXH
9DULDEOHV

ϵϴ

Les tableaux et les chaînes de caractères .

5pHO120%5(6>@
5pHO1%5
%RROpHQ75289(
(QWLHUL6XS,QI0LOLHX
'pEXW
(FULUH(QWUH]OHVpOpPHQWVWULpVGXWDEOHDX
3RXUL&L L&L/LUH120%5(6>L@
(FULUH(QWUH]OHQRPEUHjUHFKHUFKHU
/LUH1%5
6XS&
,QI&
75289(&)$8;
7DQWTXH12175289((76XS! ,QIGpEXW
0LOLHX&6XS,QI
6L1%5 120%5(6>0LOLHX@75289(&95$,
6LQRQ6L1%5120%5(6>0LOLHX@6XS&0LOLHX±
6LQRQ,QI&0LOLHX
)LQ
6L75289((FULUH1%5H[LVWHGDQVOHWDEOHDX
6LQRQ(FULUH1%5Q
H[LVWHSDVGDQVOHWDEOHDX
)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ
^
IORDW120%5(6>@
IORDW1%5
LQW75289(
LQWL6XS,QI0LOLHX
SULQWI(QWUH]OHVpOpPHQWVWULpVGXWDEOHDX?Q
IRUL L LVFDQII 120%5(6>L@
SULQWI(QWUH]OHQRPEUHjUHFKHUFKHU
VFDQII 1%5
6XS 
,QI 
75289( 
ZKLOH75289( 6XS! ,QI^
0LOLHX 6XS,QI
LI1%5 120%5(6>0LOLHX@75289( 
HOVHLI1%5120%5(6>0LOLHX@6XS 0LOLHX
HOVH,QI 0LOLHX
`
LI75289(SULQWIIH[LVWHGDQVOHWDEOHDX1%5
HOVHSULQWIIQ¶H[LVWHSDVGDQVOHWDEOHDX1%5
`
Remarque : On note que la recherche dichotomique contient la technique de
Flag, car on a besoin d¶un test d¶arrêt au cas où l¶élément recherché est trouvé.

ϵϵ

Les tableaux et les chaînes de caractères .

2.2. Tri d¶un tableau

Problème : Soit un tableau de N entiers rangés n¶importe comment. On
cherche à modifier le tableau de telle manière que les nombres y soient rangés
par ordre croissant.
Plusieurs stratégies peuvent être utilisées pour résoudre le problème de tri :
 Tri par sélection.
 Tri à bulles.
 Tri par insertion.
 Tri rapide (quick sort).
 Tri fusion (merge sort).
 Tri par tas (heap sort).
Dans ce qui suit, nous en verrons deux stratégies : le tri par sélection et le tri à bulles.
Algorithme de tri par sélection :
Dans ce cas, le tri d¶un tableau consiste à mettre en bonne position le premier
élément, c¶est-à-dire le plus petit, puis, on met en bonne position l¶élément
suivant, et ainsi de suite, jusqu¶au dernier.
$OJRULWKPH7ULBWDEBSDUBVHOHFWLRQ
9DULDEOHV
(QWLHU7>@
(QWLHU[LM
'pEXW
(FULUH'RQQH]OHVpOpPHQWVGXWDEOHDX
3RXUL&L L&L/LUH7>L@
3RXUL&L L&L
3RXUM&LM M&M6L7>L@!7>M@GpEXW
   [&7>L@
   7>L@&7>M@
   7>M@&[
   ILQ
(FULUH9RLFLOHVpOpPHQWVGXWDEOHDXWULp
3RXUL&L L&L(FULUH7>L@
)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ
^LQW7>@
LQW[LM
SULQWI'RQQH]OHVpOpPHQWVGXWDEOHDX?Q
IRUL L LVFDQIG 7>L@
IRUL L L
IRUM LM MLI7>L@!7>M@^
   [ 7>L@
   7>L@ 7>M@
   7>M@ [
   `

ϭϬϬ

Les tableaux et les chaînes de caractères .

SULQWI9RLFLOHVpOpPHQWVGXWDEOHDXWULp?Q

IRUL L LSULQWIG?Q7>L@
`
Algorithme de tri à bulles :
L¶idée de départ du tri à bulles consiste à se dire qu¶un tableau trié en ordre
croissant est un tableau dans lequel tout élément est plus petit que celui qui le
suit.
$OJRULWKPH7ULBWDEBEXOOHV
9DULDEOHV
(QWLHU7>@
(QWLHUL[
%RROpHQ3HUPXW
'pEXW
(FULUH'RQQH]OHVpOpPHQWVGXWDEOHDX
3RXUL&L L&L/LUH7>L@
5pSpWHU
GpEXW
3HUPXW&)$8;
3RXUL&L L&L6L7>L@!7>L@GpEXW
[&7>L@
7>L@&7>L@
7>L@&[
3HUPXW&95$,
ILQ
ILQ
-XVTX¶j1RQ3HUPXW
(FULUH9RLFLOHVpOpPHQWVGXWDEOHDXWULp
3RXUL&L L&L(FULUH7>L@
)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ
^
LQW7>@
LQWL[
LQW3HUPXW
SULQWI'RQQH]OHVpOpPHQWVGXWDEOHDX?Q
IRUL L LVFDQIG 7>L@
GR
^
3HUPXW 
IRUL L LLI7>L@!7>L@^
[ 7>L@
7>L@ 7>L@
7>L@ [
3HUPXW 
`
`

ϭϬϭ

Les tableaux et les chaînes de caractères .

ZKLOH3HUPXW

SULQWI9RLFLOHVpOpPHQWVGXWDEOHDXWULp?Q
IRUL L LSULQWIG?Q7>L@
`
2.3. Tableau à deux dimensions
Les tableaux vus précédemment sont à une dimension. Un tableau à deux
dimensions peut être déclaré de la manière suivante :
W\SHBGRQQpHV1RPBWDE>WDLOOHBGLP@>WDLOOHBGLP@
Où WDLOOHBGLP et WDLOOHBGLP représentent respectivement la taille de la
première et la deuxième dimension.
L¶exemple suivant permet de déclarer un tableau de réels nommé 1RWH à deux
dimensions 3 * 5 :
5pHO1RWH>@>@
En C, on écrit : IORDW1RWH>@>@
Un tableau à deux dimensions peut être représenté par un ensemble de cases
organisées en lignes et colonnes et schématisées comme suit :
     
     
     
     
Représentation du tableau 1RWH à deux dimensions
Dans ce cas-là, un élément du tableau est accessible par deux indices. Par
exemple, si on met 1RWH>@>@& et 1RWH>@>@&, le tableau 1RWH
devient :
     
     
     
     
Remarques :
xOn peut déclarer et initialiser au même temps un tableau à deux dimensions
comme suit :
IORDW 1RWH>@>@  ^^    ` ^   
`^``
ou bien :
IORDW 1RWH>@>@  ^         
`
xLes tableaux les plus utilisés sont à une ou deux dimensions, mais il est
possible de définir des tableaux à trois ou à quatre dimensions, voire plus.
Par exemple, IORDW1RWH>@>@>@>@
xOn utilise parfois le terme vecteur pour désigner un tableau à une
dimension, et le terme matrice pour désigner un tableau à deux dimensions.
x1RWH contient l¶adresse du premier élément, i.e., 1RWH est équivalent à
1RWH>@>@. En plus, les notations suivantes sont équivalentes : 1RWH>@
et 1RWH>@>@, 1RWH>@ et 1RWH>@>@, 1RWH>@ et 1RWH>@>@.
ϭϬϮ

Les tableaux et les chaînes de caractères .

3. Les chaînes de caractères

Une chaîne de caractères est une suite de caractères. Elle est équivalente à un
tableau de caractères avec des opérations supplémentaires.
3.1. Déclaration d¶une chaîne de caractères
En C, une chaîne de caractères se déclare sous forme d¶un tableau de caractères
de longueur fixe. Dans ce tableau, le caractère
?
, correspondant à la valeur
, indique la fin de la chaîne de caractères.
Ainsi : FKDU FK>@ permet d¶enregistrer une chaîne de 14 caractères
maximum (15- 1 pour le 0 indiquant la fin de la chaîne).
En C, avec FKDUFK>@ ERQMRXU, la chaîne de caractères FK peut être
représentée de la manière suivante :
              
E R Q M R X 5 ?       
Ceci est équivalent à : FKDUFK>@ ^
E

R

Q

M

R

X


U

?
`
Remarques :
xDans d¶autres langages, tels que Pascal et Java, une chaîne de caractères est
déclarée par le mot clé 6WULQJ.
xEn C, une chaîne constante doit être mise entre deux guillemets doubles
pour la distinguer d¶un identificateur de variable, comme déjà vu pour la
chaîne ERQMRXU.
xComme signalé auparavant, si vous dépassez la longueur fixée du tableau,
vous écrivez dans des cases qui suivent le tableau, et qui peuvent être
réservées pour d¶autres variables. Si vous affectez une valeur qui dépasse la
longueur prévue de la chaîne de caractères, le compilateur ne déclare pas
une erreur de compilation, mais vous aurez pu avoir un résultat inattendu.
Donc, évitez cette situation.
xIl est possible de déclarer une chaîne de caractères sans spécifier la longueur
de départ de la façon suivante : FKDUFK>@ $KPHG. De cette façon, la
chaîne fera exactement la longueur nécessaire pour stocker $KPHG et le 
final. Elle aura donc la taille 5+1=6 octets.
3.2. Manipulation des chaînes de caractères
Affichage :
Une chaîne de caractères s¶affiche grâce à la fonction SULQWI et le format V.
Ainsi, SULQWIVFK affiche : ERQMRXU
Remarques :
xSULQWI appartient à la bibliothèque VWGLRK. Si on utilise SULQWI sans
spécifier la bibliothèque VWGLRK, le compilateur C signale un [Warning].
xRappelons que SXWVFK est équivalente à SULQWIV?QFK.
ϭϬϯ

Les tableaux et les chaînes de caractères .

xLa fonction SXWV, elle aussi, appartient à la bibliothèque VWGLRK.

Accès aux caractères :
Chaque caractère peut être manipulé en utilisant son indice. Les indices valides
pour une chaîne de caractères sont des entiers compris entre 0 et la longueur de
la chaîne-1.
Ainsi, SULQWIFFK>@ affiche :Q
Longueur d¶une chaîne de caractères :
La longueur d¶une chaîne de caractères s¶obtient par la fonction VWUOHQ
(appartenant à la bibliothèque VWULQJK). Le  de fin de chaîne n¶est pas
compté dans cette longueur.
Ainsi, SULQWIGVWUOHQFK affiche : 
Affectation :
Pour affecter une valeur à une variable chaîne de caractères, il est possible
d¶utiliser la fonction VWUFS\V!W!. Cette fonction nous impose d¶ajouter
le fichier d¶en-tête VWULQJK:
Ainsi, VWUFS\FK$OLaffecte la valeur $OL à la chaîne FK.
Remarques :
x La chaîne V! doit être suffisamment grande pour accueillir W!. Si on ne
respecte pas cette règle, la réaction du programme dépond du compilateur
C utilisé.
x L¶affectation FK $OL n¶est pas acceptée par le compilateur C, car le
membre de gauche désigne une adresse alors que le membre de droite
désigne une chaîne de caractères.
La fonction strncpy :
La fonction VWUQFS\V!W!Q fait le même travail que VWUFS\, sauf
qu¶elle se limite au Q premiers caractères de W!. Si Q dépasse la longueur de
W!, alors le
?
de W! sera aussi copier dans V!, et VWUQFS\ devient
équivalente à VWUFS\.
Ainsi, VWUQFS\FKVW remplace les deux premiers caractères de FK par les
deux premiers de VW.
Lecture :
Si l¶on souhaite lire une chaîne directement au clavier, on peut utiliser la
fonction VFDQI :
Ainsi, VFDQIVFK permet de lire la chaîne de caractères FK à partir du
clavier.
Remarques :
xNous n¶avons pas mis avant FK dans VFDQIVFK, car FK lui-même
représente l¶adresse du premier caractère de la chaîne.

ϭϬϰ

Les tableaux et les chaînes de caractères .

xVFDQIV FK>@ ferait la même chose que VFDQIVFK.

xVFDQI appartient à la bibliothèque VWGLRK. Si on utilise VFDQI sans
spécifier la bibliothèque VWGLRK, le compilateur C signale un [Warning].
xEn utilisant VFDQI, la chaîne de caractères saisie ne peut comporter ni
espaces, ni tabulations.
La fonction gets :
La fonction JHWV permet de lire une chaîne de caractères validée par la touche
Entrée. Attention ! La touche Entrée elle-même n¶est pas enregistrée dans le
tableau de caractères.
Ainsi, JHWVFK permet de lire la chaîne de caractères FK à partir du clavier.
Remarques :
xA la différence de VFDQI, la fonction JHWV permet de lire une chaîne de
caractères contenant des espaces et des tabulations. Elle permet même de
lire une chaîne vide. Il est donc recommandé d¶utiliser JHWV au lieu de
VFDQI pour lire les chaînes de caractères à partir du clavier.
xLa fonction JHWV, elle aussi, appartient à la bibliothèque VWGLRK.
La fonction strcat :
La fonction VWUFDWV!W! de la bibliothèque VWULQJK ajoute la chaîne
W! à la chaîne V! (on appelle cela une concaténation). La taille de V! doit
être suffisamment grande pour contenir aussi le contenu de W!.
Ainsi, VWUFDWFKVW ajoute VW à FK.
On peut dire aussi que VWUFDWFKVW retourne la concaténation des deux
chaînes FK et VW.
La fonction strncat :
La fonction VWUQFDWV!W!Q ajoute les Q premiers caractères de la chaîne
W! à la fin de la chaîne V!.
Ainsi, VWUQFDWFKVW ajoute les deux premiers caractères de VW à la fin de
la chaîne FK.
La fonction strcmp :
La fonction VWUFPSV!W! de la bibliothèque VWULQJK compare les
chaînes de caractères V! et W! de manière lexicographique et fournit un
résultat :
x nul () si V! est égale à W!.
x négatif () si V! précède W!.
x positif () si V! suit W!.
Ainsi, VWUFPS$$$$ renvoit , VWUFPS$$%% renvoit æ, et
VWUFPS%%$$ renvoit .

ϭϬϱ

Les tableaux et les chaînes de caractères .

Remarques :
xVWUQFPSV!W!Q limite la comparaison aux Q premiers caractères
des deux chaînes.
xVWULFPSV!W! compare les deux chaînes sans distinction entre
majuscules et minuscules. Les deux chaînes sont comparées comme si elles
étaient introduites en minuscules.
xVWUQLFPSV!W!Q combine les deux fonctions VWUQFPS et VWULFPS.
Les fonctions sprintf et sscanf :
La fonction :
VSULQWIFKDvQH FLEOH!FKDvQH GH IRUPDWDJH!H[SU!H[SU!«
convertit un ou plusieurs nombres en une chaîne de caractères.
Ainsi, LQW L VSULQWIFKG permet de convertir l¶entier  en
chaîne de caractères et la stocker dans la variable FK. À l¶arrivée, FK contiendra
la chaîne de caractères , et L contiendra la longueur de cette chaîne ().
La fonction VVFDQI fait le contraire.
Ainsi, pour LQWL VVFDQIIII D E F, les
variables réelles D, E et F contiendront respectivement ,  et , et L
contiendra  (le nombre de variables remplies avec succès).
Exemple :
LQFOXGHVWGLRK!
LQFOXGHVWULQJK!
PDLQ
^
FKDUFK>@ ERQMRXU
FKDUVW>@ $KPHG
SULQWIV?QFK
SULQWIF?QFK>@
FK>@
?

SULQWIV?QFK
SULQWIG?QVWUOHQFK
VWUFS\FK$OL
SULQWIV?QFK
VWUFDWFKVW
SULQWIV?QFK
VWUQFS\FKVW 
SULQWIV?QFK
VWUQFDWFKVW
SULQWIV?QFK
SULQWIG?QVWUFPSFKVW
LQWL VSULQWIFKG
SULQWIV G?QFKL
IORDWDEF
L VVFDQIIII D E F
SULQWII I I?QDEF 
`
ϭϬϲ

Les tableaux et les chaînes de caractères .

Le programme C précédent affiche :

3.3. Tableau de chaînes de caractères

On peut aussi déclarer un tableau de chaînes de caractères qui est un tableau de
caractères à deux dimensions. Pour déclarer, par exemple, un tableau de 5
chaînes de 19 caractères maximum, on écrit : FKDUWDE>@>@. On accède à
chacune des chaînes en utilisant l¶élément WDE>L@ du tableau, et on accède à
n¶importe quel caractère j de la chaîne i par WDE>L@>M@.
4. Exercices corrigés
4.1. Exercices
Exercice 1 :
Soit l¶algorithme :
$OJRULWKPH;
9DULDEOHV
(QWLHU6XLWH>@(QWLHUL
'pEXW
6XLWH>@&6XLWH>@&
3RXUL&L L&L
6XLWH>L@&6XLWH>L@6XLWH>L@
)LQ
Représentez le tableau 6XLWH après l¶exécution des opérations de l¶algorithme
;.
Exercice 2 :
Ecrire un algorithme, ensuite le programme C, permettant de calculer la
somme, le produit et la moyenne d¶un tableau de dix réels.
Exercice 3 :
Ecrire un algorithme qui lit un tableau de 10 entiers, et affiche ensuite les
éléments d¶indice impair. Traduire l¶algorithme en C.
Exercice 4 :
Ecrire un algorithme, ensuite le programme C, permettant de déterminer la
valeur maximale et la valeur minimale dans un tableau de dix entiers, avec
leurs positions dans le tableau.
ϭϬϳ

Les tableaux et les chaînes de caractères .

Exercice 5 :
Ecrire un algorithme permettant l¶affichage des deux plus petits éléments d¶un
tableau de dix entiers. Traduire l¶algorithme en C.
Exercice 6 :
Ecrire un algorithme permettant de remplir deux tableaux, chacun contient 10
entiers, de stocker la somme de ces deux tableaux dans un troisième tableau, et
d¶afficher ce dernier. Traduire l¶algorithme en C.
Note : Chaque élément du troisième tableau est calculé par l¶addition des deux
éléments des tableaux 1 et 2 ayant la même position, comme le montre
l¶exemple suivant :
Si Tableau 1 contient : , , , , , , , , , ,
et Tableau 2 contient : , , , , , , , , , ,
alors Tableau 3 va contenir : , , , , , , , , , .
Exercice 7 :
Ecrire un algorithme permettant de lire un tableau de 7 entiers et de dire si les
éléments du tableau sont tous consécutifs ou non. Traduire l¶algorithme en C.
Note : Les nombres consécutifs sont des nombres entiers qui se suivent, comme
par exemple , , , , ,  et .
Exercice 8 :
Ecrire un algorithme qui calcule itérativement le nième terme de la suite de
Fibonacci définie comme suit : Si n = 0 alors Fn = 0 ; Si n = 1 alors Fn = 1 ; Si
n >1 alors Fn = Fn-1+Fn-2. Utilisez cette fois-ci un tableau.
Traduire ensuite l¶algorithme en C.
Exercice 9 :
Ecrire un algorithme qui supprime un élément dont la position est lue à partir
du clavier dans un tableau de dix entiers. L¶élément supprimé sera substitué par
un zéro ajouté à la fin du tableau. Traduire l¶algorithme en C.
Exercice 10 :
Ecrire un algorithme déterminant les k premiers nombres premiers. La valeur
de k étant une constante. On conservera les nombres premiers dans un tableau,
au fur et à mesure de leur découverte. Enfin, on affiche les k premiers nombres
premiers à partir du tableau. Traduire l¶algorithme en C.
Note : Un nombre premier est un entier positif qui admet exactement deux
diviseurs distincts entiers et positifs. Ces deux diviseurs sont 1 et le nombre
considéré. Les nombres 0 et 1 ne sont pas premiers. Voici, par exemple, les dix
premiers nombres premiers : , , , , , , , ,  et .
Exercice 11 :
Ecrire un algorithme permettant de créer un tableau d¶entiers à deux
dimensions (3*5), d¶initialiser ses éléments à zéro, ensuite de les afficher.
Traduire l¶algorithme en C.
ϭϬϴ

Les tableaux et les chaînes de caractères .

Exercice 12 :
Soit l¶algorithme :
$OJRULWKPH;;
9DULDEOHV
(QWLHU7>@>@
(QWLHUNP
'pEXW
3RXUN&N N&N
3RXUP&P P&P7>N@>P@&NP
)LQ
Représentez le tableau 7 après l¶exécution des opérations de l¶algorithme ;;.
Exercice 13 :
Ecrire un algorithme permettant de remplir un tableau d¶entiers à deux
dimensions (3*5) à partir du clavier, et de déterminer le nombre d¶apparition
d¶une certaine valeur saisie par l¶utilisateur. Traduire l¶algorithme en C.
Exercice 14 :
Ecrire un algorithme qui calcule la transposée d¶une matrice d¶entiers (3*3).
Traduire l¶algorithme en C.
Note : La transposée d¶une matrice est une nouvelle matrice dont les lignes sont
les colonnes de la matrice initiale et les colonnes sont les lignes de la matrice
initiale, comme le montre l¶exemple suivant :
     
La transposée de la matrice :    est :   
     
Exercice 15 :
Ecrire un algorithme qui calcule le produit matriciel de deux matrices (3*3). Le
résultat sera rangé dans une troisième matrice. Traduire l¶algorithme en C.
Note : Le produit matriciel de deux matrices est une troisième matrice là où
chaque élément (x,y) est calculer par la multiplication de la xieme ligne de la
première matrice par la yième colonne de la deuxième matrice, comme le montre
l¶exemple suivant :
          
          
          
Exercices 16 :
En utilisant une boucle IRU, écrire un programme C qui remplit un tableau de
10+1 caractères avec les lettres de l¶alphabet en commençant par
$
(code
ASCII ). Le tableau devra donc contenir ceci :
          

$

%

&

'

(

)

*

+

,

-
 
Dans le même programme :
x Faites afficher la chaîne de caractères ainsi obtenue ;
ϭϬϵ

Les tableaux et les chaînes de caractères .

x Faites afficher chaque caractère du tableau sous la forme :

&DUDFWqUHQXPpUR$.
&DUDFWqUHQXPpUR%.
«
Exercice 17 :
Qu¶affiche le programme C suivant si vous saisissez au clavier les deux mots :
VFLHQFH et LQIRUPDWLTXH ?
LQFOXGHVWGLRK!
LQFOXGHVWULQJK!
PDLQ^
FKDUFKDLQH>@ FDUDFWqUHV
?
 
FKDUFKDLQH>@
SULQWI9HXLOOH]HQWUHUYRWUHFKDvQHGHFDUDFWqUHV
JHWVFKDLQH LGHQWLTXHjVFDQIVFKDLQH
RXVFDQIV FKDLQH>@ 
VWUFS\FKDLQHFKDLQH DWWHQWLRQjO
RUGUH 
SULQWIFKDvQHYDXWV?QFKDLQH
VWUFS\FKDLQH HWQRQSDVFKDLQH  
VWUFDWFKDLQH$KPHG
SULQWI9HXLOOH]HQWUHUYRWUHFKDvQHGHFDUDFWqUHV
JHWVFKDLQH
VWUFDWFKDLQHFKDLQH
VWUFDWFKDLQH0RKDPHG$OL
SULQWIFKDvQHYDXWV?QFKDLQH
`
Exercice 18 :
Ecrire un programme C permettant de lire deux chaînes de caractères et de les
afficher par ordre alphabétique.
Exercice 19 :
Ecrire un programme C permettant de lire une chaîne de 19 caractères
maximum et de calculer le nombre d¶apparition d¶un caractère lu à partir du
clavier.
Exercice 20 :
Ecrire un programme C qui supprime toutes les lettres
H
d¶une chaîne de
caractères. La chaîne ainsi modifiée doit être affichée.
Exercice 21 :
Ecrire un programme C qui lit au clavier une chaîne d¶au plus 29 caractères et
qui l¶affiche à l¶envers.
Exercice 22 :
Ecrire un programme C qui calcule la somme des codes ASCII des caractères
d¶une chaîne lue à partir du clavier.
Exercice 23 :
Ecrire un programme C qui lit un verbe du premier groupe et qui en affiche la
conjugaison au présent de l¶indicatif. On admettra que l¶utilisateur ne fournit

ϭϭϬ

Les tableaux et les chaînes de caractères .

que des verbes réguliers (se terminant par HU), et qu¶il ne fournira pas des
verbes tels que PDQJHU.
Tester votre programme avec le verbe VDXWHU.
Exercice 24 :
Ecrire un programme C qui lit un tableau de 5 mots de 19 caractères maximum,
puis affiche à nouveau le tableau avec son contenu en majuscules, et trié par
ordre alphabétique.
Note : En langage C, la fonction de conversion d¶un caractère en majuscule est
WRXSSHUFRGH $6&,, GX FDUDFWqUH. La fonction de conversion d¶un
caractère en minuscule est WRORZHUFRGH$6&,,GXFDUDFWqUH. Toutes les
deux appartiennent à la bibliothèque FW\SHK.
Exercice 25 :
Ecrire un programme C permettant de lire un tableau de 10 chaînes de 4
caractères maximum, puis il affiche le dernier caractère de chaque chaîne.
4.2. Corrigés
Solution 1 :
Cet algorithme crée un tableau de 7 éléments de type entier. Ensuite, il remplit
le tableau par 7 valeurs :,,,,, et.
Le tableau6XLWH peut être représenté donc comme suit :
Ϭ Ϭ
ϭ ϭ
Ϯ ϭ
ϯ Ϯ
ϰ ϯ
ϱ ϱ
ϲ ϴ

Solution 2 :
$OJRULWKPH6RPB0R\B3URGXLWBWDE
9DULDEOHV
5pHO7>@
(QWLHUL
5pHOVRPPHSURGXLWPR\HQQH
'pEXW
(FULUH'RQQH]OHVpOpPHQWVGXWDEOHDX
3RXUL&L L&L/LUH7>L@
VRPPH&
SURGXLW&
3RXUL&L L&LGpEXW
VRPPH&VRPPH7>L@
ϭϭϭ

Les tableaux et les chaînes de caractères .

SURGXLW&SURGXLW 7>L@
ILQ
PR\HQQH&VRPPH
(FULUH/DVRPPH VRPPH
(FULUH/HSURGXLW SURGXLW
(FULUH/DPR\HQQH PR\HQQH
)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ
^
IORDW7>@
LQWL
IORDWVRPPHSURGXLWPR\HQQH
SULQWI'RQQH]OHVpOpPHQWVGXWDEOHDX?Q
IRUL L LVFDQII 7>L@
VRPPH 
SURGXLW 
IRUL L L^
VRPPH VRPPH7>L@
SURGXLW SURGXLW 7>L@
`
PR\HQQH VRPPH
SULQWI/DVRPPH I?QVRPPH
SULQWI/HSURGXLW I?QSURGXLW
SULQWI/DPR\HQQH IPR\HQQH
`
Solution 3 :
Algorithme :
$OJRULWKPHHOHPHQWVBLPSDLUV
9DULDEOHV
(QWLHU7>@
(QWLHUL
'pEXW
(FULUH'RQQH]OHVpOpPHQWVGXWDEOHDX
3RXUL&L L&L/LUH7>L@
(FULUH9RLFLOHVpOpPHQWVGRQWO
LQGLFHHVWLPSDLU
3RXUL&L L&L6LL (FULUH7>L@
)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ^
LQW7>@
LQWL
SXWV'RQQH]OHVpOpPHQWVGXWDEOHDX
IRUL L LVFDQIG 7>L@
SXWV9RLFLOHVpOpPHQWVGRQWO
LQGLFHHVWLPSDLU
IRUL L LLIL SULQWIG?Q7>L@

ϭϭϮ

Les tableaux et les chaînes de caractères .

`
Solution 4 :
$OJRULWKPH0D[0LQBWDE
9DULDEOHV
(QWLHU7>@
(QWLHUPD[PLQSRVBPLQSRVBPD[L
'pEXW
(FULUH'RQQH]OHVpOpPHQWVGXWDEOHDX
3RXUL&L L&L/LUH7>L@
PD[&7>@
SRVBPD[&
3RXUL&L L&L6LPD[7>L@GpEXW
PD[&7>L@
SRVBPD[&L
ILQ
PLQ&7>@
SRVBPLQ&
3RXUL&L L&L6LPLQ!7>L@GpEXW
PLQ&7>L@
SRVBPLQ&L
ILQ
(FULUHΗ>ĂǀĂůĞƵƌŵĂdžŝŵĂůĞсΗ͕ŵĂdž͕ΗŽĐĐƵƉĂŶƚůĂƉŽƐŝƚŝŽŶΗ͕ƉŽƐͺŵĂdž
(FULUHΗ>ĂǀĂůĞƵƌŵŝŶŝŵĂůĞсΗ͕ŵŝŶ͕ΗŽĐĐƵƉĂŶƚůĂƉŽƐŝƚŝŽŶΗ͕ƉŽƐͺŵŝŶ
)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ
^
LQW7>@
LQWPD[PLQSRVBPLQSRVBPD[L
SULQWI'RQQH]OHVpOpPHQWVGXWDEOHDX?Q
IRUL L LVFDQIG 7>L@
PD[ 7>@
SRVBPD[ 
IRUL L LLIPD[7>L@^
PD[ 7>L@
SRVBPD[ L
`
PLQ 7>@
SRVBPLQ 
IRUL L LLIPLQ!7>L@^
PLQ 7>L@
SRVBPLQ L
`
SULQWIΗ>ĂǀĂůĞƵƌŵĂdžŝŵĂůĞсйĚŽĐĐƵƉĂŶƚůĂƉŽƐŝƚŝŽŶйĚͰŶΗ͕ŵĂdž͕ƉŽƐͺŵĂdž
SULQWIΗ>ĂǀĂůĞƵƌŵŝŶŝŵĂůĞсйĚŽĐĐƵƉĂŶƚůĂƉŽƐŝƚŝŽŶйĚΗ͕ŵŝŶ͕ƉŽƐͺŵŝŶ
`


ϭϭϯ

Les tableaux et les chaînes de caractères .

Solution 5 :
Algorithme :
$OJRULWKPH0LQBWDE
9DULDEOHV
(QWLHU7>@
(QWLHUPLQPLQL
'pEXW
(FULUH'RQQH]OHVpOpPHQWVGXWDEOHDX
3RXUL&L L&L/LUH7>L@
PLQ&7>@
PLQ&7>@
3RXUL&L L&L
6LPLQ!PLQGpEXW6LPLQ!7>L@PLQ&7>L@ILQ
6LQRQ6LPLQ!7>L@PLQ&7>L@
(FULUH/HVGHX[YDOHXUVPLQLPDOHVVRQW
6LPLQPLQ(FULUHPLQPLQ
6LQRQ(FULUHPLQPLQ
)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ 
^
LQW7>@
LQWPLQPLQL
SULQWI'RQQH]OHVpOpPHQWVGXWDEOHDX?Q
IRUL L LVFDQIG 7>L@
PLQ 7>@
PLQ 7>@
IRUL L L
LIPLQ!PLQ^LIPLQ!7>L@PLQ 7>L@`
HOVHLIPLQ!7>L@PLQ 7>L@
SULQWI/HVGHX[YDOHXUVPLQLPDOHVVRQW?Q
LIPLQPLQSULQWIGGPLQPLQ
HOVHSULQWIGGPLQPLQ
`
Solution 6 :
Algorithme :
$OJRULWKPH6RPPHBWDE
9DULDEOHV
(QWLHU7>@7>@7>@
(QWLHUL
'pEXW
(FULUH'RQQH]OHVpOpPHQWVGXLHUWDEOHDX
3RXUL&L L&L/LUH7>L@
(FULUH'RQQH]OHVpOpPHQWVGXLqPHWDEOHDX
3RXUL&L L&L/LUH7>L@
3RXUL&L L&L7>L@&7>L@7>L@
(FULUH9RLFLOHWDEOHDX6RPPH

ϭϭϰ

Les tableaux et les chaînes de caractères .

3RXUL&L L&L(FULUH7>L@

)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ 
^
LQW7>@7>@7>@
LQWL
SULQWI'RQQH]OHVpOpPHQWVGXLHUWDEOHDX?Q
IRUL L LVFDQIG 7>L@
SULQWI'RQQH]OHVpOpPHQWVGXLqPHWDEOHDX?Q
IRUL L LVFDQIG 7>L@
IRUL L L7>L@ 7>L@7>L@
SULQWI9RLFLOHWDEOHDX6RPPH?Q
IRUL L LSULQWIG?Q7>L@
`
Solution 7 :
Algorithme :
$OJRULWKPH1RPEUHVBFRQVHFXWLIV
9DULDEOHV
(QWLHU7>@
(QWLHUL
%RROpHQ&RQV
'pEXW
(FULUH(QWUH]OHVYDOHXUV
3RXUL&L L&LGpEXW
(FULUH(QWUH]OHQRPEUHQƒL
/LUH7>L@
ILQ
&RQV&95$,
3RXUL&L L&L
6L7>L@!7>L@±&RQV&)$8;
6L&RQV(FULUH/HVQRPEUHVVRQWFRQVpFXWLIV
6LQRQ(FULUH/HVQRPEUHVQHVRQWSDVFRQVpFXWLIV
)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ 
^
LQW7>@
LQWL
LQW&RQV
SULQWI(QWUH]OHVYDOHXUV?Q
IRUL L L^
SULQWI(QWUH]OHQRPEUHQƒGL
VFDQIG 7>L@
`
&RQV 

ϭϭϱ

Les tableaux et les chaînes de caractères .

IRUL L L

LI7>L@ 7>L@&RQV 
LI&RQVSULQWI/HVQRPEUHVVRQWFRQVpFXWLIV
HOVHSULQWI/HVQRPEUHVQHVRQWSDVFRQVpFXWLIV
`
Cette solution est sans doute la plus spontanée, mais elle présente le défaut
d¶examiner la totalité du tableau, même lorsqu¶on découvre dès le départ deux
éléments non consécutifs. Aussi, dans le cas d¶un grand tableau, cette solution
est coûteuse en temps de traitement. Une autre manière de procéder serait de
sortir de la boucle dès que deux éléments non consécutifs sont détectés, et ceci
en remplaçant la deuxième boucle 3RXU par la boucle 7DQWTXH suivante :
L&
7DQWTXH&RQV(7L 
6L7>L@!7>L@±&RQV&)$8;
6LQRQL&L
En C :
L 
ZKLOH&RQV L 
LI7>L@ 7>L@&RQV 
HOVHL L
Solution 8 :
Algorithme :
$OJRULWKPH)LERQDFFL
&RQVWDQWHV
PD[ 
9DULDEOHV
(QWLHUILER>PD[@
(QWLHUQL
'pEXW
(FULUH'RQQH]XQHQWLHU
/LUHQ
6LQ PD[GpEXW
ILER>@&
ILER>@&
3RXUL&L QL&L
ILER>L@&ILER>L@ILER>L@
(FULUH)LERQDFFLQ ILER>Q@
ILQ
)LQ
Programme C :
LQFOXGHVWGLRK!
GHILQHPD[
PDLQ 
^
LQWILER>PD[@
LQWQL
SULQWI'RQQH]XQHQWLHU
ϭϭϲ

Les tableaux et les chaînes de caractères .

VFDQIG Q

LIQ PD[^
ILER>@ 
ILER>@ 
IRUL L PD[LILER>L@ ILER>L@ILER>L@
SULQWI)LERQDFFLG GQILER>Q@
`
`
Solution 9 :
Algorithme :
$OJRULWKPH6XSSULPHUBHOHPHQWBWDE
9DULDEOHV
(QWLHU7>@
(QWLHULM
'pEXW
(FULUH6DLVLUOHVpOpPHQWVG
XQWDEOHDXGHGL[HQWLHUV
3RXUL&L L&L/LUH7>L@
(FULUHΗŽŶŶĞnjůĂƉŽƐŝƚŝŽŶĚĞů[ĠůĠŵĞŶƚăƐƵƉƉƌŝŵĞƌ;ƉƌŝƐĞĞŶƚƌĞϬĞƚϵͿ͗Η
/LUHM
3RXUL&ML L&L7>L@&7>L@
7>@&
(FULUHΗ>ĞƐĠůĠŵĞŶƚƐĚƵƚĂďůĞĂƵĂƉƌğƐůĂƐƵƉƉƌĞƐƐŝŽŶĚĞů[ĠůĠŵĞŶƚŶƵŵΗ͕ũ
3RXUL&L L&L(FULUH7>L@
)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ 
^
LQW7>@
LQWLM
SULQWI6DLVLUOHVpOpPHQWVG
XQWDEOHDXGHGL[HQWLHUV?Q
IRUL L LVFDQIG 7>L@
SULQWIΗŽŶŶĞnjůĂƉŽƐŝƚŝŽŶĚĞů[ĠůĠŵĞŶƚăƐƵƉƉƌŝŵĞƌ;ƉƌŝƐĞĞŶƚƌĞϬĞƚϵͿ͗Η
VFDQIG M
IRUL ML L7>L@ 7>L@
7>@ 
SULQWIΗ>ĞƐĠůĠŵĞŶƚƐĚƵƚĂďůĞĂƵĂƉƌğƐůĂƐƵƉƉƌĞƐƐŝŽŶĚĞů[ĠůĠŵĞŶƚŶƵŵйĚͰŶΗ͕ũ
IRUL L LSULQWIG?Q7>L@
`
Solution 10 :
Algorithme :
$OJRULWKPHNBSUHPLHUV
&RQVWDQWHVN 
9DULDEOHV
(QWLHU7>N@
(QWLHULQELQG
%RROpHQ3UHPLHU
'pEXW
ϭϭϳ

Les tableaux et les chaînes de caractères .

LQG&
QE&
7DQWTXHLQGNGpEXW
3UHPLHU&95$,
L&
7DQWTXHLQE(73UHPLHU
6LQEL!3UHPLHU&)$8;
6LQRQL&L
6L3UHPLHUGpEXW
7>LQG@&QE
LQG&LQG
ILQ
QE&QE
ILQ
(FULUH/HVNSUHPLHUVQRPEUHVSUHPLHUVVRQW
3RXUL&L NL&L(FULUH7>L@
)LQ
Programme C :
LQFOXGHVWGLRK!
GHILQHN
PDLQ^
LQW7>N@
LQWLQELQG
LQW3UHPLHU
LQG 
QE 
ZKLOHLQGN^
3UHPLHU 
L 
ZKLOHLQE 3UHPLHU
LIQEL 3UHPLHU 
HOVHL L
LI3UHPLHU^
7>LQG@ QE
LQG LQG
`
QE QE
`
SULQWI/HVGSUHPLHUVQRPEUHVSUHPLHUVVRQW?QN
IRUL L NLSULQWIG?Q7>L@
`
Solution 11 :
Algorithme :
$OJRULWKPH,QLWBPDWULFH
9DULDEOHV
(QWLHU7>@>@
(QWLHULM
'pEXW
3RXUL&L L&L
ϭϭϴ

Les tableaux et les chaînes de caractères .

3RXUM&M M&M7>L@>M@&

(FULUH9RLFLODPDWULFHLQLWLDOLVpH
3RXUL&L L&L
3RXUM&M M&M(FULUH7>L@>M@
)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ 
^
LQW7>@>@
LQWLM
IRUL L L
IRUM M M7>L@>M@ 
SXWV9RLFLODPDWULFHLQLWLDOLVpH
IRUL L L^
IRUM M MSULQWIG7>L@>M@
SULQWI?Q
`
`
Solution 12 :
Cet algorithme remplit un tableau d¶entiers à deux dimensions 4*2, de la
manière suivante :
7>@   7>@   7>@   7>@   7>@ 
7>@ 7>@ 7>@ 
Le tableau7peut être représenté donc comme suit :
  
  
  
  
  
Solution 13 :
Algorithme :
$OJRULWKPH1EUBDSS
9DULDEOHV
(QWLHU7>@>@
(QWLHULM[QE
'pEXW
(FULUH'RQQH]OHVYDOHXUVGHODPDWULFH
3RXUL&L L&L
3RXUM&M M&M/LUH7>L@>M@
(FULUHΗŽŶŶĞnjůĂǀĂůĞƵƌĚŽŶƚǀŽƵƐĚĠƐŝƌĞnjĐĂůĐƵůĞƌůĞŶŽŵďƌĞĚΖĂƉƉĂƌŝƚŝŽŶ͗Η
/LUH[
QE&
3RXUL&L L&L
3RXUM&M M&M
6L[ 7>L@>M@$ORUVQE&QE
(FULUHΗ>ĞŶŽŵďƌĞĚΖĂƉƉĂƌŝƚŝŽŶĚĞůĂǀĂůĞƵƌΗ͕dž͕ΗĚĂŶƐůĂŵĂƚƌŝĐĞĞƐƚсΗ͕Ŷď
ϭϭϵ

Les tableaux et les chaînes de caractères .

)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ 
^
LQW7>@>@
LQWLM[QE
SULQWI'RQQH]OHVYDOHXUVGHODPDWULFH?Q
IRUL L LIRUM M MVFDQIG 7>L@>M@
SULQWIΗŽŶŶĞnjůĂǀĂůĞƵƌĚŽŶƚǀŽƵƐĚĠƐŝƌĞnjĐĂůĐƵůĞƌůĞŶŽŵďƌĞĚΖĂƉƉĂƌŝƚŝŽŶ͗Η
VFDQIG [
QE 
IRUL L L
IRUM M MLI[ 7>L@>M@QE QE
SULQWIΗ>ĞŶŽŵďƌĞĚΖĂƉƉĂƌŝƚŝŽŶĚĞůĂǀĂůĞƵƌйĚĚĂŶƐůĂŵĂƚƌŝĐĞĞƐƚсйĚΗ͕dž͕Ŷď
`
Solution 14 :
Algorithme :
$OJRULWKPH7UDQVSRVHHBPDWULFH
9DULDEOHV
(QWLHU7>@>@
(QWLHULM[
'pEXW
(FULUH'RQQH]OHVpOpPHQWVGHODPDWULFH
3RXUL&L L&L
3RXUM&M M&M/LUH7>L@>M@
(FULUH0DWULFHLQLWLDOH
3RXUL&L L&L
3RXUM&M M&M(FULUH7>L@>M@
3RXUL&L L&L
3RXUM&LM M&MGpEXW
[&7>L@>M@
7>L@>M@&7>M@>L@
7>M@>L@&[
ILQ
(FULUH0DWULFHWUDQVSRVpH
3RXUL&L L&L
3RXUM&M M&M(FULUH7>L@>M@
)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ 
^
LQW7>@>@
LQWLM[
SULQWI'RQQH]OHVpOpPHQWVGHODPDWULFH?Q
IRUL L LIRUM M MVFDQIG 7>L@>M@
SULQWI0DWULFHLQLWLDOH?Q
ϭϮϬ

Les tableaux et les chaînes de caractères .

IRUL L L^

IRUM M MSULQWIG7>L@>M@
SULQWI?Q
`
IRUL L LIRUM LM M
^
[ 7>L@>M@
7>L@>M@ 7>M@>L@
7>M@>L@ [
`
SULQWI0DWULFHWUDQVSRVpH?Q
IRUL L L^
IRUM M MSULQWIG7>L@>M@
SULQWI?Q
`
`
Solution 15 :
Algorithme :
$OJRULWKPHSURGXLWBPDWULFLHO
9DULDEOHV
(QWLHUPDWPDWSURGXLW>@>@
(QWLHULMN[V
'pEXW
(FULUH'RQQH]OHVpOpPHQWVGHODSUHPLqUHPDWULFH
3RXUL&L L&L
3RXUM&M M&M/LUHPDW>L@>M@
(FULUH'RQQH]OHVpOpPHQWVGHODGHX[LqPHPDWULFH
3RXUL&L L&L
3RXUM&M M&M/LUHPDW>L@>M@
3RXUL&L L&L
3RXUM&M M&MGpEXW
V&
3RXUN&N N&NV&VPDW>L@>N@ PDW>N@>M@
SURGXLW>L@>M@&V
ILQ
(FULUH5pVXOWDWGXSURGXLWPDWULFLHO
3RXUL&L L&L
3RXUM&M M&M(FULUHSURGXLW>L@>M@
)LQ
Programme C :
LQFOXGHVWGLRK!
PDLQ 
^
LQWPDW>@>@PDW>@>@SURGXLW>@>@
LQWLMN[V
SULQWI'RQQH]OHVpOpPHQWVGHODSUHPLqUHPDWULFH?Q
IRUL L L
IRUM M MVFDQIG PDW>L@>M@
SULQWI'RQQH]OHVpOpPHQWVGHODGHX[LqPHPDWULFH?Q
ϭϮϭ

Les tableaux et les chaînes de caractères .

IRUL L L

IRUM M MVFDQIG PDW>L@>M@
IRUL L LIRUM M M^
V 
IRUN N NV VPDW>L@>N@ PDW>N@>M@
SURGXLW>L@>M@ V
`
SULQWI5pVXOWDWGXSURGXLWPDWULFLHO?Q
IRUL L L
IRUM M MSULQWIG?QSURGXLW>L@>M@
`
Solution 16 :
Programme C :
LQFOXGHVWGLRK!
LQFOXGHVWGOLEK!
PDLQ^
 FDUDFWqUHVGHILQGHFKDvQH 
FKDUWDE>@
LQWL  FRPSWHXU 
 5HPSOLVVDJHGXWDEOHDXDYHFOHVFDUDFWqUHV 
IRUL L L
WDE>L@ LRXWDE>L@
$
L
 $MRXWGXGHILQGHFKDvQH 
WDE>@ 
 $IILFKDJHGHODFKDvQH 
SULQWIWDEV?QWDE
 6DXWG
XQHDXWUHOLJQH 
SULQWI?Q
 $IILFKDJHGHFKDFXQGHVFDUDFWqUHV 
IRUL LL
SULQWI&DUDFWqUHQXPpURGF?QLWDE>L@
`
Solution 17 :
Le programme affiche :
9HXLOOH]HQWUHUYRWUHFKDvQHGHFDUDFWqUHVVFLHQFH
FKDvQHYDXWVFLHQFH
9HXLOOH]HQWUHUYRWUHFKDvQHGHFDUDFWqUHVLQIRUPDWLTXH
FKDvQHYDXW$KPHGLQIRUPDWLTXH0RKDPHG$OL

Solution 18 :
Programme C :
LQFOXGHVWGLRK!
LQFOXGHVWULQJK! 
PDLQ 
^
FKDU&+>@&+>@
SULQWI'RQQH]ODSUHPLqUHFKDvQH
JHWV&+
ϭϮϮ

Les tableaux et les chaînes de caractères .

SULQWI'RQQH]ODGHX[LqPHFKDvQH

JHWV&+
LIVWUFPS&+&+ SULQWIVV&+&+
HOVHSULQWIVV&+&+
`
Solution 19 :
Programme C :
LQFOXGHVWGLRK!
LQFOXGHVWULQJK! 
PDLQ 
^
FKDU&+>@
FKDU&
LQWQEL
SULQWI'RQQH]XQHFKDvQHGHFDUDFWqUHVPD[LPXP
JHWV&+
SULQWI(QWUH]XQFDUDFWqUH
VFDQIF &
QE 
IRUL L VWUOHQ&+LLI&+>L@ &QE QE
SULQWIΗ>ĞĐĂƌĂĐƚğƌĞйĐĞƐƚĂƉƉĂƌƵйĚĨŽŝƐĚĂŶƐůĂĐŚĂŠŶĞйƐ͘Η͕͕Ŷď͕,
`
Solution 20 :
Programme C :
LQFOXGHVWGLRK!
PDLQ^
FKDUFKDLQH>@
LQWLM
SXWV'RQQH]XQHFKDvQHGHFDUDFWqUHV
JHWVFKDLQH
L 
ZKLOHFKDLQH>L@ 
?

LIFKDLQH>L@ 
H

IRUM LFKDLQH>M@ 
?
MFKDLQH>M@ FKDLQH>M@
HOVHL L
SXWVΗsŽŝĐŝůĂĐŚĂŠŶĞĂƉƌğƐůĂƐƵƉƉƌĞƐƐŝŽŶĚƵĐĂƌĂĐƚğƌĞΖĞΖ͗Η
SXWVFKDLQH
`
Solution 21 :
Programme C :
LQFOXGHVWGLRK!
LQFOXGHVWULQJK!
PDLQ^
FKDUFKDLQH>@
LQWL
SXWV'RQQH]XQHFKDvQHGHFDUDFWqUHV
JHWVFKDLQH
SXWV/DYRLFLDIILFKpHjO
HQYHUV
ϭϮϯ

Les tableaux et les chaînes de caractères .

IRUL VWUOHQFKDLQHL! L

SULQWIFFKDLQH>L@
`
Solution 22 :
Programme C :
LQFOXGHVWGLRK!
PDLQ^
FKDUFKDLQH>@
LQWLV
SULQWI'RQQH]XQHFKDvQHGHFDUDFWqUHV
JHWVFKDLQH
V 
IRUL L VWUOHQFKDLQHLV VFKDLQH>L@
SULQWI/DVRPPHGHVFRGHV$6&,, GV
`
Solution 23 :
Programme C :
LQFOXGHVWGLRK!
LQFOXGHVWULQJK!
PDLQ^
FKDUYHUEH>@FK>@
VWUFS\FK
SULQWI'RQQH]XQYHUEHGXSUHPLHUJURXSH
JHWVYHUEH
VWUQFDWFKYHUEHVWUOHQYHUEH
SULQWIΗŽŶũƵŐĂŝƐŽŶĚƵǀĞƌďĞйƐĂƵƉƌĠƐĞŶƚĚĞůΖŝŶĚŝĐĂƚŝĨ͗ͰŶΗ͕ǀĞƌďĞ
SULQWI-HVH?QFK
SULQWI7XVHV?QFK
SULQWI,O(OOHVH?QFK
SULQWI1RXVVRQV?QFK
SULQWI9RXVVH]?QFK
SULQWI,OV(OOHVVHQW?QFK
`
Avec le verbe VDXWHU, le programme affiche :
'RQQH]XQYHUEHGXSUHPLHUJURXSHVDXWHU
&RQMXJDLVRQGXYHUEHVDXWHUDXSUpVHQWGHO
LQGLFDWLI
-HVDXWH
7XVDXWHV
,O(OOHVDXWH
1RXVVDXWRQV
9RXVVDXWH]
,OV(OOHVVDXWHQW

Solution 24 :
Programme C :
ϭϮϰ

Les tableaux et les chaînes de caractères .

LQFOXGHVWGLRK!
LQFOXGHFW\SHK!
LQFOXGHVWULQJK!
PDLQ
^
FKDUPRWV>@>@
LQWLM
FKDU&+>@
/LUHOHVFKDvQHVGHFDUDFWqUHV
IRUL L L^
SULQWI'RQQH]OHPRWQƒGL
JHWVPRWV>L@
`
&RQYHUWLUOHVPRWVHQPDMXVFXOHV
IRUL L L
IRUM PRWV>L@>M@ 
?
M
PRWV>L@>M@ WRXSSHUPRWV>L@>M@ 'DQVODFRQGLWLRQGH
ODERXFOHIRURQSHXWPHWWUHM VWUOHQPRWV>L@ 
7ULHUOHVFKDvQHVSDURUGUHDOSKDEpWLTXH
IRUL L L
IRUM LM M
LIVWUFPSPRWV>L@PRWV>M@ ^
VWUFS\&+PRWV>L@
VWUFS\PRWV>L@PRWV>M@
VWUFS\PRWV>M@&+
`
$IILFKHUODOLVWHGHVPRWVWULpV
SULQWI9RLFLODOLVWHGHVPRWVDSUqVOHWUL?Q
IRUL L LSXWVPRWV>L@
`
Solution 25 :
LQFOXGHVWGLRK!
LQFOXGHVWULQJK!
PDLQ
^
FKDU7>@>@
LQWL
SULQWI6DLVLUOHVFKDvQHVGHFDUDFWqUHV?Q
IRUL L LVFDQIV7>L@
SULQWI/HVGHUQLHUVFDUDFWqUHVGHVFKDvQHV?Q
IRUL L L
SULQWIΗ>ĞĚĞƌŶŝĞƌĐĂƌĂĐƚğƌĞĚĞůĂĐŚĂŠŶĞйƐĞƐƚйĐͰŶΗ͕d΀ŝ΁͕d΀ŝ΁΀ƐƚƌůĞŶ;d΀ŝ΁ͿͲϭ΁
`

ϭϮϱ

Les sous-programmes : Procédures et Fonctions .

Chapitre 6 : Les sous-programmes : Procédures et Fonctions

1. Introduction
Pour avoir des programmes fiables, lisibles et faciles à maintenir, il faut les
réduire et les organiser en utilisant les sous-programmes. Ces derniers
permettent donc :
1.Réduction de la taille des programmes : Il est possible de déterminer les
blocs analogues, les substituer par un sous-programme, ensuite appeler le
sous-programme par son nom, dans des points d¶appel au niveau du
programme appelant (Programme Principal).
Soit le programme C suivant :
LQFOXGHVWGLRK!
PDLQ
^
LQW[\V
 EORF 
SULQWI'RQQH]ODSUHPLqUHYDOHXU
VFDQIG [
SULQWI'RQQH]ODGHX[LqPHYDOHXU
VFDQIG \
V [\
SULQWI/DVRPPH G?QV
 EORF 
SULQWI'RQQH]ODSUHPLqUHYDOHXU
VFDQIG [
SULQWI'RQQH]ODGHX[LqPHYDOHXU
VFDQIG \
V [\
SULQWI/DVRPPH G?QV
`
Pour réduire le code de ce programme, il est possible d¶utiliser un sous-
programme (dans cet exemple une procédure) comme suit :
LQFOXGHVWGLRK!
LQW[\V
YRLGVRPPH'pILQLWLRQGHODSURFpGXUH
^
SULQWI'RQQH]ODSUHPLqUHYDOHXU
VFDQIG [
SULQWI'RQQH]ODGHX[LqPHYDOHXU
VFDQIG \
V [\
SULQWI/DVRPPH G?QV 
`
PDLQ3URJUDPPH3ULQFLSDO
^
VRPPH3RLQWG¶DSSHO
ϭϮϲ

Les sous-programmes : Procédures et Fonctions .

VRPPH3RLQWG¶DSSHO
`
Notons ici que les variables ont été déplacées avant la procédure pour
qu¶elles soient accessibles aussi bien au niveau de la procédure qu¶au
niveau du programme principal.
2.Organisation du code : Le problème initial sera découpé en sous-
problèmes. Chaque sous-problème sera résolu par un sous-programme.
Soit le programme C suivant :
LQFOXGHVWGLRK!
PDLQ
^
LQW[\VSG
SULQWI'RQQH]ODSUHPLqUHYDOHXU
VFDQIG [
SULQWI'RQQH]ODGHX[LqPHYDOHXU
VFDQIG \
V [\
SULQWI/DVRPPH G?QV
S [ \
SULQWI/HSURGXLW G?QS
G [\
SULQWI/DGLIIpUHQFH G?QG
`
Pour plus d¶organisation, il est possible de subdiviser le problème en trois
sous-problèmes (addition, multiplication et soustraction). Chaque sous-
problème sera résolu par un sous-programme (procédure, dans cet
exemple). On obtient le programme suivant :
LQFOXGHVWGLRK!
LQW[\VSG
YRLGVRPPH
^
V [\
SULQWI/DVRPPH G?QV
`
YRLGSURGXLW
^
S [ \
SULQWI/HSURGXLW G?QS
`
YRLGGLIIHUHQFH
^
G [\
SULQWI/DGLIIpUHQFH G?QG
`
PDLQ3URJUDPPH3ULQFLSDO
^
SULQWI'RQQH]ODSUHPLqUHYDOHXU
ϭϮϳ

Les sous-programmes : Procédures et Fonctions .

VFDQIG [

SULQWI'RQQH]ODGHX[LqPHYDOHXU
VFDQIG \
VRPPH
SURGXLW
GLIIHUHQFH
`
Remarque : Dans ce cas-là, on utilise souvent le terme module au lieu de sous-
programme, et on parle de la programmation modulaire.
2. Les sous-programmes
Un sous-programme est un petit programme composé d¶un en-tête, d¶une partie
données et d¶une partie instructions. Le programme de calcul de la somme peut
être écrit comme suit :
LQFOXGHVWGLRK!
YRLGVRPPH
^
LQW[\V
SULQWI'RQQH]ODSUHPLqUHYDOHXU
VFDQIG [
SULQWI'RQQH]ODGHX[LqPHYDOHXU
VFDQIG \
V [\
SULQWI/DVRPPH G?QV 
`
PDLQ
^
VRPPH
VRPPH
`
Un sous-programme avec paramètres :
Dans le cas où on a des blocs qui se ressemblent en termes d¶instructions, mais
ils utilisent des variables différentes, on peut utiliser un sous-programme avec
des paramètres (arguments).
Soit le programme C suivant :
LQFOXGHVWGLRK!
PDLQ
^
LQW[\]KV
SULQWI'RQQH]ODSUHPLqUHYDOHXU
VFDQIG [
SULQWI'RQQH]ODGHX[LqPHYDOHXU
VFDQIG \
V [\
SULQWI/DVRPPH G?QV
SULQWI'RQQH]GHX[YDOHXUV?Q
VFDQIGG ] K
V ]K
ϭϮϴ

Les sous-programmes : Procédures et Fonctions .

SULQWI/DVRPPH G?QV

`
Pour réduire le code de ce programme, il est possible d¶utiliser un sous-
programme (procédure, dans cet exemple) avec deux paramètres. On obtient
alors le programme suivant :
LQFOXGHVWGLRK!
LQW[\]KV
YRLGVRPPHLQWDLQWE
^
V DE
SULQWI/DVRPPH G?QV 
`
PDLQ
^
SULQWI'RQQH]ODSUHPLqUHYDOHXU
VFDQIG [
SULQWI'RQQH]ODGHX[LqPHYDOHXU
VFDQIG \
VRPPH[\
SULQWI'RQQH]GHX[YDOHXUV?Q
VFDQIGG ] K
VRPPH]K
`
Les paramètres sont indiqués entre parenthèses et séparés par des virgules. Pour
chacun, on doit préciser le type et le nom. Dans le cas d¶absence de paramètres,
les parenthèses doivent être mises vides.
La déclaration : YRLGVRPPHLQWDE n¶est pas acceptée.
Les paramètres [, \ et ], K sont dits effectifs, fournis lors de l¶invocation du
sous-programme. Les paramètres D, E sont dits formels, apparaissant lors de la
déclaration du sous-programme.
Les paramètres formels et effectifs d¶un même sous-programme, dans le même
programme, doivent être de même nombre, tout en respectant l¶ordre des types
des paramètres.
Types de sous-programmes :
Il existe deux types de sous-programmes : Procédures et Fonctions.
Les procédures : Une procédure est un ensemble d¶instructions regroupées
sous un nom, et qui réalise un traitement particulier dans un programme
lorsqu¶on l¶appelle (effet de bord).
En C, une procédure est appelée directement dans un programme par son nom.
En C, l¶en-tête de la procédure comporte le nom de la procédure précédé par le
mot clé YRLG, et suivi éventuellement de paramètres mises entre parenthèses.
Ensuite, nous avons le corps de la procédure qui est un bloc d¶instructions
implémentant le traitement réalisé par cette procédure.

ϭϮϵ

Les sous-programmes : Procédures et Fonctions .

Les fonctions : Une fonction est un sous-programme qui retourne un et un seul

résultat au programme appelant.
En C, le point d¶appel d¶une fonction apparaît souvent dans une expression
(partie droite d¶une affectation, dans un SULQWI ou dans une condition), mais
il est possible d¶appeler une fonction directement comme s¶il s¶agit d¶une
procédure.
En C, l¶en-tête de la fonction comporte le nom de la fonction précédé par son
type, et suivi éventuellement de paramètres mises entre parenthèses. Ensuite,
nous avons le corps de la fonction. A l¶intérieur du corps de la fonction, le mot
clé UHWXUQ est suivi du résultat retourné par cette fonction. Le résultat peut être
une simple valeur ou toute une expression. UHWXUQ interrompe la fonction et
rend la main au programme appelant.
Remarques :
xSi le type d¶un sous-programme n¶est pas indiqué, le compilateur suppose
qu¶il s¶agit d¶une fonction à résultat entier.
xL¶expression après UHWXUQ doit être de même type que la fonction. La
même chose pour les paramètres effectifs qui doivent être de mêmes types
que les paramètres formels. Si ces deux règles ne sont pas respectées, le
compilateur C ne déclare pas une erreur, mais ceci peut mener à des
résultats inattendus ou erronés.
xSi on ne met pas un UHWXUQ dans une fonction, le compilateur C ne déclare
pas une erreur, mais ceci peut mener à des résultats inattendus ou erronés.
xSi vous trouvez dans un autre document l¶écriture YRLGPDLQ, ne vous en
faites pas, c¶est juste pour dire que le programme principal se comporte
comme une procédure.
Le programme C suivant permet de calculer la somme de deux valeurs lues à
partir du clavier en utilisant une fonction :
LQFOXGHVWGLRK!
LQW[\V
LQWVRPPH'pILQLWLRQGHODIRQFWLRQ
^LQWVP
VP [\
UHWXUQVP KŶƉĞƵƚŵĞƚƚƌĞĚŝƌĞĐƚĞŵĞŶƚƌĞƚƵƌŶdžнLJ͖ĞƚƉĂƌĐŽŶƐĠƋƵĞŶƚ
ĞŶůĞǀĞƌůĂĚĠĐůĂƌĂƚŝŽŶŝŶƚƐŵ͖Ğƚů[ŝŶƐƚƌƵĐƚŝŽŶƐŵсdžнLJ͖ 
`
PDLQ3URJUDPPH3ULQFLSDO
^
SULQWI'RQQH]ODSUHPLqUHYDOHXU
VFDQIG [
SULQWI'RQQH]ODGHX[LqPHYDOHXU
VFDQIG \
V VRPPH
SULQWI/DVRPPH G?QV KŶƉĞƵƚŵĞƚƚƌĞĚŝƌĞĐƚĞŵĞŶƚ
ϭϯϬ

Les sous-programmes : Procédures et Fonctions .

ƉƌŝŶƚĨ;Η>ĂƐŽŵŵĞсйĚͰŶΗ͕ƐŽŵŵĞ;ͿͿ͖ĞƚƉĂƌĐŽŶƐĠƋƵĞŶƚĞŶůĞǀĞƌůĂ
ĚĠĐůĂƌĂƚŝŽŶĚĞůĂǀĂƌŝĂďůĞƐĞƚů[ŝŶƐƚƌƵĐƚŝŽŶƐсƐŽŵŵĞ;Ϳ͖ 
`
Le mot clé UHWXUQ à la fin de la fonction permet de retourner le résultat de la
fonction.
Voyons un deuxième exemple montrant une fonction avec des paramètres :
LQFOXGHVWGLRK!
LQW6XSLQWDLQWE
^LQW[
LID!E[ 
HOVH[ 
UHWXUQ[
`
PDLQ
^
LQW[\
SULQWI'RQQH]ODSUHPLqUHYDOHXUVFDQIG [
SULQWI'RQQH]ODGHX[LqPHYDOHXUVFDQIG \
LI6XS[\SULQWIGHVWVXSpULHXUHjG[\
HOVHSULQWIGHVWVXSpULHXUHjG\[
`
Ce programme permet de comparer deux nombres entiers en indiquant quelle
est la valeur supérieure.
La fonction 6XS du programme précédent peut être écrite comme suit :
LQW6XSLQWDLQWE
^
LID!EUHWXUQ
HOVHUHWXUQ
`
Remarques :
xSi on appelle une fonction directement comme une procédure, sans qu¶elle
figure dans une expression, le compilateur C ne déclare pas une erreur.
Dans ce cas, le traitement lié à la fonction sera effectué, mais le résultat
retourné par la fonction ne sera pas utilisé. Si on fait le contraire, i.e. on
invoque une procédure dans une expression, cette fois-ci le compilateur
déclare une erreur, et n¶exécute pas le programme.
xMalgré qu¶elle soit souvent appelée directement comme une procédure,
SULQWI est une fonction entière appartenant à la bibliothèque VWGLRK, et
qui retourne le nombre de caractères affiché en cas de succès, ou bien une
valeur négative en cas d¶échec. VFDQI, elle aussi, est une fonction qui
retourne le nombre de variables affectées par la saisie en cas de succès, ou
bien (2) (qui a généralement la valeur ) en cas d¶echec de lecture.

ϭϯϭ

Les sous-programmes : Procédures et Fonctions .

En C, il existe aussi plusieurs fonctions appartenant à la bibliothèque PDWKK

permettant de faire des calculs mathématiques, telles que SRZ, VTUW, FRV, VLQ,
WDQ, etc.
La fonction DEV appartient à la bibliothèque VWGOLEK.
Le programme C suivant affiche : /DYDOHXUDEVROXHGH 
LQFOXGHVWGLRK!
LQFOXGHVWGOLEK!
PDLQ
^
SULQWI/DYDOHXUDEVROXHGH G?QDEV
`
Exercice : Ecrire votre propre fonction DEV. Nommez la $EVROXH. La fonction
$EVROXH doit retourner la valeur absolue d¶un paramètre entier.
Solution :
LQFOXGHVWGLRK!
LQW$EVROXHLQWD^
LIDD D
UHWXUQD
`
PDLQ
^LQW[
SULQWI'RQQH]XQHYDOHXU
VFDQIG [
SULQWI/DYDOHXUDEVROXHGHGHVWG?Q[$EVROXH[
`
Fichier d¶en-tête (bibliothèque) :
Nous avons souvent utilisé dans ce cours le terme bibliothèque pour référencer
les fichiers d¶en-tête (header file), tels que VWGLRK, PDWKK, etc. En fait, une
bibliothèque n¶est rien d¶autre qu¶un ensemble de fonctions et/ou procédures
stockées dans un fichier (K) qui est invoqué en tant que fichier d¶en-tête
(header file) dans un programme C.
Ci-dessous, un exemple de création d¶une bibliothèque en C :
1. Ecrire le code :
LQW6RPPHLQW[LQW\
^
 UHWXUQ[\
`
LQW'LIIHUHQFHLQW[LQW\
^
 UHWXUQ[\
`
2. Sauvegardez le fichier sous le nom Operations.h, pour dire que c¶est un
header file.
3. Dans le même répertoire, écrire le programme C :
LQFOXGHVWGLRK!
ϭϯϮ

Les sous-programmes : Procédures et Fonctions .

LQFOXGH2SHUDWLRQVKƉƉĞůĚĞůĂďŝďůŝŽƚŚğƋƵĞKƉĞƌĂƚŝŽŶƐ͘Ś
PDLQ
^
LQW[\
SULQWI'RQQH]ODSUHPLqUHYDOHXU
VFDQIG [
SULQWI'RQQH]ODGHX[LqPHYDOHXU
VFDQIG \
SULQWI6RPPH G?Q6RPPH[\
SULQWI'LIIHUHQFH G'LIIHUHQFH[\ 
`
4. Sauvegarder, compiler et exécuter votre programme.
Remarque : L¶appel de la bibliothèque au niveau du programme a été fait par
LQFOXGH2SHUDWLRQVK pour dire qu¶il s¶agit d¶un fichier d¶en-tête du
répertoire courant. Pour appeler le fichier par LQFOXGH2SHUDWLRQVK!, il
faut le sauvegarder dans le répertoire où le compilateur C stocke ce genre de
fichiers.
Appel d¶un sous-programme :
Contrairement à d¶autres langages, en C, on ne peut pas définir un sous-
programme à l¶intérieur d¶un autre. Tous les sous-programmes sont au même
niveau, c¶est-à-dire que chaque sous-programme peut appeler un autre, comme
c¶est le cas dans l¶exemple suivant :
LQFOXGHVWGLRK!
LQWVRPPHLQWDLQWE)RQFWLRQDSSHOpH
^
UHWXUQDE
`
YRLGDIILFKDJHLQWHLQWI3URFpGXUHDSSHODQWH
^
SULQWIGG G?QHIVRPPHHI
SULQWIG G G?QHISURGXLWHI
`
LQWSURGXLWLQWFLQWG)RQFWLRQDSSHOpH
^
UHWXUQF G
`
PDLQ3URJUDPPH3ULQFLSDO
^
LQW[\
SULQWI'RQQH]ODSUHPLqUHYDOHXU
VFDQIG [
SULQWI'RQQH]ODGHX[LqPHYDOHXU
VFDQIG \
DIILFKDJH[\
`

ϭϯϯ

Les sous-programmes : Procédures et Fonctions .

En C, un sous-programme peut être appelé alors qu¶il est défini ultérieurement,

i.e. défini après le sous-programme appelant. Comme c¶est le cas dans le
programme précédent là où la procédure appelante DIILFKDJH appelle la
procédure appelée SURGXLW. Il ne faut pas oublier les parenthèses quand on
appelle un sous-programme, sinon cela provoque une erreur de compilation.
Déclaration et définition d¶un sous-programme :
Si maintenant un sous-programme est défini après le programme principal
(PDLQ), alors il doit être déclaré comme montré dans l¶exemple suivant :
LQFOXGHVWGLRK!
YRLGDIILFKHUBVRPPHLQWHLQWI ĠĐůĂƌĂƚŝŽŶĚĞůĂƉƌŽĐĠĚƵƌĞ͕ŝ͘Ğ͕͘
ŵĞƚƚƌĞƐĞƵůĞŵĞŶƚů[ĞŶͲƚġƚĞĚĞůĂƉƌŽĐĠĚƵƌĞƐƵŝǀŝĚ[ƵŶƉŽŝŶƚͲǀŝƌŐƵůĞ 
PDLQ3URJUDPPH3ULQFLSDO
^
LQW[\
SULQWI'RQQH]ODSUHPLqUHYDOHXU
VFDQIG [
SULQWI'RQQH]ODGHX[LqPHYDOHXU
VFDQIG \
DIILFKHUBVRPPH[\$SSHOGHODSURFpGXUH
`
YRLGDIILFKHUBVRPPHLQWHLQWI ĠĨŝŶŝƚŝŽŶĚĞůĂƉƌŽĐĠĚƵƌĞ͕ŝ͘Ğ͕͘
ĂƐƐŽĐŝĞƌů[ĞŶͲƚġƚĞĂƵĐŽƌƉƐĚĞůĂƉƌŽĐĠĚƵƌĞ 
^
SULQWIGG G?QHIHI
`
Remarques :
xSi une fonction ou procédure est mise après PDLQ sans déclaration, ceci
est sanctionné par un [Warning] signalé par le compilateur.
xLa déclaration de la procédure DIILFKHUBVRPPH peut être mise à l¶intérieur
du PDLQ avant l¶appel de la procédure.
xDans la déclaration d¶une procédure, quand l¶en-tête est mis complet avec
ses types de paramètres, il est dit prototype, comme c¶est le cas dans
l¶exemple précédent. La déclaration peut donc ne pas comporter de
paramètres.
3. Les variables locales et les variables globales
Soit le programme C suivant :
LQFOXGHVWGLRK!
LQWV
YRLGVRPPH
^
LQW[\
SULQWI'RQQH]ODSUHPLqUHYDOHXU
VFDQIG [
SULQWI'RQQH]ODGHX[LqPHYDOHXU

ϭϯϰ

Les sous-programmes : Procédures et Fonctions .

VFDQIG \

V [\
`
PDLQ
^
 EORF 
VRPPH
SULQWI/DVRPPH G?QV 
 EORF 
VRPPH
SULQWI/DVRPPH G?QV 
`
Les variables [ et \ sont dites variables locales. Elles ne peuvent être utilisées
qu¶au niveau du sous-programme. La variable V est dite variable globale. Les
variables globales peuvent être utilisées au niveau des sous-programmes et au
niveau du programme principal.
Remarques :
xLes paramètres d¶un sous-programme se comportent de la même manière
que les variables locales de ce sous-programme.
xSi les variables globales sont déclarées après le programme qu¶il les utilise,
ceci est sanctionné par une [Error] signalée par le compilateur.
Portée d¶une variable :
Dans un même programme ou un même sous-programme, l¶endroit où la
déclaration d¶une variable est faite, influence directement la portée de la
variable (le bloc dans lequel il est possible d¶accéder à la variable), comme
illustré dans l¶exemple suivant :
PDLQ
^
 LQW$
 9DULDEOHVDFFHVVLEOHV$
 ^
  LQW%
  9DULDEOHVDFFHVVLEOHV$%
  ^
   LQW&
   9DULDEOHVDFFHVVLEOHV$%&
  `
 `
 ^
  LQW(
  9DULDEOHVDFFHVVLEOHV$(
 `
`
Notons qu¶une variable peut être déclarée dans n¶importe quel bloc dans un
programme C.

ϭϯϱ

Les sous-programmes : Procédures et Fonctions .

Deux identificateurs identiques :

Pour enlever l¶ambiguïté, il est préférable d¶éviter d¶utiliser le même
identificateur comme variable locale et globale au même temps. Voyons
l¶exemple suivant :
LQFOXGHVWGLRK!
LQWL
YRLG6
^
LQWL
L 
SULQWIL G?QL
`
PDLQ
^
L 
6
SULQWIL GL
`
Le programme affiche:
L 
L 
Convertir une fonction en procédure :
Il est possible de remplacer une fonction par une procédure en utilisant une
variable globale permettant de récupérer la valeur retournée par la fonction.
Soit le programme C suivant :
LQFOXGHVWGLRK!
LQW[\
LQW6LQWDLQWE
^
UHWXUQDE
`
PDLQ
^
SULQWI'RQQH]ODSUHPLqUHYDOHXU
VFDQIG [
SULQWI'RQQH]ODGHX[LqPHYDOHXU
VFDQIG \
SULQWI6RPPH G6[\
`
La fonction 6 peut être remplacée par une procédure 6 en ajoutant une variable
globale, et cela comme suit :
LQFOXGHVWGLRK!
LQW[\=
YRLG6LQWDLQWE
^
= DE
`
ϭϯϲ

Les sous-programmes : Procédures et Fonctions .

PDLQ
^
SULQWI'RQQH]ODSUHPLqUHYDOHXU
VFDQIG [
SULQWI'RQQH]ODGHX[LqPHYDOHXU
VFDQIG \
6[\
SULQWI6RPPH G=
`
Variable locale statique :
Il est possible d¶attribuer un emplacement permanent à une variable locale, en
la déclarant par le mot clé VWDWLF. Sa valeur se conserve donc d¶un appel au
suivant. Soit l¶exemple :
LQFOXGHVWGLRK!
YRLGIFW
^
VWDWLFLQWL
L
SULQWIG?QL
`
PDLQ3URJUDPPH3ULQFLSDO
^
LQWQ
IRUQ Q QIFW
`
Ce programme affiche :



Remarques :
xUne variable locale statique se comporte donc comme une variable globale,
sauf que son utilisation se limite au sous-programme là où elle a été déclarée.
xElle est automatiquement initialisée par 0.
xLe mot VWDWLF, employé sans indication de type, est équivalent à VWDWLF
LQW.
xUne déclaration d¶une variable globale précédée par le mot clé H[WHUQ
précise que cette variable a été déjà définie dans un autre fichier source.
Une telle déclaration n¶effectue aucune réservation d¶espace mémoire.
4. Le passage des paramètres
Soit le programme C suivant :
LQFOXGHVWGLRK!
YRLGFKDQJHLQW\3URFpGXUH
^
\ 
`
ϭϯϳ

Les sous-programmes : Procédures et Fonctions .

PDLQ3URJUDPPH3ULQFLSDO
^
LQW,
, 
FKDQJH,
SULQWIG,
`
Ce programme comporte une procédure FKDQJH déclarée avec un paramètre
formel \. Le programme principal PDLQ contient une variable locale ,,
passée comme paramètre effectif à la procédure FKDQJH. La valeur qui sera
affichée en sortie est .
Malgré que le paramètre ait changé au niveau de la procédure, ce changement
n¶a pas été transmis au programme principal. Ce type de passage de paramètres
est dit par valeur.
Voyons un deuxième exemple :
LQFOXGHVWGLRK!
YRLGFKDQJHLQW \ LJĞƐƚƵŶƉŽŝŶƚĞƵƌǀĞƌƐƵŶĞŶƚŝĞƌ͕ŝ͘Ğ͕͘LJĐŽŶƚŝĞŶƚ
ů[ĂĚƌĞƐƐĞĚ[ƵŶĞǀĂƌŝĂďůĞĚĞƚLJƉĞĞŶƚŝĞƌ 
^
 \ ODYDULDEOHSRLQWpHSDU\UHoRLWODYDOHXU
`
PDLQ
^
LQW,
, 
FKDQJH ,KŶƉĂƐƐĞĐŽŵŵĞƉĂƌĂŵğƚƌĞů[ĂĚƌĞƐƐĞĚĞůĂǀĂƌŝĂďůĞ/
SULQWIG,
`
\ est un paramètre formel de la procédure FKDQJH. Le symbole indique le
type pointeur. Ce symbole est utilisé pour transmettre la valeur de la variable
pointée par \ vers le programme principal. Par conséquent, la valeur affichée
par le programme sera .
Une variable de type pointeur, au lieu de contenir la valeur d¶une variable, elle
contient son adresse. Donc lors de l¶appel de la procédure, on met comme
paramètre effectif une adresse d¶une variable indiquée par le symbole
précédant le nom de la variable. Le type pointeur sera vu en détail dans un
prochain chapitre.
Le passage de paramètres par le symbole est dit par adresse (par variable ou
par référence).
Remarques :
xQuand on utilise le passage par valeur, il est possible d¶invoquer le sous-
programme par des paramètres effectifs exprimés sous forme d¶expressions,
par exemple, FKDQJH, , FKDQJH«
ϭϯϴ

Les sous-programmes : Procédures et Fonctions .

xPour la fonction SULQWI, les paramètres sont passés par valeur. Pour la
fonction VFDQI, les paramètres sont passés par adresse.
Représentation graphique de la pile :
La zone mémoire réservée pour l¶exécution d¶un programme C dans la RAM
est constituée de plusieurs parties, parmi lesquelles on cite :
x Segment de données : variables globales.
x Pile : variables locales et paramètres.
x Tas : allocation dynamique, qui sera étudiée ultérieurement.
La répartition de l¶espace mémoire entre ces différentes parties dépend du
modèle mémoire adopté : Small (le modèle par défaut), Tiny, Medium, etc. Le
choix du modèle se fait avant la compilation du programme.
En particulier, la pile (stack en anglais) se compose d¶une ou plusieurs boites
(frames). Dans chacune de ces boites sont stockées, entre autres, les variables
locales et les paramètres d¶une procédure ou fonction. La partie de la pile
allouée à une fonction ou procédure est désallouée quand elle se termine.
La pile avec la procédure FKDQJH peut être représentée comme suit :
WŝůĞ WŝůĞ
ĐŚĂŶŐĞϭ ĐŚĂŶŐĞϭ ĐŚĂŶŐĞϭ
 
LJ Ϭ LJ ϭ &ŝŶĚĞůĂ  LJ ϭ
ƉƉĞůĚĞůĂ
WŝůĞ ƉƌŽĐĠĚƵƌĞ dƌĂŝƚĞŵĞŶƚ ƉƌŽĐĠĚƵƌĞ
ŵĂŝŶ ŵĂŝŶ ŵĂŝŶ ŵĂŝŶ
ĨƌĂŵĞ    
/ Ϭ / Ϭ / Ϭ / Ϭ

La pile avec la procédure FKDQJH peut être représentée comme suit :

WŝůĞ WŝůĞ WŝůĞ
ĐŚĂŶŐĞϮ ĐŚĂŶŐĞϮ ĐŚĂŶŐĞϮ
 
LJ Θ/ LJ Θ/ 
&ŝŶĚĞůĂ LJ Θ/
ƉƉĞůĚĞůĂ
WŝůĞ ƉƌŽĐĠĚƵƌĞ dƌĂŝƚĞŵĞŶƚ ƉƌŽĐĠĚƵƌĞ
ŵĂŝŶ ŵĂŝŶ ŵĂŝŶ ŵĂŝŶ
   
/ Ϭ / Ϭ / ϭ / ϭ

Remarquez bien qu¶en C, le programme principal (PDLQ) est traité comme

une simple fonction.
Exercice :
1.Qu¶affiche le programme C suivant ?
ϭϯϵ

Les sous-programmes : Procédures et Fonctions .

LQFOXGHVWGLRK!
LQW[\6RP
YRLG6LQWDLQWE
^6RP DE
D DE
E 
`
PDLQ
^[ \ 
6[\
SULQWIGG G[\6RP
`
2.Qu¶affiche programme précédent si :
a) on remplace la procédure par :
YRLG6LQWDLQW E
^6RP D E
D D E
 E 
`
et on l¶appelle par : 6[ \
b) on remplace la procédure par :
YRLG6LQW DLQWE
^6RP  DE
 D  DE
E 
`
et on l¶appelle par : 6 [\
c) on remplace la procédure par :
YRLG6LQW DLQW E
^6RP  D E
 D  D E
 E 
`
et on l¶appelle par : 6 [ \
Solution :
1.Le programme affiche :  
2.Le programme affiche :
D Pour 6LQWDLQW E :  
E Pour 6LQW DLQWE :  
F Pour 6LQW DLQW E :  
Passer un tableau en paramètre :
En langage C, il est possible de définir un sous-programme avec un paramètre
de type tableau. Rappelons qu¶une variable de type tableau correspond à
l¶adresse du premier élément (l¶élément 0) de ce tableau. Donc, le passage d¶un

ϭϰϬ

Les sous-programmes : Procédures et Fonctions .

tableau en paramètre est un passage par adresse, sans le préciser par , ni

l¶appeler par .
Soit le programme C suivant :
LQFOXGHVWGLRK!
YRLGLQLWLDOLVHULQW9>@
^
9>@ 9>@ 9>@ 9>@ 
`
PDLQ
^
LQW7>@ ^`
LQWL 
LQLWLDOLVHU7 DĂůŐƌĠƋƵĞĐ[ĞƐƚƵŶƉĂƐƐĂŐĞƉĂƌĂĚƌĞƐƐĞ͕ŽŶŶĞŵĞƚƉĂƐ
ŝŶŝƚŝĂůŝƐĞƌ;ΘdͿ͖ĐĂƌdůƵŝͲŵġŵĞĞƐƚƵŶĞĂĚƌĞƐƐĞ 
IRUL LLSULQWIG?Q7>L@
`
Le programme affiche :





Remarque : Quand on passe un tableau comme paramètre d¶un sous-
programme, il est possible de ne pas préciser la taille de ce tableau. La
déclaration YRLGLQLWLDOLVHULQW9>@ est donc aussi correcte. Il est aussi
possible de mettre la déclaration YRLGLQLWLDOLVHULQW 9.
Nombre variable de paramètres :
Le langage C permet de définir une fonction ou procédure avec un nombre
indéterminé de paramètres. La fonction doit avoir au moins un argument fixe.
La procédure définie dans le programme suivant permet d¶afficher ses
paramètres jusqu¶à atteindre le paramètre ayant comme valeur .
LQFOXGHVWGLRK!
LQFOXGHVWGDUJK!
YRLGHVVDLLQWSDUFKDUSDU
^
YDBOLVWDGSDU
LQWSDUY
SULQWIG?QSDU
SULQWIF?QSDU
YDBVWDUWDGSDUSDU
SDUY YDBDUJDGSDULQW
ZKLOHSDUY ^
SULQWIG?QSDUY
SDUY YDBDUJDGSDULQW
`
`
ϭϰϭ

Les sous-programmes : Procédures et Fonctions .

PDLQ
^
SXWV3UHPLHUHVVDL
HVVDL
F

SXWV'HX[LqPHHVVDL
HVVDL
D

`
Le programme affiche :
3UHPLHUHVVDL

F



'HX[LqPHHVVDL

D


Le type YDBOLVW identifie une liste de variables. La fonction YDBVWDUW permet
de se pointer juste après un argument fixe. La fonction YDBDUJ permet de
récupérer l¶argument en cours selon un type donné, et passer à l¶argument
suivant. YDBOLVW, YDBVWDUW et YDBDUJ appartiennent à la bibliothèque
VWGDUJK.
Remarque : On appelle fonction variadique, une fonction qui peut prendre un
nombre variable de paramètres. SULQWI et VFDQI sont des fonctions
variadiques.
5. La récursivité (récursion)
5.1. Définition
Une procédure ou fonction est dite récursive si elle fait référence à elle-même,
i.e., elle s¶appelle elle-même.
5.2. Exemple (Calcul de la factorielle)
La factorielle d¶un nombre n se note n!, avec n! = n*(n- «  . Ainsi, 5!
= 5*4*3*2*1.
La fonction itérative (en utilisant une boucle) pour calculer la factorielle est
donnée ci-dessous :
LQWIDFWLQWQ
^LQWLI
I 
IRUL L QLI I L
UHWXUQI
`
ϭϰϮ

Les sous-programmes : Procédures et Fonctions .

La définition mathématique de la factorielle en tant que formule récurrente est

la suivante : pour tout n entier, si (n = 0) fact(0) = 1, si (n>0) fact(n) = n *
fact(n-1).
La fonction récursive pour le calcul de la factorielle est la suivante :
LQWIDFWLQWQ
^LQWI 
LIQ I 
HOVHI Q IDFWQ
UHWXUQI
`
Ou bien :
LQWIDFWLQWQ
^LIQ UHWXUQ
HOVHUHWXUQQ IDFWQ
`
Remarques :
xToute solution itérative peut être transformée en solution récursive, et vice
versa.
xL¶appel d¶une fonction à l¶intérieur d¶elle-même est dit appel récursif.
L¶appel récursif dans la fonction récursive IDFW est IDFWQ.
Une fonction ou une procédure récursive doit vérifier les deux conditions
suivantes :
1.L¶existence d¶un critère d¶arrêt. Le critère d¶arrêt dans la fonction
récursive IDFW est Q .
2.Les paramètres de l¶appel récursif doivent converger vers le critère d¶arrêt.
Arbre des appels :
L¶arbre des appels est une représentation graphique des appels récursifs.
L¶arbre des appels de la fonction récursive IDFW pour n = 3 peut être représenté
comme suit.
ĨĂĐƚ;ϯͿ

](~ïAAìY
ĞůƐĞĨсϯΎ ĨĂĐƚ;ϮͿ ϲ

](~îAAìY
ĞůƐĞĨсϮΎ ĨĂĐƚ;ϭͿ Ϯ

](~íAAìY ϭ
ĞůƐĞĨсϭΎ ĨĂĐƚ;ϬͿ

ŝĨ;ϬссϬͿĨсϭ͖ ϭ
o Y
ϭϰϯ

Les sous-programmes : Procédures et Fonctions .

Remarques :
xL¶utilisation de la récursivité est coûteuse en termes d¶espace mémoire.
Comme illustré par l¶arbre des appels, le contexte de la fonction IDFW pour
n=3 va être stocké 4 fois dans la pile. Ceci peut nous ramener à un problème
dit Débordement de pile (Stack Overflow) si le n devient plus grand.
xL¶arbre des appels devient plus complexe quand la fonction s¶appelle elle-
même plus d¶une fois.
6. Exercices corrigés
6.1. Exercices
Exercice 1 :
Ecrire un programme C qui calcule la division entière entre deux nombres lus à
partir du clavier en utilisant une fonction avec deux paramètres entiers.
Donnez la représentation graphique de la mémoire (pile) qui correspond au
programme quand l¶utilisateur donne successivement les deux nombres : 9 et 2.
Exercice 2 :
Ecrire un programme C qui affiche le code ASCII d¶un caractère lu à partir du
clavier en utilisant une fonction.
Exercice 3 :
Ecrire un programme C qui décide si un nombre est premier ou non en utilisant
une fonction qui restituera la valeur 0 lorsque le nombre n¶est pas premier et la
valeur 1 lorsqu¶il est premier.
Note : On dit qu¶un nombre entier positif est premier s¶il possède exactement
deux diviseurs positifs : 1 et lui-même. 0 et 1 ne sont pas des nombres premiers.
Voici quelques nombres premiers «
Exercice 4 :
Ecrire une fonction qui calcule la moyenne de trois nombres passés en
paramètres. Ecrire un programme C qui affiche la moyenne de trois nombres
lus à partir du clavier en appelant la fonction déjà définie.
Exercice 5 :
Ecrire un programme C permettant de calculer la surface d¶un rectangle en
utilisant une fonction ayant comme paramètres la longueur et la largeur de ce
rectangle.
Exercice 6 :
Ecrire une procédure qui retourne le quotient et le reste de la division d¶un
entier p par un entier q. Ecrire le programme C qui lit deux nombres, appelle
cette procédure et affiche les résultats.
Exercice 7 :
Ecrire un programme C permettant d¶afficher la somme de deux entiers et la
concaténation de deux chaînes de caractères en utilisant une procédure.

ϭϰϰ

Les sous-programmes : Procédures et Fonctions .

La procédure aura comme paramètres deux entiers et deux chaînes de

caractères.
Exercice 8 :
Ecrire un programme C permettant à partir de la saisie de trois entiers a, b et c,
de calculer la factorielle de : soit a, soit b, soit c. L¶utilisateur doit faire un
choix à partir d¶un menu. Le calcul de la factorielle doit être effectué par une
fonction. Remplacer ensuite (dans un autre programme) la fonction par une
procédure.
Exercice 9 :
Soit un barème de l¶impôt défini comme suit : pour un ménage X avec un
revenu total R et un nombre n de membres du foyer, l¶impôt est donné par :
x 10% de R si R/n < 500 DA
x 20% de R si R/n >= 500 DA
Ecrire un programme C qui lit R et n au clavier, puis affiche l¶impôt et le
revenu net en utilisant les deux fonctions suivantes :
1. Une fonction ,PSRW qui calcule le montant de l¶impôt en fonction de R et n.
2. Une fonction 5HYHQX1HW qui calcule le revenu net d¶un ménage après
paiement de l¶impôt en fonction de R et n.
Exercice 10 :
Qu¶affiche le programme C suivant ?
LQFOXGHVWGLRK!
LQWQ 
YRLGIFWLQWS
^
SULQWIGG?QQS
`
YRLGPDLQ3URJUDPPH3ULQFLSDO
^
LQWQ 
IFWQ
`
Exercice 11 :
Quel est le résultat d¶exécution des deux programmes suivants ?
LQFOXGHVWGLRK! LQFOXGHVWGLRK!
LQWL LQWL
LQWLPSLQWD LQWLPSLQW D
^ ^
SULQWIG?QD SULQWIG?Q D
D D  D  D
` `
PDLQ PDLQ
^ ^
L  L 
ZKLOHL^ ZKLOHL^
ϭϰϱ

Les sous-programmes : Procédures et Fonctions .

LPSL LPS L
L L L L
` `
` `
Exercice 12 :
Qu¶affichent les deux programmes suivants ?
Programme 1 Programme 2
LQFOXGHVWGLRK! LQFOXGHVWGLRK!
LQWILQWDLQWE LQWILQW DLQW E
^ ^
D DD  D D D
UHWXUQDE UHWXUQ D E
` `
YRLGPDLQ YRLGPDLQ
^ ^
LQWLM[ LQWLM[
L  L 
M  M 
[ ILM [ I L M
SULQWIΗŝсйĚ͕ũсйĚ͕džсйĚΗ͕ŝ͕ũ͕dž SULQWIΗŝсйĚ͕ũсйĚ͕džсйĚΗ͕ŝ͕ũ͕dž
` `
Exercice 13 :
Ecrire un programme C permettant de lire deux entiers et de permuter leurs
contenus en utilisant une procédure qui recevra ces deux entiers en paramètres.
Le programme doit enfin afficher les valeurs de ces variables afin de vérifier la
permutation. Donnez la représentation graphique de la mémoire (pile) qui
correspond au programme précédent quand l¶utilisateur donne 9 pour la
première variable et 2 pour la deuxième.
Exercice 14 :
Ecrire un programme C qui initialise deux entiers et un réel à 0 en utilisant une
procédure qui aura trois variables en paramètres.
Exercice 15 :
Ecrire un programme C qui affiche la somme et le produit des éléments d¶un
tableau de 5 entiers lus à partir du clavier. Le programme doit utiliser pour les
calculs une procédure ayant comme paramètre un tableau.
Exercice 16 :
Ecrire en C des sous-programmes de :
1. calcul de la somme des éléments d¶un vecteur ;
2. recherche de la position de la première occurrence de l¶élément minimum
d¶un vecteur ;
3. addition de deux vecteurs et rangement du résultat dans un troisième
vecteur.
Ecrire ensuite un programme principal dans lequel on appellera les divers sous-
programmes.
ϭϰϲ

Les sous-programmes : Procédures et Fonctions .

Exercice 17 :
Ecrire une fonction qui calcule la somme des éléments d¶un tableau d¶entiers de
taille quelconque.
Exercice 18 :
En utilisant la notion de sous-programme, essayez de réduire la taille du
programme C suivant :
LQFOXGHVWGLRK!
PDLQ
^
LQW[\]V
SXWV'RQQH]WURLVQRPEUHV
VFDQIGGG [ \ ]
V [\
SULQWIGG G?Q[\V
V \]
SULQWIGG G?Q\]V
V ][
SULQWIGG G?Q][V
`
Exercice 19 :
Soit le problème : Trouvez le maximum et le minimum dans un tableau de dix
entiers, ensuite déterminez la position de la valeur maximale et la valeur
minimale.
Subdivisez ce problème en sous-problèmes simples. Ensuite, essayez de les
résoudre par la notion de sous-programme en langage C.
Exercice 20 :
Expliquez ce que fait la procédure suivante :
YRLG3LQWQ
^
LIQ!^
SULQWIG?QQ
3Q
SULQWIG?QQ
`
`
Exercice 21 :
Ecrire un programme C permettant le calcul de la puissance en utilisant une
fonction itérative, ensuite un deuxième programme qui utilise une fonction
récursive.
Exercice 22 :
Ecrire un programme contenant une fonction récursive permettant de calculer le
nième terme de la suite de Fibonacci définie comme suit : Si n = 0 alors Fn = 0 ;
Si n = 1 alors Fn = 1 ; Si n >1 alors Fn = Fn-1+Fn-2.
Donnez l¶arbre des appels de la fonction pour n=4.
ϭϰϳ

Les sous-programmes : Procédures et Fonctions .

Exercice 23 :
Ecrire un programme C qui utilise une fonction récursive pour le calcul de la
fonction de Ackermann, notée A, de deux paramètres m et n. La fonction est
définie comme suit :
x Si m<0 ou n<0 : A(m, n) = 0 ;
x Si m=0 : A(0, n) = n+1 ;
x Si n=0 : A(m, 0) = A(m-1, 1) ;
x Si m>0 et n > 0 : A(m, n) = A(m-1, A(m, n-1)).
Exercice 24 :
Ecrire une fonction récursive pour le calcul de la somme : Un = 1 + 24 + 34«
+ n4, sachant que pour n<=0 la fonction retourne 0. Appeler la fonction dans
un programme C pour n=6.
Réécrire un deuxième programme faisant le même travail avec une fonction
itérative.
Exercice 25 :
Ecrire un programme C qui affiche la chaîne miroir d¶une chaîne de caractères
lue à partir du clavier en utilisant une fonction récursive.
La chaîne miroir de ERQMRXU est UXRMQRE.
Exercice 26 :
Ecrire la fonction itérative, ensuite la fonction récursive permettant de calculer
le PGCD (le plus grand diviseur commun) de deux entiers.
Exercice 27 :
Soit la procédure suivante contenant une boucle simple :
YRLGFRPSWHU
^
LQWL
IRUL L LSULQWIG?QL
`
Exprimez cette procédure par une autre récursive, faisant le même travail.
6.2. Corrigés
Solution 1 :
Programme C :
LQFOXGHVWGLRK!
LQWGLYBHQWLQWDLQWE
^
UHWXUQDE
`
PDLQ
^
LQW[\
SULQWI'RQQH]ODSUHPLqUHYDOHXU
VFDQIG [

ϭϰϴ

Les sous-programmes : Procédures et Fonctions .

SULQWI'RQQH]ODGHX[LqPHYDOHXU

VFDQIG \
SULQWIGG G[\GLYBHQW[\
`
Représentation de la mémoire :
WŝůĞ WŝůĞ
ĚŝǀͺĞŶƚ ĚŝǀͺĞŶƚ ĚŝǀͺĞŶƚ

 Ă ϵ  Ă ϵ  Ă ϱ

ƉƉĞůĚĞůĂ ď Ϯ ď Ϯ &ŝŶĚĞůĂ ď Ϯ
WŝůĞ ϰ ĨŽŶĐƚŝŽŶ
ĨŽŶĐƚŝŽŶ dƌĂŝƚĞŵĞŶƚ
ŵĂŝŶ ŵĂŝŶ ŵĂŝŶ ŵĂŝŶ

 dž ϵ  dž ϵ  dž ϵ  dž ϵ

LJ Ϯ LJ Ϯ LJ Ϯ LJ Ϯ

Solution 2 :
LQFOXGHVWGLRK!
LQW$6&,,FKDUD
^
UHWXUQD
`
PDLQ
^
FKDUF
SULQWI'RQQH]XQFDUDFWqUH
VFDQIF F
SULQWI&RGH$6&,,GXFDUDFWqUHFHVWGF$6&,,F
`
Solution 3 :
LQFOXGHVWGLRK!
LQWSUHPLHULQWD
^
LQWS L
IRUL L DLLIDL S 
LID UHWXUQ
UHWXUQS
`
PDLQ
^
LQW[
SULQWI'RQQH]XQQRPEUHHQWLHUSRVLWLI
VFDQIG [
LISUHPLHU[SULQWIGHVWXQQRPEUHSUHPLHU[
HOVHSULQWIGQ
HVWSDVXQQRPEUHSUHPLHU[
ϭϰϵ

Les sous-programmes : Procédures et Fonctions .

`
Ou bien :
LQFOXGHVWGLRK!
LQWSUHPLHULQWD
^
LQWS L
IRUL L DLLIDL S
LIS UHWXUQ
HOVHUHWXUQ
`
PDLQ
^
LQW[
SULQWI'RQQH]XQQRPEUHHQWLHUSRVLWLI
VFDQIG [
LISUHPLHU[SULQWIGHVWXQQRPEUHSUHPLHU[
HOVHSULQWIGQ
HVWSDVXQQRPEUHSUHPLHU[
`
Solution 4 :
LQFOXGHVWGLRK!
IORDWPR\HQQHIORDWDIORDWEIORDWF
^
UHWXUQDEF
`
PDLQ
^
IORDW[\]
SULQWI'RQQH]WURLVQRPEUHV?Q
VFDQIIII [ \ ]
SULQWI/DPR\HQQHGHVWURLVQRPEUHV IPR\HQQH[\]
`
Solution 5 :
LQFOXGHVWGLRK!
IORDWVXUIDFHIORDWDIORDWE
^
UHWXUQD E
`
PDLQ
^
IORDWOQJOUJ
SULQWI'RQQH]ODORQJXHXUHWODODUJHXU?Q
VFDQIII OQJ OUJ
SULQWI/DVXUIDFH IVXUIDFHOQJOUJ
`
Solution 6 :
LQFOXGHVWGLRK!
LQWTXRWPRG
YRLGTXRWBPRGLQWDLQWE

ϭϱϬ

Les sous-programmes : Procédures et Fonctions .

^
TXRW DE
PRG DE
`
PDLQ
^
LQWST
SULQWI'RQQH]ODSUHPLqUHYDOHXU
VFDQIG S
SULQWI'RQQH]ODGHX[LqPHYDOHXU
VFDQIG T
TXRWBPRGST
SULQWIGG GHWGG GSTTXRWSTPRG
`
Solution 7 :
LQFOXGHVWGLRK!
LQFOXGHVWULQJK!
YRLGVRPBFRQLQWDLQWEFKDUF>@FKDUF>@
^
SULQWI/HUpVXOWDWGHODVRPPH G?QDE
SULQWIΗ>ĞƌĠƐƵůƚĂƚĚĞůĂĐŽŶĐĂƚĠŶĂƚŝŽŶсйƐΗ͕ƐƚƌĐĂƚ;Đϭ͕ĐϮͿ
`
PDLQ
^
LQW[\
FKDUFK>@FK>@
SULQWI'RQQH]GHX[QRPEUHV?Q
VFDQIGG [ \
SULQWI'RQQH]GHX[FKDvQHVGHFDUDFWqUHV?Q
VFDQIVVFKFK
VRPBFRQ[\FKFK
`
Solution 8 :
Programme C avec une fonction :
LQFOXGHVWGLRK!
LQWIDFWRLQW[
^
LQWLI
I 
IRUL L [LI L
UHWXUQI
`
PDLQ
^
LQWDEFFKRL[
SULQWI'RQQH]WURLVHQWLHUV?Q
VFDQIGGG D E F
SULQWI7DSH]SRXUFODFXOHUODIDFWRULHOOHGHG?QD
SULQWI7DSH]SRXUFODFXOHUODIDFWRULHOOHGHG?QE
ϭϱϭ

Les sous-programmes : Procédures et Fonctions .

SULQWI7DSH]SRXUFODFXOHUODIDFWRULHOOHGHG?QF
VFDQIG FKRL[
VZLWFKFKRL[
^
FDVHLID! ƉƌŝŶƚĨ;Η>ĂĨĂĐƚŽƌŝĞůůĞĚĞйĚĞƐƚйĚ͘Η͕Ă͕ĨĂĐƚŽ;ĂͿͿ͖
HOVHSULQWI&DOFXOLPSRVVLEOHEUHDN
FDVHLIE! ƉƌŝŶƚĨ;Η>ĂĨĂĐƚŽƌŝĞůůĞĚĞйĚĞƐƚйĚ͘Η͕ď͕ĨĂĐƚŽ;ďͿͿ͖
HOVHSULQWI&DOFXOLPSRVVLEOHEUHDN
FDVHLIF! ƉƌŝŶƚĨ;Η>ĂĨĂĐƚŽƌŝĞůůĞĚĞйĚĞƐƚйĚ͘Η͕Đ͕ĨĂĐƚŽ;ĐͿͿ͖
HOVHSULQWI&DOFXOLPSRVVLEOHEUHDN
GHIDXOWSULQWI&KRL[LQYDOLGH
`
`
Programme C avec une procédure :
LQFOXGHVWGLRK!
LQW=
YRLGIDFWRLQW[
^
LQWLI
I 
IRUL L [LI L
= I
`
PDLQ
^
LQWDEFFKRL[
SULQWI'RQQH]WURLVHQWLHUV?Q
VFDQIGGG D E F
SULQWI7DSH]SRXUFODFXOHUODIDFWRULHOOHGHG?QD
SULQWI7DSH]SRXUFODFXOHUODIDFWRULHOOHGHG?QE
SULQWI7DSH]SRXUFODFXOHUODIDFWRULHOOHGHG?QF
VFDQIG FKRL[
VZLWFKFKRL[
^
FDVHLID! ^ĨĂĐƚŽ;ĂͿ͖ƉƌŝŶƚĨ;Η>ĂĨĂĐƚŽƌŝĞůůĞĚĞйĚĞƐƚйĚ͘Η͕Ă͕Ϳ͖`
HOVHSULQWI&DOFXOLPSRVVLEOHEUHDN
FDVHLIE! ΂ĨĂĐƚŽ;ďͿ͖ƉƌŝŶƚĨ;Η>ĂĨĂĐƚŽƌŝĞůůĞĚĞйĚĞƐƚйĚ͘Η͕ď͕Ϳ͖΃
HOVHSULQWI&DOFXOLPSRVVLEOHEUHDN
FDVHLIF! ΂ĨĂĐƚŽ;ĐͿ͖ƉƌŝŶƚĨ;Η>ĂĨĂĐƚŽƌŝĞůůĞĚĞйĚĞƐƚйĚ͘Η͕Đ͕Ϳ͖΃
HOVHSULQWI&DOFXOLPSRVVLEOHEUHDN
GHIDXOWSULQWI&KRL[LQYDOLGH
`
`
Solution 9 :
LQFOXGHVWGLRK!
IORDW,PSRWIORDW5LQWQ
^
LI5QUHWXUQ 5

ϭϱϮ

Les sous-programmes : Procédures et Fonctions .

HOVHUHWXUQ 5
`
IORDW5HYHQX1HWIORDW5LQWQ
^
UHWXUQ5,PSRW5Q
`
PDLQ
^
IORDW[
LQW\
SULQWI'RQQH]OHUHYHQXWRWDO
VFDQII [
SULQWI'RQQH]OHQRPEUHGHPHPEUHVGXIR\HU
VFDQIG \
SULQWIΗ/ŵƉŽƚсйĨ͕ZĞǀĞŶƵEĞƚсйĨΗ͕/ŵƉŽƚ;dž͕LJͿ͕ZĞǀĞŶƵEĞƚ;dž͕LJͿ
`
Solution 10 :
Le programme affiche :


Solution 11 :
Le premier programme affiche :




Le deuxième programme affiche :



Solution 12 :
Le premier programme affiche :
L M [ 
Le deuxième programme affiche :
L M [ 
Solution 13 :
Programme C :
LQFOXGHVWGLRK!
YRLGSHUPXWHULQW DLQW E
^
LQWF
F  D
 D  E
 E F
`
ϭϱϯ

Les sous-programmes : Procédures et Fonctions .

PDLQ
^
LQW[\
SULQWI'RQQH]ODYDOHXUGH[
VFDQIG [
SULQWI'RQQH]ODYDOHXUGH\
VFDQIG \
SHUPXWHU [ \
SULQWI[ G\ G[\
`
Représentation de la mémoire :
WŝůĞ WŝůĞ
ƉĞƌŵƵƚĞƌ ƉĞƌŵƵƚĞƌ ƉĞƌŵƵƚĞƌ

Ă Θdž Ă Θdž Ă Θdž

ƉƉĞůĚĞůĂ ď ΘLJ ď ΘLJ ď ΘLJ

&ŝŶĚĞůĂ
WŝůĞ ƉƌŽĐĠĚƵƌĞ dƌĂŝƚĞŵĞŶƚ ƉƌŽĐĠĚƵƌĞ
ŵĂŝŶ ŵĂŝŶ ŵĂŝŶ ŵĂŝŶ

dž ϵ dž ϵ dž Ϯ dž Ϯ

LJ Ϯ LJ Ϯ LJ ϵ LJ ϵ

Solution 14 :
LQFOXGHVWGLRK!
YRLGLQLWLQW DLQW EIORDW F
^
 D E 
F 
`
PDLQ
^
LQW[\
IORDW]
LQLW [ \ ]
SULQWI[ G \ G?Q[\
SULQWI] I]
`
Solution 15 :
LQFOXGHVWGLRK!
LQWVRPSURG
YRLGVRPBSURGBWDELQWD>@
^
LQWN
VRP 
IRUN N NVRP D>N@

ϭϱϰ
Les sous-programmes : Procédures et Fonctions .

SURG 
IRUN N NSURG D>N@
`
PDLQ
^
LQW7>@
LQWL
SXWV'RQQH]OHVFLQTpOpPHQWVGXWDEOHDX
IRUL L LVFDQIG 7>L@
VRPBSURGBWDE7
SULQWI6RPPH G3URGXLW GVRPSURG
`
Solution 16 :
LQFOXGHVWGLRK!
GHILQHQHW1RPEUHGHVpOpPHQWVG
XQWDEOHDX
LQW7>QHW@7>QHW@7>QHW@
LQWL
)RQFWLRQGHFDOFXOGHODVRPPHG
XQWDEOHDX
LQWVRPPHBWDELQW7>QHW@
^
LQWVRP 
IRUL L QHWLVRP 7>L@
UHWXUQVRP
`
&ŽŶĐƚŝŽŶƋƵŝĚĠƚĞƌŵŝŶĞůĂƉƌĞŵŝğƌĞƉŽƐŝƚŝŽŶĚΖƵŶĠůĠŵĞŶƚĚĂŶƐƵŶƚĂďůĞĂƵ
LQWSRVLQW[LQW7>QHW@
^
LQWS W 
L 
ZKLOHL QHW W
LI7>L@ [^S LW `HOVHL
UHWXUQS
`
&ŽŶĐƚŝŽŶƋƵŝĚĠƚĞƌŵŝŶĞůĂƉŽƐŝƚŝŽŶĚƵŵŝŶŝŵƵŵĚΖƵŶƚĂďůĞĂƵ
LQWSRVBPLQLQW7>QHW@
^
LQWPLQ 7>@
IRUL L QHWLLIPLQ!7>L@PLQ 7>L@
UHWXUQSRVPLQ7
`
3URFpGXUHG
DGGLWLRQGHGHX[WDEOHDX[
YRLGDGGBWDELQW$>QHW@LQW%>QHW@
^
IRUL L QHWL7>L@ $>L@%>L@
`
PDLQ
^
SULQWI'RQQH]OHVpOpPHQWVGXSUHPLHUWDEOHDX?Q
IRUL L QHWLVFDQIG 7>L@
ϭϱϱ

Les sous-programmes : Procédures et Fonctions .

SULQWI'RQQH]OHVpOpPHQWVGXGHX[LqPHWDEOHDX?Q

IRUL L QHWLVFDQIG 7>L@
SULQWIΗ>ĂƐŽŵŵĞĚĞƐĠůĠŵĞŶƚƐĚƵƉƌĞŵŝĞƌƚĂďůĞĂƵсйĚͰŶΗ͕ƐŽŵŵĞͺƚĂď;dϭͿ
SULQWIΗ>ĂƉŽƐŝƚŝŽŶĚƵŵŝŶŝŵƵŵĚƵƉƌĞŵŝĞƌƚĂďůĞĂƵĞƐƚ͗йĚͰŶΗ͕ƉŽƐͺŵŝŶ;dϭͿ
SULQWI/
DGGLWLRQGHVGHX[WDEOHDX[GRQQH?Q
DGGBWDE77
IRUL L QHWLSULQWIG?Q7>L@
`
Solution 17 :
LQWVRPLQWW>@LQWQE
^
LQWV L
IRUL LQELV W>L@
UHWXUQV
`
Solution 18 :
LQFOXGHVWGLRK!
LQWV
YRLGVRPLQWDLQWE
^
V DE
SULQWIGG G?QDEV
`
PDLQ
^
LQW[\]V
SXWV'RQQH]WURLVQRPEUHV
VFDQIGGG [ \ ]
VRP[\
VRP\]
VRP][
`
Solution 19 :
Ce problème peut être subdivisé en trois sous-problèmes :
1.Déterminer le max d¶un tableau.
2.Déterminer le min d¶un tableau.
3.Déterminer la position d¶une valeur.
Voici le programme C :
LQFOXGHVWGLRK!
LQWWDE>@
LQWPD[PLQL
YRLGPD[LPXP
^
PD[ WDE>@
IRUL L LLIPD[WDE>L@PD[ WDE>L@
`
YRLGPLQLPXP
ϭϱϲ

Les sous-programmes : Procédures et Fonctions .

^
PLQ WDE>@
IRUL L LLIPLQ!WDE>L@PLQ WDE>L@
`
LQWSRVLWLRQLQW[
^
LQWSRV 
IRUL L LLIWDE>L@ [SRV L
UHWXUQSRV
`
PDLQ
^
SXWV'RQQH]OHVpOpPHQWVGXWDEOHDX
IRUL L LVFDQIG WDE>L@
PD[LPXP
PLQLPXP
SULQWIΗ>ĞŵĂdžŝŵƵŵĞƐƚйĚ͕ƐĂƉŽƐŝƚŝŽŶĞƐƚйĚͰŶΗ͕ŵĂdž͕ƉŽƐŝƚŝŽŶ;ŵĂdžͿ
SULQWIΗ>ĞŵŝŶŝŵƵŵĞƐƚйĚ͕ƐĂƉŽƐŝƚŝŽŶĞƐƚйĚΗ͕ŵŝŶ͕ƉŽƐŝƚŝŽŶ;ŵŝŶͿ
`
Solution 20 :
Pour un entier positif n, la procédure 3Q permet d¶afficher les valeurs de n
jusqu¶à 1, ensuite de 1 jusqu¶à n. Par exemple, pour n=4, la procédure affiche :









Solution 21 :
Programme C utilisant une fonction itérative :
LQFOXGHVWGLRK!
LQWSXLVVDQFHLQW[LQW\
^
LQWLSXLV 
IRUL L \LSXLV [
UHWXUQSXLV
`
PDLQ
^
LQWQS
SULQWI'RQQH]XQQRPEUH
VFDQIG Q
SULQWI'RQQH]ODSXLVVDQFH

ϭϱϳ

Les sous-programmes : Procédures et Fonctions .

VFDQIG S
SULQWIGSXLVVDQFHG GQSSXLVVDQFHQS
`
Programme C utilisant une fonction récursive :
LQFOXGHVWGLRK!
LQWSXLVVDQFHLQW[LQW\
^
LQWSXLV
LI\ SXLV 
HOVHSXLV [ SXLVVDQFH[\
UHWXUQSXLV
`
PDLQ
^
LQWQS
SULQWI'RQQH]XQQRPEUH
VFDQIG Q
SULQWI'RQQH]ODSXLVVDQFH
VFDQIG S
SULQWIGSXLVVDQFHG GQSSXLVVDQFHQS
`
La fonction récursive SXLVVDQFH peut être aussi écrite comme suit :
LQWSXLVVDQFHLQW[LQW\
^
LI\ UHWXUQ
HOVHUHWXUQ[ SXLVVDQFH[\
`
Solution 22 :
LQFOXGHVWGLRK!
LQWILERLQWQ
^
LQWI
LIQ __Q I Q
HOVHI ILERQILERQ
UHWXUQI
`
PDLQ
^
LQW[
SULQWI(QWUH]XQHYDOHXU
VFDQIG [
SULQWI)LERG G[ILER[
`
La fonction récursive ILER peut être aussi écrite comme suit :
LQWILERLQWQ
^LIQ __Q UHWXUQQ
HOVHUHWXUQILERQILERQ
`
ϭϱϴ

Les sous-programmes : Procédures et Fonctions .

Solution 23 :
LQFOXGHVWGLRK!
LQW$FNHUPDQQLQW[LQW\
^
LI[__\UHWXUQ
HOVHLI[ UHWXUQ\
HOVHLI\ UHWXUQ$FNHUPDQQ[
HOVHUHWXUQ$FNHUPDQQ[$FNHUPDQQ[\
`
PDLQ
^
LQWPQ
SULQWI'RQQH]P
VFDQIG P
SULQWI'RQQH]Q
VFDQIG Q
SULQWI$FNHUPDQQGG GPQ$FNHUPDQQPQ
`
Solution 24 :
Programme C utilisant une fonction récursive :
LQFOXGHVWGLRK!
LQFOXGHPDWKK!
LQW6RPPHLQWQ
^
LIQ UHWXUQ
HOVHUHWXUQSRZQ6RPPHQ
`
PDLQ
^
SULQWIG6RPPH
`
Programme C utilisant une fonction itérative :
LQFOXGHVWGLRK!
LQFOXGHPDWKK!
LQW6RPPHLQWQ
^
LQWL) 
IRUL L QL) SRZL
UHWXUQ)
`
PDLQ
^
SULQWIG6RPPH
`
Solution 25 :
LQFOXGHVWGLRK!
LQFOXGHVWULQJK!
FKDUFKDLQH>@PLURLU>@
ϭϱϵ

Les sous-programmes : Procédures et Fonctions .

FKDU 0,5FKDUFK>@

^
LIVWUOHQFK __VWUOHQFK UHWXUQFK
HOVH^
FKDUV>@ ^FK>VWUOHQFK@
?
` ƐƵŶĞĐŚĂŠŶĞĚĞ
ĐĂƌĂĐƚğƌĞƐĐŽŶƚĞŶĂŶƚůĞĚĞƌŶŝĞƌĐĂƌĂĐƚğƌĞĚĞĐŚ 
FKDUVV>@ ^
?
`ƐƐƵŶĞĐŚĂŠŶĞĚĞĐĂƌĂĐƚğƌĞƐǀŝĚĞ
VWUFDWV0,5VWUQFS\VVFKVWUOHQFK
VWUFS\PLURLUV
UHWXUQPLURLU
 `
`
PDLQ
^
SULQWI'RQQH]XQHFKDvQHGHFDUDFWqUHV
VFDQIVFKDLQH
SULQWIΗ>ĂĐŚĂŠŶĞŵŝƌŽŝƌĚĞйƐĞƐƚйƐΗ͕ĐŚĂŝŶĞ͕D/Z;ĐŚĂŝŶĞͿ
`
Solution 26 :
LQW3*&'LQWPLQWQ
^
LQWU
ZKLOHPQ ^
U PQ
P QQ U
`
UHWXUQQ
`
La version récursive de cette fonction peut être écrite de la manière suivante :
LQW3*&'LQWPLQWQ
^
LIPQ UHWXUQQ
HOVHUHWXUQ3*&'QPQ
`
Solution 27 :
YRLGFRPSWHULQWL
^
LIL SULQWIG?QL
HOVH^
SULQWIG?QL
FRPSWHUL
`
`
La procédure récursive FRPSWHU sera invoquée dans le programme principal
par : FRPSWHU

ϭϲϬ

Les types personnalisés .

Chapitre 7 : Les types personnalisés

1. Introduction
Les types qu¶on a vus jusqu¶à maintenant (entier, réel, caractère, booléen,
tableau et chaîne de caractères) sont prédéfinis, c.-à-d. qu¶ils existent dans les
langages de programmation. Le langage C offre aux programmeurs la
possibilité de définir de nouveaux types de données, dits personnalisés.
2. Définition des types en C
En C, le programmeur peut définir ses propres types, et donner les noms qu¶il
veut à ces types. La déclaration d¶un nouveau type doit précéder son utilisation.
Pour donner un nom à un type, on utilise W\SHGHI.
Dans l¶exemple suivant, le programmeur a préféré d¶utiliser le mot (QWLHU au
lieu de LQW pour déclarer des entiers :
LQFOXGHVWGLRK!
W\SHGHILQW(QWLHU 'pILQLWLRQG
XQQRXYHDXW\SH(QWLHU 
PDLQ
^
(QWLHU[\
SULQWI'RQQH]ODSUHPLqUHYDOHXU
VFDQIG [
SULQWI'RQQH]ODGHX[LqPHYDOHXU
VFDQIG \
SULQWI6RPPH G?Q[\
`
Dans ce cas-là, le type (QWLHU est tout simplement synonyme de LQW. Nous
verrons dans ce qui suit comment définir des types plus compliqués,
notamment le type structure.
Remarque : Un nouveau type défini (type personnalisé) ne peut être utilisé que
dans le bloc d¶instructions là où il a été défini. Dans l¶exemple précédent, le
nouveau type (QWLHU peut être utilisé par tout dans le programme C. Si nous
avions, par exemple PDLQ^W\SHGHILQW(QWLHU«`, le type (QWLHU
n¶aurait pu être utilisé qu¶à l¶interieur du programme principal.
3. Le type structure
Une structure est un type qui permet de stocker plusieurs données, de même
type ou de types différents, dans une même variable. Une structure est
composée de plusieurs champs. Chaque champ correspond à une donnée.
A la différence du tableau qui est un type de données complexe homogène, une
structure est un type de données complexe hétérogène : complexe parce qu¶il y
en a plusieurs données ; hétérogène parce que ces données peuvent être de
types différents.
Format général :
ϭϲϭ

Les types personnalisés .

VWUXFW1RPBVWUXFWXUH!
^
7\SHBGRQQpHV!FKDPS!
7\SHBGRQQpHV!FKDPS!
«
7\SHBGRQQpHVQ!FKDPSQ!
`
Remarques :
xLa définition d¶un type structure se termine par un point-virgule après
l¶accolade fermante.
xL¶espace mémoire réservé à une variable de type structure est égal à la
somme des espaces réservés pour ses champs.
Exemple :
Voici la déclaration d¶une structure SHUVRQQH contenant les champs QRP,
SUHQRP et DJH :
VWUXFWSHUVRQQH
^
FKDUQRP>@
FKDUSUHQRP>@
VKRUWDJH
`
Pour déclarer une variable de type SHUVRQQH, on met par exemple :
VWUXFWSHUVRQQHSHUH
Dans ce cas, la variable SHUH prendra 22 octets en mémoire.
Pour éviter de reprendre VWUXFWSHUVRQQH chaque fois qu¶on déclare une
variable de ce type, il est possible de mettre :
W\SHGHIVWUXFWSHUVRQQH
^
FKDUQRP>@
FKDUSUHQRP>@
VKRUWDJH
`3HUV
3HUVSHUH
Une fois la variable déclarée, on peut la manipuler champ par champ en
concaténant le nom de la variable avec le champ désiré de la manière suivante :
SHUHQRP, SHUHSUHQRP et SHUHDJH. La composante obtenue se comporte
exactement comme toute variable de même type que le champ considéré.
On peut mettre, par exemple : SHUHDJH 
Remarques :
xUne structure peut être passée comme paramètre d¶une fonction ou
procédure.
xLa seule opération qu¶on peut appliquer sur une structure sans passer par ses
champs est l¶affectation. Par exemple, si nous avions $ et % deux variables
ϭϲϮ

Les types personnalisés .

de type 3HUV, nous aurions pu avoir dans notre programme les affectations
$ %ou% $.
xL¶initialisation d¶une structure peut être effectuée à la déclaration, par
exemple : 3HUVSHUH ^$KPHG$OL`
xIl était aussi possible de déclarer des variables lors de la définition de la
structure, par exemple :
VWUXFWSHUVRQQH
^
FKDUQRP>@
FKDUSUHQRP>@
VKRUWDJH
`SHUH
Ou même :
VWUXFW
^
FKDUQRP>@
FKDUSUHQRP>@
VKRUWDJH
`SHUH
Exemple :
LQFOXGHVWGLRK!
W\SHGHIVWUXFWSHUVRQQH
^
FKDUQRP>@
FKDUSUHQRP>@
VKRUWDJH
`3HUV
YRLG$IILFKHU3HUV3^
 SXWV9RLFLOHVLQIRUPDWLRQVGXSqUH
 SULQWIV?QV?QG3QRP3SUHQRP3DJH
`
PDLQ
^
3HUVSHUH
SULQWI'RQQH]OHQRPGXSqUH
VFDQIVSHUHQRP
SULQWI'RQQH]OHSUpQRPGXSqUH
VFDQIVSHUHSUHQRP
SULQWI'RQQH]O
kJHGXSqUH
VFDQIG SHUHDJH
$IILFKHUSHUH
`
Le programme C précédent permet de lire les informations d¶une variable SHUH
de type structure 3HUV. Il permet ensuite d¶afficher ces informations en utilisant
une procédure permettant l¶affichage des champs d¶une variable de type 3HUV
déjà défini.
ϭϲϯ

Les types personnalisés .

Remarques :
xIl est possible de déclarer un tableau dont les éléments sont de type
structure, par exemple, 3HUV7>@. L¶accès au premier élément du tableau
s¶effectuera, par exemple, comme suit : 7>@DJH .
xAu niveau de la procédure $IILFKHU, il y avait un passage de paramètre par
valeur. Il est aussi possible de passer une structure par adresse à une
fonction ou procédure, eg. YRLG,QLW3HUV 3. L¶accès à un champ au
niveau de cette procédure se fait par 3!DJH ou par  3DJH, et l¶appel au
niveau du programme principal se fait par ,QLW SHUH.
Soit l¶exemple :
LQFOXGHVWGLRK!
W\SHGHIVWUXFWSHUVRQQH
^
FKDUQRP>@
FKDUSUHQRP>@
VKRUWDJH
`3HUV
YRLG,QLW3HUV 3^
 3!DJH RXELHQ  3DJH 
`
PDLQ
^
3HUVSHUH
,QLW SHUH
SULQWI/¶kJHGXSqUHHVWGSHUHDJH
`
Le programme affiche :/¶kJHGXSqUHHVW
4. Le type union
L¶union est un type de données qui permet de stocker des données de types
différents à la même adresse mémoire (dans le même emplacement ou la même
case mémoire).
Une union peut être définie avec plusieurs champs, mais, à un moment donné,
il n¶y a qu¶un seul champ qui peut prendre une valeur.
A la différence d¶une structure qui est un type de données complexe
hétérogène, l¶union est un type simple hétérogène : simple à cause de l¶unicité
de la valeur ; l¶hétérogénéité vient du fait que cette valeur peut être de
différents types.
On ne peut manipuler qu¶un seul champ à la fois au détriment des autres
champs, i.e., une variable de type union ne peut prendre qu¶une seule valeur de
ses champs à un moment donné.
Le type union a pour objectif de permettre au programmeur d¶utiliser une seule
variable de différentes manières sans perdre de l¶espace mémoire.
Format général en C :
ϭϲϰ

Les types personnalisés .

XQLRQ1RPBXQLRQ!
^
7\SHBGRQQpHV!FKDPS!
7\SHBGRQQpHV!FKDPS!
«
7\SHBGRQQpHVQ!FKDPSQ!
`
Remarques :
xLa définition d¶un type union se termine par un point-virgule après
l¶accolade fermante.
xL¶espace mémoire réservé pour une variable de type union est égal à
l¶espace mémoire réservé pour le champ le plus grand, i.e, le champ qui
prend le plus d¶espace par rapport aux autres champs.
Exemple :
On peut définir une union dont les éléments peuvent être soit LQW, soit IORDW,
comme suit :
XQLRQGDWD
^
LQWL
IORDW[
`
Pour déclarer une variable de type XQLRQGDWD, on met par exemple :
XQLRQGDWDG
La variable G prendra 4 octets en mémoire (la taille du type IORDW).
Pour éviter de reprendre XQLRQGDWD chaque fois qu¶on déclare une variable de
ce type, il est possible de mettre :
W\SHGHIXQLRQGDWD
^
LQWL
IORDW[
`'DWD
'DWDG
Une fois la variable déclarée, on peut la manipuler à travers un seul champ à la
fois en concaténant le nom de la variable avec le champ désiré de la manière
suivante : GL ou G[.
On peut mettre, par exemple : GL . Si on met par la suite G[ , la
valeur  sera perdue.
Remarques :
xUne union peut être passée comme paramètre d¶une fonction ou procédure.
xLa seule opération qu¶on peut appliquer sur une union sans passer par ses
champs est l¶affectation. Par exemple, si nous avions $ et % deux variables
de type 'DWD, on aurait pu trouver dans notre programme les affectations : $
%ou % $.
ϭϲϱ

Les types personnalisés .

Exemple :
LQFOXGHVWGLRK!
W\SHGHIXQLRQGDWD
^LQWL
IORDW[
`'DWD
PDLQ
^
'DWDG
LQWFKRL[
SULQWI9RXOH]YRXVHQWUHUXQHQWLHURXXQUpHO
VFDQIG FKRL[
VZLWFKFKRL[
^FDVHVFDQIG GLSULQWIGGLEUHDN
FDVHVFDQII G[SULQWIIG[EUHDN
GHIDXOWSULQWI&KRL[LQFRUUHFW
`
`
Le programme C précédent permet, à travers un menu affiché, de lire une
variable G de type 'DWD, soit en tant que variable entière, soit en tant que
variable réelle. Il affiche ensuite la valeur saisie selon le choix.
5. Le type énumération
Une énumération est un type de données qui permet à une variable de prendre
un nombre fini de valeurs. Les valeurs d¶un type énumération sont des
identificateurs (noms ou symboles). Chaque identificateur correspond à une
constante entière. Le type énumération est un type simple homogène.
Format général en C :
HQXP1RPBHQXP!^YDOYDO«YDOQ`
Remarques :
xLa définition d¶un type énumération se termine par un point-virgule après
l¶accolade fermante.
xL¶espace mémoire réservé pour une variable de type énumération est
généralement égal à l¶espace nécessaire pour le stockage d¶un entier.
Exemple :
Voici la déclaration d¶un type énumération $QLPDO représentant différentes
sortes d¶animaux :
HQXP$QLPDO^OLRQHOHSKDQWFKDWJLUDIH`
Pour déclarer une variable de type$QLPDO, on met par exemple :
HQXP$QLPDO$
La variable $ peut prendre comme valeur soit OLRQ, HOHSKDQW, FKDW ou
JLUDIH.
Pour éviter de reprendre HQXP$QLPDO chaque fois qu¶on déclare une variable
de ce type, il est possible de mettre :
ϭϲϲ

Les types personnalisés .

W\SHGHIHQXP$QLPDO^OLRQHOHSKDQWFKDWJLUDIH`$QLP
$QLP$
Remarques :
xLes valeurs d¶un type HQXP correspondent par défaut à des constantes
entières , , ... Donc, OLRQ correspond à , HOHSKDQW à , etc. On peut
redéfinir ces valeurs tout en gardant de préférence leur ordre croissant, par
exemple : HQXP $QLPDO ^OLRQ HOHSKDQW  FKDW JLUDIH ` 
Comme ça, OLRQ correspond à  (valeur prise par défaut), HOHSKDQW à ,
FKDW aura  (suivant de , son prédécesseur), et JLUDIH aura . Dans ce
cas, les deux écritures LI $ FKDW ^«` et LI $  ^«` seront
équivalentes.
xUne variable de type énumération se comporte comme celle de type entier.
On peut faire une affectation (eg. $ OLRQ et $  sont équivalentes),
une boucle (eg. IRU$ OLRQ$ JLUDIH$^«`), choix multiple
(eg. VZLWFK $ ^ FDVH OLRQ « FDVH HOHSKDQW « «`), une
comparaison (eg. OLRQHOHSKDQW retourne  pour dire 95$,), un
affichage (eg. SULQWI/LRQGOLRQaffiche : ), une lecture (eg.
VFDQIG $), un passage en paramètre d¶une fonction ou procédure,
etc.
Exemple :
LQFOXGHVWGLRK!
W\SHGHIHQXP$QLPDO^OLRQHOHSKDQWFKDWJLUDIH`$QLP
$QLP6DLVLH&KRL[
^
LQWFKRL[
SXWVΗŚŽŝƐŝƌƵŶŶŽŵďƌĞŝŶĚŝƋƵĂŶƚƵŶĂŶŝŵĂů͗Ϭ;ůŝŽŶͿ͕ϭ;ĠůĠƉŚĂŶƚͿ͕Ϯ;ĐŚĂƚͿŽƵϯ;ŐŝƌĂĨĞͿ͗Η
VFDQIG FKRL[
VZLWFKFKRL[
^
FDVHOLRQUHWXUQOLRQEUHDN
FDVHHOHSKDQWUHWXUQHOHSKDQWEUHDN
FDVHFKDWUHWXUQFKDWEUHDN
FDVHJLUDIHUHWXUQJLUDIHEUHDN
GHIDXOWSULQWIΗŚŽŝdžŝŶĐŽƌƌĞĐƚ͊sŽƵƐĂƵƌĞnjƉĂƌĚĠĨĂƵƚůĞĐŚŽŝdžůŝŽŶ͘ͰŶΗ
UHWXUQOLRQ
`
`
PDLQ
^
$QLP$
$ 6DLVLH&KRL[
LI$ FKDWSULQWI$QLPDOGRPHVWLTXH
HOVHSULQWI$QLPDOVDXYDJH
`

ϭϲϳ

Les types personnalisés .

Dans ce programme, nous avons défini un type énumération $QLP avec un

ensemble d¶animaux. Nous avons défini une fonction de type $QLP. La fonction
retourne une valeur de type $QLP selon un nombre saisi au choix. Au niveau du
programme principal, nous avons déclaré une variable $ de type $QLP qui aura
sa valeur selon le nombre saisi au clavier, et selon cette valeur, le programme
va nous indiquer s¶il s¶agit d¶un animal sauvage ou domestique.
6. Exercices corrigés
6.1. Exercices
Exercice 1 :
Présentez en C les types structures suivants :
x Un nombre complexe est défini par une partie réelle et une partie
imaginaire.
x Une date est composée d¶un numéro de jour (1..31), d¶un numéro de mois
(1..12) et d¶une année.
x Un stage peut être défini par un intitulé (une chaîne de caractères), une date
de début et une date de fin (deux dates), un nombre de places (entier).
x Une identité décrivant le nom, le prénom et la date de naissance.
x Une fiche bibliographique est définie par le titre du livre (chaîne), les
auteurs (10 auteurs maximum, chacun est défini par nom, prénom et date
de naissance), la date de parution, l¶éditeur (nom, prénom et date de
naissance), le numéro ISBN (chaîne).
Comment peut-on affecter une valeur à :
x Une partie réelle d¶une variable X de type complexe.
x Jour d¶une variable Y de type date.
x Mois de la date de début d¶une variable Z de type stage.
x Année de la date de naissance d¶une variable G de type identité.
x Jour de la date naissance du premier auteur d¶une variable H de type fiche
bibliographique.
Exercice 2 :
Ecrire un programme C permettant de définir un type structure dit SHUH
possédant les champs QRP de type chaîne de caractères, GDWHBQDLVde type
chaîne de caractères, QEUBHQI de type entier, et OLVWHBHQI de type chaîne de
caractères. Le programme doit permettre de lire et d¶afficher les informations
d¶une variable SHUH de type structure déjà défini.
Exercice 3 :
Reprendre l¶exercice 2, mais cette fois-ci en modifiant la structure SHUH comme
suit : le champ GDWHBQDLV doit être à son tour défini en tant que type structure
possédant les champs : MRXU, PRLV, et DQQHH. Le champ OLVWHBHQI doit être
déclaré en tant que tableau de chaînes de caractères.
ϭϲϴ

Les types personnalisés .

Exercice 4 :
Reprendre l¶exercice 2, mais cette fois-ci en utilisant une procédure qui reçoit
en paramètre une variable de type enregistrement (SHUH), puis, elle l¶affiche.
Exercice 5 :
En utilisant le type structure SHUH défini dans l¶exercice 2, essayez cette fois de
déclarer dans un programme C deux variables SHUH et SHUH de type SHUH, de
lire uniquement le nombre d¶enfants des deux pères, et de calculer et d¶afficher
le nombre total d¶enfants.
Exercice 6 :
Ecrire un programme C permettant de déclarer un tableau de cinq éléments de
type structure SHUH défini dans l¶exercice 2, de lire ses éléments, de les
afficher, et enfin d¶afficher le nombre total d¶enfants.
Exercice 7 :
On considère dix candidats inscrits à une formation diplômante. Chaque
candidat va obtenir une note pour cette formation. Ecrire le programme C
permettant d¶afficher la liste des candidats dont la note est supérieure ou égale à
la moyenne des notes de tous les candidats (les noms des candidats et les notes
étant lus à partir du clavier). Utilisez un tableau dont les éléments sont de type
structure. Le type structure doit contenir un champ indiquant le nom du
candidat et un autre indiquant la note du candidat.
Exercice 8 :
Ecrire un programme C qui lit un tableau dont les éléments sont de type
structure SRLQW défini comme suit :
VWUXFWSRLQW^
LQWQXP
IORDW[
IORDW\
`
Le programme doit afficher l¶ensemble des informations précédentes. Notons
que le programme doit utiliser une procédure pour la lecture et une autre pour
l¶affichage.
Exercice 9 :
Définir une structure 1RPEUH5DWLRQQHO permettant de coder un nombre
rationnel, avec numérateur et dénominateur. On écrira une procédure de saisie
sans paramètres. Une procédure d¶affichage avec un paramètre passé par
valeur. On écrira aussi des fonctions de multiplication et d¶addition de deux
rationnels. Pour l¶addition, pour simplifier, on ne cherchera pas nécessairement
le plus petit dénominateur commun. Le programme principal doit être capable
de lire deux nombres rationnels, de les afficher, et d¶afficher leur multiplication
et addition.

ϭϲϵ

Les types personnalisés .

Exercice 10 :
Une menuiserie industrielle gère un stock de panneaux de bois. Chaque
panneau possède une largeur, une longueur et une épaisseur en millimètres,
ainsi que le type de bois qui peut être pin (code 0), chêne (1) ou hêtre (code 2).
1. Définir une structure 3DQQHDX contenant toutes les informations
relatives à un panneau de bois.
2. Ecrire des procédures de saisie et d¶affichage d¶un panneau de bois.
3. Ecrire une fonction qui calcul le volume en mètres cubes d¶un panneau.
Exercice 11 :
Un grossiste en composants électroniques vend quatre types de produits :
x Des cartes mères (code 1) ;
x Des processeurs (code 2) ;
x Des barrettes de mémoire (code 3) ;
x Des cartes graphiques (code 4).
Chaque produit possède une référence (qui est un nombre entier), un prix en
dinars et une quantité disponible.
1. Définir une structure 3URGXLW qui code un produit.
2. Ecrire des procédures de saisie et d¶affichage des données d¶un produit.
3. Ecrire une procédure &RPPDQGH qui permet à un utilisateur de saisir les
données d¶un produit (appel de la procédure de saisie). L¶utilisateur saisit
aussi la quantité commandée du produit. La procédure affiche toutes les
données du produit (procédure d¶affichage), ainsi que le prix total à payer
pour effectuer la commande.
4. Le programme principal fait appel à seulement la procédure &RPPDQGH.
Exercice 12 :
L¶université organise un tournoi de tennis de table en double. Chaque équipe
engagée se compose de deux joueurs et possède un nom. Chaque joueur est
caractérisé par un nom, un prénom, un âge, et un score allant de 0 à 100
indiquant son niveau.
1) Définissez les types structures MRXHXU et HTXLSH correspondants.
2) Ecrivez une procédure VDLVLUBMRXHXU permettant de saisir les
caractéristiques d¶un joueur. Le paramètre doit être passé par adresse.
3) En utilisant la procédure précédente, écrivez une procédure
VDLVLUBHTXLSH permettant de saisir les caractéristiques d¶une équipe. Le
paramètre doit être passé par adresse.
4) Ecrivez le programme PDLQ qui crée et remplit un tableau de quatre
équipes en utilisant la procédure VDLVLUBHTXLSH.
5) Ecrivez les procédures DIILFKHUBMRXHXU et DIILFKHUBHTXLSH pour
afficher à l¶écran les équipes et leurs joueurs.

ϭϳϬ

Les types personnalisés .

6) Complétez le programme PDLQ de manière à afficher les équipes après la

saisie.
Exercice 13 :
Une taille peut être exprimée soit en centimètres, soit en mètres. Quel est le
type adéquat pour représenter une telle information ? Donnez sa présentation en
C.
Exercice 14 :
Comme le type booléen n¶existe pas en C, essayez de le définir par un type
énumération. Résoudre le problème de la recherche dans un tableau (technique
de Flag) en utilisant le type que vous avez défini.
Exercice 15 :
Une entreprise veut stocker dans un tableau ses recettes mensuelles pour une
année.
1) Définissez un type énumération PRLV permettant de représenter les 12 mois
de l¶année.
2) Ecrivez une procédure $IILFKHBPRLV permettant d¶afficher le mot
correspondant au numéro du mois passé en paramètre.
3) Ecrivez une procédure 6DLVLUBUHFHWWHV demandant à un utilisateur de
remplir le tableau des recettes mensuelles.
4) Ecrivez le programme principal PDLQ qui appelle 6DLVLUBUHFHWWHV et
affiche la somme des recettes de l¶année entière.
Exercice 16 :
Ecrire un programme C permettant de définir un type énumération ayant
comme valeurs les jours de la semaine, ensuite de lire une variable entière et de
dire si ça correspond à un jour férié dans la liste des valeurs énumérées ou non.
Exercice 17 :
Ecrire un programme C permettant de définir un type énumération ayant
comme valeurs les couleurs d¶un feu permettant la gestion de la circulation
dans un carrefour, ensuite de lire une variable entière et d¶afficher à quelle
couleur cette valeur correspond.
6.2. Corrigés
Solution 1 :
LQFOXGHVWGLRK!
'pFODUDWLRQGHVW\SHV
W\SHGHIVWUXFWQRPEUHBFRPSOH[H^
IORDW3BUHHOOH
IORDW3BLPDJLQDLUH
`1RPEUHBFRPSOH[H
W\SHGHIVWUXFWGDWH^
VKRUWMRXU
VKRUWPRLV
LQWDQQHH
ϭϳϭ

Les types personnalisés .

`'DWH
W\SHGHIVWUXFWVWDJH^
FKDULQWLWXOH>@
'DWHGDWHBGHEXWGDWHBILQ
LQWQEUBSODFH
`6WDJH
W\SHGHIVWUXFWLGHQWLWH^
FKDUQRP>@
FKDUSUHQRP>@
'DWHGDWHBQDLV
`,GHQWLWH
W\SHGHIVWUXFWILFKHBELEOLR^
FKDUWLWUH>@
,GHQWLWHDXWHXUV>@
'DWHGDWHBSDUXWLRQ
,GHQWLWHHGLWHXU
FKDUQXPB,6%1>@
`)LFKHBELEOLR
'pFODUDWLRQGHVYDULDEOHV
1RPEUHBFRPSOH[H;
'DWH<
6WDJH=
,GHQWLWH*
)LFKHBELEOLR+
PDLQ^
ĐĐğƐĂƵdžĐŚĂŵƉƐĚĞƐǀĂƌŝĂďůĞƐ͘>ĞƐǀĂůĞƵƌƐĂĨĨĞĐƚĠĞƐƐŽŶƚƐĞƵůĞŵĞŶƚĚĞƐĞdžĞŵƉůĞƐ͘
;3BUHHOOH 
<MRXU 
=GDWHBGHEXWPRLV 
*GDWHBQDLVDQQHH 
+DXWHXUV>@GDWHBQDLVMRXU 
`
Solution 2 :
LQFOXGHVWGLRK!
W\SHGHIVWUXFWSHUH^
FKDUQRP>@
FKDUGDWHBQDLV>@
LQWQEUBHQI
FKDUOLVWHBHQI>@
`3HUH
3HUHSHUH
PDLQ^
SULQWI'RQQH]OHQRPGXSqUH
VFDQIVSHUHQRP
SULQWI'RQQH]ODGDWHGHQDLVVDQFHGXSqUH
VFDQIVSHUHGDWHBQDLV
SULQWI'RQQH]OHQRPEUHG
HQIDQWVGXSqUH
VFDQIG SHUHQEUBHQI
SULQWI'RQQH]ODOLVWHGHVHQIDQWVGXSqUH
ϭϳϮ

Les types personnalisés .

VFDQIVSHUHOLVWHBHQI

SXWV9RLFLOHVLQIRUPDWLRQVFRQFHUQDQWFHSqUH
SULQWIΗEŽŵ͗йƐ͕ĂƚĞŶĂŝƐƐĂŶĐĞ͗йƐ͕EŽŵďƌĞĚΖĞŶĨĂŶƚƐ͗йĚͰŶΗ͕ƉĞƌĞϭ͘ŶŽŵ͕
ƉĞƌĞϭ͘ĚĂƚĞͺŶĂŝƐ͕ƉĞƌĞϭ͘ŶďƌͺĞŶĨ
SULQWI/LVWHGHVHQIDQWVVSHUHOLVWHBHQI
`
Solution 3 :
LQFOXGHVWGLRK!
W\SHGHIVWUXFWGDWH^
VKRUWMRXU
VKRUWPRLV
LQWDQQHH
`'DWH
W\SHGHIVWUXFWSHUH^
FKDUQRP>@
'DWHGDWHBQDLV
LQWQEUBHQI
FKDUOLVWHBHQI>@>@
`3HUH
3HUHSHUH
LQWL
PDLQ^
SULQWI'RQQH]OHQRPGXSqUH
VFDQIVSHUHQRP
SXWV'RQQH]ODGDWHGHQDLVVDQFHGXSqUH
SULQWI-RXUVFDQIG SHUHGDWHBQDLVMRXU
SULQWI0RLVVFDQIG SHUHGDWHBQDLVPRLV
SULQWI$QQpHVFDQIG SHUHGDWHBQDLVDQQHH
SULQWI'RQQH]OHQRPEUHG
HQIDQWVGXSqUH
VFDQIG SHUHQEUBHQI
SXWV'RQQH]ODOLVWHGHVHQIDQWV
IRUL L SHUHQEUBHQIL^
SULQWI'RQQH]OHQRPGHO
HQIDQWQXPGL
VFDQIVSHUHOLVWHBHQI>L@
`
SXWV9RLFLOHVLQIRUPDWLRQVFRQFHUQDQWFHSqUH
SULQWIΗEŽŵ͗йƐ͕ĂƚĞŶĂŝƐƐĂŶĐĞ͗йĚͬйĚͬйĚ͕EŽŵďƌĞĚΖĞŶĨĂŶƚƐ͗йĚͰŶΗ͕
ƉĞƌĞϭ͘ŶŽŵ͕ƉĞƌĞϭ͘ĚĂƚĞͺŶĂŝƐ͘ũŽƵƌ͕ƉĞƌĞϭ͘ĚĂƚĞͺŶĂŝƐ͘ŵŽŝƐ͕
ƉĞƌĞϭ͘ĚĂƚĞͺŶĂŝƐ͘ĂŶŶĞĞ͕ƉĞƌĞϭ͘ŶďƌͺĞŶĨ
SXWV9RLFLODOLVWHGHVHVHQIDQWV
IRUL L SHUHQEUBHQILSULQWIV?Q
SHUHOLVWHBHQI>L@
`
Solution 4 :
LQFOXGHVWGLRK!
W\SHGHIVWUXFWSHUH^
FKDUQRP>@
FKDUGDWHBQDLV>@

ϭϳϯ

Les types personnalisés .

LQWQEUBHQI
FKDUOLVWHBHQI>@
`3HUH
3HUHSHUH
YRLG$IILFKHU3HUH;^
SXWV9RLFLOHVLQIRUPDWLRQVFRQFHUQDQWFHSqUH
SULQWIΗEŽŵ͗йƐ͕ĂƚĞŶĂŝƐƐĂŶĐĞ͗йƐ͕EŽŵďƌĞĚΖĞŶĨĂŶƚƐ͗йĚͰŶΗ͕y͘ŶŽŵ͕
y͘ĚĂƚĞͺŶĂŝƐ͕y͘ŶďƌͺĞŶĨ
SULQWI/LVWHGHVHQIDQWVV;OLVWHBHQI
`
PDLQ^
SULQWI'RQQH]OHQRPGXSqUH
VFDQIVSHUHQRP
SULQWI'RQQH]ODGDWHGHQDLVVDQFHGXSqUH
VFDQIVSHUHGDWHBQDLV
SULQWI'RQQH]OHQRPEUHG
HQIDQWVGXSqUH
VFDQIG SHUHQEUBHQI
SULQWI'RQQH]ODOLVWHGHVHQIDQWVGXSqUH
VFDQIVSHUHOLVWHBHQI
$IILFKHUSHUH
`
Solution 5 :
LQFOXGHVWGLRK!
W\SHGHIVWUXFWSHUH^
FKDUQRP>@
FKDUGDWHBQDLV>@
LQWQEUBHQI
FKDUOLVWHBHQI>@
`3HUH
3HUHSHUHSHUH
LQWVRPPH
PDLQ^
SULQWI'RQQH]OHQRPEUHG
HQIDQWVGXSUHPLHUSqUH
VFDQIG SHUHQEUBHQI
SULQWI'RQQH]OHQRPEUHG
HQIDQWVGXGHX[LqPHSqUH
VFDQIG SHUHQEUBHQI
VRPPH SHUHQEUBHQISHUHQEUBHQI
SULQWI1RPEUHWRWDOG
HQIDQWVHVWGVRPPH
`
Solution 6 :
LQFOXGHVWGLRK!
W\SHGHIVWUXFWSHUH^
FKDUQRP>@
FKDUGDWHBQDLV>@
LQWQEUBHQI
FKDUOLVWHBHQI>@
`3HUH
3HUHSHUHV>@
LQWMQEU
ϭϳϰ

Les types personnalisés .

PDLQ^
QEU 
IRUM M M^
SULQWI'RQQH]OHQRPGXSqUHQXPGM
VFDQIVSHUHV>M@QRP
SULQWI'RQQH]ODGDWHGHQDLVVDQFHGXSqUHQXPGM
VFDQIVSHUHV>M@GDWHBQDLV
SULQWI'RQQH]OHQRPEUHG
HQIDQWVGXSqUHQXPGM
VFDQIG SHUHV>M@QEUBHQI
QEU SHUHV>M@QEUBHQI
SULQWI'RQQH]ODOLVWHGHVHQIDQWVGXSqUHQXPGM
VFDQIVSHUHV>M@OLVWHBHQI
`
SULQWIΗͰŶsŽŝĐŝůĂůŝƐƚĞĚĞƐƉğƌĞƐ͗ͰŶΗ͕ũ
IRUM M M^
SULQWIΗsŽŝĐŝůĞƐŝŶĨŽƌŵĂƚŝŽŶƐĐŽŶĐĞƌŶĂŶƚůĞƉğƌĞŶƵŵйĚͰŶΗ͕ũ
SULQWI1RPV?QSHUHV>M@QRP
SULQWI/DGDWHGHQDLVVDQFHV?QSHUHV>M@GDWHBQDLV
SULQWI/HQRPEUHG
HQIDQWVG?QSHUHV>M@QEUBHQI
SULQWI/DOLVWHGHVHQIDQWVV?QSHUHV>M@OLVWHBHQI
`
SULQWI/HQRPEUHWRWDOG¶HQIDQWV GQEU
`
Solution 7 :
LQFOXGHVWGLRK!
GHILQHPD[
W\SHGHIVWUXFWFDQGLGDW^
FKDUQRP>@
IORDWQRWH
`&DQGLGDW
&DQGLGDWOLVWH>PD[@
IORDWVRPPHPR\
LQWL
PDLQ^
VRPPH 
 6DLVLUOHVQRPVHWOHVQRWHVGHVFDQGLGDWV 
IRUL L PD[L^
SULQWI6DLVLUOHQRPGXFDQGLGDWQƒGL
VFDQIVOLVWH>L@QRP
SULQWI6DLVLUODQRWHGXFDQGLGDWVOLVWH>L@QRP
VFDQII OLVWH>L@QRWH
VRPPH OLVWH>L@QRWH
`
 $IILFKHUODPR\HQQHGHVQRWHVGHVFDQGLGDWV 
PR\ VRPPHPD[
SULQWIΗ>ĂŵŽLJĞŶŶĞĚĞƐŶŽƚĞƐĚĞƐĐĂŶĚŝĚĂƚƐĞƐƚĠŐĂůĞăйĨͰŶΗ͕ŵŽLJ
 ĨĨŝĐŚĞƌůĞƐĐĂŶĚŝĚĂƚƐĚŽŶƚůĂŶŽƚĞĞƐƚхсăůĂŵŽLJĞŶŶĞĚĞƐŶŽƚĞƐĚĞƚŽƵƐůĞƐĐĂŶĚŝĚĂƚƐ 
SXWVΗsŽŝĐŝůĂůŝƐƚĞĚĞƐĐĂŶĚŝĚĂƚƐĚŽŶƚůĂŶŽƚĞĞƐƚхсăůĂŵŽLJĞŶŶĞΗ
IRUL L PD[L
ϭϳϱ

Les types personnalisés .

LIOLVWH>L@QRWH! PR\

SULQWIΗйƐĂǀĞĐƵŶĞŶŽƚĞĚĞйĨͰŶΗ͕ůŝƐƚĞ΀ŝ΁͘ŶŽŵ͕ůŝƐƚĞ΀ŝ΁͘ŶŽƚĞ
`
Solution 8 :
LQFOXGHVWGLRK!
GHILQH1EUB3
W\SHGHIVWUXFWSRLQW^
LQWQXP
IORDW[
IORDW\
`3RLQW
3RLQW7>1EUB3@
LQWL
YRLG/LUH^
 IRUL L1EUB3L^
  SULQWIΗŽŶŶĞnjůĞƐŝŶĨŽƌŵĂƚŝŽŶƐĚĞůΖĠůĠŵĞŶƚйĚ͗ͰŶΗ͕ŝ
  SULQWI1XPpURVFDQIG 7>L@QXP
  SULQWI[VFDQII 7>L@[
  SULQWI\VFDQII 7>L@\
 `
`
YRLG$IILFKHU^
 IRUL L1EUB3L^
 SULQWIΗsŽŝĐŝůĞƐŝŶĨŽƌŵĂƚŝŽŶƐĚĞůΖĠůĠŵĞŶƚйĚ͗ͰŶΗ͕ŝ
 SULQWIΗEƵŵĠƌŽ͗йĚ͕Ͱƚdž͗йĨ͕ͰƚLJ͗йĨͰŶΗ͕d΀ŝ΁͘ŶƵŵ͕d΀ŝ΁͘dž͕d΀ŝ΁͘LJ
 `
`
PDLQ^
SXWV ,QWURGXLUHOHVLQIRUPDWLRQVGHVpOpPHQWV 
/LUH
SXWV 9RLFLOHVLQIRUPDWLRQVGHVpOpPHQWV 
$IILFKHU
`
Solution 9 :
LQFOXGHVWGLRK!
W\SHGHIVWUXFWUDWLRQQHO^
LQWQXPHUDWHXUGHQRPLQDWHXU
`1RPEUH5DWLRQQHO
1RPEUH5DWLRQQHO;<0$
YRLG6DLVLU^
SXWV(QWUH]OHQXPpUDWHXUHWOHGpQRPLQDWHXUGH;
VFDQIGG ;QXPHUDWHXU ;GHQRPLQDWHXU
SXWV(QWUH]OHQXPpUDWHXUHWOHGpQRPLQDWHXUGH<
VFDQIGG <QXPHUDWHXU <GHQRPLQDWHXU
`
YRLG$IILFKHU1RPEUH5DWLRQQHOQ^
SULQWI1XPpUDWHXUG?W'pQRPLQDWHXUG?Q
QQXPHUDWHXUQGHQRPLQDWHXU

ϭϳϲ

Les types personnalisés .

`
1RPEUH5DWLRQQHO0XOWLSOLHUEŽŵďƌĞZĂƚŝŽŶŶĞůŵ͕EŽŵďƌĞZĂƚŝŽŶŶĞůŶ^
 1RPEUH5DWLRQQHOU
 UQXPHUDWHXU PQXPHUDWHXU QQXPHUDWHXU
 UGHQRPLQDWHXU PGHQRPLQDWHXU QGHQRPLQDWHXU
 UHWXUQU
`
1RPEUH5DWLRQQHO$GGLWLRQQHUEŽŵďƌĞZĂƚŝŽŶŶĞůŵ͕EŽŵďƌĞZĂƚŝŽŶŶĞůŶ^
 1RPEUH5DWLRQQHOU
 UQXPHUDWHXU PQXPHUDWHXU QGHQRPLQDWHXU
QQXPHUDWHXU PGHQRPLQDWHXU
 UGHQRPLQDWHXU PGHQRPLQDWHXU QGHQRPLQDWHXU
 UHWXUQU
`
PDLQ^
SXWV ,QWURGXLUH;HW< 
6DLVLU
SXWV $IILFKHU;HW< 
$IILFKHU;
$IILFKHU<
SXWV?Q /DPXOWLSOLFDWLRQGH;SDU<GRQQH
0 0XOWLSOLHU;<
SULQWI?W1XPpUDWHXU G?W'pQRPLQDWHXU G?Q
0QXPHUDWHXU0GHQRPLQDWHXU
SXWV?Q /
DGGLWLRQGH;HW<GRQQH
$ $GGLWLRQQHU;<
SULQWI?W1XPpUDWHXU G?W'pQRPLQDWHXU G?Q
$QXPHUDWHXU$GHQRPLQDWHXU
`
Solution 10 :
LQFOXGHVWGLRK!
W\SHGHIVWUXFWSDQQHDX^
IORDWORQJXHXUODUJHXUHSDLVVHXU
VKRUWW\SH
`3DQQHDX
3DQQHDX;
YRLG6DLVLU^
SULQWI(QWUH]ODORQJXHXUHQPLOOLPqWUHVGXSDQQHDX
VFDQII ;ORQJXHXU
SULQWI(QWUH]ODODUJHXUHQPLOOLPqWUHVGXSDQQHDX
VFDQII ;ODUJHXU
SULQWI(QWUH]O
pSDLVVHXUHQPLOOLPqWUHVGXSDQQHDX
VFDQII ;HSDLVVHXU
SULQWIΗŶƚƌĞnjůĞƚLJƉĞĚƵƉĂŶŶĞĂƵϬͲƉŝŶ͕ϭͲĐŚġŶĞŽƵϮͲŚġƚƌĞ͗Η
VFDQIG ;W\SH
`
YRLG$IILFKHU3DQQHDX3^
SULQWIΗ>ĂůŽŶŐƵĞƵƌĞŶŵŝůůŝŵğƚƌĞƐĚƵƉĂŶŶĞĂƵ͗йĨͰŶΗ͕W͘ůŽŶŐƵĞƵƌ
SULQWIΗ>ĂůĂƌŐĞƵƌĞŶŵŝůůŝŵğƚƌĞƐĚƵƉĂŶŶĞĂƵ͗йĨͰŶΗ͕W͘ůĂƌŐĞƵƌ
ϭϳϳ

Les types personnalisés .

SULQWIΗ>ΖĠƉĂŝƐƐĞƵƌĞŶŵŝůůŝŵğƚƌĞƐĚƵƉĂŶŶĞĂƵ͗йĨͰŶΗ͕W͘ĞƉĂŝƐƐĞƵƌ
SULQWI/HW\SHGXSDQQHDX
VZLWFK3W\SH^
FDVHSULQWI3LQ?QEUHDN
FDVHSULQWI&KrQH?QEUHDN
FDVHSULQWI+rWUH?QEUHDN
GHIDXOWSULQWI7\SHLQFRQQX?Q
  `
`
IORDW9ROXPH3DQQHDXS^
 UHWXUQSODUJHXU SORQJXHXU SHSDLVVHXUH
`
PDLQ^
SXWV ,QWURGXLUHXQ3DQQHDX 
6DLVLU
SXWV $IILFKHUOH3DQQHDX 
$IILFKHU;
SULQWIΗͰŶΎΎΎΎsŽůƵŵĞĞŶŵğƚƌĞƐĐƵďĞƐĚƵƉĂŶŶĞĂƵсйĨΗ͕sŽůƵŵĞ;yͿ
`
Solution 11 :
LQFOXGHVWGLRK!
W\SHGHIVWUXFWSURGXLW^
 VKRUWW\SH
 XQVLJQHGLQWUHIHUHQFH
 IORDWSUL[
 XQVLJQHGLQWTXDQWLWHBGLVSR
`3URGXLW
3URGXLW;
YRLG6DLVLU^
SULQWIΗŶƚƌĞnjůĞƚLJƉĞĚƵƉƌŽĚƵŝƚϭͲĐĂƌƚĞŵğƌĞ͕ϮͲƉƌŽĐĞƐƐĞƵƌ͕Η
SULQWIEDUUHWWHPpPRLUHRXFDUWHJUDSKLTXH
VFDQIG ;W\SH
SULQWI(QWUH]ODUpIHUpQFHGXSURGXLW
VFDQIG ;UHIHUHQFH
SULQWI(QWUH]OHSUL[GXSURGXLW
VFDQII ;SUL[
SULQWI(QWUH]ODTXDQWLWpGLVSRQLEOHGXSURGXLW
VFDQIG ;TXDQWLWHBGLVSR
`
YRLG$IILFKHU3URGXLW3^
 SULQWI/HW\SHGXSURGXLW
 VZLWFK3W\SH^
 FDVHSULQWI&DUWHPqUH?QEUHDN
 FDVHSULQWI3URFHVVHXU?QEUHDN
 FDVHSULQWI%DUUHWWHPpPRLUH?QEUHDN
 FDVHSULQWI&DUWHJUDSKLTXH?QEUHDN
 GHIDXOWSULQWI7\SHLQFRQQX?Q
 `
 SULQWI/DUpIpUHQFHGXSURGXLWG?Q3UHIHUHQFH
ϭϳϴ

Les types personnalisés .

 SULQWI/HSUL[GXSURGXLWI?Q3SUL[

 SULQWIΗ>ĂƋƵĂŶƚŝƚĠĚƵƉƌŽĚƵŝƚ͗йĚͰŶΗ͕W͘ƋƵĂŶƚŝƚĞͺĚŝƐƉŽ
`
YRLG&RPPDQGH^
SXWV ,QWURGXLUHXQSURGXLW 
6DLVLU
XQVLJQHGLQWTW
SULQWI(QWUH]ODTXDQWLWpFRPPDQGpH
VFDQIG TW
SXWV $IILFKHUOHSURGXLW 
$IILFKHU;
LITW ;TXDQWLWHBGLVSR
SULQWIΗWƌŝdžƚŽƚĂůăƉĂLJĞƌƉŽƵƌƐĂƚŝƐĨĂŝƌĞůĂĐŽŵŵĂŶĚĞсйĨΗ͕y͘ƉƌŝdžΎƋƚ
HOVHSULQWIΗYĂŶƚŝƚĠĚŝƐƉŽŶŝďůĞŝŶƐƵĨĨŝƐĂŶƚĞƉŽƵƌƐĂƚŝƐĨĂŝƌĞůĂĐŽŵŵĂŶĚĞ͊͊Η
`
PDLQ^
&RPPDQGH
`
Solution 12 :
LQFOXGHVWGLRK!
GHILQH1
W\SHGHIVWUXFWMRXHXU
^
FKDUQRP>@
FKDUSUHQRP>@
VKRUWDJH
VKRUWQLYHDX
`-RXHXU
W\SHGHIVWUXFWHTXLSH
^FKDUQRP>@
-RXHXUMRXHXU
-RXHXUMRXHXU
`(TXLSH
YRLG6DLVLUBMRXHXU-RXHXU M
^SULQWI(QWUH]OHSUpQRPVFDQIVM!SUHQRP
SULQWI(QWUH]OHQRPVFDQIVM!QRP
SULQWI(QWUH]O
kJHVFDQIG M!DJH
SULQWI(QWUH]OHQLYHDXVFDQIG M!QLYHDX
`
YRLG6DLVLUBHTXLSH(TXLSH H
^SULQWI(QWUH]OHQRPVFDQIVH!QRP
SXWV-RXHXU
6DLVLUBMRXHXU H!MRXHXU
SXWVMRXHXU
6DLVLUBMRXHXU H!MRXHXU
`
YRLG$IILFKHUBMRXHXU-RXHXUM
^SULQWI?W3UpQRPV?QMSUHQRP
SULQWI?W1RPV?QMQRP
ϭϳϵ

Les types personnalisés .

SULQWI?W$JHG?QMDJH
SULQWI?W1LYHDXG?QMQLYHDX
`
YRLG$IILFKHUBHTXLSH(TXLSHH
^SULQWI1RPV?QHQRP
SXWV-RXHXU
$IILFKHUBMRXHXUHMRXHXU
SXWV-RXHXU
$IILFKHUBMRXHXUHMRXHXU
`
PDLQ
^(TXLSHWDE>1@
LQWLM
IRUL L1L ^
SULQWI(TXLSHG?QLM L
6DLVLUBHTXLSH WDE>M@
`
SXWV 9RLFLODOLVWHGHVpTXLSHV 
IRUL L1L^
SULQWI(TXLSHG?QL
$IILFKHUBHTXLSHWDE>L@
`
`
Solution 13 :
Le type adéquat pour représenter cette information est le type : XQLRQ.
XQLRQWDLOOH
^VKRUWFHQWLPHWUHV
IORDWPHWUHV
`
Solution 14 :
LQFOXGHVWGLRK!
W\SHGHIHQXP%/^)$/6(758(`%RROHDQ
PDLQ
^
LQW7>@
LQW1%5
%RROHDQ)ODJ
LQWL
SULQWI(QWUH]OHVpOpPHQWVGXWDEOHDX?Q
IRUL L LVFDQIG 7>L@
SULQWI(QWUH]OHQRPEUHjUHFKHUFKHU
VFDQIG 1%5
)ODJ )$/6(L 
ZKLOHL  )ODJLI7>L@ 1%5)ODJ 758(
HOVHL
LI)ODJSULQWIGIDLWSDUWLHGXWDEOHDX1%5
HOVHSULQWIGQHIDLWSDVSDUWLHGXWDEOHDX1%5
`

ϭϴϬ

Les types personnalisés .

Solution 15 :
LQFOXGHVWGLRK!
W\SHGHIHQXP^MDQ 
IHYPDUVDYUPDLMXLQMXLODRXWVHSWRFWQRYGHF`PRLV
YRLG$IILFKHBPRLVPRLVP
^VZLWFKP
^FDVHMDQSULQWI-DQYLHUEUHDN
FDVHIHYSULQWI)pYULHUEUHDN
FDVHPDUVSULQWI0DUVEUHDN
FDVHDYUSULQWI$YULOEUHDN
FDVHPDLSULQWI0DLEUHDN
FDVHMXLQSULQWI-XLQEUHDN
FDVHMXLOSULQWI-XLOOHWEUHDN
FDVHDRXWSULQWI$RXWEUHDN
FDVHVHSWSULQWI6HSWHPEUHEUHDN
FDVHRFWSULQWI2FWREUHEUHDN
FDVHQRYSULQWI1RYHPEUHEUHDN
FDVHGHFSULQWI'pFHPEUHEUHDN
`
`
YRLG6DLVLUBUHFHWWHVLQWUHFHWWHV>@
^PRLVP
IRUP MDQP GHFP
^SULQWI(QWUH]ODUHFHWWHSRXU
$IILFKHBPRLVP
SULQWI
VFDQIG UHFHWWHV>P@
`
`
PDLQ
^
LQW5>@LVRPPH 
6DLVLUBUHFHWWHV5
IRUL L LVRPPH 5>L@
SULQWIΗ>ĂƐŽŵŵĞĚĞƐƌĞĐĞƚƚĞƐĚĞůΖĂŶŶĠĞĞŶƚŝğƌĞсйĚΗ͕ƐŽŵŵĞ
`
Solution 16 :
LQFOXGHVWGLRK!
W\SHGHIHQXPMRXU^6DPHGL'LPDQFKH/XQGL0DUGL
0HUFUHGL-HXGL9HQGUHGL`-RXU
LQWQXP
PDLQ^
SXWV(QWUH]XQQXPpURGHMRXUHQWUHHW
VFDQIG QXP
LIQXP 6DPHGL__QXP 9HQGUHGL
SULQWI&
HVWXQMRXUIpULp
HOVHSULQWI&HQ
HVWSDVXQMRXUIpULp
`

ϭϴϭ

Les types personnalisés .

Solution 17 :
LQFOXGHVWGLRK!
W\SHGHIHQXPIHX^YHUWRUDQJHURXJH`)HX
LQWQXP
PDLQ^
SXWV(QWUH]XQQXPpURGHMRXUHQWUHHW
VFDQIG QXP
VZLWFKQXP
^
FDVHYHUWSXWV)HXYHUWEUHDN
FDVHRUDQJHSXWV)HXRUDQJHEUHDN
FDVHURXJHSXWV)HXURXJHEUHDN
GHIDXOWSXWV&KRL[LQFRUUHFW
`
`


ϭϴϮ

Les fichiers .

Chapitre 8 : Les fichiers

1. Introduction
Toutes les structures de données que nous avons utilisées jusqu¶à maintenant
permettent le stockage temporaire (pendant l¶exécution du programme) des
variables dans la RAM. Les fichiers permettent le stockage permanent des
données.
2. Les fichiers
Un fichier est un ensemble d¶informations stockées sur un support non volatil
(disque dur, clé USB, etc.) pour une durée indéterminée.
Le langage C offre deux façons pour accéder aux fichiers : des fonctions de bas
niveau (routines du système d¶exploitation) et des fonctions de haut niveau
(indépendantes du système). Dans ce qui suit, nous utiliserons les fonctions de
haut niveau pour la manipulation des fichiers.
2.1. La structure FILE
L¶accès à un fichier en écriture ou en lecture passe par une zone mémoire
intermédiaire dite tampon (buffer).
Lors de l¶écriture dans un fichier, on écrit d¶abord dans le tampon. Quand cette
zone est pleine, le système écrit le contenu du tampon dans le fichier, puis on
recommence à remplir ce tampon. De même, lors de la lecture, les données lues
à partir du fichier sont copiées dans le tampon. On ne lit donc pas directement à
partir du fichier, mais plutôt à partir de la mémoire tampon. Cette méthode
permet de minimiser le nombre d¶accès au fichier, car ces accès sont
relativement coûteux, surtout en termes de temps.

Ecriture Ecriture

WƌŽŐƌĂŵŵĞ &ŝĐŚŝĞƌ
Tampon

Lecture Lecture

RAM 'LVTXHGXUFOp86%RXG¶DXWUHV

ϭϴϯ

Les fichiers .

Le tampon se trouve au niveau de la mémoire centrale, plus exactement la

RAM. Le fichier se trouve bien évidemment au niveau du disque dur ou de la
clé USB, ou d¶autres supports non volatils.
Pour la manipulation des fichiers en C, on utilise une variable de type structure
),/(, qui est définie dans VWGLRK. Cette bibliothèque contient également les
fonctions utilisées dans ce chapitre.
Exemple : La déclaration d¶un pointeur IS vers un fichier se fait comme suit :
),/( IS
La structure ),/( permet de désigner un fichier. Elle contient plusieurs
champs. On cite en particulier :
x Un pointeur vers l¶adresse de début du tampon ;
x Un pointeur vers la position courante dans le tampon ;
x La taille du tampon.
2.2. Ouverture d¶un fichier
Pour lire ou écrire dans un fichier, il faut tout d¶abord l¶ouvrir en utilisant la
fonction IRSHQ comme suit :
),/( ILFKLHU IRSHQQRPBILFKLHUPRGH
La fonction IRSHQ renvoie un pointeur (ILFKLHU) vers une structure ),/(, ou
bien 18// en cas d¶erreur. Le paramètre QRPBILFKLHU est une chaîne de
caractères contenant le chemin du fichier à ouvrir, i.e. son emplacement et son
nom. Le paramètre PRGH est également une chaîne de caractères qui indique
comment le fichier doit être ouvert. Il existe de nombreux modes, mais dans ce
cours, nous utiliserons les plus simples :
xU (read) : lecture seule.
 Renvoie 18// si le fichier n¶existe pas.
xZ (write) : écriture seule.
 Si le fichier existe, son contenu sera réinitialisé.
 Sinon, il est créé.
xD (append) : ajout de données à la fin du fichier.
 Fichier créé s¶il n¶existe pas déjà.
 Sinon, ça permet d¶écrire de nouvelles données après les données
existantes.
Exemple : L¶exemple suivant permet l¶ouverture en lecture d¶un fichier appelé
PRQBILFKLHUW[W se trouvant dans le répertoire courant du programme :
),/( IS IRSHQPRQBILFKLHUW[WU
LIIS 18//
^WUDLWHPHQWHQFDVG¶HUUHXU

`
HOVH
^WUDLWHPHQWQRUPDO

ϭϴϰ

Les fichiers .

«
`
Voici comment ouvrir un fichier &?0\GLU?P\ILOHW[W sous Windows :
),/( IS IRSHQ&??0\GLU??P\ILOHW[WU
Notons ici que nous avons utilisé le caractère spécial
??
pour représenter le
caractère antislash (\), car ce dernier est utilisé en C pour introduire des
caractères spéciaux, tels que
?Q
,
?S
, etc.
Sous Unix, on peut trouver, par exemple :
),/( IS IRSHQKRPH0\GLUP\ILOHW[WU
Une erreur d¶ouverture peut se produire, par exemple, en cas de fichier
inexistant, ou en cas de droits d¶accès limités.
Lorsqu¶on ouvre un fichier, on récupère un pointeur vers une variable de type
),/(, qui est utilisée pour lire ou écrire le fichier.

Ecriture Ecriture
&/>
Lecture

WƌŽŐƌĂŵŵĞ &ŝĐŚŝĞƌ
Tampon

Lecture

RAM 'LVTXHGXUFOp86%RXG¶DXWUHV
2.3. Fermeture d¶un fichier
A la fin de la manipulation d¶un fichier, on le ferme par la fonction IFORVH
comme suit :
LQWQRPBYDU IFORVHILFKLHU
QRPBYDU est une variable entière. Le paramètre ILFKLHU est un pointeur vers
une structure ),/( représentant le fichier à fermer. Si la fonction réussit, elle
renvoie la valeur . Si elle échoue, elle renvoie la constante (2) (End of File,
qui a généralement la valeur ). Cette constante est fréquemment utilisée dans
les fonctions manipulant des fichiers, pour indiquer qu¶un comportement
anormal s¶est produit.
La fermeture d¶un fichier permet de libérer l¶espace réservé (tampon) pour
manipuler le fichier lors de son ouverture. En cas d¶écriture, la fermeture
permet aussi d¶écrire dans le fichier les données encore présentes dans le
ϭϴϱ

Les fichiers .

buffer. Donc, en cas d¶oubli de IFORVH, certaines données risquent de ne pas

être transférées entre la mémoire centrale et le fichier.
Exemple : La fermeture du fichier précédemment ouvert IS se fait comme suit:
LQW[ IFORVHIS
LI[ (2)^WUDLWHPHQWHQFDVG¶HUUHXU
«
`
HOVH^WUDLWHPHQWQRUPDO
«
`
Remarque : La fonction IFORVH est souvent appelée directement par son nom
dans un programme C comme une procédure, sans qu¶elle figure dans une
expression.
2.4. Accès au fichier
On distingue deux méthodes d¶accès au fichier :
1. Accès séquentiel qui consiste à traiter les informations dans l¶ordre où
elles apparaissent, à partir du premier jusqu¶à l¶information désirée.
2. Accès direct qui consiste à se placer immédiatement sur l¶information
désirée, sans avoir à parcourir celles qui la précèdent.
Un fichier peut être manipulé avec un accès séquentiel ou direct, comme on
peut combiner les deux méthodes pour un même fichier.
Sur le plan implémentation :
Il existe différentes techniques pour accéder séquentiellement au contenu d¶un
fichier :
xAccès non-formaté : on lit/écrit des caractères dans des fichiers textes. On
distingue deux sortes d¶accès non-formaté :
 Mode caractère : on lit/écrit un seul caractère à la fois ;
 Mode chaîne : on lit/écrit plusieurs caractères (une chaîne de
caractères) simultanément.
xAccès formaté : on lit/écrit des données typées dans des fichiers textes.
xAccès par bloc : on manipule des séquences d¶octets, indépendamment de
leur type. Il s¶agit de travailler avec des fichiers binaires.
Dans ce qui suit, on décrit toutes ces manières d¶accès aux fichiers, sans oublier
l¶accès direct.
2.4.1. Lecture/écriture non-formatées en mode caractère
Pour la lecture, on utilise la fonction IJHWF comme suit :
LQWFRGHBFDU IJHWFILFKLHU
Le paramètre ILFKLHU est un pointeur vers une structure ),/( représentant un
fichier déjà ouvert en lecture. La fonction renvoie le code ASCII du caractère
lu, ou bien la constante (2) en cas d¶erreur.

ϭϴϲ

Les fichiers .

Exemple : On affiche le contenu d¶un fichier déjà ouvert IS caractère par

caractère comme suit :
LQWF IJHWFIS
ZKLOHF (2)^
SXWFKDUF
F IJHWFIS
`
Fin du fichier
IJHWF renvoie (2) quand on arrive à la fin du fichier. Le problème est que la
valeur (2) peut aussi être renvoyée à cause d¶une autre erreur, par exemple, si
l¶accès au fichier n¶est plus possible.
Pour être sûr qu¶on a atteint la fin du fichier, on utilisera la fonction IHRI
comme suit :
LQWQRPBYDU IHRIILFKLHU
Cette fonction renvoie une valeur non-nulle si la position courante correspond à
la fin du fichier représenté par le pointeur. Sinon, elle renvoie la valeur .
Exemple : Même exemple précédent.
LQWF IJHWFIS
ZKLOHIHRIIS^
SXWFKDUF
F IJHWFIS
`
Pour l¶écriture, on utilise la fonction ISXWF comme suit :
LQWQRPBYDU ISXWFFRGHBFDUILFKLHU
La fonction ISXWF prend FRGHBFDU de type LQW en paramètre (code ASCII du
caractère à écrire, comme on peut mettre directement un caractère). La fonction
prend aussi comme paramètre un pointeur vers un fichier déjà ouvert pour
écriture. En cas de succès, la fonction renvoie la valeur qui a été écrite. Sinon,
elle renvoie (2), par exemple, dans le cas d¶un disque plein (saturé).
Exemple : On écrit le caractère
$
dans un fichier déjà ouvert en écriture IS
comme suit :
FKDUF 
$

LQW[ ISXWFFIS
LI[ (2)
^WUDLWHPHQWGHO¶HUUHXU
«
`
2.4.2. Lecture/écriture non-formatées en mode chaîne
Pour la lecture d¶une une chaîne de caractères, au lieu de lire un seul caractère
à la fois, on utilise la fonction IJHWV comme suit :
FKDU QRPBFK IJHWVFKDLQHQRPEUHILFKLHU
FKDLQH va contenir la chaîne de caractères lue à partir du fichier (ou plus
exactement à partir du tampon). QRPEUH de type LQW indique le nombre
ϭϴϳ

Les fichiers .

maximal de caractères à lire. Le pointeur ILFKLHU désigne le fichier à lire (qui

a été préalablement ouvert en lecture, bien entendu).
La fonction renvoie un pointeur vers la chaîne lue (i.e. FKDLQH>@), ou bien
18// en cas de fin de fichier ou en cas d¶erreur. La fonction IHRI nous permet
d¶être sûrs qu¶on a atteint la fin du fichier.
La fonction IJHWV tente de lire QRPEUH caractères du fichier. Elle rajoute
automatiquement le caractère
?
à la fin de la chaîne. La lecture est
interrompue si la fonction rencontre le caractère
?Q
(le
?Q
est quand même
recopié dans le tampon).
Exemple : On affiche le contenu d¶un fichier déjà ouvert IS chaîne par chaîne
comme suit :
FKDUWPS>@
FKDU FK IJHWVWPSIS
ZKLOHFK 18//^
SULQWIVWPS
FK IJHWVWPSIS
`
Si, par exemple, le fichier contient les deux lignes :
ERQMRXU
DKPHG
Alors, WPS va prendre en premier lieu {'b', 'o', 'n', 'j', 'o', 'u', 'r', '\n', '\0'}. Ensuite,
elle prendra {'a', 'h', 'm', 'e', 'd', '\0'}.
L¶écriture d¶une chaîne est effectuée grâce à la fonction ISXWV utilisée comme
suit :
LQWQRPBYDU ISXWVFKDLQHILFKLHU
FKDLQH étant la chaîne de caractères à écrire dans le fichier. Le paramètre
ILFKLHUest un pointeur vers un fichier déjà ouvert en écriture. La fonction ne
recopie pas le caractère
?
terminal. La fonction renvoie une valeur non-
négative en cas de succès, ou bien (2) en cas d¶erreur.
Exemple : Stocker la chaîne ERQMRXU dans un fichier déjà ouvert en écriture
IS comme suit :
LQW[ ISXWVERQMRXUIS
LI[ (2)WUDLWHUO¶HUUHXU
2.4.3. Lecture/écriture formatées
Si on veut formater les données lues ou écrites dans les fichiers textes, i.e. les
lire ou les écrire selon leurs types et selon la manière d¶organisation, on utilise
les fonctions IVFDQI et ISULQWI, dédiées respectivement à la lecture et à
l¶écriture dans un fichier.
Elles se comportent comme les fonctions VFDQI et SULQWI, à la différence du
fait qu¶un paramètre supplémentaire, placé en première position, désigne le
fichier dans lequel on veut lire ou écrire :
ϭϴϴ

Les fichiers .

LQWQEUBYDU IVFDQIILFKLHUIRUPDWOLVWHBDGUHVVHV

LQWQEUBYDU ISULQWIILFKLHUIRUPDWOLVWHBH[SUHVVLRQV
Ces fonctions renvoient le nombre de variables lues ou écrites, ou bien (2) en
cas d¶erreur (ou de fin de fichier).
Exemple : Lire un IORDW à partir d¶un fichier ouvert en lecture comme suit :
IORDWI
LQW[ IVFDQIISI I
LI[ (2)WUDLWHUO¶HUUHXU
Notons qu¶à chaque lecture par IVFDQI, le pointeur passe automatiquement à la
suite dans le fichier.
Exemple : Ecrire un IORDW dans un fichier ouvert en écriture comme suit :
IORDWI 
LQW[ ISULQWIISII
LI[ (2)WUDLWHUO¶HUUHXU
Remarque : Les deux types d¶accès formaté et non-formaté permettent la
manipulation des fichiers textes contenant du texte ASCII. Si nous avions, par
exemple, un fichier texte contenant , cette information aurait pu être
lue comme :
1) la chaîne de caractères  en accès non-formaté, ou
2) comme le nombre réel  en accès formaté, comme si nous avions
une lecture de chaîne de caractères suivie d¶une conversion en réel
dans ce deuxième cas.
2.4.4. Lecture/écriture par bloc
Lorsqu¶on veut manipuler de grandes quantités de données dans des fichiers
binaires, sans s¶occuper de leur type ou de leur organisation, on utilise les accès
par bloc. Ceci est réalisé grâce aux fonctions IUHDG et IZULWH :
VL]HBWQEUBEORFVBOXV IUHDG WPSWDLOOHQRPEUHILFKLHU
VL]HBWQEUBEORFVBHFULWV IZULWH WPSWDLOOHQRPEUHILFKLHU
WPS correspond à l¶adresse d¶un ou plusieurs blocs d¶information. WDLOOH de
type VL]HBW est la taille d¶un seul bloc en octets. QRPEUH de type VL]HBW est le
nombre de blocs à lire ou à écrire. ILFKLHUest un pointeur vers un fichier. Le
type VL]HBW est défini dans VWGLRK ; il s¶agit d¶un entier non-signé.
La fonction IUHDG lit WDLOOH*QRPEUH octets à partir du fichier, et les recopie
dans WPS. La fonction IZULWH lit WDLOOH*QRPEUH octets à partir de WPS, et les
recopie dans le fichier. Les deux fonctions renvoient le nombre de blocs
lus/écrits : une valeur inférieure à QRPEUH indique donc qu¶une erreur est
survenue au cours du traitement.
Remarques :
xLorsqu¶une variable est écrite dans un fichier binaire, on écrit directement la
valeur exacte de la variable, telle qu¶elle est codée en binaire en mémoire.
Cette manière est plus précise et plus compacte pour stocker des nombres.
ϭϴϵ

Les fichiers .

Par exemple, l¶information 1111.51 a besoin de 7 octets (nombre de

caractères) pour la stocker comme chaîne de caractères dans un fichier
texte, mais elle n¶a besoin que de 4 octets (l¶espace nécessaire pour le
stockage d¶un réel dans la mémoire) pour la stocker dans un fichier binaire.
xLorsqu¶on veut lire ou écrire un tableau dans un fichier en mode par bloc,
alors le premier paramètre doit être mis sans , tandis qu¶avec une structure,
il faudra utiliser pour en obtenir l¶adresse. Dans ce dernier cas, il est
préférable d¶utiliser la fonction VL]HRI pour déterminer avec certitude la
taille d¶un bloc.
Exemple : Lire par bloc les cinq premiers caractères d¶un fichier texte ouvert
en lecture, ensuite les afficher :
FKDUFK>@
VL]HBWQEU IUHDGFKIS
LIQEU WUDLWHUO
HUUHXU
HOVHSULQWIVFK
2.4.5. Accès direct
Toutes les fonctions de manipulation des fichiers qu¶on a vues précédemment
permettent un accès séquentiel au fichier. Pour accéder directement à n¶importe
quel point dans un fichier, il est possible d¶utiliser la fonction IVHHN comme
suit :
LQWQRPBYDU IVHHNILFKLHUQEUBRFWHWVPRGHBDFWLRQ
La fonction IVHHN possède comme paramètres :
xUn pointeur vers un fichier (ILFKLHU).
xLe nombre d¶octets après lesquels on désire se positionner (QEUBRFWHWV) de
type ORQJ. Pour se mettre au début du fichier, cette valeur doit être .
xLe paramètre PRGHBDFWLRQ de type LQW indique la manière d¶agir sur le
pointeur :
  : indique un déplacement à partir du début de fichier.
  : indique un déplacement à partir de la position courante du fichier.
  : indique un déplacement à partir de la fin de fichier.
IVHHN retourne  dans le cas de la réussite du positionnement, et une valeur
quelconque dans le cas contraire.
Exemple 1 : Se positionner pour lire et afficher le sixième caractère d¶un
fichier texte ouvert en lecture :
LQW[ IVHHNIS VL]HRIFKDULQWF
LI[ WUDLWHUO¶HUUHXU
HOVH^F IJHWFIS
SXWFKDUF`
Exemple 2 : Se positionner pour lire le sixième réel à partir d¶un fichier binaire
là où on a stocké des réels :
LQW[ IVHHNIS VL]HRIIORDW
LI[ WUDLWHUO¶HUUHXU
ϭϵϬ

Les fichiers .

Remarques :
xLorsqu¶on écrit sur un emplacement qu¶on a atteint après IVHHN, la donnée
qui existait éventuellement à cet emplacement est effacée et remplacée par
la donnée écrite.
xDans le cas de la création d¶un fichier en mode direct, dès qu¶on écrit le
nième octet du fichier, il y aura automatiquement la réservation de la place de
tous les octets précédents ; leur contenu va être aléatoire.
x Pour avoir la position courante dans le fichier, i.e., après combien d¶octets
on en est dans le fichier, il est possible d¶utiliser la fonction IWHOO de la
forme : ORQJQEUBRFWHWV IWHOOILFKLHU
Remarque importante : Notons que dans ce cours, nous avons essayé de
simplifier l¶utilisation des fonctions de manipulation des fichiers. C¶est
pourquoi, nous avons évité de donner la forme originale (en-tête ou prototype)
des fonctions dans la bibliothèque VWGLRK. Par exemple, l¶en-tête (prototype)
de la fonction IRSHQ dans la bibliothèque est le suivant :
),/( IRSHQFRQVWFKDU QRPBILFKLHUFRQVWFKDU PRGH
Alors que son utilisation a été simplifiée dans ce cours comme suit :
),/( ILFKLHU IRSHQQRPBILFKLHUPRGH
Dans cette forme simplifiée, nous avons montré la variable qui va prendre la
valeur de retour de IRSHQ. Nous avons aussi remplacé les pointeurs par des
chaînes de caractères, car à ce niveau, le lecteur n¶a pas encore maitrisé la
notion de pointeur qui va être étudiée, avec plus de détail, dans le chapitre
suivant.
3. Exercices corrigés
3.1. Exercices
Exercice 1 :
Ecrire un programme C permettant de stocker le caractère
$
dans un fichier
texte. Ecrire un deuxième programme C permettant de lire un caractère à partir
du fichier texte précédent.
Exercice 2 :
Ecrire un programme C permettant de lire le contenu d¶un fichier texte nommé
ILFKLHUW[W, se trouvant dans le même répertoire que le programme. Pour ce
faire, utiliser la lecture non-formatée en mode caractère.
Exercice 3 :
Reprendre le même exercice précédent, mais cette fois-ci en utilisant la lecture
non-formatée en mode chaîne.
Exercice 4 :
Ecrire un programme C permettant de créer un fichier texte nommé
ILFKLHUW[W, stockant une suite de cinq caractères lus à partir du clavier.
Utiliser l¶écriture non-formatée en mode caractère.
ϭϵϭ

Les fichiers .

Exercice 5 :
Ecrire un programme C permettant de créer un fichier texte nommé
ILFKLHUW[W, stockant une suite de cinq chaînes de caractères lues à partir du
clavier. Utiliser l¶écriture non-formatée en mode chaîne de caractères.
Exercice 6 :
Ecrire un programme C permettant de créer un fichier texte nommé
ILFKLHUW[W, stockant une chaîne de caractères lue à partir du clavier. Utiliser
l¶écriture non-formatée en mode caractère.
Exercice 7 :
Ecrivez un programme C qui réalise une copie d¶un fichier existant
ILFKLHUW[W par lecture/écriture en mode caractère.
Exercice 8 :
Par un menu de choix multiple, écrire un programme C permettant de demander
à l¶utilisateur de lire un fichier texte (ILFKLHUW[W), de créer un nouveau
fichier texte (ILFKLHUW[W) ou d¶ajouter des données à un fichier existant
(ILFKLHUW[W). Chaque choix doit être assuré par une procédure. Pour ce faire,
utiliser lecture/écriture non-formatées en mode chaîne de caractères.
Exercice 9 :
Ecrire un programme C permettant de lire un réel à partir du clavier, et le
stocker ensuite dans un fichier UHHOVW[W. Utiliser le mode écriture formatée.
Exercice 10 :
Ecrire un programme C permettant d¶afficher un nombre réel à partir du fichier
UHHOVW[W. Utiliser le mode lecture formatée.
Exercice 11 :
En utilisant le mode lecture/écriture formatées, on veut stocker les informations
des employés d¶une entreprise dans un fichier HPSOR\HUVW[W. Chaque
employé est identifié par un numéro de type entier, un nom et prénom de type
chaîne de caractères. Les informations étant lues à partir du clavier. Après le
stockage de ces informations, essayez de les afficher à nouveau à partir du
fichier pour confirmer le stockage.
Exercice 12 :
Utilisez l¶écriture par bloc pour stocker la chaîne de caractères ERQMRXU dans
un fichier EORFW[W.
Exercice 13 :
Utilisez la lecture par bloc pour lire un bloc de sept caractères à partir du fichier
EORFW[W créé dans l¶exercice précédent.
Exercice 14 :
Ecrire un programme C permettant d¶enregistrer séquentiellement dans un
fichier, dont le nom est lu à partir du clavier, une suite de nombres entiers
qu¶on lui fournit au clavier. Utiliser l¶écriture par bloc.
ϭϵϮ

Les fichiers .

Exercice 15 :
Ecrire un programme C permettant de lire un fichier créé par le programme de
l¶exercice précédent. Le nom du fichier étant lu à partir du clavier. Utiliser la
lecture par bloc.
Exercice 16 :
Reprendre l¶exercice 11, mais cette fois-ci en utilisant lecture/écriture par bloc.
Exercice 17 :
Avec la même structure d¶un employé définie dans l¶exercice 11, et en utilisant
lecture/écriture par bloc, on veut stocker les informations des employés d¶une
entreprise dans un fichier binaire. Les informations étant lues à partir du
clavier. A partir de ce fichier, essayez de stocker ces informations dans un
tableau de structure, ensuite les afficher à nouveau à partir de ce tableau pour
confirmer le stockage.
Exercice 18 :
Avec la même structure d¶un employé définie dans l¶exercice 11, et en utilisant
lecture/écriture par bloc, on veut stocker les informations de cinq employés
d¶une entreprise dans un tableau lu à partir du clavier. Le tableau doit être
ensuite stocké dans un fichier binaire. Le contenu du fichier doit être enfin
affiché.
Exercice 19 :
Ecrire un programme C permettant, à partir du fichier créé par l¶exercice 16, de
retrouver les informations correspondant à un employé dont le nom est lu au
clavier. Il vous faudra une recherche séquentielle.
Exercice 20 :
Ecrire un programme C permettant de lire n¶importe quel entier du fichier créé
par le programme de l¶exercice 14. La position du nombre à lire étant lue à
partir du clavier. Utiliser l¶accès direct.
3.2. Corrigés
Solution 1 :
Programme 1 :
 3URJUDPPH&SHUPHWWDQWGHVWRFNHUOHFDUDFWqUH
$
GDQVXQ
ILFKLHUWH[WH 
LQFOXGHVWGLRK!
PDLQ
^FKDUFLQW[
),/( IS IRSHQG??ILFKLHUW[WZ
LIIS 18//^
F 
$

[ ISXWFFIS
LI[ (2)SULQWIΗĐŚĞĐĚĞƐƚŽĐŬĂŐĞĚƵĐĂƌĂĐƚğƌĞйĐĚĂŶƐĨŝĐŚŝĞƌ͘ƚdžƚ͊ͰŶΗ͕Đ
HOVHSULQWIΗ^ƚŽĐŬĂŐĞƌĠƵƐƐŝĚƵĐĂƌĂĐƚğƌĞйĐĚĂŶƐĨŝĐŚŝĞƌ͘ƚdžƚ͘ͰŶΗ͕Đ
IFORVHIS

ϭϵϯ

Les fichiers .

`HOVHSULQWI(FKHFGHFUpDWLRQ
`
Programme 2:
 3URJUDPPH&SHUPHWWDQWGHOLUHXQFDUDFWqUHjSDUWLUGX
ILFKLHUWH[WHSUpFpGHQW 
LQFOXGHVWGLRK!
PDLQ
^
LQW[
),/( IS IRSHQG??ILFKLHUW[WU
LIIS 18//^
[ IJHWFIS
LI[ (2)SULQWIΗĐŚĞĐĚĞůĞĐƚƵƌĞĚƵĐĂƌĂĐƚğƌĞăƉĂƌƚŝƌĚƵĨŝĐŚŝĞƌ͘ƚdžƚ͊ͰŶΗ
HOVHSULQWIΗ>ĞĐƚƵƌĞĚƵĐĂƌĂĐƚğƌĞйĐĂǀĞĐƐƵĐĐğƐăƉĂƌƚŝƌĚƵĨŝĐŚŝĞƌ͘ƚdžƚͰŶΗ͕dž
IFORVHIS
`HOVHSULQWI(FKHFG
RXYHUWXUH
`
Solution 2 :
LQFOXGHVWGLRK!
PDLQ
^
),/( IS IRSHQILFKLHUW[WU
LIIS 18//^
LQWF IJHWFIS
ZKLOHF (2)^ KŶƉĞƵƚŵĞƚƚƌĞĂƵƐƐŝǁŚŝůĞ;͊ĨĞŽĨ;ĨƉͿͿ
SXWFKDUF
F IJHWFIS
`
IFORVHIS
`
HOVHSULQWI,PSRVVLEOHG
RXYULUOHILFKLHU?Q
`
Solution 3 :
LQFOXGHVWGLRK!
PDLQ
^
),/( IS IRSHQILFKLHUW[WU
LIIS 18//^
FKDUWPS>@
FKDU FK IJHWVWPSIS
ZKLOHFK 18//^
SULQWIVWPS
FK IJHWVWPSIS
`
IFORVHIS
`
HOVHSULQWI,PSRVVLEOHG
RXYULUOHILFKLHU?Q
`

ϭϵϰ

Les fichiers .

Ou bien :
LQFOXGHVWGLRK!
PDLQ
^
),/( IS IRSHQILFKLHUW[WU
LIIS 18//^
FKDUWPS>@
FKDU FK IJHWVWPSIS
ZKLOHIHRIIS^
SULQWIVWPS
FK IJHWVWPSIS
`
SULQWIVWPS ũŽƵƚĞĐĞƚƚĞŝŶƐƚƌƵĐƚŝŽŶƉŽƵƌƋƵĞƚƵƉƵŝƐƐĞƐ
ĂĨĨŝĐŚĞƌůĂĚĞƌŶŝğƌĞůŝŐŶĞĚƵĨŝĐŚŝĞƌ 
IFORVHIS
`
HOVHSULQWI,PSRVVLEOHG
RXYULUOHILFKLHU?Q
`
Solution 4 :
LQFOXGHVWGLRK!
PDLQ
^
),/( IS IRSHQILFKLHUW[WZ
LQWLFKDUFLQW[
IRUL L L^
SULQWI'RQQH]XQFDUDFWqUH
F JHWFKDURXELHQ VFDQIF F
JHWFKDU
[ ISXWFFIS
LI[ (2)SULQWIΗĐŚĞĐĚĞƐƚŽĐŬĂŐĞĚƵĐĂƌĂĐƚğƌĞйĐĚĂŶƐĨŝĐŚŝĞƌ͘ƚdžƚ͊ͰŶΗ͕Đ
HOVHSULQWIΗ^ƚŽĐŬĂŐĞƌĠƵƐƐŝĚƵĐĂƌĂĐƚğƌĞйĐĚĂŶƐĨŝĐŚŝĞƌ͘ƚdžƚ͘ͰŶΗ͕Đ
`
IFORVHIS
`
Solution 5 :
LQFOXGHVWGLRK!
PDLQ
^
),/( IS IRSHQILFKLHUW[WZ
LQWLFKDUFK>@LQW[
IRUL L L^
SULQWI'RQQH]XQHFKDvQHGHFDUDFWqUHV
JHWVFK RXELHQ VFDQIVFK
[ ISXWVFKIS
LI[ (2)
SULQWIΗĐŚĞĐĚĞƐƚŽĐŬĂŐĞĚĞůĂĐŚĂŠŶĞĚĞĐĂƌĂĐƚğƌĞƐйƐĚĂŶƐĨŝĐŚŝĞƌ͘ƚdžƚ͊ͰŶΗ͕ĐŚ
HOVHSULQWIΗ^ƚŽĐŬĂŐĞƌĠƵƐƐŝĚĞůĂĐŚĂŠŶĞĚĞĐĂƌĂĐƚğƌĞƐйƐĚĂŶƐĨŝĐŚŝĞƌ͘ƚdžƚ͘ͰŶΗ͕ĐŚ
`

ϭϵϱ

Les fichiers .

IFORVHIS
`
Solution 6 :
LQFOXGHVWGLRK!
LQFOXGHVWULQJK!
PDLQ
^
),/( IS IRSHQILFKLHUW[WZ
LQWLFKDUFK>@LQW[
SULQWIΗŽŶŶĞnjƵŶĞĐŚĂŠŶĞĚĞĐĂƌĂĐƚğƌĞƐăƐƚŽĐŬĞƌĚĂŶƐĨŝĐŚŝĞƌ͘ƚdžƚ͗Η
JHWVFK
IRUL LVWUOHQFKL^
[ ISXWFFK>L@IS
LI[ (2)
SULQWIΗĐŚĞĐĚĞƐƚŽĐŬĂŐĞĚƵĐĂƌĂĐƚğƌĞйĐĚĂŶƐĨŝĐŚŝĞƌ͘ƚdžƚ͊ͰŶΗ͕ĐŚ΀ŝ΁
`
IFORVHIS
`
Solution 7 :
LQFOXGHVWGLRK!
PDLQ
^
2QRXYUHOHILFKLHUVRXUFHHQOHFWXUH
),/( VRXUFH IRSHQILFKLHUW[WU
LIVRXUFH 18//^
2QRXYUHOHILFKLHUFLEOHHQpFULWXUH
),/( FLEOH IRSHQFRSLHW[WZ
 2QOLWODVRXUFHFDUDFWqUHSDUFDUDFWqUH
HQpFULYDQWFKDTXHFDUDFWqUHGDQVODFLEOH 
LQWF IJHWFVRXUFHLQW[LQWIODJ 
ZKLOHF (2)^ 
[ ISXWFFFLEOH
LI[ (2)^
SULQWIΗĐŚĞĐĚĞƐƚŽĐŬĂŐĞĚƵĐĂƌĂĐƚğƌĞйĐĚĂŶƐĐŽƉŝĞ͘ƚdžƚ͊ͰŶΗ͕Đ
IODJ 
`
F IJHWFVRXUFH
`
LIIODJSULQWIΗŽƉŝĂŐĞƌĠƵƐƐŝĚĞĨŝĐŚŝĞƌ͘ƚdžƚĞŶĐŽƉŝĞ͘ƚdžƚ͘ͰŶΗ
HOVHSULQWI(FKHFGH&RSLDJH?Q
IFORVHFLEOH
IFORVHVRXUFH
`
HOVHSULQWI,PSRVVLEOHG
RXYULUILFKLHUW[W?Q
`
Solution 8 :
LQFOXGHVWGLRK!
YRLG/LUHBILFKLHU
ϭϵϲ

Les fichiers .

^
),/( IS IRSHQILFKLHUW[WU
LIIS 18//^
FKDUWPS>@
FKDU FK IJHWVWPSIS
ZKLOHIHRIIS^
SULQWIVWPS
FK IJHWVWPSIS
`
SULQWIVWPS ũŽƵƚĞĐĞƚƚĞŝŶƐƚƌƵĐƚŝŽŶƉŽƵƌƋƵĞƚƵƉƵŝƐƐĞƐĂĨĨŝĐŚĞƌ
ůĂĚĞƌŶŝğƌĞůŝŐŶĞĚƵĨŝĐŚŝĞƌ 
IFORVHIS
`
HOVHSULQWI,PSRVVLEOHG
RXYULUOHILFKLHU?Q
`
YRLG&UHHUBILFKLHU
^
),/( IS IRSHQILFKLHUW[WZ
LQWLFKDUFK>@LQW[FKDUF
GR^
SULQWI'RQQH]XQHFKDvQHGHFDUDFWqUHV
VFDQIVFK
[ ISXWVFKIS
LI[ (2)
SULQWIΗĐŚĞĐĚĞƐƚŽĐŬĂŐĞĚĞůĂĐŚĂŠŶĞĚĞĐĂƌĂĐƚğƌĞƐйƐĚĂŶƐĨŝĐŚŝĞƌ͘ƚdžƚ͊ͰŶΗ͕ĐŚ
HOVHSULQWIΗ^ƚŽĐŬĂŐĞƌĠƵƐƐŝĚĞůĂĐŚĂŠŶĞĚĞĐĂƌĂĐƚğƌĞƐйƐĚĂŶƐĨŝĐŚŝĞƌ͘ƚdžƚ͘ͰŶΗ͕ĐŚ
SULQWI9RXOH]YRXVDMRXWHUXQHDXWUHFKDvQHRQ"
JHWFKDU
F JHWFKDUJHWFKDU
`ZKLOHF 
Q

IFORVHIS
`
YRLG$MRXWHUBILFKLHU
^
),/( IS IRSHQILFKLHUW[WD
LQWLFKDUFK>@LQW[FKDUF
GR^
SULQWI'RQQH]XQHFKDvQHGHFDUDFWqUHV
VFDQIVFK
[ ISXWVFKIS
LI[ (2)
SULQWIΗĐŚĞĐĚĞƐƚŽĐŬĂŐĞĚĞůĂĐŚĂŠŶĞĚĞĐĂƌĂĐƚğƌĞƐйƐĚĂŶƐĨŝĐŚŝĞƌ͘ƚdžƚ͊ͰŶΗ͕ĐŚ
HOVHSULQWIΗ^ƚŽĐŬĂŐĞƌĠƵƐƐŝĚĞůĂĐŚĂŠŶĞĚĞĐĂƌĂĐƚğƌĞƐйƐĚĂŶƐĨŝĐŚŝĞƌ͘ƚdžƚ͘ͰŶΗ͕ĐŚ
SULQWI9RXOH]YRXVDMRXWHUXQHDXWUHFKDvQHRQ"
JHWFKDU
F JHWFKDUJHWFKDU
`ZKLOHF 
Q

IFORVHIS
`

ϭϵϳ

Les fichiers .

PDLQ
^
 LQWFKRL[
 GR^
SULQWIΗͰŶŽŶŶĞnjǀŽƚƌĞĐŚŽŝdž͗ͰŶͰƚϭͲ>ŝƌĞĨŝĐŚŝĞƌ͕ͰŶͰƚϮͲƌĠĞƌĨŝĐŚŝĞƌ͕Η
SULQWIΗͰŶͰƚϯͲũŽƵƚĞƌăƵŶĨŝĐŚŝĞƌĞƚͰŶͰƚϰͲYƵŝƚƚĞƌůĞƉƌŽŐƌĂŵŵĞͰŶΗ
 VFDQIG FKRL[
VZLWFKFKRL[^
 FDVH/LUHBILFKLHUEUHDN
 FDVH&UHHUBILFKLHUEUHDN
FDVH$MRXWHUBILFKLHUEUHDN
 FDVHEUHDN
 GHIDXOWSULQWI&KRL[LQFRUUHFW
 `
 `ZKLOHFKRL[ 
`
Solution 9 :
LQFOXGHVWGLRK!
PDLQ
^
),/( IS IRSHQUHHOW[WZ
IORDWI
SULQWI'RQQH]XQQRPEUHUpHO
VFDQII I
LQW[ ISULQWIISII
LI[ (2)SULQWIΗ>ĞƐƚŽĐŬĂŐĞĂĠƚĠĨĂŝƚĂǀĞĐƐƵĐĐğƐ͘ͰŶΗ
HOVHSULQWI(FKHFGHVWRFNDJHGDQVOHILFKLHU?Q
IFORVHIS
`
Solution 10 :
LQFOXGHVWGLRK!
PDLQ
^
),/( IS IRSHQUHHOW[WU
IORDWI
LQW[ IVFDQIISI I
LI[ (2)SULQWIΗ>ĞŶŽŵďƌĞůƵăƉĂƌƚŝƌĚƵĨŝĐŚŝĞƌĞƐƚ͗йĨͰŶΗ͕Ĩ
HOVHSULQWI(FKHFGHOHFWXUHjSDUWLUGXILFKLHU?Q
IFORVHIS
`
Solution 11 :
LQFOXGHVWGLRK!
W\SHGHIVWUXFWHPSOR\H^
 LQWQXP
 FKDUQRP>@SUHQRP>@
`(PSOR\H
PDLQ
^
ϭϵϴ

Les fichiers .

(PSOR\HHFKDUFLQW[
6WRFNDJHpFULWXUHGHVHPSOR\pV
),/( IS IRSHQHPSOR\HVW[WZ
GR^
SULQWI'RQQH]OHQXPpURGHO
HPSOR\p
VFDQIG HQXP
SULQWI'RQQH]OHQRPGHO
HPSOR\p
VFDQIVHQRP
SULQWI'RQQH]OHSUpQRPGHO
HPSOR\p
VFDQIVHSUHQRP
[ ISULQWIISG?QV?QV?QHQXPHQRPHSUHQRP
LI[ (2)SULQWIΗ>ĞƐƚŽĐŬĂŐĞĂĠƚĠĨĂŝƚĂǀĞĐƐƵĐĐğƐ͘ͰŶΗ
HOVHSULQWI(FKHFGHVWRFNDJHGDQVOHILFKLHU?Q
SULQWI9RXOH]YRXVDMRXWHUXQDXWUHHPSOR\pRQ"
JHWFKDU
F JHWFKDUJHWFKDU
`ZKLOHF 
Q

IFORVHIS
$IILFKDJHOHFWXUHGHVHPSOR\pV
IS IRSHQHPSOR\HVW[WU
[ IVFDQIISG?QV?QV?Q HQXPHQRPHSUHQRP
LI[ (2)SULQWIΗsŽŝĐŝůĂůŝƐƚĞĚĞƐĞŵƉůŽLJĠƐƐƚŽĐŬĠƐĚĂŶƐůĞĨŝĐŚŝĞƌ͗ͰŶΗ
ZKLOH[ (2)^
SULQWI?WGVV?QHQXPHQRPHSUHQRP
[ IVFDQIISG?QV?QV?Q HQXPHQRPHSUHQRP
`
IFORVHIS
`
Solution 12 :
LQFOXGHVWGLRK!
PDLQ
^
),/( IS IRSHQEORFW[WZ
VL]HBWQEH IZULWHERQMRXUIS
LIQEH SULQWI6WRFNDJHDYHFVXFFqV?Q
HOVHSULQWI(FKHFGHVWRFNDJHGDQVOHILFKLHUEORFW[W?Q
IFORVHIS
`
Solution 13 :
LQFOXGHVWGLRK!
PDLQ
^
),/( IS IRSHQEORFW[WU
FKDUFK>@
VL]HBWQEO IUHDGFKIS
LIQEO SULQWI/DFKDvQHOXHHVWV?QFK
HOVHSULQWIΗĐŚĞĐĚĞůĞĐƚƵƌĞăƉĂƌƚŝƌĚƵĨŝĐŚŝĞƌďůŽĐ͘ƚdžƚ͊ͰŶΗ
IFORVHIS
`
ϭϵϵ

Les fichiers .

Solution 14 :
LQFOXGHVWGLRK!
PDLQ
^
LQW[FKDUQRPILFKLHU>@FKDUFVL]HBWQEHQEO
),/( IS
6WRFNDJHpFULWXUHGHVHQWLHUV
SULQWI'RQQH]OHQRPGXILFKLHUjFUpHU
VFDQIVQRPILFKLHU
IS IRSHQQRPILFKLHUZ
LIIS 18//^
GR^
SULQWI'RQQH]XQHQWLHU
VFDQIG [
QEH IZULWH [VL]HRI[IS
LIQEH SULQWI6WRFNDJHDYHFVXFFqV?Q
HOVHSULQWI(FKHFGHVWRFNDJHGDQVOHILFKLHU?Q
SULQWI9RXOH]YRXVDMRXWHUXQDXWUHQRPEUHRQ"
JHWFKDU
F JHWFKDUJHWFKDU
`ZKLOHF 
Q

IFORVHIS
`
HOVHSULQWI,PSRVVLEOHG
RXYULUOHILFKLHU?Q
`
Solution 15 :
LQFOXGHVWGLRK!
PDLQ
^
LQW[FKDUQRPILFKLHU>@VL]HBWQEO),/( IS
$IILFKDJHOHFWXUHGHVHQWLHUV
SULQWI'RQQH]OHQRPGXILFKLHUjOLUH
VFDQIVQRPILFKLHU
IS IRSHQQRPILFKLHUU
LIIS 18//^
SXWV9RLFLODOLVWHGHVHQWLHUVVWRFNpVGDQVOHILFKLHU
QEO IUHDG [VL]HRI[IS
LIQEO SULQWI?WG?Q[
ZKLOHIHRIIS QEO^
QEO IUHDG [VL]HRI[IS
LIQEO SULQWI?WG?Q[
`
IFORVHIS
`
HOVHSULQWI,PSRVVLEOHG
RXYULUOHILFKLHU?Q
`
Solution 16 :
LQFOXGHVWGLRK!
W\SHGHIVWUXFWHPSOR\H^
ϮϬϬ

Les fichiers .

 LQWQXP
 FKDUQRP>@SUHQRP>@
`(PSOR\H
PDLQ
^
(PSOR\HHFKDUFVL]HBWQEHQEO),/( IS
6WRFNDJHpFULWXUHGHVHPSOR\pV
IS IRSHQHPSOR\HVEOFZ
GR^
SULQWI'RQQH]OHQXPpURGHO
HPSOR\p
VFDQIG HQXP
SULQWI'RQQH]OHQRPGHO
HPSOR\p
VFDQIVHQRP
SULQWI'RQQH]OHSUpQRPGHO
HPSOR\p
VFDQIVHSUHQRP
QEH IZULWH HVL]HRIHIS
LIQEH SULQWI6WRFNDJHDYHFVXFFqV?Q
HOVHSULQWI(FKHFGHVWRFNDJHGDQVHPSOR\HVEOF?Q
SULQWI9RXOH]YRXVDMRXWHUXQDXWUHHPSOR\pRQ"
JHWFKDU
F JHWFKDUJHWFKDU
`ZKLOHF 
Q

IFORVHIS
$IILFKDJHOHFWXUHGHVHPSOR\pV
IS IRSHQHPSOR\HVEOFU
SXWV9RLFLODOLVWHGHVHPSOR\pVVWRFNpVGDQVOHILFKLHU
QEO IUHDG HVL]HRIHIS
LIQEO SULQWI?WGVV?QHQXPHQRPHSUHQRP
ZKLOHIHRIIS QEO^
QEO IUHDG HVL]HRIHIS
LIQEO SULQWI?WGVV?QHQXPHQRPHSUHQRP
`
IFORVHIS
`
Solution 17 :
LQFOXGHVWGLRK!
LQFOXGHVWULQJK!
W\SHGHIVWUXFWHPSOR\H^
 LQWQXP
 FKDUQRP>@SUHQRP>@
`(PSOR\H
PDLQ
^
(PSOR\HHFKDUFVL]HBWQEHQEO),/( IS
(PSOR\H(PSOR\HV>@LQWLM
6WRFNDJHpFULWXUHGHVHPSOR\pV
IS IRSHQHPSOR\HVEOFZ
GR^
SULQWI'RQQH]OHQXPpURGHO
HPSOR\p

ϮϬϭ

Les fichiers .

VFDQIG HQXP

SULQWI'RQQH]OHQRPGHO
HPSOR\p
VFDQIVHQRP
SULQWI'RQQH]OHSUpQRPGHO
HPSOR\p
VFDQIVHSUHQRP
QEH IZULWH HVL]HRIHIS
LIQEH SULQWI6WRFNDJHDYHFVXFFqV?Q
HOVHSULQWI(FKHFGHVWRFNDJHGDQVHPSOR\HVEOF?Q
SULQWI9RXOH]YRXVDMRXWHUXQDXWUHHPSOR\pRQ"
JHWFKDU
F JHWFKDUJHWFKDU
`ZKLOHF 
Q

IFORVHIS
6WRFNDJHGHVHPSOR\pVGDQVXQWDEOHDXGHVWUXFWXUH
IS IRSHQHPSOR\HVEOFU
L 
QEO IUHDG HVL]HRIHIS
LIQEO ^
 (PSOR\HV>L@QXP HQXP
 VWUFS\(PSOR\HV>L@QRPHQRP
 VWUFS\(PSOR\HV>L@SUHQRPHSUHQRP
 L
`
ZKLOHIHRIIS QEO^
QEO IUHDG HVL]HRIHIS
LIQEO ^
 (PSOR\HV>L@QXP HQXP
 VWUFS\(PSOR\HV>L@QRPHQRP
 VWUFS\(PSOR\HV>L@SUHQRPHSUHQRP
 L
`
`
IFORVHIS
$IILFKDJHGHVHPSOR\pVjSDUWLUGHFHWDEOHDX
LIL SXWVΗsŽŝĐŝůĂůŝƐƚĞĚĞƐĞŵƉůŽLJĠƐƐƚŽĐŬĠƐĚĂŶƐůĞĨŝĐŚŝĞƌ͗Η
IRUM MLM
SULQWIΗͰƚйĚйƐйƐͰŶΗ͕ŵƉůŽLJĞƐ΀ũ΁͘ŶƵŵ͕ŵƉůŽLJĞƐ΀ũ΁͘ŶŽŵ͕ŵƉůŽLJĞƐ΀ũ΁͘ƉƌĞŶŽŵ
`
Solution 18 :
LQFOXGHVWGLRK!
W\SHGHIVWUXFWHPSOR\H^
 LQWQXP
 FKDUQRP>@SUHQRP>@
`(PSOR\H
(PSOR\H7>@
PDLQ
^
),/( ISLQWL
IS IRSHQHPSOR\HVEOFZ
ϮϬϮ

Les fichiers .

IRUL LL^
SULQWI'RQQH]OHQXPpURGHO
HPSOR\pGL
VFDQIG 7>L@QXP
SULQWI'RQQH]OHQRPGHO
HPSOR\pGL
VFDQIV7>L@QRP
SULQWI'RQQH]OHSUpQRPGHO
HPSOR\pGL
VFDQIV7>L@SUHQRP
`
^ƚŽĐŬĂŐĞ;ĠĐƌŝƚƵƌĞͿĚƵƚĂďůĞĂƵĚĞƐĞŵƉůŽLJĠƐĚĂŶƐƵŶĨŝĐŚŝĞƌďŝŶĂŝƌĞ
IZULWH7VL]HRI(PSOR\HIS
IFORVHIS
$IILFKDJHOHFWXUHGXILFKLHUGHVHPSOR\pV
IS IRSHQHPSOR\HVEOFU
IUHDG7VL]HRI(PSOR\HIS
IRUL LL^
SULQWI9RLFLOHVLQIRUPDWLRQVGHO
HPSOR\pG?QL
SULQWIΗͰƚEƵŵ͗йĚ͕EŽŵ͗йƐ͕WƌĞŶŽŵ͗йƐͰŶΗ͕d΀ŝ΁͘ŶƵŵ͕d΀ŝ΁͘ŶŽŵ͕d΀ŝ΁͘ƉƌĞŶŽŵ
`
IFORVHIS
`
Solution 19 :
LQFOXGHVWGLRK!
W\SHGHIVWUXFWHPSOR\H^
 LQWQXP
 FKDUQRP>@SUHQRP>@
`(PSOR\H
PDLQ
^
(PSOR\HHFKDUQRP>@VL]HBWQEO),/( ISLQWH[LVWH
$IILFKDJHOHFWXUHGHVHPSOR\pV
IS IRSHQHPSOR\HVEOFU
LIIS 18//^
SULQWI'RQQH]OHQRPGHO
HPSOR\pTXHYRXVFKHUFKH]
JHWVQRP
H[LVWH 
QEO IUHDG HVL]HRIHIS
LIQEO LIVWUFPSHQRPQRP ^
SXWV9RLFLOHVLQIRUPDWLRQVGHO
pOpPHQWUHFKHUFKp
SULQWIΗͰƚEƵŵ͗йĚ͕EŽŵ͗йƐ͕WƌĞŶŽŵ͗йƐͰŶΗ͕Ğ͘ŶƵŵ͕Ğ͘ŶŽŵ͕Ğ͘ƉƌĞŶŽŵ
H[LVWH 
`
ZKLOHIHRIIS QEO H[LVWH^
QEO IUHDG HVL]HRIHIS
LIQEO LIVWUFPSHQRPQRP ^
SXWV9RLFLOHVLQIRUPDWLRQVGHO
pOpPHQWUHFKHUFKp
SULQWIΗͰƚEƵŵ͗йĚ͕EŽŵ͗йƐ͕WƌĠŶŽŵ͗йƐͰŶΗ͕Ğ͘ŶƵŵ͕Ğ͘ŶŽŵ͕Ğ͘ƉƌĞŶŽŵ
H[LVWH 
`
`
ϮϬϯ

Les fichiers .

LIH[LVWHSULQWI(OpPHQWLQWURXYDEOH?Q

IFORVHIS
`HOVHSULQWI,PSRVVLEOHG
RXYULUOHILFKLHU?Q
`
Solution 20 :
LQFOXGHVWGLRK!
PDLQ
^
LQW[\SRVLWLRQFKDUQRPILFKLHU>@VL]HBWQEO
),/( IS
$IILFKDJHOHFWXUHG
XQHQWLHU
SULQWI'RQQH]OHQRPGXILFKLHUjRXYULU
VFDQIVQRPILFKLHU
SULQWI'RQQH]ODSRVLWLRQGHO
HQWLHUjOLUH
VFDQIG SRVLWLRQ
IS IRSHQQRPILFKLHUU
LIIS 18//^
\ IVHHNISSRVLWLRQ VL]HRILQW
LI\ ^
QEO IUHDG [VL]HRI[IS
LIQEO SULQWI(QWLHUG?Q[
`HOVHSULQWI(FKHFGHSRVLWLRQQHPHQW?Q
IFORVHIS
`
HOVHSULQWI,PSRVVLEOHG
RXYULUOHILFKLHU?Q
`


ϮϬϰ

Les listes chaînées .

Chapitre 9 : Les listes chaînées

1. Introduction
Pour stocker un ensemble d¶éléments de même type, il est possible d¶utiliser les
tableaux. Cependant, le nombre d¶éléments du tableau doit être fixé lors de sa
déclaration. Les tableaux ne peuvent donc pas être étendus pendant l¶exécution
du programme. Les listes chaînées peuvent être étendues pendant l¶exécution
du programme par l¶allocation (réservation) d¶un nouvel espace mémoire quand
c¶est nécessaire. Elles peuvent être aussi réduites par une désallocation de
l¶espace non utile. La construction d¶une liste chaînée consiste à regrouper un
ensemble d¶objets éparpillés en mémoire et liés par des pointeurs.
2. Les pointeurs
Un pointeur est une variable qui contient une adresse mémoire, et non pas la
valeur. C¶est une variable qui au lieu de contenir la donnée, contient son
adresse en mémoire.
Format général : W\SHGHGRQQpHV! 1RPBSRLQWHXU
Exemple :
Pour déclarer un pointeur < vers un entier (contient l¶adresse d¶un entier), on
met :
9DULDEOHV
(QWLHU <
En C, un pointeur est déclaré comme suit :
LQW <
Si nous avions ; une variable entière ayant comme valeur , et < un pointeur
vers la variable entière ;, les deux variables ; et < auraient pu être représentées
en mémoire comme suit :
ĚƌĞƐƐĞƐŵĠŵŽŝƌĞ

ϭϬϬϭϭ

y ϭϬϬϭϮ ϳϭ
ϭϬϬϭϯ

ϭϬϬϭϰ

ϭϬϬϭϱ

z ϭϬϬϭϲ ϭϬϬϭϮ
En fait, cette représentation n¶est pas tout à fait exacte, car réellement la
mémoire est constituée d¶un ensemble d¶octets, chacun est identifié par une
ϮϬϱ

Les listes chaînées .

adresse. La case mémoire correspondant à une variable est constituée d¶un

ensemble d¶octets selon son type. L¶adresse d¶une variable est l¶adresse du
premier octet de l¶espace mémoire réservé (alloué) à la variable.
Un pointeur peut recevoir la valeur d¶un autre pointeur par une opération
d¶affectation. On peut aussi comparer deux pointeurs pointant vers des objets
de même type par les opérateurs de comparaison ( , !, , ! ,  , !).
On peut additionner ou soustraire un entier d¶un pointeur ; le résultat sera un
pointeur. Par conséquent, un pointeur peut être incrémenté ou décrémenté. On
peut faire la différence de deux pointeurs ; on aura un entier. Les autres
RSpUDWLRQVDULWKPpWLTXHVVRPPHSURGXLW«QHVRQWSDVDFFHSWpHV
L¶espace mémoire réservé à une variable de type pointeur dépend du système
utilisé. Il peut varier en fonction du matériel et du système d¶exploitation. Ça
peut être 2 octets, 4 ou même 8 octets.
Les pointeurs mènent à une gestion dynamique de la mémoire.
3. Gestion dynamique de la mémoire
Quand on utilise un tableau dans un programme, on doit fixer sa taille avant
l¶exécution, et on parle d¶une gestion statique de la mémoire. La gestion
dynamique permet la réservation (allocation) de l¶espace pendant l¶exécution
du programme grâce à des variables de type pointeur.
Une variable de type pointeur contient l¶adresse d¶une variable dite variable
pointée.
Pour la gestion dynamique de la mémoire, on utilise principalement les deux
procédures :
 $OORXHUS qui permet de réserver un espace mémoire pour une variable
pointée par le pointeur S. En C, c¶est la fonction
PDOORFQRPEUHBRFWHWV, mais on écrit d¶une façon plus explicite et
sûre : S W\SHBGRQQpHV! PDOORFVL]HRIW\SHBGRQQpHV!
W\SHBGRQQpHV! étant le type d¶élément vers lequel pointe S. La fonction
PDOORF retourne l¶adresse du premier octet réservé.
PDOORF est à l¶origine de type YRLG , i.e., PDOORF retourne une adresse,
mais qu¶on ne sait pas sur quel type elle pointe. C¶est pourquoi, on
convertira ce YRLG en un type plus explicite, tel que LQW , IORDW , etc.,
en fonction du besoin, et on met (W\SHBGRQQpHV! ).
Pour éviter les erreurs lorsqu¶on exprime la taille de la mémoire à allouer,
on utilisera la fonction VL]HRI, qui renvoie la taille en octets d¶une
donnée du type spécifié en paramètre.
 'pVDOORXHUS qui permet de libérer l¶espace mémoire réservé à une
variable pointée par le pointeur S. En C, c¶est IUHHS. La fonction IUHH
est souvent appelée directement par son nom dans un programme C
comme une procédure, sans qu¶elle figure dans une expression.
ϮϬϲ

Les listes chaînées .

Les deux fonctions, PDOORF et IUHH, appartiennent à la bibliothèque VWGOLEK.

Exemple :
$OJRULWKPHSRLQWHXUV
9DULDEOHV
(QWLHU \
'pEXW
$OORXHU\
 \&
(FULUH/DYDOHXUHVW \
'pVDOORXHU\
)LQ
En C :
LQFOXGHVWGLRK!
LQFOXGHVWGOLEK!
PDLQ
^LQW \
\ LQW PDOORFVL]HRILQW
 \ 
SULQWI/DYDOHXUHVWG?Q \
IUHH\
`
Le programme C précédent permet de créer une variable \ de type pointeur vers
un entier. Il alloue un espace pour la variable pointée. Ensuite, il affecte la
valeur  à la variable pointée. Il affiche cette valeur. Enfin, il libère l¶espace
réservé à la variable pointée.
Voyons ce que fait l¶exemple C suivant :
LQFOXGHVWGLRK!
PDLQ
^LQW \LQW[
[ 
\  [SULQWI \ G?Q \
 \ SULQWI[ G?Q[
VFDQIG [SULQWI[ G?Q[
VFDQIG\SULQWI[ G?Q[
`
Après avoir déclaré un entier [ et un pointeur vers un entier \, le programme C
précédent affecte la valeur  à la variable [. Il affecte l¶adresse de la variable [,
indiquée par , à la variable \. Il affiche la valeur de la variable pointée par \
( \ ). La variable pointée par \ aura par la suite . La valeur de [ sera donc
, et le programme l¶affiche : [ . Le programme va encore lire au clavier la
valeur de [ et l¶afficher. Ces deux dernières opérations seront répétées deux fois.
L¶opérateur de référençage , aussi appelé opérateur d¶adressage, permet de
connaitre l¶adresse d¶une variable. Il faut le placer devant la variable
considérée. Par exemple, supposons qu¶on a une variable [ déjà déclarée.
Alors, l¶expression [ correspond à l¶adresse de cette variable.
ϮϬϳ

Les listes chaînées .

Voyons encore un autre exemple :

LQFOXGHVWGLRK!
PDLQ
^LQW \ 
SULQWI \ G?Q \
SULQWI\ G?Q\
SULQWI \ G?Q \
`
Cet exemple affichera la valeur de la variable pointée ( \ ), l¶adresse de la
variable pointée, i.e. le contenu du pointeur (\ «), et l¶adresse du pointeur,
qui est une adresse d¶une adresse ( \ «).
Remarques :
 Pour dire qu¶un pointeur ne pointe vers aucun élément, il faut lui affecter la
valeur 18// de bibliothèque VWGOLEK. Une fois créé, un pointeur pointe
vers n¶importe quel octet de la mémoire. Il est donc recommandé
d¶initialiser ce pointeur à 18//, sinon on risque d¶avoir une erreur
d¶exécution.
 Les deux fonctions PDOORF et IUHH utilisent une zone mémoire appelée
TAS (en anglais Heap). Quand cette zone est pleine, on aura une erreur
d¶exécution appelée fuite de mémoire.
4. Les listes chaînées
Une liste chaînée est un ensemble d¶éléments de même type. Chaque élément
est lié à son successeur par un pointeur.
Une liste chaînée est composée d¶un ensemble d¶éléments (maillons, cellules,
Q°XGV ou composants). Un élément étant une structure (enregistrement) qui
contient des données à stocker et un pointeur vers le prochain élément
(successeur) de la liste.
W\SHGHIVWUXFWHOHPHQW
^
7\SHBGRQQpHV!FKDPS
7\SHBGRQQpHV!FKDPS
«
VWUXFWHOHPHQW 6XLYDQW
`(OHPHQW
On parle ici d¶une structure de données récursive (6XLYDQW étant un pointeur
vers une structure de même type).
Une variable 3 de type pointeur vers (OHPHQW ((OHPHQW 3) peut être
représentée comme suit :
W

Zu‰íZu‰îY

ϮϬϴ

Les listes chaînées .

L¶adresse de l¶élément est rangée dans la variable 3. L¶élément contient deux

parties : la partie données contenant les champs : FKDPS, FKDPS«, et le
pointeur 6XLYDQW contenant l¶adresse de l¶élément suivant (successeur). On
accède aux champs de données de l¶élément de l¶adresse 3 comme suit :
3!FKDPS, 3!FKDPS«
On accède à l¶adresse du successeur par 3!6XLYDQW.
Remarque : Il ne faut pas confondre entre le point () et la flèche (!) pour
accéder aux champs d¶une structure. Pour accéder aux champs d¶une variable de
type structure, on utilise un point (eg. ;QXP), mais pour accéder aux champs d¶une
variable de type pointeur vers structure, on utilise une flèche (eg. ;!QXP).
Exemple :
Soit une liste contenant les chaînes de caractères suivantes classées dans cet
ordre : 2UDQ, 0DVFDUD, 1DDPD, 6%$, 7OHPFHQ.
La liste peut être représentée en mémoire comme suit :
ĚƌĞƐƐĞƐŵĠŵŽŝƌĞ

dġƚĞ ϭϬϬϬϱ ϭϬϬϬϲ

ϭϬϬϬϲ KƌĂŶ ϭϬϬϭϮ
ϭϬϬϬϳ
ϭϬϬϬϴ ^ ϭϬϬϭϬ
ϭϬϬϬϵ
ϭϬϬϭϬ důĞŵĐĞŶ Eh>>
ϭϬϬϭϭ
ϭϬϬϭϮ DĂƐĐĂƌĂ ϭϬϬϭϲ
ϭϬϬϭϯ
YƵĞƵĞ ϭϬϬϭϰ ϭϬϬϭϬ
ϭϬϬϭϱ
ϭϬϬϭϲ EĂĂŵĂ ϭϬϬϬϴ

Une deuxième représentation facile à être assimilée est la suivante :

KƌĂŶ  DĂƐĐĂƌĂ  EĂĂŵĂ  ^  důĞŵĐĞŶ  Eh>>

dġƚĞ  YƵĞƵĞ 

ϮϬϵ

Les listes chaînées .

Il n¶est pas possible d¶accéder directement à un élément quelconque de la liste.

C¶est l¶adresse (pointeur) du premier élément qui détermine la liste. Cette
adresse doit se trouver dans une variable que nous appelons souvent Tête,
Sommet ou Début de la liste. Le pointeur vers le dernier élément de la liste est
appelé Queue de la liste.
5. Opérations sur les listes chaînées
Plusieurs opérations peuvent être effectuées sur une liste.
5.1. Créer et remplir une liste
Pour créer et remplir la liste des villes représentée ci-dessus, on doit :
1.Définir la structure 9LOOH suivante :
W\SHGHIVWUXFWYLOOH
^
FKDU'HV>@
VWUXFWYLOOH 6XLYDQW
`9LOOH
2.On déclare deux variables 7HWH et 4XHXH comme suit :
9LOOH 7HWH 4XHXH
3.Le premier élément de la liste peut être créé comme suit :
 On réserve un espace mémoire pour une variable pointée par 7HWH :
7HWH 9LOOH PDOORFVL]HRI9LOOH
 Remplir le premier élément de la liste :
VWUFS\7HWH!'HV2UDQ
 A ce niveau, le premier élément et au même temps le dernier. Par
conséquent, la queue pointe vers la tête : 4XHXH 7HWH
 Le successeur de la queue est 18// : 4XHXH!6XLYDQW 18//
Le tableau suivant décrit le changement d¶état de la mémoire selon les
instructions du programme :
Instruction Représentation en mémoire

dĞƚĞс;sŝůůĞΎͿŵĂůůŽĐ;ƐŝnjĞŽĨ;sŝůůĞͿͿ͖
dġƚĞ

KƌĂŶ
ƐƚƌĐƉLJ;dĞƚĞͲхĞƐ͕ΗKƌĂŶΗͿ͖
dġƚĞ

KƌĂŶ
YƵĞƵĞсdĞƚĞ͖
dġƚĞ YƵĞƵĞ

ϮϭϬ

Les listes chaînées .

KƌĂŶ Eh>>

YƵĞƵĞͲх^ƵŝǀĂŶƚсEh>>͖
dġƚĞ YƵĞƵĞ
4.L¶ajout d¶un deuxième élément à la fin de la liste se fait comme suit :
 On réserve un espace mémoire pour une variable pointée par le
successeur de la queue : 
4XHXH!6XLYDQW 9LOOH PDOORFVL]HRI9LOOH
 La queue va pointer maintenant vers son successeur :
4XHXH 4XHXH!6XLYDQW
 Remplir le nouvel élément de la liste :
VWUFS\4XHXH!'HV0DVFDUD
 Le successeur de la queue est le 18// : 4XHXH!6XLYDQW 18//
Le tableau suivant décrit le changement d¶état de la mémoire selon les
instructions du programme :
Instruction Représentation en mémoire
KƌĂŶ
YƵĞƵĞͲх^ƵŝǀĂŶƚс
;sŝůůĞΎͿŵĂůůŽĐ;ƐŝnjĞŽĨ;sŝůůĞͿͿ͖
dġƚĞ YƵĞƵĞ

KƌĂŶ
YƵĞƵĞсYƵĞƵĞͲх^ƵŝǀĂŶƚ͖
dġƚĞ YƵĞƵĞ

KƌĂŶ
ƐƚƌĐƉLJ;YƵĞƵĞͲхĞƐ͕
ΗDĂƐĐĂƌĂΗͿ͖ DĂƐĐĂƌĂ
dġƚĞ YƵĞƵĞ

KƌĂŶ
YƵĞƵĞͲх^ƵŝǀĂŶƚсEh>>͖ DĂƐĐĂƌĂ Eh>>
dġƚĞ YƵĞƵĞ

5.Pour ajouter le troisième, le quatrième et le cinquième élément, il est

possible de substituer l¶étape 4 par une procédure permettant l¶ajout d¶un
élément à la fin de la liste. La procédure possède comme paramètre le nom
de la ville à ajouter, et elle est écrite comme suit :
YRLG$MRXWHUB4FKDU9>@
^
4XHXH!VXLYDQW 9LOOH PDOORFVL]HRI9LOOH
4XHXH 4XHXH!6XLYDQW
VWUFS\4XHXH!'HV9
Ϯϭϭ

Les listes chaînées .

4XHXH!6XLYDQW 18//
`
Le programme C complet pour créer la liste des villes est alors le suivant :
LQFOXGHVWGLRK!
LQFOXGHVWULQJK!
LQFOXGHVWGOLEK!
W\SHGHIVWUXFWYLOOH
^
FKDU'HV>@
VWUXFWYLOOH 6XLYDQW
`9LOOH
9LOOH 7HWH 4XHXH
 3URFpGXUHG
DMRXWG
XQpOpPHQWjODILQGHODOLVWH 
YRLG$MRXWHUB4FKDU9>@
^
4XHXH!6XLYDQW 9LOOH PDOORFVL]HRI9LOOH
4XHXH 4XHXH!6XLYDQW
VWUFS\4XHXH!'HV9
4XHXH!6XLYDQW 18//
`
PDLQ
^
 &UpHUHWUHPSOLUOHSUHPLHUpOpPHQWGHODOLVWH 
7HWH 9LOOH PDOORFVL]HRI9LOOH
VWUFS\7HWH!'HV2UDQ
4XHXH 7HWH
4XHXH!6XLYDQW 18//
 $MRXWHUOHUHVWHGHVpOpPHQWVjODOLVWH 
$MRXWHUB40DVFDUD
$MRXWHUB41DDPD
$MRXWHUB46%$
$MRXWHUB47OHPFHQ
`
5.2. Afficher les éléments de la liste
Pour consulter la liste chaînée que nous avons créée précédemment, il faut se
positionner au début de la liste, puis la parcourir élément par élément jusqu¶à la
fin.
 3URFpGXUHG
DIILFKDJHGHVpOpPHQWVGHODOLVWH 
YRLG$IILFKHUB/LVWH
^
9LOOH 3
LQWL
3 7HWH
L 
ZKLOH3 18//^
SULQWI/
pOpPHQWQXPƒGGHODOLVWHHVWV?QL3!'HV
L L
3 3!6XLYDQW
`
ϮϭϮ

Les listes chaînées .

`
Remarque : Si on remplace la condition (3 18//) par (3!6XLYDQW 
18//), le dernier élément de la liste ne sera pas affiché.
On peut aussi parcourir une liste chaînée par une boucle IRU de la manière
suivante :
 3URFpGXUHG
DIILFKDJHGHVpOpPHQWVGHODOLVWH 
YRLG$IILFKHUB/LVWH
^
9LOOH 3
LQWL
L 
IRU3 7HWH3 18//3 3!6XLYDQW^
SULQWI/
pOpPHQWQXPƒGGHODOLVWHHVWV?QL3!'HV
L L
`
`
5.3. Ajouter un élément au début de la liste
L¶ajout d¶un élément au début de la liste se fait comme suit :
 On réserve un espace mémoire pour une variable 3 de type pointeur
vers 9LOOH : 3 9LOOH PDOORFVL]HRI9LOOH
 Remplir le nouvel élément pointé par 3 : VWUFS\3!'HV9
 On effectue l¶enchaînement du nouvel élément avec la liste
existante : 3!6XLYDQW 7HWH
 La tête va pointer maintenant vers le nouvel élément : 7HWH 3
Le tableau suivant décrit le changement d¶état de la mémoire selon les
instructions de la procédure :
Instruction Représentation en mémoire

Wс;sŝůůĞΎͿŵĂůůŽĐ;ƐŝnjĞŽĨ;sŝůůĞͿͿ͖
W

s
ƐƚƌĐƉLJ;WͲхĞƐ͕sͿ͖
W

s
WͲх^ƵŝǀĂŶƚсdĞƚĞ͖ Y
W dġƚĞ

s
dĞƚĞсW͖ Y
W dġƚĞ
Ϯϭϯ

Les listes chaînées .

N¶oubliez pas de mettre à jour la queue dans le cas où on désir ajouter un

élément dans une liste vide.
La procédure permettant l¶ajout d¶un élément au début de la liste est alors la
suivante :
 3URFpGXUHG
DMRXWG
XQpOpPHQWDXGpEXWGHODOLVWH 
YRLG$MRXWHUB7FKDU9>@
^9LOOH 3
3 9LOOH PDOORFVL]HRI9LOOH
VWUFS\3!'HV9
3!6XLYDQW 7HWH
7HWH 3
LI4XHXH 18//4XHXH 7HWH
`
5.4. Insérer un élément dans la liste
On désir maintenant implémenter une procédure permettant d¶insérer un
élément après un autre dans une liste (insérer une ville 9 après 9). Pour ce
faire, on aura besoin de déclarer deux variables 3 et 3 pointant vers une
ville : 9LOOH 3 3. Le pointeur 3 va pointer vers l¶élément à insérer (un
nouvel élément contenant la ville 9). Le pointeur 3 va nous permettre de
localiser la ville 9 dans la liste. Après ça, on doit suivre les étapes suivantes :
 Le successeur de 3 devient le successeur de 3 :
3!6XLYDQW 3!6XLYDQW
 Le successeur de 3 devient 3 lui même : 3!6XLYDQW 3
Le tableau suivant décrit ces deux dernières étapes :
Instruction Représentation en mémoire
WϮ sϮ

ͬΎǀĂŶƚů[ŝŶƐĞƌƚŝŽŶΎͬ Y sϭ Y Y

Wϭ

WϮ sϮ
WϮͲх^ƵŝǀĂŶƚс
WϭͲх^ƵŝǀĂŶƚ͖ Y sϭ Y Y

Wϭ

WϮ sϮ

WϭͲх^ƵŝǀĂŶƚсWϮ͖ Y sϭ Y Y

Wϭ


Ϯϭϰ

Les listes chaînées .

La procédure permettant d¶insérer un élément après un autre est alors la

suivante :
 3URFpGXUHG
LQVHUWLRQG
XQHYLOOH9DSUqV9GDQVODOLVWH 
YRLG,QVHUHUB$3B9LOOHFKDU9>@FKDU9>@
^
9LOOH 3 3
LIVWUFPS4XHXH!'HV9 $MRXWHUB49
HOVH^
6HSRLQWHUYHUVO
pOpPHQWFRQWHQDQW9
3 7HWH
ZKLOHVWUFPS3!'HV9 3 3!6XLYDQW
&UpHUXQQRXYHOpOpPHQWFRQWHQDQW9
3 9LOOH PDOORFVL]HRI9LOOH
VWUFS\3!'HV9
,QVpUHUOHQRXYHOpOpPHQWGDQVODOLVWH
3!6XLYDQW 3!6XLYDQW
3!6XLYDQW 3
`
`
Remarque : Dans la procédure ci-dessus, on suppose que 9 existe
obligatoirement dans la liste. Il faut donc que cette procédure soit enrichie par
le traitement du cas où 9 n¶existe pas dans la liste.
5.5. Supprimer la tête de la liste
Pour supprimer la tête de la liste, on utilise une variable 3 pointant vers une
ville : 9LOOH 3. Ensuite, il faut suivre les étapes suivantes :
 La variable 3 sera utilisée pour garder l¶adresse du premier élément :
3 7HWH
 Maintenant, on met à jour l¶adresse de la nouvelle tête de la liste :
7HWH 7HWH!6XLYDQW
 Enfin, on libère l¶espace mémoire réservé par l¶ancienne tête :
IUHH3
Le tableau suivant décrit le changement d¶état de la mémoire selon les
instructions de la procédure :
Instruction Représentation en mémoire
Y
WсdĞƚĞ͖
Y
W dġƚĞ

Y
dĞƚĞсdĞƚĞͲх^ƵŝǀĂŶƚ͖ Y
W dġƚĞ

Ϯϭϱ

Les listes chaînées .

Y
ĨƌĞĞ;WͿ͖
Y
W dġƚĞ

La procédure permettant la suppression de la tête de la liste est alors la

suivante :
 3URFpGXUHGHVXSSUHVVLRQGHODWrWHGHODOLVWH 
YRLG6XSSULPHUB7
^
9LOOH 3
LI7HWH 18//
LI7HWH!6XLYDQW 18//^
 IUHH7HWH
 7HWH 18//
 4XHXH 18//
 `
HOVH^
3 7HWH
7HWH 7HWH!6XLYDQW
IUHH3
`
`
Remarque : Avant de traiter le cas général, nous avons traité les deux cas
triviaux : liste vide et liste contenant un seul élément. Un cas trivial est un cas
basique et simple qui peut être traité en isolement du cas général.
5.6. Supprimer un élément de la liste
La procédure permettant la suppression d¶un élément de la liste possède un
paramètre 9 indiquant la ville à supprimer. Dans cette procédure, on aura
besoin de déclarer deux variables 3 et 3 pointant vers une ville : 9LOOH 3
3. Le pointeur 3 va pointer vers l¶élément à supprimer. Le pointeur 3
pointe juste avant 3. Après ça, on doit suivre les étapes suivantes :
 Le successeur de 3 devient le successeur de 3 :
3!6XLYDQW 3!6XLYDQW
 Libérer l¶espace mémoire occupé par l¶élément supprimé :
IUHH3
Le tableau suivant décrit ces deux dernières étapes :
Instruction Représentation en mémoire
WϮ s
ͬΎǀĂŶƚůĂ
ƐƵƉƉƌĞƐƐŝŽŶΎͬ Y Y Y Y

Wϭ

Ϯϭϲ

Les listes chaînées .

WϮ s
WϭͲх^ƵŝǀĂŶƚс
WϮͲх^ƵŝǀĂŶƚ͖ Y Y Y Y

Wϭ

WϮ s
ĨƌĞĞ;WϮͿ͖
Y Y Y Y

Wϭ

N¶oubliez pas de mettre à jour la queue dans le cas où l¶élément à supprimer est
le dernier de la liste.
La procédure permettant de supprimer un élément de la liste est alors la
suivante :
 3URFpGXUHGHVXSSUHVVLRQG
XQpOpPHQWGHODOLVWH 
YRLG6XSSULPHUFKDU9>@
^9LOOH 3 3
LIVWUFPS7HWH!'HV9 6XSSULPHUB7
HOVH^
6HSRLQWHUYHUVO
pOpPHQWFRQWHQDQW9
3 7HWH
3 3!6XLYDQW
ZKLOHVWUFPS3!'HV9 ^
3 3
3 3!6XLYDQW
`
 DĞƚƚƌĞăũŽƵƌůĂƋƵĞƵĞĚĂŶƐůĞĐĂƐŽƶůΖĠůĠŵĞŶƚăƐƵƉƉƌŝŵĞƌĞƐƚůĞĚĞƌŶŝĞƌĚĞůĂůŝƐƚĞ 
LI4XHXH 34XHXH 3
6XSSULPHUO
pOpPHQWFRQWHQDQW9
3!6XLYDQW 3!6XLYDQW
IUHH3
`
`
Remarque : Dans la procédure ci-dessus, on suppose que 9 existe
obligatoirement dans la liste. Il faut donc que cette procédure soit enrichie par
le traitement du cas où 9 n¶existe pas dans la liste.
6. Les listes doublement chaînées
Il est possible de parcourir une liste dans les deux sens en ajoutant un pointeur
permettant l¶accès à l¶élément précédent. On obtient alors une liste doublement
chaînée appelée aussi liste bidirectionnelle, contrairement à une liste
simplement chaînée ou unidirectionnelle.

Ϯϭϳ

Les listes chaînées .

L¶ensemble des villes stockées dans une liste doublement chaînée peut être
représenté comme suit :
Eh>>  KƌĂŶ   DĂƐĐĂƌĂ   EĂĂŵĂ   ^   důĞŵĐĞŶ  Eh>>

dġƚĞ  YƵĞƵĞ 

Pour créer la liste doublement chaînée représentée ci-dessus, il faut suivre les
étapes suivantes :
1.On définit la structure 9LOOH suivante :
W\SHGHIVWUXFWYLOOH
^
FKDU'HV>@
VWUXFWYLOOH 3UHFHGHQW 6XLYDQW
`9LOOH
2.On déclare deux variables 7HWH et 4XHXH comme suit :
9LOOH 7HWH 4XHXH
3.Le premier élément de la liste peut être créé comme suit :
 On réserve un espace mémoire pour une variable pointée par 7HWH :
7HWH 9LOOH PDOORFVL]HRI9LOOH
 Remplir le premier élément de la liste :
VWUFS\7HWH!'HV2UDQ
Le premier élément n¶a pas de précédent, ce qui se traduit par :
7HWH!3UHFHGHQW 18//
 A ce niveau, le premier élément et au même temps le dernier. Par
conséquent, la queue pointe vers la tête : 4XHXH 7HWH
Le successeur de la queue est le 18// : 4XHXH!6XLYDQW 18//
Le tableau suivant décrit le changement d¶état de la mémoire selon les
instructions du programme :
Instruction Représentation en mémoire

dĞƚĞс;sŝůůĞΎͿŵĂůůŽĐ;ƐŝnjĞŽĨ;sŝůůĞͿͿ͖
dġƚĞ

Eh>> KƌĂŶ
ƐƚƌĐƉLJ;dĞƚĞͲхĞƐ͕ΗKƌĂŶΗͿ͖

dĞƚĞͲхWƌĞĐĞĚĞŶƚсEh>>͖ dġƚĞ

Eh>> Eh>>
YƵĞƵĞсdĞƚĞ͖ KƌĂŶ

YƵĞƵĞͲх^ƵŝǀĂŶƚсEh>>͖ dġƚĞ YƵĞƵĞ

Ϯϭϴ

Les listes chaînées .

4.L¶ajout d¶un deuxième élément à la fin liste doublement chaînée se fait

comme suit :
 On réserve un espace mémoire pour une variable pointée par le
successeur de la queue :
4XHXH!6XLYDQW 9LOOH PDOORFVL]HRI9LOOH
 Le nouvel élément créé sera précédé par la queue :
4XHXH!6XLYDQW!3UHFHGHQW 4XHXH
 La queue va pointer maintenant vers son successeur :
4XHXH 4XHXH!6XLYDQW
 Remplir le nouvel élément de la liste :
VWUFS\4XHXH!'HV0DVFDUD
Le successeur de la queue est le 18// :4XHXH!6XLYDQW 18//
Le tableau suivant décrit le changement d¶état de la mémoire selon les
instructions du programme :
Instruction Représentation en mémoire
Eh>> KƌĂŶ
YƵĞƵĞͲх^ƵŝǀĂŶƚс
;sŝůůĞΎͿŵĂůůŽĐ;ƐŝnjĞŽĨ;sŝůůĞͿͿ͖
dġƚĞ YƵĞƵĞ

Eh>> KƌĂŶ
YƵĞƵĞͲх^ƵŝǀĂŶƚͲхWƌĞĐĞĚĞŶƚ
сYƵĞƵĞ͖
dġƚĞ YƵĞƵĞ

Eh>> KƌĂŶ
YƵĞƵĞсYƵĞƵĞͲх^ƵŝǀĂŶƚ͖
dġƚĞ YƵĞƵĞ

ƐƚƌĐƉLJ;YƵĞƵĞͲхĞƐ͕ Eh>> KƌĂŶ

ΗDĂƐĐĂƌĂΗͿ͖
 DĂƐĐĂƌĂ Eh>>
YƵĞƵĞͲх^ƵŝǀĂŶƚсEh>>͖ dġƚĞ YƵĞƵĞ

5.Pour ajouter le troisième, le quatrième et le cinquième élément, il est

possible de substituer l¶étape 4 par une procédure permettant l¶ajout d¶un
élément à la fin de la liste. La procédure possède comme paramètre le nom
de la ville à ajouter, et elle est écrite comme suit :
YRLG$MRXWHUB4FKDU9>@
^4XHXH!6XLYDQW 9LOOH PDOORFVL]HRI9LOOH
4XHXH!6XLYDQW!3UHFHGHQW 4XHXH
4XHXH 4XHXH!6XLYDQW
VWUFS\4XHXH!'HV9
4XHXH!6XLYDQW 18//
`
Ϯϭϵ

Les listes chaînées .

Le programme C complet pour la création de la liste doublement chaînée est

alors le suivant :
LQFOXGHVWGLRK!
LQFOXGHVWULQJK!
LQFOXGHVWGOLEK!
W\SHGHIVWUXFWYLOOH
^
FKDU'HV>@
VWUXFWYLOOH 3UHFHGHQW 6XLYDQW
`9LOOH
9LOOH 7HWH 4XHXH
 3URFpGXUHG
DMRXWG
XQpOpPHQWjODILQGHODOLVWH 
YRLG$MRXWHUB4FKDU9>@
^4XHXH!6XLYDQW 9LOOH PDOORFVL]HRI9LOOH
4XHXH!6XLYDQW!3UHFHGHQW 4XHXH
4XHXH 4XHXH!6XLYDQW
VWUFS\4XHXH!'HV9
4XHXH!6XLYDQW 18//
`
PDLQ
^ &UpHUHWUHPSOLUOHSUHPLHUpOpPHQWGHODOLVWH 
7HWH 9LOOH PDOORFVL]HRI9LOOH
VWUFS\7HWH!'HV2UDQ
7HWH!3UHFHGHQW 18//
4XHXH 7HWH
4XHXH!6XLYDQW 18//
 $MRXWHUOHUHVWHGHVpOpPHQWVjODOLVWH 
$MRXWHUB40DVFDUD
$MRXWHUB41DDPD
$MRXWHUB46%$
$MRXWHUB47OHPFHQ
`
7. Les listes chaînées particulières
En conditionnant l¶accès aux listes, on obtient des listes chaînées particulières,
à savoir les piles et les files.
7.1. Les piles
Une pile est une liste dont les éléments ne peuvent être ajoutés ou supprimés
qu¶à partir d¶une extrémité appelée sommet de la pile : dernier entré, premier
sorti. En anglais, on dit : Last In, First Out (LIFO).
Dans notre vie quotidienne, on trouve par exemple la pile d¶assiettes.
La pile peut être représentée tout simplement comme suit :
^ŽŵŵĞƚ

ĂƐĞ

ϮϮϬ

Les listes chaînées .

Le premier élément de la pile est appelé Sommet de la pile. Le dernier est

appelé Base de la pile.
Remarque : Attention ! Il ne faut pas confondre entre la pile (stack) qui est une
zone mémoire réservée pour l¶exécution des programmes, et la pile étudiée
dans cette section.
7.1.1. Primitives d¶accès
On définit habituellement les deux primitives suivantes pour accéder à une
pile :
 (PSLOHU( qui ajoute un nouvel élément ( au sommet de la pile.
 'pSLOHU qui supprime l¶élément sommet de la pile
Exemple : Dans une pile de caractères contenant initialement les éléments : $,
% et &, on désir empiler encore le caractère ', ensuite dépiler deux caractères.
Ces opérations peuvent être représentées comme suit :
^ŽŵŵĞƚ

^ŽŵŵĞƚ ^ŽŵŵĞƚ
  
^ŽŵŵĞƚ
   
ĂƐĞ ĂƐĞ ĂƐĞ ĂƐĞ
   

ƚĂƚĚĞůĂƉŝůĞ ƚĂƚĚĞůĂƉŝůĞ
ƚĂƚŝŶŝƚŝĂůĚĞ ƚĂƚĚĞůĂƉŝůĞ
ĂƉƌğƐĠƉŝůĞƌ;Ϳ ĂƉƌğƐĠƉŝůĞƌ;Ϳ
ůĂƉŝůĞ ĂƉƌğƐŵƉŝůĞƌ;ΖΖͿ

7.1.2. Représentation d¶une pile par une liste doublement chaînée

Une pile peut être représentée par un tableau, une liste simplement ou
doublement chaînée. Dans ce qui suit, nous avons choisi une liste doublement
chaînée pour représenter une pile :
 L¶opération d¶empilement se traduit par un ajout en tête de la liste
doublement chaînée.
 L¶opération de dépilement se traduit par une suppression de la tête de la
liste doublement chaînée.
 Le sommet et la base de la pile étant la tête et la queue de la liste
doublement chaînée.
Pour la manipulation d¶une pile de caractères, on doit suivre les étapes
suivantes :
1.On définit la structure 3LOH comme suit :
W\SHGHIVWUXFWSLOH
^
FKDU&DU
VWUXFWSLOH 3UHFHGHQW 6XLYDQW
`3LOH

ϮϮϭ

Les listes chaînées .

2.Ensuite, on déclare le sommet et la base de la pile comme suit :

3LOH %DVH 6RPPHW
3.La procédure permettant d¶empiler un élément dans la pile est la suivante :
 3URFpGXUHSHUPHWWDQWG
HPSLOHUXQpOpPHQWGDQVODSLOH 
YRLG(PSLOHUFKDU&
^
3LOH 3
3 3LOH PDOORFVL]HRI3LOH
3!&DU &
3!3UHFHGHQW 18//
3!6XLYDQW 6RPPHW
LI6RPPHW 18//6RPPHW!3UHFHGHQW 3
6RPPHW 3
LI%DVH 18//%DVH 6RPPHW
`
4.La procédure permettant de dépiler un élément de la pile est la suivante :
 3URFpGXUHSHUPHWWDQWGHGpSLOHUXQpOpPHQWGHODSLOH 
YRLG'HSLOHU
^
LI6RPPHW 18//SXWV'pSLOHPHQWLPSRVVLEOH3LOH9LGH
HOVHLI6RPPHW!6XLYDQW 18//^
SULQWI(OpPHQWGpSLOpF?Q6RPPHW!&DU
IUHH6RPPHW
6RPPHW 18//
%DVH 18//
`
HOVH^SULQWI(OpPHQWGpSLOpF?Q6RPPHW!&DU
6RPPHW 6RPPHW!6XLYDQW
IUHH6RPPHW!3UHFHGHQW
6RPPHW!3UHFHGHQW 18//
`
`
7.2. Les files
Une file est une liste dont les éléments sont ajoutés à une extrémité appelée
queue, et retirés de l¶autre appelée tête : premier entré, premier sorti. En
anglais, on dit : First In, First Out (FIFO).
Dans notre vie quotidienne, on trouve par exemple la file d¶attente à un guichet.
La file peut être représentée tout simplement comme suit :
dġƚĞ YƵĞƵĞ

Le premier élément de la file est appelé Tête de la file. Le dernier est appelé
Queue de la file.

ϮϮϮ

Les listes chaînées .

Remarque : Il ne faut pas confondre entre le mot file (en français), et le mot
),/( (en anglais) qui veut dire fichier et qui est utilisé pour la manipulation des
fichiers en C.
7.2.1. Accès à une file
Comme illustré dans l¶exemple suivant, on ne peut effectuer un ajout à la file
(Enfilement) qu¶à travers sa queue. Par contre, la suppression (Défilement) est
effectuée à partir de la tête de la file.
Exemple :
Soit une file de caractères contenant initialement les éléments : $, % et &. On
désir ajouter le caractère ', ensuite supprimer deux caractères. Ces opérations
peuvent être représentées comme suit :
dġƚĞ YƵĞƵĞ dġƚĞ YƵĞƵĞ

      
ƚĂƚŝŶŝƚŝĂůĚĞůĂĨŝůĞ ƚĂƚĚĞůĂĨŝůĞĂƉƌğƐŶĨŝůĞƌ;ΖΖͿ
dġƚĞ YƵĞƵĞ dġƚĞ YƵĞƵĞ

    
ƚĂƚĚĞůĂĨŝůĞĂƉƌğƐ ƚĂƚĚĞůĂĨŝůĞĂƉƌğƐ
ĠĨŝůĞƌ;Ϳ ĠĨŝůĞƌ;Ϳ
7.2.2. Représentation d¶une file par une liste doublement chaînée
Comme une pile, la file peut être représentée par un tableau, une liste
simplement ou doublement chaînée. Dans ce qui suit, nous avons choisi une
liste doublement chaînée pour représenter une file :
 L¶opération d¶enfilement se traduit par un ajout en queue de la liste
doublement chaînée.
 L¶opération de défilement se traduit par la suppression de la tête de la liste
doublement chaînée.
 La tête et la queue de la file étant la tête et la queue de la liste doublement
chaînée.
8. Exercices corrigés
8.1. Exercices
Exercice 1 :
Rappelons que le nom du tableau correspond à l¶adresse de la première case du
tableau. Rappelons aussi qu¶on peut additionner un entier à un pointeur pour
avoir un nouveau pointeur (l¶adresse de l¶emplacement mémoire suivant), donc
un pointeur peut être incrémenté. Exploitez ces propriétés pour dire ce
qu¶affiche le programme suivant :
LQFOXGHVWGLRK!
ϮϮϯ

Les listes chaînées .

PDLQ
^
LQWW>@ ^`
LQW S WL
IRUL LL^
SULQWIG?Q S
S ,QFUpPHQWHUOHSRLQWHXUG¶XQHXQLWpGRQQHUDO¶DGUHVVH
GHO¶pOpPHQWO¶HQWLHUGDQVFHWH[HUFLFHVXLYDQW 
`
`
Exercice 2 :
En utilisant la notion de gestion dynamique de la mémoire, et en exploitant le
fait que le nom d¶un tableau correspond à un pointeur sur le premier élément du
tableau, écrire un programme C permettant de lire un tableau dont le nombre
d¶éléments est lu au clavier. Le programme doit permettre également d¶afficher
le contenu de ce tableau.
Exercice 3 :
Qu¶affiche le programme C suivant ?
LQFOXGHVWGOLEK!
LQFOXGHVWGLRK!
PDLQ
^
LQW DG DG DG
LQWQ S 
DG  Q
DG  S
 DG  DG
SULQWIG?QQ
 DG 
SULQWIG?QQ
DG LQW PDOORFVL]HRILQW
 DG QS
SULQWIG?Q DG
`
Exercice 4 :
Expliquez ce que fait le programme suivant, partie par partie :
LQFOXGHVWGLRK!
LQFOXGHVWGOLEK!
PDLQ
^
LQW[ S
 3RLQWHXU 
3DUWLH«
[ 
S  [
SULQWI9DOHXUSRLQWpHSDUSG?Q S
3DUWLH«

ϮϮϰ

Les listes chaînées .

S LQW PDOORFVL]HRILQW

LIS 18//^
 S 
SULQWI9DOHXUSRLQWpHSDUSG?Q S
IUHHS
 ` 
 /LVWH 
3DUWLH«
W\SHGHIVWUXFWVB(OHPHQW
^
LQWYDOHXU
VWUXFWVB(OHPHQW VXLYDQW
`(OHPHQW
3DUWLH«
(OHPHQW 7HWH 4XHXH
3DUWLH«
7HWH (OHPHQW PDOORFVL]HRI(OHPHQW
7HWH!YDOHXU 
7HWH!VXLYDQW 18//
4XHXH 7HWH
3DUWLH«
4XHXH!VXLYDQW (OHPHQW PDOORFVL]HRI(OHPHQW
4XHXH 4XHXH!VXLYDQW
4XHXH!YDOHXU 
4XHXH!VXLYDQW 18//
3DUWLH«
SULQWI7HWH G?Q7HWH!YDOHXU
SULQWI4XHXH G?Q4XHXH!YDOHXU
`
Exercice 5 :
Expliquez la différence entre les deux programmes C :
Programme 1 : Programme 2 :
LQFOXGHVWGLRK! LQFOXGHVWGLRK!
LQWDE K LQWDE K
YRLGFKDQJHLQW [ YRLGFKDQJHLQW [
^[  D` ^ [  D`
PDLQ PDLQ
^ ^
D E  D E 
K  E K  E
FKDQJHK FKDQJH K
SULQWIG?Q K SULQWIG?Q K
` `
Exercice 6 :
Qu¶affiche le programme C suivant ?
LQFOXGHVWGLRK!
LQFOXGHVWULQJK!
LQFOXGHVWGOLEK!

ϮϮϱ

Les listes chaînées .

W\SHGHIVWUXFWYLOOH
^
FKDU'HV>@
VWUXFWYLOOH 6XLYDQW
`9LOOH
9LOOH 7HWH 4XHXH
 3URFpGXUHG
DMRXWG
XQpOpPHQWjODILQGHODOLVWH 
YRLG$MRXWHUB4FKDU9>@
^
4XHXH!6XLYDQW 9LOOH PDOORFVL]HRI9LOOH
4XHXH 4XHXH!6XLYDQW
VWUFS\4XHXH!'HV9
4XHXH!6XLYDQW 18//
`
 3URFpGXUHG
DIILFKDJHGHVpOpPHQWVGHODOLVWH 
YRLG$IILFKHUB/LVWH
^
9LOOH 3
LQWL
3 7HWH
L 
ZKLOH3 18//^
SULQWI/
pOpPHQWQXPƒGGHODOLVWHHVWV?QL3!'HV
L L
3 3!6XLYDQW
`
`
 3URFpGXUHG
DMRXWG
XQpOpPHQWDXGpEXWGHODOLVWH 
YRLG$MRXWHUB7FKDU9>@
^
9LOOH 3
3 9LOOH PDOORFVL]HRI9LOOH
VWUFS\3!'HV9
3!6XLYDQW 7HWH
7HWH 3
LI4XHXH 18//4XHXH 7HWH
`
 3URFpGXUHG
LQVHUWLRQG
XQHYLOOH9DSUqV9GDQVODOLVWH 
YRLG,QVHUHUB$3B9LOOHFKDU9>@FKDU9>@
^
9LOOH 3 3
LIVWUFPS4XHXH!'HV9 $MRXWHUB49
HOVH^
6HSRLQWHUYHUVO
pOpPHQWFRQWHQDQW9
3 7HWH
ZKLOHVWUFPS3!'HV9 3 3!6XLYDQW
&UpHUXQQRXYHOpOpPHQWFRQWHQDQW9
3 9LOOH PDOORFVL]HRI9LOOH
VWUFS\3!'HV9
,QVpUHUOHQRXYHOpOpPHQWGDQVODOLVWH
ϮϮϲ

Les listes chaînées .

3!6XLYDQW 3!6XLYDQW
3!6XLYDQW 3
`
`
 3URFpGXUHGHVXSSUHVVLRQGHODWrWHGHODOLVWH 
YRLG6XSSULPHUB7
^
9LOOH 3
LI7HWH 18//
LI7HWH!6XLYDQW 18//^
 IUHH7HWH
 7HWH 18//
 4XHXH 18//
 `
HOVH^
3 7HWH
7HWH 7HWH!6XLYDQW
IUHH3
`
`
 3URFpGXUHGHVXSSUHVVLRQG
XQpOpPHQWGHODOLVWH 
YRLG6XSSULPHUFKDU9>@
^
9LOOH 3 3
LIVWUFPS7HWH!'HV9 6XSSULPHUB7
HOVH^
6HSRLQWHUYHUVO
pOpPHQWFRQWHQDQW9
3 7HWH
3 3!6XLYDQW
ZKLOHVWUFPS3!'HV9 ^
3 3
3 3!6XLYDQW
`
DĞƚƚƌĞăũŽƵƌůĂƋƵĞƵĞĚĂŶƐůĞĐĂƐŽƶůΖĠůĠŵĞŶƚăƐƵƉƉƌŝŵĞƌĞƐƚůĞĚĞƌŶŝĞƌĚĞůĂůŝƐƚĞ
LI4XHXH 34XHXH 3
6XSSULPHUO
pOpPHQWFRQWHQDQW9
3!6XLYDQW 3!6XLYDQW
IUHH3
`
`
PDLQ
^
 &UpHUHWUHPSOLUOHSUHPLHUpOpPHQWGHODOLVWH 
7HWH 9LOOH PDOORFVL]HRI9LOOH
VWUFS\7HWH!'HV2UDQ
4XHXH 7HWH
4XHXH!6XLYDQW 18//
 $MRXWHUOHUHVWHGHVpOpPHQWVjODOLVWH 
$MRXWHUB40DVFDUD
$MRXWHUB41DDPD
ϮϮϳ

Les listes chaînées .

$MRXWHUB46%$

$MRXWHUB47OHPFHQ
$MRXWHUB7%HFKDU
,QVHUHUB$3B9LOOH%HFKDU%OLGD
6XSSULPHUB7
6XSSULPHU0DVFDUD
$IILFKHUB/LVWH
`
Exercice 7 :
Ecrire en C une procédure d¶ajout d¶un élément au début de la liste doublement
chaînée (la liste des villes créée dans le cours).
Exercice 8 :
Ecrire en C une procédure permettant d¶insérer un élément après un autre dans
une liste doublement chaînée (insérer une ville 9 après 9 dans la liste des
villes créée dans le cours).
Exercice 9 :
Ecrire en C une procédure permettant de supprimer la tête de la liste
doublement chaînée et récupérer l¶espace mémoire occupé par cet élément (la
liste des villes créée dans le cours).
Exercice 10 :
Ecrire en C une procédure permettant la suppression d¶un élément de la liste
doublement chaînée (la liste des villes créée dans le cours). La procédure
possède un paramètre 9 indiquant la ville à supprimer.
Exercice 11 :
Ecrire en C une procédure permettant d¶afficher les éléments de la liste
doublement chaînée (la liste des villes créée dans le cours).
Exercice 12 :
Qu¶affiche le programme C suivant ?
LQFOXGHVWGLRK!
LQFOXGHVWULQJK!
LQFOXGHVWGOLEK!
W\SHGHIVWUXFWYLOOH
^
FKDU'HV>@
VWUXFWYLOOH 3UHFHGHQW 6XLYDQW
`9LOOH
9LOOH 7HWH 4XHXH
 3URFpGXUHG
DMRXWG
XQpOpPHQWjODILQGHODOLVWH 
YRLG$MRXWHUB4FKDU9>@
^
4XHXH!6XLYDQW 9LOOH PDOORFVL]HRI9LOOH
4XHXH!6XLYDQW!3UHFHGHQW 4XHXH
4XHXH 4XHXH!6XLYDQW
VWUFS\4XHXH!'HV9

ϮϮϴ

Les listes chaînées .

4XHXH!6XLYDQW 18//
`
 3URFpGXUHG
DIILFKDJHGHVpOpPHQWVGHODOLVWH7 
YRLG$IILFKHUB/LVWHB7
^
9LOOH 3
LQWL
3 7HWH
L 
ZKLOH3 18//^
SULQWI/
pOpPHQWQXPƒGGHODOLVWHHVWV?QL3!'HV
L L
3 3!6XLYDQW
`
`
 3URFpGXUHG
DIILFKDJHGHVpOpPHQWVGHODOLVWH4 
YRLG$IILFKHUB/LVWHB4
^
9LOOH 3
LQWL
3 4XHXH
L 
ZKLOH3 18//^
SULQWI/
pOpPHQWQXPƒGGHODOLVWHHVWV?QL3!'HV
L L
3 3!3UHFHGHQW
`
`
 3URFpGXUHG
DMRXWG
XQpOpPHQWDXGpEXWGHODOLVWH 
YRLG$MRXWHUB7FKDU9>@
^
9LOOH 3
3 9LOOH PDOORFVL]HRI9LOOH
VWUFS\3!'HV9
3!3UHFHGHQW 18//
3!6XLYDQW 7HWH
LI7HWH 18//7HWH!3UHFHGHQW 3
7HWH 3
LI4XHXH 18//4XHXH 7HWH
`
 3URFpGXUHG
LQVHUWLRQG
XQHYLOOH9DSUqV9GDQVODOLVWH 
YRLG,QVHUHUB$3B9LOOHFKDU9>@FKDU9>@
^
9LOOH 3 3
LIVWUFPS4XHXH!'HV9 $MRXWHUB49
HOVH^
6HSRLQWHUYHUVO
pOpPHQWFRQWHQDQW9
3 7HWH
ZKLOHVWUFPS3!'HV9 3 3!6XLYDQW
&UpHUXQQRXYHOpOpPHQWFRQWHQDQW9
ϮϮϵ

Les listes chaînées .

3 9LOOH PDOORFVL]HRI9LOOH

VWUFS\3!'HV9
,QVpUHUOHQRXYHOpOpPHQWGDQVODOLVWH
3!6XLYDQW 3!6XLYDQW
3!3UHFHGHQW 3
3!6XLYDQW 3
3!6XLYDQW!3UHFHGHQW 3
`
`
 3URFpGXUHGHVXSSUHVVLRQGHODWrWHGHODOLVWH 
YRLG6XSSULPHUB7
^
LI7HWH 18//
LI7HWH!6XLYDQW 18//^
 IUHH7HWH
 7HWH 18//
 4XHXH 18//
 `
HOVH^
7HWH 7HWH!6XLYDQW
IUHH7HWH!3UHFHGHQW
7HWH!3UHFHGHQW 18//
`
`
 3URFpGXUHGHVXSSUHVVLRQG
XQpOpPHQWGHODOLVWH 
YRLG6XSSULPHUFKDU9>@
^
9LOOH 3
LIVWUFPS7HWH!'HV9 6XSSULPHUB7
HOVH^
6HSRLQWHUYHUVO
pOpPHQWFRQWHQDQW9
3 7HWH
ZKLOHVWUFPS3!'HV9 3 3!6XLYDQW
DĞƚƚƌĞăũŽƵƌůĂƋƵĞƵĞĚĂŶƐůĞĐĂƐŽƶůΖĠůĠŵĞŶƚăƐƵƉƉƌŝŵĞƌĞƐƚůĞĚĞƌŶŝĞƌĚĞůĂůŝƐƚĞ
LI4XHXH 34XHXH 3!3UHFHGHQW
6XSSULPHUO
pOpPHQWFRQWHQDQW9
3!3UHFHGHQW!6XLYDQW 3!6XLYDQW
LI3!6XLYDQW 18//3!6XLYDQW!3UHFHGHQW 3!3UHFHGHQW
IUHH3
`
`
PDLQ
^ &UpHUHWUHPSOLUOHSUHPLHUpOpPHQWGHODOLVWH 
7HWH 9LOOH PDOORFVL]HRI9LOOH
VWUFS\7HWH!'HV2UDQ
7HWH!3UHFHGHQW 18//
4XHXH 7HWH
4XHXH!6XLYDQW 18//
 $MRXWHUOHUHVWHGHVpOpPHQWVjODOLVWH 
$MRXWHUB40DVFDUD
ϮϯϬ

Les listes chaînées .

$MRXWHUB41DDPD

$MRXWHUB46%$
$MRXWHUB47OHPFHQ
$MRXWHUB7%HFKDU
,QVHUHUB$3B9LOOH6%$%OLGD
6XSSULPHUB7
6XSSULPHU2UDQ
$IILFKHUB/LVWHB7
`
Exercice 13 :
Ecrire un programme C permettant de lire et d¶afficher un entier. La lecture
étant faite par une fonction qui réserve un espace mémoire pour une variable
pointée, lit la valeur de cette variable au clavier et retourne cette valeur au
programme appelant.
Exercice 14 :
Ecrire un programme C permettant de créer et d¶afficher une liste simplement
chaînée. Chaque élément est de type structure 3HUVRQQH contenant les
informations : 1XP de type entier et 1RP de type chaîne de caractères. Utilisez
une procédure pour l¶ajout d¶une personne et une autre pour afficher les
éléments de la liste. La tête et la queue de la liste étant captés par deux
pointeurs 7HWH et 4XHXH pointant vers 3HUVRQQH.
Quelle instruction doit-on ajouter pour rendre la liste circulaire ? Dans une liste
circulaire, il est possible de revenir à un point de départ en parcourant la liste
dans un seul sens sans revenir dans le sens inverse.
Exercice 15 :
Ecrire en C une procédure permettant de libérer l¶espace mémoire occupé par la
liste des personnes déjà créée dans l¶exercice 14.
Exercice 16 :
Ecrire en C une fonction entière permettant de calculer la longueur d¶une liste.
Les éléments de la liste étant de type 3HUVRQQH décrit dans l¶exercice 14. La
fonction doit posséder comme paramètre la tête de la liste.
Exercice 17 :
Ecrire en C une fonction booléenne permettant la recherche d¶un élément dans
la liste des personnes. La fonction doit posséder comme paramètres la tête de la
liste, le numéro et le nom de l¶élément à rechercher.
Exercice 18 :
Modifier la fonction de l¶exercice précédent de telle sorte que cette fonction
retourne un pointeur vers l¶élément recherché s¶il existe. Dans le cas contraire,
elle pointe vers le 18//.
Exercice 19 :
Ecrire en C une fonction qui retourne un pointeur vers le nième élément de la
liste des personnes. Si Q dépasse la taille de la liste, la fonction retourne 18//.
Ϯϯϭ

Les listes chaînées .

Si Q est inférieur à , la fonction retourne 18// aussi. La fonction doit posséder

comme paramètres la tête de la liste et le numéro d¶ordre, commençant par 0,
de l¶élément désiré.
Exercice 20 :
Ecrire en C la procédure permettant d¶insérer un élément à la kième position dans
une liste de personnes. Si k<=0, l¶ajout sera en tête de la liste. Si N dépasse la
longueur de la liste, l¶ajout sera en queue de la liste. La procédure aura comme
paramètres les informations à insérer, la position, la tête et la queue de la liste.
Exercice 21 :
Ecrire en C une procédure permettant de supprimer l¶élément de la kième
position dans une liste de personnes. Si k<=0, c¶est la tête qui sera supprimée
de la liste. Si le N dépasse la longueur de la liste, la queue sera supprimée. La
procédure aura comme paramètres la position, la tête et la queue de la liste.
Exercice 22 :
Ecrire en C une procédure permettant de renverser et d¶afficher une liste de
personnes. La procédure doit posséder comme paramètres un pointeur vers la
tête et un autre vers la queue de la liste à renverser.
Exercice 23 :
Ecrire en C une procédure récursive permettant d¶afficher une liste de
personnes.
Exercice 24 :
Ecrire un programme C permettant de créer deux listes chaînées, ayant un
nombre d¶éléments indéfini. Ensuite, afficher les éléments des deux listes.
Chaque élément d¶une liste est de type structure 1RPEUH contenant une
information : 9DO de type entier. Utilisez une procédure pour la création d¶une
liste. Cette procédure doit posséder la tête et la queue d¶une liste comme
paramètres. Pour l¶ajout d¶un élément à une liste, utilisez une procédure
possédant comme paramètre la queue de la liste dans laquelle on veut ajouter le
nouvel élément. Une autre procédure possédant la tête d¶une liste comme
paramètre est utilisée pour afficher les éléments de cette liste. La tête et la
queue de la première liste étant captés par deux pointeurs 7HWH et 4XHXH. La
tête et la queue de la deuxième liste étant captés par deux pointeurs 7HWH et
4XHXH.
Exercice 25 :
Ecrire en C une fonction qui retourne la somme des éléments d¶une liste de
nombres dont la structure est déjà décrite ci-dessus. La fonction possède
comme paramètre la tête de la liste en question.
Exercice 26 :
Ecrire en C une procédure permettant, à partir d¶une liste de nombres, de créer
deux listes de nombres : la première ayant des nombres impairs, la deuxième
ϮϯϮ

Les listes chaînées .

avec des nombres pairs. La procédure possède comme paramètres la tête de la

liste source, la tête et la queue de la première liste (celle qui va contenir les
nombres pairs), et la tête et la queue de la deuxième liste (celle qui va contenir
les nombres impairs).
Exercice 27 :
Ecrire en C une procédure permettant de concaténer deux listes. Les éléments
de la liste étant de type 1RPEUH décrit ci-dessus. La procédure doit posséder
comme paramètres un pointeur vers la tête de la première liste (passé par
adresse, car c¶est lui qui va récupérer le résultat de la concaténation) et un autre
vers la tête de la deuxième liste.
Exercice 28 :
Ecrire en C une procédure permettant de trier une liste en ordre croissant. Les
éléments de la liste étant de type 1RPEUH déjà décrit. La procédure doit
posséder comme paramètre un pointeur vers la tête de la liste à trier.
Exercice 29 :
Ecrire en C une procédure permettant d¶insérer un élément dans une liste triée
en ordre croissant. Les éléments de la liste étant de type 1RPEUH déjà défini. La
procédure doit posséder comme paramètres la valeur à insérer et un pointeur
vers la tête de la liste.
Exercice 30 :
Ecrire en C une procédure permettant de fusionner deux listes déjà triées en
ordre croissant. Les éléments de chaque liste étant de type 1RPEUH déjà décrit.
La procédure doit posséder comme paramètres un pointeur vers la tête de la
première liste (passé par adresse pour récupérer le résultat) et un pointeur vers
la tête de la deuxième liste.
Exercice 31 :
Reprendre l¶exercice 14, mais cette fois-ci en stockant les informations dans
une liste doublement chaînée.
Exercice 32 :
Ecrire en C une procédure permettant l¶insertion d¶un élément avant un autre
dans la liste doublement chaînée créée dans l¶exercice précédent. La procédure
doit posséder comme paramètres le numéro et le nom de l¶élément à insérer,
ainsi que le numéro et le nom de l¶élément avant lequel on désir faire
l¶insertion.
Exercice 33 :
Ecrire en C une procédure permettant de supprimer les éléments qui se répètent
dans la liste doublement chaînée créée ci-dessus. La procédure possède comme
paramètre la tête de la liste à traiter. On veut donc modifier la liste de manière à
ce que la même personne (1XP et 1RP) n¶apparaisse qu¶une seule fois dans cette
liste.
Ϯϯϯ

Les listes chaînées .

Exercice 34 :
Ecrire un programme C permettant la gestion de la pile de caractères décrite
dans le cours : empilement, dépilement et affichage du contenu de la pile.
Exercice 35 :
Ecrire un programme C permettant la gestion de la file de caractères décrite
dans le cours : enfilement, défilement et affichage du contenu de la file.
8.2. Corrigés
Solution 1 :
Le programme affiche les éléments du tableau, à savoir :





Solution 2 :
LQFOXGHVWGLRK!
LQFOXGHVWGOLEK!
PDLQ
^LQW WLQ
SULQWI'RQQH]OHQRPEUHG
pOpPHQWVGXWDEOHDX
VFDQIG Q
W LQW PDOORFVL]HRILQW Q
SXWV'RQQH]OHVpOpPHQWVGXWDEOHDX
IRUL LQLVFDQIG W>L@
SXWV9RLFLOHVpOpPHQWVGXWDEOHDX
IRUL LQLSULQWIG?QW>L@
`
Solution 3 :
Le programme affiche :




Solution 4 :
Voici ce que fait le programme C partie par partie :
Partie 1 : affecter une adresse à une variable pointeur.
Partie 2 : allocation et désallocation.
Partie 3 : définition de la structure d¶un élément de la liste .
Partie 4 : déclarer la tête et la queue.
Partie 5 : créer le premier élément de la liste 80.
Partie 6 : créer le deuxième élément de la liste 88.
Partie 7 : afficher l¶élément tête et l¶élément queue.

Ϯϯϰ

Les listes chaînées .

Solution 5 :
Dans le premier programme, le pointeur [ est passé par valeur à la procédure
FKDQJH. L¶appel de la procédure FKDQJH avec le paramètre effectif K ne
change pas la valeur de ce dernier, et elle restera E. Donc, c¶est la valeur de E
qui sera affichée, à savoir .
Dans le deuxième programme, le pointeur [ est passé par adresse à la
procédure FKDQJH, c¶est pourquoi nous avons mis LQW [. L¶appel de la
procédure FKDQJH avec K changera la valeur de K, et elle deviendra D. Par
conséquent, c¶est la valeur de D qui sera affichée, à savoir .
Solution 6 :
Le programme affiche :
/
pOpPHQWQXPƒGHODOLVWHHVW%OLGD
/
pOpPHQWQXPƒGHODOLVWHHVW2UDQ
/
pOpPHQWQXPƒGHODOLVWHHVW1DDPD
/
pOpPHQWQXPƒGHODOLVWHHVW6%$
/
pOpPHQWQXPƒGHODOLVWHHVW7OHPFHQ

Solution 7 :
 3URFpGXUHG
DMRXWG
XQpOpPHQWDXGpEXWGHODOLVWH
GRXEOHPHQWFKDvQpHGHVYLOOHV 
YRLG$MRXWHUB7FKDU9>@
^
9LOOH 3
3 9LOOH PDOORFVL]HRI9LOOH
VWUFS\3!'HV9
3!3UHFHGHQW 18//
3!6XLYDQW 7HWH
LI7HWH 18//7HWH!3UHFHGHQW 3
7HWH 3
LI4XHXH 18//4XHXH 7HWH
`
Solution 8 :
 3URFpGXUHG
LQVHUWLRQG
XQHYLOOH9DSUqV9GDQVODOLVWH
GRXEOHPHQWFKDvQpHGHVYLOOHV 
YRLG,QVHUHUB$3B9LOOHFKDU9>@FKDU9>@
^
9LOOH 3 3
LIVWUFPS4XHXH!'HV9 $MRXWHUB49
HOVH^
6HSRLQWHUYHUVO
pOpPHQWFRQWHQDQW9
3 7HWH
ZKLOHVWUFPS3!'HV9 3 3!6XLYDQW
&UpHUXQQRXYHOpOpPHQWFRQWHQDQW9
3 9LOOH PDOORFVL]HRI9LOOH
VWUFS\3!'HV9
,QVpUHUOHQRXYHOpOpPHQWGDQVODOLVWH
Ϯϯϱ

Les listes chaînées .

3!6XLYDQW 3!6XLYDQW
3!3UHFHGHQW 3
3!6XLYDQW 3
3!6XLYDQW!3UHFHGHQW 3
`
`
Solution 9 :
 3URFpGXUHGHVXSSUHVVLRQGHODWrWHGHODOLVWHGRXEOHPHQW
FKDvQpHGHVYLOOHV 
YRLG6XSSULPHUB7
^
LI7HWH 18//
LI7HWH!6XLYDQW 18//^
 IUHH7HWH
 7HWH 18//
 4XHXH 18//
 `
HOVH^
7HWH 7HWH!6XLYDQW
IUHH7HWH!3UHFHGHQW
7HWH!3UHFHGHQW 18//
`
`
Solution 10 :
 3URFpGXUHGHVXSSUHVVLRQG
XQpOpPHQWGHODOLVWH
GRXEOHPHQWFKDvQpHGHVYLOOHV 
YRLG6XSSULPHUFKDU9>@
^
9LOOH 3
LIVWUFPS7HWH!'HV9 6XSSULPHUB7
HOVH^
6HSRLQWHUYHUVO
pOpPHQWFRQWHQDQW9
3 7HWH
ZKLOHVWUFPS3!'HV9 3 3!6XLYDQW
DĞƚƚƌĞăũŽƵƌůĂƋƵĞƵĞĚĂŶƐůĞĐĂƐŽƶůΖĠůĠŵĞŶƚăƐƵƉƉƌŝŵĞƌĞƐƚůĞĚĞƌŶŝĞƌĚĞůĂůŝƐƚĞ
LI4XHXH 34XHXH 3!3UHFHGHQW
6XSSULPHUO
pOpPHQWFRQWHQDQW9
3!3UHFHGHQW!6XLYDQW 3!6XLYDQW
LI3!6XLYDQW 18//3!6XLYDQW!3UHFHGHQW 3!3UHFHGHQW
IUHH3
`
`
Solution 11 :
La procédure permettant d¶afficher la liste des villes doublement chaînée créée
dans le cours de gauche à droite est la suivante :
 3URFpGXUHG
DIILFKDJHGHVpOpPHQWVGHODOLVWHGHVYLOOHVj
SDUWLUGHODWrWH 
YRLG$IILFKHUB/LVWHB7
Ϯϯϲ

Les listes chaînées .

^
9LOOH 3
LQWL
3 7HWH
L 
ZKLOH3 18//^
SULQWI/
pOpPHQWQXPƒGGHODOLVWHHVWV?QL3!'HV
L L
3 3!6XLYDQW
`
`
La procédure permettant d¶afficher la liste des villes doublement chaînée créée
dans le cours de droite à gauche est la suivante :
 3URFpGXUHG
DIILFKDJHGHVpOpPHQWVGHODOLVWHGHVYLOOHVj
SDUWLUGHODTXHXH 
YRLG$IILFKHUB/LVWHB4
^
9LOOH 3
LQWL
3 4XHXH
L 
ZKLOH3 18//^
SULQWI/
pOpPHQWQXPƒGGHODOLVWHHVWV?QL3!'HV
L L
3 3!3UHFHGHQW
`
`
Solution 12 :
Le programme affiche :
/
pOpPHQWQXPƒGHODOLVWHHVW0DVFDUD
/
pOpPHQWQXPƒGHODOLVWHHVW1DDPD
/
pOpPHQWQXPƒGHODOLVWHHVW6%$
/
pOpPHQWQXPƒGHODOLVWHHVW%OLGD
/
pOpPHQWQXPƒGHODOLVWHHVW7OHPFHQ

Solution 13 :
LQFOXGHVWGLRK!
LQFOXGHVWGOLEK!
LQWOLUHBHQWLHU
^LQW SUHVXOWDW
S LQW PDOORFVL]HRILQW
SULQWI(QWUH]O
HQWLHUVFDQIGS
UHVXOWDW  S
IUHHS
UHWXUQUHVXOWDW
`
PDLQ
^LQW[
Ϯϯϳ

Les listes chaînées .

[ OLUHBHQWLHU
SULQWI9RLFLO
HQWLHUG?Q[
`
Solution 14 :
LQFOXGHVWGLRK!
LQFOXGHVWULQJK!
LQFOXGHVWGOLEK!
W\SHGHIVWUXFWSHUVRQQH
^
LQW1XP
FKDU1RP>@
VWUXFWSHUVRQQH 6XLYDQW
`3HUVRQQH
3HUVRQQH 7HWH 4XHXH
 3URFpGXUHG
DMRXWG
XQpOpPHQWjODILQGHODOLVWH 
YRLG$MRXWHUB(B4LQW1FKDU0>@
^
LI7HWH 18//^
 &UpHUHWUHPSOLUOHSUHPLHUpOpPHQWGHODOLVWH 
7HWH 3HUVRQQH PDOORFVL]HRI3HUVRQQH
7HWH!1XP 1
VWUFS\7HWH!1RP0
4XHXH 7HWH
4XHXH!6XLYDQW 18//  
 `
 HOVH^
 $MRXWG
XQpOpPHQWjODILQGHODOLVWH 
4XHXH!6XLYDQW 3HUVRQQH PDOORFVL]HRI3HUVRQQH
4XHXH 4XHXH!6XLYDQW
4XHXH!1XP 1
VWUFS\4XHXH!1RP0
4XHXH!6XLYDQW 18//
 `
`
 3URFpGXUHG
DIILFKDJHGHVpOpPHQWVGHODOLVWH 
YRLG$IILFKHUB/LVWH
^
3HUVRQQH 3
3 7HWH
LI3 18//SXWV9RLFL/HVpOpPHQWVGHODOLVWH
HOVHSXWV/LVWHYLGH
ZKLOH3 18//^
SULQWI1XPG1RPV?Q3!1XP3!1RP
3 3!6XLYDQW
`
`
PDLQ
^
7HWH 18//4XHXH 18//

Ϯϯϴ

Les listes chaînées .

FKDUFV>@
LQWQ
GR^
SULQWI9RXOH]YRXVDMRXWHUXQpOpPHQWjODOLVWHRQ"
F JHWFKDUJHWFKDU
LIF
R
^
SULQWI'RQQH]OHQXPGHODSHUVRQQHjDMRXWHU
VFDQIG Q
SULQWI'RQQH]OHQRPGHODSHUVRQQHjDMRXWHU
VFDQIVVJHWFKDU
$MRXWHUB(B4QV   
`
`ZKLOHF 
Q

$IILFKHUB/LVWH
`
Pour obtenir une liste simplement chaînée circulaire, il faut ajouter après la
création de la liste, l¶instruction : 4XHXH!6XLYDQW 7HWH
Solution 15 :
  3URFpGXUH GH OLEpUDWLRQ GH O
HVSDFH PpPRLUH RFFXSp SDU OD
OLVWHGHVSHUVRQQHV 
YRLG/LEHUHUB/LVWH
^
3HUVRQQH 3
3 7HWH
ZKLOH3 18//^
7HWH 7HWH!6XLYDQW
IUHH3
3 7HWH
`
4XHXH 18//
`
Solution 16 :
  )RQFWLRQ GH FDOFXO GH OD ORQJXHXU GH OD OLVWH GHV
SHUVRQQHV 
LQW/RQJXHXUB/LVWH3HUVRQQH 7
^3HUVRQQH 3
3 7LQW/ 
ZKLOH3 18//^
/
3 3!6XLYDQW
`
UHWXUQ/
`
Solution 17 :
  )RQFWLRQ GH UHFKHUFKH G
XQ pOpPHQW GDQV OD OLVWH GHV
SHUVRQQHV 
LQW5HFKHUFKHUB/LVWHLQW1FKDU0>@3HUVRQQH 7
^
Ϯϯϵ

Les listes chaînées .

3HUVRQQH 3
3 7LQW([LVW 
ZKLOH3 18// ([LVW
 LI3!1XP 1 VWUFPS3!1RP0 ([LVW 
HOVH3 3!6XLYDQW
UHWXUQ([LVW
`
Solution 18 :
  )RQFWLRQ GH UHFKHUFKH G
XQ pOpPHQW GDQV OD OLVWH GHV
SHUVRQQHV 
3HUVRQQH 5HFKHUFKHUB/LVWHLQW1FKDU0>@3HUVRQQH 7
^
3HUVRQQH 3 ([LVW
3 7([LVW 18//
ZKLOH3 18// ([LVW 18//
 LI3!1XP 1 VWUFPS3!1RP0 ([LVW 3
HOVH3 3!6XLYDQW
UHWXUQ([LVW
`
Solution 19 :
  )RQFWLRQ GH UHFKHUFKH GX QLHPH pOpPHQW GH OD OLVWH GHV
SHUVRQQHV 
3HUVRQQH 1LHPHB(OHPHQWB/LVWHLQW13HUVRQQH 7
^
3HUVRQQH 3
LI1! 3 7
HOVH3 18//
LQWQ 
ZKLOH3 18// Q1^
3 3!6XLYDQW
Q
`
UHWXUQ3
`
Solution 20 :
 3URFpGXUHG
LQVHUWLRQG
XQpOpPHQWjODNLqPHSRVLWLRQGDQV
ODOLVWHGHVSHUVRQQHV 
YRLG ,QVHUHUB. LQW 1 FKDU 0>@ LQW N 3HUVRQQH 7
3HUVRQQH 4
^
 3HUVRQQH 3 3LQWQ 
 3 3HUVRQQH PDOORFVL]HRI3HUVRQQH
 3!1XP 1
 VWUFS\3!1RP0
 3!6XLYDQW 18//
 LI 7 18//^
  6LODOLVWHHVWLQLWLDOHPHQWYLGH
   7 3 4 3

ϮϰϬ

Les listes chaînées .

  `
HOVH
 LIN ^
  $MRXWHQ7HWHGHODOLVWH
   3!6XLYDQW  7
   7 3
 `HOVH^
  ,QVpUHUXQpOpPHQWGDQVODOLVWH
  3  7
  ZKLOH3!6XLYDQW 18// QN^
   3 3!6XLYDQWQ
  `
  3!6XLYDQW 3!6XLYDQW
  3!6XLYDQW 3
  LI 4 3 4 3
 `
`
Remarque : Le premier élément de la liste possède la position 0. Pour insérer la
personne 0RKDPHG dont le numéro est  à la position , on appelle la
procédure par : ,QVHUHUB.0RKDPHG 7HWH 4XHXH
Solution 21 :
 3URFpGXUHGHVXSSUHVVLRQGHO¶pOpPHQWGHODNLqPHSRVLWLRQGDQV
ODOLVWHGHVSHUVRQQHV 
YRLG6XSSULPHUB.LQWN3HUVRQQH 73HUVRQQH 4
^
3HUVRQQH 3 3LQWQ 
LI 7 18//^
6LODOLVWHHVWLQLWLDOHPHQWYLGH
SXWV/LVWHYLGH6XSSUHVVLRQLPSRVVLEOH
 `
HOVH
LIN ^
6XSSUHVVLRQGHOD7HWHGHODOLVWH
3  7
 7 3!6XLYDQW
LI 4 3 4  7
SULQWIΗůĠŵĞŶƚ^ƵƉƉƌŝŵĠ͘͘͘EƵŵ͗йĚ͕EŽŵ͗йƐͰŶΗ͕WϭͲхEƵŵ͕WϭͲхEŽŵ
IUHH3
 `HOVH
 LI 7!6XLYDQW 18//^
 IUHH 7
  7 18//
  4 18//
 `HOVH^
 6XSSULPHUXQpOpPHQWGHODOLVWH
 3  7
 ZKLOH3!6XLYDQW 18// QN^
  3 3!6XLYDQWQ

Ϯϰϭ

Les listes chaînées .

 `
 3 3!6XLYDQW
 LI3 18//3!6XLYDQW 3!6XLYDQW
 LI 4 3 4 3
 SULQWIΗůĠŵĞŶƚ^ƵƉƉƌŝŵĠ͘͘͘EƵŵ͗йĚ͕EŽŵ͗йƐͰŶΗ͕WϭͲхEƵŵ͕WϭͲхEŽŵ
 IUHH3
 `
`
Remarque : De même que pour l¶insertion, la position du premier élément est 0.
Pour supprimer l¶élément dont la position est , on met :
6XSSULPHUB. 7HWH 4XHXH
Solution 22 :
3URFpGXUHGHUHYHUVHPHQWGHODOLVWHGHVSHUVRQQHV
YRLG5HQYHUVHU3HUVRQQH 73HUVRQQH 4
^
3HUVRQQH 3 3
LI 7 18//^
3  7
ZKLOH3!6XLYDQW 18//^
3 3!6XLYDQW
3!6XLYDQW 3!6XLYDQW
3!6XLYDQW  7
 7 3
`
 4 3
`
`
Remarque : L¶appel de la procédure se fait par :
5HQYHUVHU 7HWH 4XHXH
Solution 23 :
  3URFpGXUH UpFXUVLYH G
DIILFKDJH GHV pOpPHQWV GH OD OLVWH
GHVSHUVRQQHV 
YRLG$IILFKHUB/LVWHB53HUVRQQH 7
^
LI7 18//^
SULQWI1XPG1RPV?Q7!1XP7!1RP
$IILFKHUB/LVWHB57!6XLYDQW
`
`
Remarque : L¶appel de la procédure se fait par : $IILFKHUB/LVWHB57HWH
Solution 24 :
LQFOXGHVWGLRK!
LQFOXGHVWGOLEK!
W\SHGHIVWUXFWQRPEUH^
LQW9DO
VWUXFWQRPEUH 6XLYDQW
`1RPEUH
ϮϰϮ

Les listes chaînées .

1RPEUH 7HWH 7HWH 4XHXH 4XHXH

FKDUF
 3URFpGXUHG
DMRXWG
XQpOpPHQWjODOLVWH 
YRLG$MRXWHUB1RPEUH1RPEUH 4
^
 4!6XLYDQW 1RPEUH PDOORFVL]HRI1RPEUH
 4  4!6XLYDQW
SULQWI'RQQH]ODYDOHXUGHFHWpOpPHQW
VFDQIG  4!9DO
 4!6XLYDQW 18//
`
 3URFpGXUHGHFUpDWLRQG
XQHOLVWH 
YRLG&UHHUB/LVWH1RPEUH 71RPEUH 4
^
 ,QLWLDOHPHQWODOLVWHHVWYLGH 
 7 18//
 4 18//
 &UpHUHWUHPSOLUOHSUHPLHUpOpPHQWGHODOLVWHFRXUDQWH 
 7 1RPEUH PDOORFVL]HRI1RPEUH
SULQWI'RQQH]ODYDOHXUGXSUHPLHUpOpPHQWGHODOLVWH
VFDQIG  7!9DO
JHWFKDU
 4  7
 4!6XLYDQW 18//
GR^
SULQWI9RXOH]YRXVDMRXWHUXQDXWUHpOpPHQWRQ"
F JHWFKDU
LIF 
R
$MRXWHUB1RPEUH 4
JHWFKDU
`ZKLOHF 
Q

`
 3URFpGXUHG
DIILFKDJHGHVpOpPHQWVGHODOLVWH 
YRLG$IILFKHUB/LVWH1RPEUH 7
^
1RPEUH 3
3 7
ZKLOH3 18//^
SULQWIG?Q3!9DO
3 3!6XLYDQW
`
`
PDLQ 3URJUDPPHSULQFLSDO 
^
SXWV &UpDWLRQGHODSUHPLqUHOLVWH 
&UHHUB/LVWH 7HWH 4XHXH
SXWV?Q &UpDWLRQGHODGHX[LqPHOLVWH 
&UHHUB/LVWH 7HWH 4XHXH
SXWVΗͰŶΎΎΎΎΎΎΎΎsŽŝĐŝůĞƐĠůĠŵĞŶƚƐĚĞůĂƉƌĞŵŝğƌĞůŝƐƚĞΎΎΎΎΎΎΎΎΗ
$IILFKHUB/LVWH7HWH
SXWVΗͰŶΎΎΎΎΎΎΎΎsŽŝĐŝůĞƐĠůĠŵĞŶƚƐĚĞůĂĚĞƵdžŝğŵĞůŝƐƚĞΎΎΎΎΎΎΎΎΗ
Ϯϰϯ

Les listes chaînées .

$IILFKHUB/LVWH7HWH
`
Solution 25 :
 )RQFWLRQGHFDOFXOGHODVRPPHGHVpOpPHQWVGHODOLVWHGHV
QRPEUHV 
LQW6RPPHB/LVWH1RPEUH 7
^
 1RPEUH 3
 3 7LQW6 
 ZKLOH3 18//^
  6 3!9DO
  3 3!6XLYDQW
 `
 UHWXUQ6
`
Remarque : Si on veut, par exemple, afficher la somme des éléments de la
première liste de l¶exercice 24, on met :
SULQWIG6RPPHB/LVWH7HWH
Solution 26 :
 3URFpGXUHGHGLYLVLRQG
XQHOLVWHGHQRPEUHVHQGHX[OLVWHV
SDLUHHWLPSDLUH 
YRLG'LYLVHUB/LVWH1RPEUH 71RPEUH 71RPEUH 4
1RPEUH 71RPEUH 4
^
1RPEUH 3
3 7
ZKLOH3 18//^
LI3!9DO 
 LI 7 18//^
  7 1RPEUH PDOORFVL]HRI1RPEUH
  7!9DO 3!9DO
  7!6XLYDQW 18//
  4  7
`
HOVH^
 4!6XLYDQW 1RPEUH PDOORFVL]HRI1RPEUH
 4  4!6XLYDQW
 4!9DO 3!9DO
 4!6XLYDQW 18//
`
HOVHLI 7 18//^
  7 1RPEUH PDOORFVL]HRI1RPEUH
  7!9DO 3!9DO
  7!6XLYDQW 18//
  4  7
 `
 HOVH^
  4!6XLYDQW 1RPEUH PDOORFVL]HRI1RPEUH
Ϯϰϰ

Les listes chaînées .

  4  4!6XLYDQW

  4!9DO 3!9DO
  4!6XLYDQW 18//
 `
3 3!6XLYDQW
`
`
Remarque : Pour utiliser cette procédure dans le programme de l¶exercice 24,
on peut déclarer quatre nouveaux pointeurs comme variables globales : 1RPEUH
73 43 7, 4,. Les deux premiers pointeurs ( 73 et 43) correspondent à
la liste qui va contenir les nombres pairs, et les deux autres ( 7, et 4,)
correspondent à la liste qui va contenir les nombres impairs. L¶appel d¶une telle
procédure au niveau du programme principal se fera, par exemple, par :
'LYLVHUB/LVWH7HWH 73 43 7, 4,. Ensuite, on peut afficher
les deux nouvelles listes par : $IILFKHUB/LVWH73 et $IILFKHUB/LVWH7,.
Solution 27 :
 3URFpGXUHGHFRQFDWpQDWLRQGHGHX[OLVWHVGHQRPEUHV 
YRLG&RQFDWB/LVWH1RPEUH 71RPEUH 7
^
1RPEUH 3
LI 7 18// 7 18//^
3  7
ZKLOH3!6XLYDQW 18//3 3!6XLYDQW
3!6XLYDQW 7
`
`
Remarque : Cette procédure peut être invoquée dans le programme de
l¶exercice 24, par exemple, par :&RQFDWB/LVWH 7HWH7HWH
Solution 28 :
 3URFpGXUHGHWULG
XQHOLVWHGHQRPEUHV 
YRLG7ULB/LVWH1RPEUH 7
^
1RPEUH 3 3
LQW[
3  7
ZKLOH3!6XLYDQW 18//^
3 3!6XLYDQW
ZKLOH3 18//^
LI3!9DO!3!9DO^
[ 3!9DO
3!9DO 3!9DO
3!9DO [
`
3 3!6XLYDQW
`
3 3!6XLYDQW

Ϯϰϱ

Les listes chaînées .

`
`
Remarque : Cette procédure peut être invoquée dans le programme de
l¶exercice 24, par exemple, par :7ULB/LVWH 7HWH
Solution 29 :
  3URFpGXUH G
LQVHUWLRQ G
XQ pOpPHQW GDQV XQH OLVWH WULpH GH
QRPEUHV 
YRLG,QVHUHUB9DOLQW91RPEUH 7
^
1RPEUH 3 3
 &UpHUOHQRXYHOpOpPHQW 
3 1RPEUH PDOORFVL]HRI1RPEUH
3!9DO 9
3!6XLYDQW 18//
 /HFDVROHQRXYHOpOpPHQWHVWLQIpULHXUjODWrWH 
LI9  7!9DO^
3!6XLYDQW  7
 7 3
`
HOVH^
 /HFDVROHQRXYHOpOpPHQWHVWVXSpULHXUjODTXHXH 
3  7
ZKLOH3!6XLYDQW 18//3 3!6XLYDQW
LI9! 3!9DO3!6XLYDQW 3
HOVH^
 ,QVHUWLRQGDQVODOLVWH 
3  7
ZKLOH9! 3!6XLYDQW!9DO3 3!6XLYDQW
3!6XLYDQW 3!6XLYDQW
3!6XLYDQW 3
`
`
`
Remarque : Supposant que 7HWH du programme de l¶exercice 24 pointe vers
une liste triée. Pour insérer la valeur  dans cette liste, on met :
,QVHUHUB9DO 7HWH
Solution 30 :
 3URFpGXUHGHIXVLRQGHGHX[OLVWHVGHQRPEUHV 
YRLG)XVLRQQHUB/LVWHV1RPEUH 71RPEUH 7
^
1RPEUH 3 3
ZKLOH7 18//^
 ,VROHUOHSUHPLHUpOpPHQWGHODGHX[LqPHOLVWH 
3 7
7 7!6XLYDQW
3!6XLYDQW 18//
 >ĞĐĂƐŽƶůΖĠůĠŵĞŶƚŝƐŽůĠĞƐƚŝŶĨĠƌŝĞƵƌăůĂƚġƚĞĚĞůĂƉƌĞŵŝğƌĞůŝƐƚĞ 

Ϯϰϲ

Les listes chaînées .

LI3!9DO  7!9DO^

3!6XLYDQW  7
 7 3
`
HOVH^
 >ĞĐĂƐŽƶůΖĠůĠŵĞŶƚŝƐŽůĠĞƐƚƐƵƉĠƌŝĞƵƌăůĂƋƵĞƵĞĚĞůĂƉƌĞŵŝğƌĞůŝƐƚĞ 
3  7
ZKLOH3!6XLYDQW 18//3 3!6XLYDQW
LI3!9DO! 3!9DO3!6XLYDQW 3
HOVH^
 ,QVHUWLRQGHO
pOpPHQWLVROpGDQVODSUHPLqUHOLVWH 
3  7
ZKLOH3!9DO! 3!6XLYDQW!9DO3 3!6XLYDQW
3!6XLYDQW 3!6XLYDQW
3!6XLYDQW 3
`
`
`
`
Remarque : Supposant que 7HWH et 7HWH du programme de l¶exercice 24
pointent vers deux listes triées. Pour fusionner ces deux listes, on peut mettre :
)XVLRQQHUB/LVWHV 7HWH7HWH
Solution 31 :
LQFOXGHVWGLRK!
LQFOXGHVWULQJK!
LQFOXGHVWGOLEK!
W\SHGHIVWUXFWSHUVRQQH
^
LQW1XP
FKDU1RP>@
VWUXFWSHUVRQQH 3UHFHGHQW 6XLYDQW
`3HUVRQQH
3HUVRQQH 7HWH 4XHXH
 3URFpGXUHG
DMRXWG
XQpOpPHQWjODILQGHODOLVWH 
YRLG$MRXWHUB(B4LQW1FKDU0>@
^
LI7HWH 18//^
 &UpHUHWUHPSOLUOHSUHPLHUpOpPHQWGHODOLVWH 
7HWH 3HUVRQQH PDOORFVL]HRI3HUVRQQH
7HWH!1XP 1
VWUFS\7HWH!1RP0
7HWH!3UHFHGHQW 18//
4XHXH 7HWH
4XHXH!6XLYDQW 18//  
 `
HOVH^
 $MRXWG
XQpOpPHQWjODILQGHODOLVWH 
4XHXH!6XLYDQW 3HUVRQQH PDOORFVL]HRI3HUVRQQH
4XHXH!6XLYDQW!3UHFHGHQW 4XHXH
Ϯϰϳ

Les listes chaînées .

4XHXH 4XHXH!6XLYDQW
4XHXH!1XP 1
VWUFS\4XHXH!1RP0
4XHXH!6XLYDQW 18//
 `
`
 3URFpGXUHG
DIILFKDJHGHVpOpPHQWVGHODOLVWH 
YRLG$IILFKHUB/LVWH
^
3HUVRQQH 3
3 7HWH
LI3 18//SXWV9RLFL/HVpOpPHQWVGHODOLVWH
HOVHSXWV/LVWHYLGH
ZKLOH3 18//^
SULQWI1XPG1RPV?Q3!1XP3!1RP
3 3!6XLYDQW
`
`
PDLQ
^
7HWH 18//4XHXH 18//
FKDUFV>@
LQWQ
GR^
SULQWI9RXOH]YRXVDMRXWHUXQpOpPHQWjODOLVWHRQ"
F JHWFKDUJHWFKDU
LIF
R
^
 SULQWI'RQQH]OHQXPGHODSHUVRQQHjDMRXWHU
 VFDQIG Q
 SULQWI'RQQH]OHQRPGHODSHUVRQQHjDMRXWHU
 VFDQIVVJHWFKDU
 $MRXWHUB(B4QV   
 `
`ZKLOHF 
Q

$IILFKHUB/LVWH
`
Pour obtenir une liste doublement chaînée circulaire, il faut ajouter après la
création de la liste, les instructions :
4XHXH!6XLYDQW 7HWH7HWH!3UHFHGHQW 4XHXH
Solution 32 :
  3URFpGXUH G
LQVHUWLRQ G¶XQ pOpPHQW DYDQW XQ DXWUH GDQV XQH
OLVWHGRXEOHPHQWFKDvQpHGHSHUVRQQHV 
YRLG,QVHUHUB$9B3HUVRQQHŝŶƚEƵϭ͕ĐŚĂƌEŽϭ΀ϮϬ΁͕ŝŶƚEƵϮ͕ĐŚĂƌEŽϮ΀ϮϬ΁
^
3HUVRQQH 3 3
^
LI7HWH!1XP 1X VWUFPS7HWH!1RP1R ^
3 3HUVRQQH PDOORFVL]HRI3HUVRQQH
3!1XP 1X
Ϯϰϴ

Les listes chaînées .

VWUFS\3!1RP1R
3!3UHFHGHQW 18//
3!6XLYDQW 7HWH
7HWH!3UHFHGHQW 3
7HWH 3
`
HOVH^
 6HSRLQWHUDYDQWO
pOpPHQW3U 
3 7HWH
ZKLOH;WϮͲх^ƵŝǀĂŶƚͲхEƵŵ͊сEƵϮͿΘΘ;ƐƚƌĐŵƉ;WϮͲх^ƵŝǀĂŶƚͲхEŽŵ͕EŽϮͿ͊сϬͿ
3 3!6XLYDQW
 &UpHUXQQRXYHOpOpPHQWFRQWHQDQW3U 
3 3HUVRQQH PDOORFVL]HRI3HUVRQQH
3!1XP 1X
VWUFS\3!1RP1R
 ,QVpUHUOHQRXYHOpOpPHQWGDQVODOLVWH 
3!3UHFHGHQW 3
3!6XLYDQW 3!6XLYDQW
3!6XLYDQW!3UHFHGHQW 3
3!6XLYDQW 3
`
`
`
Remarque : Pour que cette procédure fonctionne correctement dans le
programme de l¶exercice 31, l¶élément avant lequel on veut faire l¶insertion
doit exister obligatoirement dans la liste. Il est possible d¶enrichir cette
procédure pour traiter le cas où cet élément n¶existe pas dans la liste.
Solution 33 :
  3URFpGXUH GH VXSSUHVVLRQ GHV pOpPHQWV HQ GRXEOH GDQV OD
OLVWHGHVSHUVRQQHV 
YRLG6XSSULPHUB'RXEOH3HUVRQQH 7HWH
^
3HUVRQQH 3 3 '
LI 7HWH 18//
LI 7HWH!6XLYDQW 18//^
3  7HWH
ZKLOH3 18//^
3 3!6XLYDQW
ZKLOH3 18//^
LI3!1XP 3!1XP VWUFPS3!1RP3!1RP ^
 ' 33 3!6XLYDQW
 '!3UHFHGHQW!6XLYDQW '!6XLYDQW
 LI'!6XLYDQW 18//
'!6XLYDQW!3UHFHGHQW '!3UHFHGHQW
 IUHH'
 `
 HOVH3 3!6XLYDQW
 `

Ϯϰϵ

Les listes chaînées .

3 3!6XLYDQW
`
`
`
Remarque : Cette procédure peut être invoquée dans le programme de
l¶exercice 31, par exemple, par : 6XSSULPHUB'RXEOH 7HWH
Solution 34 :
LQFOXGHVWGLRK!
LQFOXGHVWGOLEK!
W\SHGHIVWUXFWSLOH
^
FKDU&DU
VWUXFWSLOH 3UHFHGHQW 6XLYDQW
`3LOH
3LOH %DVH 6RPPHW
LQW&KRL[
FKDU(OHPHQWUHSRQVH
 3URFpGXUHSHUPHWWDQWG
HPSLOHUXQpOpPHQWGDQVODSLOH 
YRLG(PSLOHUFKDU&
^
3LOH 3
3 3LOH PDOORFVL]HRI3LOH
3!&DU &
3!3UHFHGHQW 18//
3!6XLYDQW 6RPPHW
LI6RPPHW 18//6RPPHW!3UHFHGHQW 3
6RPPHW 3
LI%DVH 18//%DVH 6RPPHW
`
 3URFpGXUHSHUPHWWDQWGHGpSLOHUXQpOpPHQWGHODSLOH 
YRLG'HSLOHU
^
LI6RPPHW 18//SXWV'pSLOHPHQWLPSRVVLEOH3LOH9LGH
HOVHLI6RPPHW!6XLYDQW 18//^
SULQWI(OpPHQWGpSLOpF?Q6RPPHW!&DU
IUHH6RPPHW
6RPPHW 18//
%DVH 18//
`
HOVH^
SULQWI(OpPHQWGpSLOpF?Q6RPPHW!&DU
6RPPHW 6RPPHW!6XLYDQW
IUHH6RPPHW!3UHFHGHQW
6RPPHW!3UHFHGHQW 18//
`
`
 3URFpGXUHSHUPHWWDQWO
DIILFKDJHGHVpOpPHQWVGHODSLOH 
YRLG$IILFKHUB3LOH
^
ϮϱϬ

Les listes chaînées .

3LOH 3
LI6RPPHW 18//SXWV$XFXQpOpPHQW3LOHYLGH
HOVH^
3 6RPPHW
SXWV/HVpOpPHQWVGHODSLOHFLWpVGXVRPPHWYHUVODEDVH
ZKLOH3 18//^
SULQWIF?Q3!&DU
3 3!6XLYDQW
`
`
`
PDLQ
^ ,QLWLDOHPHQWODSLOHHVWYLGH 
6RPPHW 18//%DVH 18//
GR^
SXWV4XHOOH2SpUDWLRQGpVLUH]YRXV"
SXWV(PSLOHU'pSLOHU$IILFKHU
VFDQIG &KRL[JHWFKDU
VZLWFK&KRL[
^
FDVHSULQWI'RQQH]OHFDUDFWqUHjHPSLOHU
(OHPHQW JHWFKDUJHWFKDU
(PSLOHU(OHPHQW
EUHDN
FDVH'HSLOHUEUHDN
FDVH$IILFKHUB3LOHEUHDN
GHIDXOWSXWV&KRL[QRQ$FFHSWp
`
SULQWI9RXOH]YRXVXQDXWUHWHVWRQ"
UHSRQVH JHWFKDUJHWFKDU
`
ZKLOHUHSRQVH 
Q

`
Solution 35 :
LQFOXGHVWGLRK!
LQFOXGHVWGOLEK!
W\SHGHIVWUXFWILOH
^
FKDU&DU
VWUXFWILOH 3UHFHGHQW 6XLYDQW
`)LOH
)LOH 4XHXH 7HWH
LQW&KRL[
FKDU(OHPHQWUHSRQVH
 3URFpGXUHSHUPHWWDQWG
DMRXWHUXQpOpPHQWjODILOH 
YRLG$MRXWHUB)LOHFKDU&
^
LI4XHXH 18//^
7HWH )LOH PDOORFVL]HRI)LOH

Ϯϱϭ

Les listes chaînées .

7HWH!&DU &
7HWH!3UHFHGHQW 18//
4XHXH 7HWH
4XHXH!6XLYDQW 18//
`
HOVH^
4XHXH!6XLYDQW )LOH PDOORFVL]HRI)LOH
4XHXH!6XLYDQW!3UHFHGHQW 4XHXH
4XHXH 4XHXH!6XLYDQW
4XHXH!&DU &
4XHXH!6XLYDQW 18//
`
`
 3URFpGXUHSHUPHWWDQWGHVXSSULPHUXQpOpPHQWGHODILOH 
YRLG6XSSULPHUB)LOH
^
LI7HWH 18//SXWV6XSSUHVVLRQLPSRVVLEOH)LOH9LGH
HOVHLI7HWH!6XLYDQW 18//^
SULQWI(OpPHQW6XSSULPpF?Q7HWH!&DU
IUHH7HWH
7HWH 18//
4XHXH 18//
`
HOVH^
SULQWI(OpPHQWVXSSULPpF?Q7HWH!&DU
7HWH 7HWH!6XLYDQW
IUHH7HWH!3UHFHGHQW
7HWH!3UHFHGHQW 18//
`
`
 3URFpGXUHSHUPHWWDQWO
DIILFKDJHGHVpOpPHQWVGHODILOH 
YRLG$IILFKHUB)LOH
^
)LOH 3
LI7HWH 18//SXWV$XFXQpOpPHQW)LOHYLGH
HOVH^
3 7HWH
SXWVΗ>ĞƐĠůĠŵĞŶƚƐĚĞůĂĨŝůĞĐŝƚĠƐĚĞůĂƚġƚĞǀĞƌƐůĂƋƵĞƵĞ͗Η
ZKLOH3 18//^
SULQWIF?Q3!&DU
3 3!6XLYDQW
`
`
`
PDLQ
^
 ,QLWLDOHPHQWODILOHHVWYLGH 
7HWH 18//4XHXH 18//
GR^
SXWV4XHOOH2SpUDWLRQGpVLUH]YRXV"
ϮϱϮ

Les listes chaînées .

SXWV$MRXWHU6XSSULPHU$IILFKHU

VFDQIG &KRL[JHWFKDU
VZLWFK&KRL[
^
FDVHSULQWIΗŽŶŶĞnjůĞĐĂƌĂĐƚğƌĞăĂũŽƵƚĞƌăůĂĨŝůĞ͗Η
(OHPHQW JHWFKDUJHWFKDU
$MRXWHUB)LOH(OHPHQW
EUHDN
FDVH6XSSULPHUB)LOHEUHDN
FDVH$IILFKHUB)LOHEUHDN
GHIDXOWSXWV&KRL[QRQ$FFHSWp
`
SULQWI9RXOH]YRXVXQDXWUHWHVWRQ"
UHSRQVH JHWFKDUJHWFKDU
`
ZKLOHUHSRQVH 
Q

`

Ϯϱϯ

Les arbres .

Chapitre 10 : Les arbres

1. Introduction
En informatique, on manipule parfois des structures de données récursives
générales appelées les arbres. Il s¶agit d¶un cas particulier des graphes qui
seront vus dans le chapitre suivant.
2. Définitions
Un arbre : C¶HVW XQHQVHPEOHGH Q°XGV (sommets) reliés par des arcs (liens,
branches ou arêtes) formant une hiérarchie. Un arbre peut être représenté
graphiquement comme suit :


  

 & '
&KDTXHVRPPHWRXQ°XG$, %, &, ', (, ), *) possède un certain nombre de fils.
Par exemple, %, & et ' sont les fils de $. On dit aussi que %, & et ' sont des
frères. Lorsqu¶XQ Q°XG Q¶a pas de fils (ici (, ), & et *), on dit que c¶est une
feuille de l¶arbre.
,QYHUVHPHQWFKDTXHQ°XGSRVVqGHXQVHXOSqUH. Par exemple, $ est le père de
%, & et ' /H Q°XG SDUWLFXOLHU TXL Q¶a pas de père (ici $) est appelé racine de
l¶arbre.
ƐŽŶƚĚĞƐƐŽƵƐͲĂƌďƌĞƐĚĞ
 ,  ,  o[ŒŒ]ͲĚĞƐƐƵƐ
 & '
Niveau ou profondeur : Le niveau de la racine de l¶arbre est égal à . Le
niveau d¶XQQ°XGDXWUHTXHODUDFLQHHVWpJDODXQLYHDXGHVRQSqUHSOXV . Par
exemple, pour l¶arbre ci-dessus, OHV Q°XGV (, ) et *, sont de même niveau
(niveau ).
Mot des feuilles d¶un arbre : Le mot des feuilles d¶un arbre est la chaîne
formée, de gauche à droite, des valeurs des feuilles de l¶arbre. Par exemple,
pour l¶arbre ci-dessus, le mot des feuilles est égal à : ()&*.
Taille d¶un arbre : La taille d¶un arbre est égale au nombre de Q°XGVGHFHW
arbre. La taille d¶un arbre vide est égale à . La taille de l¶arbre précédent est
égale à .
Hauteur d¶un arbre : C¶est la distance entre la feuille la plus éloignée et la
racine. La hauteur d¶un arbre vide est égale à . La hauteur de l¶arbre précédent
est égale à .

Ϯϱϰ

Les arbres .

Un arbre n-aire : Un arbre n-aire HVWXQDUEUHSRXUOHTXHOFKDTXHQ°XGDGPHW

au plus n fils. Le n est dit arité de l¶arbre. L¶arbre ci-dessus est donc un arbre 3-
aire ou encore ternaire.
3. Arbre binaire
3.1. Définition
Un arbre binaire est un arbre n-aire pour lequel n est égal à , i.e., c¶est un arbre
GDQVOHTXHOXQQ°XGSHXWDYRLU ,  ou  fils. Il peut être représenté sous forme
graphique ou sous forme parenthèsée.


  ;;͕Ϳ͕;͕&ͿͿ

  &
&ŽƌŵĞŐƌĂƉŚŝƋƵĞ &ŽƌŵĞƉĂƌĞŶƚŚğƐĠĞ
'DQV OH FDV GHV DUEUHV ELQDLUHV SRXU FKDTXH Q°XG GRQQp RQ SDUOH GH ILOV
gauche et de fils droit.
3.2. Passage d¶un arbre n-aire à un arbre binaire
Tout arbre n-aire peut être représenté sous forme binaire : le premier fils gauche
d¶XQQ°XGGHYLHQWOHILOVJDXFKHGHFHQ°XG ; le premier frère droit d¶XQQ°XG
GHYLHQWOHILOVGURLWGHFHQ°XG
Exemple :
L¶exemple suivant illustre la transformation d¶un arbre n-aire en un arbre
binaire équivalent :



 
  
& 
 & '
'
ƌďƌĞϯͲĂŝƌĞŽƵƚĞƌŶĂŝƌĞ ƌďƌĞďŝŶĂŝƌĞĠƋƵŝǀĂůĞŶƚ
Puisque chaque arbre n-aire peut être représenté par un arbre binaire équivalent,
nous limiterons notre étude dans le reste de ce chapitre aux arbres binaires.
3.3. Représentation chaînée d¶un arbre binaire
Un arbre binaire peut être représenté en mémoire par une liste chaînée. Chaque
Q°XG GH OD OLVWH HVW XQH VWUXFWXUH TXL FRQWLHQW GHV LQIRUPDWLRQV j VWRFNHU HW
GHX[SRLQWHXUVYHUVOHVQ°XGVILOV
L¶arbre A(B(D, ), C(E, F)) peut être représenté par la liste chaînée suivante :

Ϯϱϱ

Les arbres .

ZĂĐŝŶĞ

  
 Eh>>
   
Eh>>  Eh>> Eh>>  Eh>> Eh>> & Eh>>

Où racine est une variable de type pointeur contenant l¶DGUHVVHGXQ°XGUDFLQH

de l¶arbre.
Exercice : Ecrire le programme C permettant de créer l¶arbre ci-dessus en
utilisant une représentation chaînée.
Solution :
LQFOXGHVWGLRK!
LQFOXGHVWGOLEK!
 6WUXFWXUHG¶XQQ°XGGHO¶DUEUH 
W\SHGHIVWUXFWDUEUH^
FKDU&DU
VWUXFWDUEUH )BJDXFKH )BGURLW
`$UEUH
$UEUH 5DFLQH
 3URFpGXUHG
DMRXWG
XQILOVJDXFKHjXQQ°XG 
YRLG$MRXWHUB)*$UEUH 5FKDU&
^
5!)BJDXFKH $UEUH PDOORFVL]HRI$UEUH
5!)BJDXFKH!&DU &
5!)BJDXFKH!)BJDXFKH 18//
5!)BJDXFKH!)BGURLW 18//
`
 3URFpGXUHG
DMRXWG
XQILOVGURLWjXQQ°XG 
YRLG$MRXWHUB)'$UEUH 5FKDU&
^
5!)BGURLW $UEUH PDOORFVL]HRI$UEUH
5!)BGURLW!&DU &
5!)BGURLW!)BJDXFKH 18//
5!)BGURLW!)BGURLW 18//
`
 3URJUDPPH3ULQFLSDO 
PDLQ^
 &UpHUHWUHPSOLUODUDFLQHGHO
DUEUH 
5DFLQH $UEUH PDOORFVL]HRI$UEUH
5DFLQH!&DU 
$

5DFLQH!)BJDXFKH 18//
5DFLQH!)BGURLW 18//
 $MRXWHUOHUHVWHGHVpOpPHQWVjO
DUEUH 
$MRXWHUB)*5DFLQH
%

$MRXWHUB)*5DFLQH!)BJDXFKH
'

$MRXWHUB)'5DFLQH
&

Ϯϱϲ

Les arbres .

$MRXWHUB)*5DFLQH!)BGURLW
(

$MRXWHUB)'5DFLQH!)BGURLW
)

`
3.4. Parcours d¶un arbre binaire
Dans ce cours, on s¶intéresse à trois manières classiques pour parcourir un arbre
binaire qui sont des cas particuliers du parcours en profondeur : parcours
préfixé, parcours infixé et parcours postfixé.
3.4.1. Parcours préfixé (préordre ou RGD)
2QYLVLWHXQQ°XG, ensuite son fils gauche, ensuite son fils droit.
Exemple :
Soit l¶arbre suivant :


 
 & ' ,

/ : < > D
Cet arbre peut être traité (en parcours préfixé) dans l¶ordre suivant : $%(,-
).&*+/0. La procédure C récursive du parcours préfixé d¶un arbre
binaire s¶écrit comme suit :
YRLG5*'$UEUH 5
^
LI5 18//^
7UDLWHU5
5*'5!)BJDXFKH
5*'5!)BGURLW
`
`
7UDLWHUpWDQWXQHSURFpGXUHTXLHIIHFWXHOHWUDLWHPHQWGpVLUpVXUOHQ°XGSULV
comme paramètre.
Exercice : Ecrire en C la procédure permettant d¶afficher en RGD l¶arbre de
caractères créé précédemment.
Solution :
 3URFpGXUHG
DIILFKDJHGHVpOpPHQWVG
XQDUEUHHQ5*' 
YRLG$IILFKHUB5*'$UEUH 5
^
LI5 18//^
SULQWIF5!&DU
$IILFKHUB5*'5!)BJDXFKH
$IILFKHUB5*'5!)BGURLW
`
`

Ϯϱϳ

Les arbres .

La procédure sera invoquée dans le programme principal par :

$IILFKHUB5*'5DFLQH
3.4.2. Parcours infixé (projectif, symétrique ou encore GRD)
On commence par visiter le fils gauche d¶XQQ°XGHQVXLWHOHQ°XGOXL-même,
HQILQOHILOVGURLWGHFHQ°XG
Pour l¶DUEUH SUpFpGHQW RQ WUDLWH OHV Q°XGV HQ SDUFRXUV LQIL[p GDQV O¶ordre
suivant : ,(-%).$*&/+0. La procédure récursive du parcours
infixé d¶un arbre binaire s¶écrit comme suit :
YRLG*5'$UEUH 5
^
LI5 18//^
*5'5!)BJDXFKH
7UDLWHU5
*5'5!)BGURLW
`
`
3.4.3. Parcours postfixé (ordre terminal ou GDR)
On commence par visiter le fils gauche d¶XQ Q°XG HQVXLWH le fils droit de ce
Q°XGHQILQOHQ°XGOXL-même.
Pour l¶DUEUHSUpFpGHQW RQWUDLWHOHVQ°XGVHQSDUFRXUVSRVWIL[pGDQVO¶ordre
suivant : ,-(.)%*/0+&$. La procédure récursive du parcours
postfixé d¶un arbre binaire s¶écrit comme suit :
YRLG*'5$UEUH 5
^
LI5 18//^
*'55!)BJDXFKH
*'55!)BGURLW
7UDLWHU5
`
`
3.5. Arbres binaires particuliers
3.5.1. Arbre binaire complet
On dit qu¶un arbre binaire est complet VL FKDTXH Q°XG DXWUH TX¶une feuille
admet deux descendants, et si toutes les feuilles sont au même niveau.
Exemple :

 

  & '

, / : < > D E K

La taille d¶un arbre binaire complet est égale à 2n ± 1, où n est le niveau des
feuilles.
Ϯϱϴ

Les arbres .

3.5.2. Arbre dégénéré

Un arbre est dit dégénéré VLWRXVOHVQ°XGVGHFHWDUEUHRQWDXSOXVXQILOV
Exemple :









Un arbre dégénéré est équivalent à une liste simplement chaînée.
3.5.3. Arbre binaire ordonné
Soit une relation d¶ordre (noté <=) définie sur l¶ensemble des valeurs attachées
DX[ Q°XGV G¶un arbre binaire. Un arbre binaire est dit ordonné (appelé aussi
arbre binaire de recherche) si la chaîne infixée des valeurs, correspondant au
parcours infixé, est ordonnée.
Exemple :
ϮϮ
ϱ ϯϬ

Ϯ ϭϭ Ϯϰ

ϴ ϭϰ Ϯϵ
Le parcours infixé de l¶arbre ci-dessus donne : --------.
Remarques :
xUn arbre binaire de recherche ne peut pas contenir plusieurs fois la même
valeur.
x&KDTXHQ°XGHVWVXSpULHXUjWRXVOHVQ°XGVVHtrouvant dans son sous-arbre
de gauche (s¶LO H[LVWH HW LQIpULHXU j WRXV OHV Q°XGV VH WURXYDQW GDQV VRQ
sous-arbre de droite (s¶il existe).
x&KDTXHQ°XGHVWFRPSULVHQWUHGHX[Q°XGV : (1) son prédécesseur, qui est
le maximum de son sous-arbre gauche (s¶il existe), et (2) son successeur,
qui est le minimum de son sous-arbre droit (s¶il existe).
4. Exercices corrigés
4.1. Exercices
Exercice 1 :
Proposez une structure pour stocker un arbre n-aire contenant des valeurs
entières.

Ϯϱϵ

Les arbres .

Exercice 2 :
Transformez l¶arbre n-aire suivant en arbre binaire équivalent.

    & '
, / : < > D
E K W Y
ƌďƌĞϲͲĂŝƌĞ
Exercice 3 :
Ecrire un programme C permettant de créer et d¶afficher les éléments d¶un
arbre binaire de caractères. Pour la création d¶XQQ°XGXWLOLVH]XQHSURFpGXUH
récursive. Pour l¶affichage, faites le parcours RGD de l¶arbre binaire.
Exercice 4 :
Ecrire en C une fonction récursive booléenne permettant la recherche d¶un
élément dans un arbre binaire de caractères. La fonction possède comme
SDUDPqWUHV XQ SRLQWHXU YHUV XQ Q°XG GH O¶arbre binaire et un caractère
indiquant l¶élément recherché.
Exercice 5 :
Modifier la fonction de l¶exercice précédent de telle sorte qu¶elle retourne un
pointeur vers l¶élément recherché. La fonction possède comme paramètres un
SRLQWHXU YHUV XQ Q°XG GH O¶arbre binaire et un caractère indiquant l¶élément
recherché.
Exercice 6 :
Ecrire en C une fonction qui retourne le niveau d¶XQ Q°XG GDQV XQ DUEUH
binaire de caractères. La fonction possède comme paramètres un pointeur vers
XQ Q°XG GH O¶DUEUH ELQDLUH HW OH FRQWHQX GX Q°XG SRXU OHTXHO RQ GpVLUH
déterminer le niveau.
Exercice 7 :
Ecrire en C une fonction récursive qui retourne le nombre de feuilles d¶un arbre
binaire. La fonction possède cRPPH SDUDPqWUH XQ SRLQWHXU YHUV XQ Q°XG GH
l¶arbre binaire.
Exercice 8 :
Ecrire en C une procédure qui affiche le mot des feuilles d¶un arbre binaire de
FDUDFWqUHV/DSURFpGXUH SRVVqGHFRPPHSDUDPqWUH XQSRLQWHXUYHUV XQQ°XG
de l¶arbre binaire.
Exercice 9 :
Ecrire en C une fonction qui retourne la taille d¶un arbre binaire. La taille d¶un
arbre binaire est égale à 1 (l¶élément racine) plus la taille du sous-arbre gauche
plus la taille du sous-arbre droit. La fonction possède comme paramètre un
pointeur veUVXQQ°XGGHO¶arbre binaire.
ϮϲϬ

Les arbres .

Exercice 10 :
Ecrire en C une fonction booléenne permettant de déterminer si un arbre binaire
est dégénéré ou non. La fonction possède comme paramètre un pointeur vers un
Q°XGGHO¶arbre binaire.
Exercice 11 :
Ecrire en C une fonction qui retourne la hauteur d¶un arbre binaire. La fonction
SRVVqGHFRPPHSDUDPqWUHXQSRLQWHXUYHUVXQQ°XGGHO¶arbre binaire.
Exercice 12 :
Ecrire en C une fonction booléenne permettant de dire si un arbre binaire est
équilibré ou non 8Q DUEUH HVW pTXLOLEUp VL SRXU FKDFXQ GH VHV Q°XGV OD
différence entre la hauteur du sous-arbre gauche et la hauteur du sous-arbre
droit est d¶au plus une unité. La fonction possède comme paramètre un pointeur
YHUVXQQ°XGGHO¶arbre binaire.
Exercice 13 :
Soit un arbre binaire d¶entiers dont la structure de chaque élément est décrite
comme suit :
W\SHGHIVWUXFWDUEUH
^
LQW9DO
VWUXFWDUEUH )BJDXFKH )BGURLW
`$UEUH
Ecrire la fonction qui calcule OD VRPPH GHV YDOHXUV GHV Q°XGV G¶un arbre
binaire d¶entiers. La fonction possède comme paramètre un pointeur vers un
Q°XGGHO¶arbre binaire.
Exercice 14 :
Ecrire en C une fonction qui GpWHUPLQHODSOXVJUDQGH YDOHXUGHVQ°XGVG¶un
arbre binaire d¶entiers (décrit dans l¶exercice 13). La fonction possède comme
SDUDPqWUHXQSRLQWHXUYHUVXQQ°XGGHO¶arbre binaire.
Exercice 15 :
Ecrire en C une fonction qui détermine la plus petite des vaOHXUV GHV Q°XGV
d¶un arbre binaire d¶entiers. La fonction possède comme paramètre un pointeur
YHUVXQQ°XGGHO¶arbre binaire.
Exercice 16 :
Ecrire en C une fonction booléenne permettant de dire si un arbre binaire
d¶entiers est ordonné (arbre de recherche) ou non. La fonction possède comme
SDUDPqWUHXQSRLQWHXUYHUVXQQ°XGGHO¶arbre binaire.
Exercice 17 :
Ecrire en C une procédure permettant de libérer l¶espace mémoire occupé par
un arbre binaire d¶entiers. La procédure possède comme paramètre un pointeur
YHUVXQQ°XGGHO¶arbre binaire passé par adresse.

Ϯϲϭ

Les arbres .

4.2. Corrigés
Solution 1 :
Une première proposition consiste à définir la structure comme suit :
 8QHYDULDEOHHQWLqUHFRUUHVSRQGDQWDXFRQWHQXGXQ°XG
 8QWDEOHDXGHSRLQWHXUVYHUVOHVQ°XGVILOV
W\SHGHIVWUXFWDUEUHBQDLUH
^
LQW9DO
VWUXFWDUEUHBQDLUH )LOV>@
`$UEUHBQDLUH
On peut également définir la structure comme suit :
 8QHYDULDEOHHQWLqUHFRUUHVSRQGDQWDXFRQWHQXGXQ°XG
 8QSRLQWHXUYHUVOHQ°XGILOV
 8QSRLQWHXUYHUVOHQ°XGfrère.
W\SHGHIVWUXFWDUEUHBQDLUH
^
LQW9DO
VWUXFWDUEUHBQDLUH )LOV )UHUH
`$UEUHBQDLUH
Une autre manière pour définir la structure :
 8QHYDULDEOHHQWLqUHFRUUHVSRQGDQWDXFRQWHQXGXQ°XG
 8QSRLQWHXUYHUVOHQ°XGSqUH
W\SHGHIVWUXFWDUEUHBQDLUH
^
LQW9DO
VWUXFWDUEUHBQDLUH 3HUH
`$UEUHBQDLUH
Solution 2 :
Arbre binaire équivalent :


, 
E / 
K : 
< &
W > '
Y D

Solution 3 :
LQFOXGHVWGLRK!
LQFOXGHVWGOLEK!
ϮϲϮ

Les arbres .

W\SHGHIVWUXFWDUEUH^
FKDU&DU
VWUXFWDUEUH )BJDXFKH )BGURLW
`$UEUH
$UEUH 5DFLQH
 3URFpGXUHUpFXUVLYHSRXUODFUpDWLRQG
XQDUEUHELQDLUH 
YRLG&UHHUB1RHXG$UEUH 5
^FKDU&UHSRQVH
SULQWI'RQQH]ODYDOHXUGXQRHXG
& JHWFKDUJHWFKDU
 5 $UEUH PDOORFVL]HRI$UEUH
 5!&DU &
 5!)BJDXFKH 18//
 5!)BGURLW 18//
SULQWI/HQRHXGFSRVVqGHWLOXQILOVJDXFKHRQ"&
UHSRQVH JHWFKDUJHWFKDU
LIUHSRQVH 
R
&UHHUB1RHXG  5!)BJDXFKH
SULQWI/HQRHXGFSRVVqGHWLOXQILOVGURLWRQ"&
UHSRQVH JHWFKDUJHWFKDU
LIUHSRQVH 
R
&UHHUB1RHXG  5!)BGURLW
`
 3URFpGXUHG
DIILFKDJHGHVpOpPHQWVG
XQDUEUHHQ5*' 
YRLG$IILFKHUB5*'$UEUH 5
^
LI5 18//^
SULQWIF5!&DU
$IILFKHUB5*'5!)BJDXFKH
$IILFKHUB5*'5!)BGURLW
`
`
 3URJUDPPH3ULQFLSDO 
PDLQ^
 &UpHUHWUHPSOLUO
DUEUH 
SXWVΗƌĠĞƌƵŶĂƌďƌĞďŝŶĂŝƌĞ͗ůĞƉƌĞŵŝĞƌĠůĠŵĞŶƚĞƐƚůĂƌĂĐŝŶĞĚĞůΖĂƌďƌĞ͘Η
&UHHUB1RHXG 5DFLQH
SXWV9RLFLO
DUEUHELQDLUHDIILFKpHQ5*'
$IILFKHUB5*'5DFLQH
`
Solution 4 :
 )RQFWLRQGHUHFKHUFKHG
XQpOpPHQWGDQVXQDUEUHELQDLUHGH
FDUDFWqUHV 
LQW5HFKHUFKHB$UEUH$UEUH 5FKDU&
^
LQW7URXYH 
LI5 18//
LI5!&DU &7URXYH 
HOVHdƌŽƵǀĞсZĞĐŚĞƌĐŚĞͺƌďƌĞ;ZͲх&ͺŐĂƵĐŚĞ͕ͿͮͮZĞĐŚĞƌĐŚĞͺƌďƌĞ;ZͲх&ͺĚƌŽŝƚ͕Ϳ͖
UHWXUQ7URXYH
`
Ϯϲϯ

Les arbres .

Remarque : Cette fonction peut être invoquée dans le programme C de

l¶exercice 3, par exemple, comme suit :
LI5HFKHUFKHB$UEUH5DFLQH
6
SXWV([LVWH
HOVHSXWV1¶H[LVWHSDV
Solution 5 :
 )RQFWLRQGHUHFKHUFKHG
XQpOpPHQWGDQVXQDUEUHELQDLUHGH
FDUDFWqUHV 
$UEUH 5HFKHUFKHB$UEUH$UEUH 5FKDU&
^
$UEUH 3
3 18//
LI5 18//
LI5!&DU &3 5
HOVH^
3 5HFKHUFKHB$UEUH5!)BJDXFKH&
LI3 18//3 5HFKHUFKHB$UEUH5!)BGURLW&
`
UHWXUQ3
`
Remarque : Cette fonction peut être invoquée dans le programme C de
l¶exercice 3, par exemple, comme suit :
LI5HFKHUFKHB$UEUH5DFLQH
6
 18//SXWV([LVWH
HOVHSXWV1¶H[LVWHSDV
Solution 6 :
 )RQFWLRQTXLGpWHUPLQHOHQLYHDXG
XQQ°XGGDQVXQDUEUH
ELQDLUHGHFDUDFWqUHV 
LQW1LYHDXB1RHXG$UEUH 5FKDU&LQWQS
^
LQWQ ͬͬϭϬϬĠƚĂŶƚůĂŚĂƵƚĞƵƌŵĂdžƋƵ[ŽŶĞƐƚŝŵĞƉŽƵƌŶŽƚƌĞĂƌďƌĞ
LI5 18//
LI5!&DU &Q QS
HOVHLI;EŝǀĞĂƵͺEŽĞƵĚ;ZͲх&ͺĚƌŽŝƚ͕͕ŶƉнϭͿфEŝǀĞĂƵͺEŽĞƵĚ;ZͲх&ͺŐĂƵĐŚĞ͕͕ŶƉнϭͿͿ
Q 1LYHDXB1RHXG5!)BGURLW&QS
HOVHQ 1LYHDXB1RHXG5!)BJDXFKH&QS
UHWXUQQ
`
Remarque : /H Q°XG & doit exister dans l¶arbre.QS veut dire le niveau du
père ; lors de l¶invocation de la fonction dans le programme,QS aura. Pour
afficherSDUH[HPSOHOHQLYHDXGXQ°XGD\DQWFRPPHYDOHXUOHFDUDFWqUH
$
,
on met : SULQWIΗ>ĞŶŝǀĞĂƵĚƵĐĂƌĂĐƚğƌĞΖΖ͗йĚΗ͕EŝǀĞĂƵͺEŽĞƵĚ;ZĂĐŝŶĞ͕ΖΖ͕Ϭ
Solution 7 :
 )RQFWLRQGHFDOFXOGXQRPEUHGHIHXLOOHVG¶XQDUEUHELQDLUH
GHFDUDFWqUHV 
LQW1EUB)HXLOOHVB$UEUH$UEUH 5
^
LQW1EU
Ϯϲϰ

Les arbres .

LI5 18//1EU 

HOVHLI5!)BJDXFKH 18// 5!)BGURLW 18//1EU 
HOVHEďƌсEďƌͺ&ĞƵŝůůĞƐͺƌďƌĞ;ZͲх&ͺŐĂƵĐŚĞͿнEďƌͺ&ĞƵŝůůĞƐͺƌďƌĞ;ZͲх&ͺĚƌŽŝƚͿ͖
UHWXUQ1EU
`
Remarque : Cette fonction peut être invoquée dans le programme C de
l¶exercice 3, par exemple, comme suit :
ƉƌŝŶƚĨ;Η>ĞŶŽŵďƌĞĚĞĨĞƵŝůůĞƐĚĞůΖĂƌďƌĞĞƐƚ͗йĚΗ͕Eďƌͺ&ĞƵŝůůĞƐͺƌďƌĞ;ZĂĐŝŶĞͿͿ͖
Solution 8 :
 3URFpGXUHTXLDIILFKHOHPRWGHVIHXLOOHVG¶XQDUEUHELQDLUHGH
FDUDFWqUHV 
YRLG0RWB)HXLOOHVB$UEUH$UEUH 5
^
LI5 18//
LI5!)BJDXFKH 18// 5!)BGURLW 18//
SXWFKDU5!&DU
HOVH^
 0RWB)HXLOOHVB$UEUH5!)BJDXFKH
 0RWB)HXLOOHVB$UEUH5!)BGURLW
`
`
Remarque : Cette procédure peut être invoquée dans le programme C de
l¶exercice 3, par exemple, comme suit : 0RWB)HXLOOHVB$UEUH5DFLQH
Solution 9 :
 )RQFWLRQTXLFDOFXOHODWDLOOHG¶XQDUEUHELQDLUHGH
FDUDFWqUHV 
LQW7DLOOHB$UEUH$UEUH 5
^LQW7
LI5 18//7 
HOVHdсϭнdĂŝůůĞͺƌďƌĞ;ZͲх&ͺŐĂƵĐŚĞͿнdĂŝůůĞͺƌďƌĞ;ZͲх&ͺĚƌŽŝƚͿ͖
UHWXUQ7
`
Remarque : Cette fonction peut être invoquée dans le programme C de
l¶exercice 3, par exemple, comme suit :
SULQWI/DWDLOOHGHO¶DUEUHHVWG7DLOOHB$UEUH5DFLQH
Solution 10 :
 )RQFWLRQTXLGpWHUPLQHVLXQDUEUHHVWGpJpQpUpRXQRQ 
LQW'HJHQHUHB$UEUH$UEUH 5
^
LQW'HJHQHUH
'HJHQHUH 
LI5 18//
LI5!)BJDXFKH 18// 5!)BGURLW 18//'HJHQHUH 
HOVHĞŐĞŶĞƌĞсĞŐĞŶĞƌĞͺƌďƌĞ;ZͲх&ͺŐĂƵĐŚĞͿΘΘĞŐĞŶĞƌĞͺƌďƌĞ;ZͲх&ͺĚƌŽŝƚͿ͖
UHWXUQ'HJHQHUH
`

Ϯϲϱ

Les arbres .

Remarque : Cette fonction peut être invoquée dans le programme C de

l¶exercice 3, par exemple, comme suit :
LI'HJHQHUHB$UEUH5DFLQHSXWV'pJpQpUp
HOVHSXWV1RQGpJpQpUp
Solution 11 :
 )RQFWLRQTXLGpWHUPLQHODKDXWHXUG
XQDUEUHELQDLUH 
LQW+DXWHXUB$UEUH$UEUH 5
^
LQW++
+ 
+ 
LI5 18//^
+ +DXWHXUB$UEUH5!)BJDXFKH
+ +DXWHXUB$UEUH5!)BGURLW
`
LI+!+UHWXUQ+
HOVHUHWXUQ+
`
Remarque : Cette fonction peut être invoquée dans le programme C de
l¶exercice 3, par exemple, comme suit :
SULQWIΗ>ĂŚĂƵƚĞƵƌĚĞů[ĂƌďƌĞĞƐƚ͗йĚΗ͕,ĂƵƚĞƵƌͺƌďƌĞ;ZĂĐŝŶĞͿ
Solution 12 :
 )RQFWLRQTXLGpWHUPLQHVLXQDUEUHHVWpTXLOLEUpRXQRQ 
LQW(TXLOLEUHB$UEUH$UEUH 5
^
LQWHTXLOLEUH
HTXLOLEUH 
LI5 18//
LI;ĂďƐ;,ĂƵƚĞƵƌͺƌďƌĞ;ZͲх&ͺŐĂƵĐŚĞͿͲ,ĂƵƚĞƵƌͺƌďƌĞ;ZͲх&ͺĚƌŽŝƚͿͿхϭͿHTXLOLEUH 
HOVHĞƋƵŝůŝďƌĞсƋƵŝůŝďƌĞͺƌďƌĞ;ZͲх&ͺŐĂƵĐŚĞͿΘΘƋƵŝůŝďƌĞͺƌďƌĞ;ZͲх&ͺĚƌŽŝƚͿ͖
UHWXUQHTXLOLEUH
`
Remarque : Cette fonction peut être invoquée dans le programme C de
l¶exercice 3, par exemple, comme suit :
LI(TXLOLEUHB$UEUH5DFLQHSXWV(TXLOLEUp
HOVHSXWV1RQpTXLOLEUp
Solution 13 :
 )RQFWLRQTXLFDOFXOHODVRPPHGHVpOpPHQWVG
XQDUEUH
ELQDLUHG¶HQWLHUV 
LQW6RPPHB$UEUH$UEUH 5
^
LQW6
LI5 18//6 
HOVH^сZͲхsĂůн^ŽŵŵĞͺƌďƌĞ;ZͲх&ͺŐĂƵĐŚĞͿн^ŽŵŵĞͺƌďƌĞ;ZͲх&ͺĚƌŽŝƚͿ͖
UHWXUQ6
`

Ϯϲϲ

Les arbres .

Remarque : Après avoir créé un arbre binaire d¶entiers, la fonction peut être
invoquée dans le programme C, par exemple, comme suit :
SULQWI6RPPHDUEUHG6RPPHB$UEUH5DFLQH
Solution 14 :
 )RQFWLRQTXLGpWHUPLQHOHPD[LPXPGDQVXQDUEUHELQDLUH
G¶HQWLHUV 
LQW0D[B$UEUH$UEUH 5
^
LQW0D[
LI5 18//^
0D[ 5!9DO
LI5!)BJDXFKH 18//
LI0D[0D[B$UEUH5!)BJDXFKH0D[ 0D[B$UEUH5!)BJDXFKH
LI5!)BGURLW 18//
LI0D[0D[B$UEUH5!)BGURLW0D[ 0D[B$UEUH5!)BGURLW
`
UHWXUQ0D[
`
Remarque : L¶arbre binaire d¶entiers ne doit pas être vide. La fonction peut être
invoquée dans le programme C, par exemple, comme suit :
SULQWI0D[DUEUHG0D[B$UEUH5DFLQH
Solution 15 :
 )RQFWLRQTXLGpWHUPLQHOHPLQLPXPGDQVXQDUEUHELQDLUH
G¶HQWLHUV 
LQW0LQB$UEUH$UEUH 5
^
LQW0LQ
LI5 18//^
0LQ 5!9DO
LI5!)BJDXFKH 18//
LI0LQ!0LQB$UEUH5!)BJDXFKH0LQ 0LQB$UEUH5!)BJDXFKH
LI5!)BGURLW 18//
LI0LQ!0LQB$UEUH5!)BGURLW0LQ 0LQB$UEUH5!)BGURLW
`
UHWXUQ0LQ
`
Remarque : L¶arbre binaire d¶entiers ne doit pas être vide. La fonction peut être
invoquée dans le programme C, par exemple, comme suit :
SULQWI0LQDUEUHG0LQB$UEUH5DFLQH
Solution 16 :
 )RQFWLRQTXLGpWHUPLQHVLXQDUEUHELQDLUHG¶HQWLHUVHVW
RUGRQQpRXQRQ 
LQW2UGRQQHB$UEUH$UEUH 5
^
LQW2UG
2UG 
LI5 18//^

Ϯϲϳ

Les arbres .

LI5!)BJDXFKH 18//LI0D[B$UEUH5!)BJDXFKH!5!9DO2UG 

LI5!)BGURLW 18//LI0LQB$UEUH5!)BGURLW5!9DO2UG 
2UG 2UGRQQHB$UEUH5!)BJDXFKH 2UGRQQHB$UEUH5!)BGURLW 2UG
`
UHWXUQ2UG
`
Remarque : Cette fonction peut être invoquée dans le programme C, par
exemple, comme suit :
LI2UGRQQHB$UEUH5DFLQHSXWV2UGRQQp
HOVHSXWV1RQRUGRQQp
Solution 17 :
 3URFpGXUHGHOLEpUDWLRQGHO
HVSDFHPpPRLUHRFFXSpSDUXQ
DUEUHELQDLUH 
YRLG/LEHUHUB$UEUH$UEUH 5
^
$UEUH 3  5
LI3 18//^
 /LEHUHUB$UEUH 3!)BJDXFKH
 /LEHUHUB$UEUH 3!)BGURLW
 IUHH3
`
 5 18//
`
Remarque : Cette procédure peut être invoquée dans le programme C comme
suit : /LEHUHUB$UEUH 5DFLQH

Ϯϲϴ

Les graphes .

Chapitre 11 : Les graphes

1. Introduction
Les graphes sont des structures de données très générales dont les listes et les
arbres ne sont que des cas particuliers. Les graphes permettent de modéliser de
nombreux problèmes algorithmiques.
2. Définitions
Un graphe est un ensemble de Q°XGV (sommets) reliés par des liens (arcs). Ce
n¶est plus un arbre dès qu¶il existe deux parcours différents pour aller au moins
d¶XQQ°XGjXQDXWUH
Un graphe est connexe lorsqu¶il est possible de trouver au moins un parcours
SHUPHWWDQWGHUHOLHUOHVQ°XGVGHX[jGHX[XQDUEUHHVWXQ JUDSKHFRQQH[H ;
deux arbres forment un graphe non connexe).
Un graphe est dit pondéré lorsque chaque lien est associé à une valeur (appelée
poids). On utilisera un graphe pondéré, par exemple, pour répondre à la
question : quelle est la route la plus courte pour aller d¶une ville à une autre ?
Un graphe est dit orienté lorsque les liens sont unidirectionnels. Dans le reste
du cours, on ne traite que des graphes orientés.
Ϭ ϭ Ϯ

ϯ ϰ ϱ ϲ

Exemple d¶un graphe orienté

Un graphe est dit acyclique s¶il ne contient aucun cycle. Un cycle est un chemin
permettant de revenir à un sommet de départ en passant par tous les sommets
du chemin. Un chemin étant une suite d¶DUFV R OH Q°XG FLEOH G¶un arc
FRUUHVSRQG DX Q°XG VRXUFH GH O¶arc suivant, mais pas nécessairement pour le
dernier arc du chemin. La longueur d¶un chemin est égale au nombre d¶arcs qui
le composent.
Un graphe est dit fortement connexe si pour chaque deux sommets i et j, soit i=j
ou bien il existe un chemin entre i et j et un autre entre j et i.
3. Représentation d¶un graphe
3.1. Liste d¶adjacence
On peut représenter un graphe par une liste d¶adjacence qui est un tableau de N
listes avec N est le nombre de sommets. La ième liste du tableau correspond aux
successeurs du ième sommet.

Ϯϲϵ

Les graphes .

Ϭ  ϭ  ϯ 

ϭ  ϰ 

Ϯ  ϱ  ϰ 

ϯ  ϭ 

ϰ  ϯ 

ϱ  ϱ 

ϲ 

La liste d¶adjacence représentant le graphe présenté précédemment

La structure, permettant de représenter le graphe, est définie en C comme suit :
GHILQHQEUV
W\SHGHIVWUXFWVXFF
^
LQW6RPPHW
VWUXFWVXFF 6XLYDQW
`6XFF

6XFF *>QEUV@
3.2. Matrice d¶adjacence
Une autre solution consiste à numéroter les N sommets et utiliser une matrice
carrée N*N dite matrice d¶adjacence, avec la valeur 0 s¶il n¶y a pas un lien
HQWUHOHVQ°XGVi et j, et la valeur 1 s¶LO\DXQOLHQHQWUHFHVGHX[Q°XGV3RXU
des graphes non orientés, la matrice est symétrique par rapport à la diagonale.

       

       
       
       
       
       
       
       
La matrice d¶adjacence représentant le graphe présenté précédemment
Cette matrice peut être déclarée en C comme suit :
GHILQHQEUV
LQW0>QEUV@>QEUV@
ϮϳϬ

Les graphes .

Une représentation par matrice est surtout intéressante lorsqu¶il y a beaucoup

de liens (graphe presque complet). La représentation par liste d¶adjacence étant
moins gourmande en mémoire pour les graphes comportant peu de liens par
Q°XG
La matrice d¶adjacence permet aussi de calculer le nombre de chemins entre
deux sommets par (Mk)i,j ; avec M la matrice d¶adjacence et k la longueur du
chemin entre les sommets i et j. A partir de là, on peut déduire qu¶il existe un
chemin entre deux sommets i et j si est seulement si Ni,j <> 0 avec N = M + M2
 «  0n. On peut maintenant définir la fermeture transitive d¶un graphe
commettant un nouveau graphe avec les mêmes sommets, où deux sommets
sont reliés par un arc si et seulement s¶il existe un chemin entre ces deux
sommets dans le graphe original.
La fermeture transitive peut être utilisée pour déterminer les composantes
fortement connexes d¶un graphe. Pour cela, on doit suivre les étapes suivantes :
1. Déterminer la matrice F correspondant à la fermeture transitive du graphe.
2. Rendre la matrice symétrique par Fi,j = Fi,j * Fj,i.
3. On ajoute la relation de réflexivité, i.e. pour chaque sommet i on met Fi,i = 1.
Les composantes fortement connexes sont obtenues ligne par ligne dans la
matrice résultante.
Notons aussi que la représentation par matrice d¶adjacence concentre sur les
liens entre les sommets. Si chaque sommet du graphe est associé à un ensemble
d¶informations, il est possible de définir encore un tableau de structure. Chaque
élément de ce tableau correspond à un sommet. La structure dépend des
informations qu¶on veut associer à chaque sommet, par exemple, nom, numéro,
etc.
4. Parcours d¶un graphe
Un graphe peut être parcouru de deux manières selon l¶ordre de visite des
Q°XGVSDUFRXUVHQSURIRQGHXUG¶abord ou parcours en largeur d¶abord.
4.1. Parcours en largeur d¶abord
Dans le parcours en largeur d¶abord, un sommet s est fixé comme origine et
l¶on visite tous les sommets situés à distance k de s avant tous les sommets
situés à distance k+1.
Par exemple, à partir du sommet 0, le parcours du graphe précédent en largeur
d¶abord permet de visiter les sommets dans l¶ordre suivant : , , , , , , .
4.2. Parcours en profondeur d¶abord
Le principe du parcours en profondeur d¶abord est de visiter tous les sommets
en allant d¶abord du plus profondément possible dans le graphe.
Par exemple, à partir du sommet 0, le parcours du graphe précédent en
profondeur d¶abord permet de visiter les sommets dans l¶ordre suivant : , , ,
, , , .

Ϯϳϭ

Les graphes .

5. Exercices corrigés
5.1. Exercices
Exercice 1 :
Ecrire un programme C permettant de créer et d¶afficher le graphe du cours en
utilisant une liste d¶adjacence.
Exercice 2 :
Ecrire un programme C permettant de créer le graphe du cours en utilisant une
matrice d¶adjacence, ensuite afficher ce graphe.
Exercice 3 :
Ecrire en C une procédure permettant de transformer la structure du premier
exercice en structure du deuxième exercice. Autrement dit, la procédure doit
remplir la matrice d¶adjacence à partir de la liste d¶adjacence déjà créée.
Exercice 4 :
Ecrire en C une procédure permettant d¶DIILFKHU OHV Q°XGV GX JUDSKH
implémenté sous forme de matrice d¶adjacence en utilisant la stratégie du
parcours en largeur d¶abord à partir du sommet numéro 0.
Exercice 5 :
Ecrire en C une procédure permettant d¶DIILFKHU OHV Q°XGV GX JUDSKH
implémenté sous forme de matrice d¶adjacence en utilisant la stratégie du
parcours en profondeur d¶abord à partir du sommet 0.
Exercice 6 :
Ecrire un programme C permettant de créer et d¶afficher un graphe de QEUV
sommets représenté par une matrice d¶adjacence M(nbrs*nbrs). QEUV étant une
constante indiquant le nombre de sommets. Le programme doit utiliser deux
procédures : une pour la création et une autre pour l¶affichage. Vous pouvez
choisir, par exemple, nbrs = 5.
Exercice 7 :
Ecrire en C une fonction booléenne permettant de tester l¶existence d¶un
chemin entre deux sommets d¶un graphe représenté par une matrice
d¶adjacence M(nbrs*nbrs).
Exercice 8 :
Ecrire en C une procédure permettant de déterminer la fermeture transitive d¶un
graphe représenté par une matrice d¶adjacence M(nbrs*nbrs).
Exercice 9 :
Ecrire en C une fonction permettant de dire si un graphe représenté par une
matrice d¶adjacence M(nbrs*nbrs) est fortement connexe ou non.
Exercice 10 :
Ecrire en C une procédure permettant de déterminer et d¶afficher les
composantes fortement connexes d¶un graphe représenté par une matrice
d¶adjacence M(nbrs*nbrs).
ϮϳϮ

Les graphes .

5.2. Corrigés
Solution 1 :
LQFOXGHVWGLRK!
LQFOXGHVWGOLEK!
GHILQHQEUV
'pILQLWLRQGHODOLVWHG
DGMDFHQFH
W\SHGHIVWUXFWVXFF
^
LQW6RPPHW
VWUXFWVXFF 6XLYDQW
`6XFF
6XFF *>QEUV@
LQWL
6XFF 3
 3URFpGXUHG
DMRXWG
XQVXFFHVVHXUjXQVRPPHW 
YRLG$MRXWHUB6XFFLQW6LQW$GM^
 LI*>6@ 18//^
 *>6@ 6XFF PDOORFVL]HRI6XFF
 *>6@!6RPPHW $GM
 *>6@!6XLYDQW 18//
 `HOVH^
  3 *>6@
  ZKLOH3!6XLYDQW 18//3 3!6XLYDQW
  3!6XLYDQW 6XFF PDOORFVL]HRI6XFF
  3 3!6XLYDQW
  3!6RPPHW $GM
  3!6XLYDQW 18//
 `
`
 3URFpGXUHG
DIILFKDJHGXJUDSKH 
YRLG$IILFKHUB*UDSKH
^
 IRUL LQEUVL^
  SULQWI6RPPHWG?QL
  LI*>L@ 18//^
   SULQWI?W6HVVXFFHVVHXUVVRQWL
   3 *>L@
   ZKLOH3 18//^
    SULQWIG3!6RPPHW
    3 3!6XLYDQW
   `
   SULQWI?Q
  `
 `
`
PDLQ^
,QLWLDOLVHUODOLVWHG
DGMDFHQFH
IRUL LQEUVL*>L@ 18//
&UpDWLRQGXJUDSKH
Ϯϳϯ

Les graphes .

$MRXWHUB6XFF
$MRXWHUB6XFF
$MRXWHUB6XFF
$MRXWHUB6XFF
$MRXWHUB6XFF
$MRXWHUB6XFF
$MRXWHUB6XFF
$MRXWHUB6XFF
$IILFKDJH
$IILFKHUB*UDSKH
`
Solution 2 :
LQFOXGHVWGLRK!
GHILQHQEUV
'pILQLWLRQGHODPDWULFHG
DGMDFHQFH
LQW0>QEUV@>QEUV@
 3URFHGXUHG
DIILFKDJHGHVpOpPHQWVGXJUDSKH 
YRLG$IILFKHUB*UDSKH
^LQWLM
IRUL LQEUVL^
SULQWI6RPPHWG?QL
IRUM MQEUVM
LI0>L@>M@ SULQWI?W6XFFHVVHXUG?QM
`
`
PDLQ 3URJUDPPHSULQFLSDO 
^
 ,QLWLDOLVHUODPDWULFHG
DGMDFHQFH 
LQWNO
IRUN NQEUVN
IRUO OQEUVO0>N@>O@ 
 &UpDWLRQGXJUDSKH 
0>@>@ 
0>@>@ 
0>@>@ 
0>@>@ 
0>@>@ 
0>@>@ 
0>@>@ 
0>@>@ 
 $IILFKHUOHJUDSKH 
$IILFKHUB*UDSKH
`
Solution 3 :
 3URFpGXUHGHWUDQVIRUPDWLRQG
XQHOLVWHG
DGMDFHQFHHQ
PDWULFHG
DGMDFHQFH 
YRLG7UDQVIRUPHU
^
IRUL LQEUVL^
Ϯϳϰ

Les graphes .

3 *>L@
ZKLOH3 18//^
0>L@>3!6RPPHW@ 
3 3!6XLYDQW
`
`
`
Remarque : Pour tester cette procédure, on doit reprendre le programme de
l¶exercice 1, tout en supprimant la procédure d¶affichage du graphe (liste
d¶adjacence) qui sera remplacée par la procédure d¶affichage du graphe
(matrice d¶adjacence) du programme de l¶exercice 2, sans oublier la déclaration
de cette matrice (LQW 0>QEUV@>QEUV@). Maintenant, on peut ajouter la
procédure de transformation avec la déclaration de deux variables globales (LQW
L et 6XFF 3). Avant d¶appeler la procédure 7UDQVIRUPHU et afficher la
matrice d¶adjacence, les éléments de la matrice doivent être initialisés à .
Solution 4 :
 3URFpGXUHG
DIILFKDJHGHVpOpPHQWVGXJUDSKHHQODUJHXU 
YRLG$IILFKHUB/DUJ
^LQWL,PD[,PLQ
/HWDEOHDX9LVLWHLQGLTXHTX
XQQ°XGDpWpGpMjYLVLWpRXQRQ
/HWDEOHDX7/DUJYDFRQWHQLUOHUpVXOWDWGXSDUFRXUVHQODUJHXU
LQW9LVLWH>QEUV@7/DUJ>QEUV@
 ,QLWLDOLVDWLRQ 
IRUL LQEUVL^
9LVLWH>L@ 
7/DUJ>L@ 
`
,PLQ 
,PD[ 
7/DUJ>@ 
9LVLWH>@ 
 5HPSOLUOHWDEOHDX7/DUJ 
ZKLOH,PD[QEUV^
IRUL LQEUVL
LI0>7/DUJ>,PLQ@@>L@  9LVLWH>L@^
,PD[
7/DUJ>,PD[@ L
9LVLWH>L@ 
`
,PLQ
LI,PLQ ,PD[^
L 
ZKLOHLQEUV 9LVLWH>L@L
LILQEUV^
,PD[
7/DUJ>,PD[@ L
9LVLWH>L@ 

Ϯϳϱ

Les graphes .

`
`
`
IRUL LQEUVLSULQWIG7/DUJ>L@
`
Solution 5 :
 /HWDEOHDX9LVLWHGpFODUpFRPPHYDULDEOHJOREDOHLQGLTXHTX
XQ
Q°XGDpWpGpMjYLVLWpRXQRQ 
LQW9LVLWH>QEUV@

 3URFpGXUHUpFXUVLYHG
DIILFKDJHGHVpOpPHQWVG
XQQRHXGHQ
SURIRQGHXU 
YRLG$IILFKHUB3URIB5LQWV
^
 LQWL
 LI9LVLWH>V@^
  9LVLWH>V@ 
  SULQWIGV
  IRUL LQEUVLLI0>V@>L@ 
$IILFKHUB3URIB5L
 `
`
 3URFpGXUHG
DIILFKDJHGHVpOpPHQWVGXJUDSKHFRPSOHWHQ
SURIRQGHXU 
YRLG$IILFKHUB3URI
^
LQWLE
 ,QLWLDOLVDWLRQGXWDEOHDX9LVLWH 
IRUL LQEUVL9LVLWH>L@ 
GR
^
E 
 IRUL LQEUVLLI9LVLWH>L@^
  $IILFKHUB3URIB5L
  E 
`
`
ZKLOHE
`
Solution 6 :
LQFOXGHVWGLRK!
GHILQHQEUV
LQW0>QEUV@>QEUV@
 3URFpGXUHGHFUpDWLRQGXJUDSKH 
YRLG&UHDWLRQ
^LQWLM
FKDUF
IRUL LQEUVL
IRUM MQEUVM^
Ϯϳϲ

Les graphes .

0>L@>M@ 
SULQWIΗdžŝƐƚĞͲŝůƵŶĂƌĐĞŶƚƌĞůĞƐŽŵŵĞƚйĚĞƚůĞƐŽŵŵĞƚйĚŽͬŶ͍Η͕ŝ͕ũ
F JHWFKDUJHWFKDU
LIF
R
0>L@>M@ 
`
`
 3URFpGXUHG
DIILFKDJHGHVpOpPHQWVGXJUDSKH 
YRLG$IILFKHUB*UDSKH
^LQWLM
IRUL LQEUVL^
SULQWI6RPPHWG?QL
IRUM MQEUVM
LI0>L@>M@ SULQWI?W6XFFHVVHXUG?QM
`
`
PDLQ 3URJUDPPHSULQFLSDO 
^
 &UpHUOHJUDSKH 
&UHDWLRQ
 $IILFKHUOHJUDSKH 
$IILFKHUB*UDSKH
`
Solution 7 :
Déterminer l¶existence d¶XQ FKHPLQ HQWUH GHX[ Q°XGV UHYLHQW j FDOFXOHU OD
somme : M1 + M2«0nbrs.
Avant d¶implémenter la fonction désirée, nous allons déclarer une variable
globale + comme suit :
LQW+>QEUV@>QEUV@
La variable + va être utilisée pour stocker le résultat de la puissance de la
matrice 0 par une valeur Q.
Pour des raisons de lisibilité de programme, nous allons diviser le problème en
une procédure qui détermine la puissance de 0 par une valeur Q, ensuite nous
développons la fonction qui détermine l¶existence d¶un lien entre deux
sommets, et cela comme suit :
 3URFpGXUHTXLFDOFXOHODSXLVVDQFHGH0SDUQHWUDQJHOH
UpVXOWDWGDQV+ 
YRLG0BSXLVVDQFHLQWQ
^LQWLMSNV
LQW;>QEUV@>QEUV@
IRUL LQEUVL
IRUM MQEUVM+>L@>M@ 0>L@>M@
IRUS S QS^
IRUL LQEUVL
IRUM MQEUVM^
V 
IRUN NQEUVNV V+>L@>N@ 0>N@>M@

Ϯϳϳ

Les graphes .

;>L@>M@ V
`
IRUL LQEUVL
IRUM MQEUVM+>L@>M@ ;>L@>M@
`
`
 /DIRQFWLRQTXLGpWHUPLQHVLXQOLHQH[LVWHHQWUHGHX[
VRPPHWVRXQRQ 
LQW([LVWHB&KHPLQLQWVLQWV
^LQWLMNE
LQW;>QEUV@>QEUV@
E 
IRUL LQEUVL
IRUM MQEUVM;>L@>M@ 0>L@>M@
IRUN N QEUVN^
0BSXLVVDQFHN
IRUL LQEUVL
IRUM MQEUVM;>L@>M@ ;>L@>M@+>L@>M@
`
LI;>V@>V@ E 
UHWXUQE
`
Remarque : Maintenant, pour tester cette procédure dans le programme C de
l¶exercice 2 ou 6, il est possible de mettre, par exemple :
LI([LVWHB&KHPLQSULQWIΗ/ůLJĂƵŶĐŚĞŵŝŶĞŶƚƌĞůĞƐĚĞƵdžƐŽŵŵĞƚƐ͘Η
HOVHSULQWIΗWĂƐĚĞĐŚĞŵŝŶĞŶƚƌĞůĞƐĚĞƵdžƐŽŵŵĞƚƐ͘Η
Solution 8 :
Pour cette solution, nous allons utiliser une variable globale ) qui va retourner
le résultat de la fermeture transitive. Cette variable est déclarée comme suit :
LQW)>QEUV@>QEUV@
La procédure de la fermeture transitive est la suivante:
YRLG)HUPHWXUH
^LQWLM
IRUL LQEUVL
IRUM MQEUVM
LI([LVWHB&KHPLQLM)>L@>M@ 
HOVH)>L@>M@ 
`
Remarque : Après avoir invoqué cette procédure dans le programme C de
l¶exercice 2 ou 6, on affiche la matrice ) comme suit :
LQW[\
IRU[ [QEUV[
IRU\ \QEUV\SULQWI)>GG@ G?Q[\)>[@>\@
Solution 9 :
 )RQFWLRQTXLGpWHUPLQHVLOHJUDSKH0QEUV QEUV HVW
IRUWHPHQWFRQQH[HRXQRQ 
LQW*UDSKHB)RUB&RQ
Ϯϳϴ

Les graphes .

^LQWLME
E 
IRUL LQEUVL
IRUM MQEUVM
LIL M
LI([LVWHB&KHPLQLM ([LVWHB&KHPLQMLE 
UHWXUQE
`
Remarque : Après avoir invoqué cette procédure dans le programme C de
l¶exercice 2 ou 6, on teste si le graphe est connexe ou non comme suit :
LI*UDSKHB)RUB&RQSULQWI/HJUDSKHHVWIRUWHPHQWFRQQH[H
HOVHSULQWI/HJUDSKHQ
HVWSDVIRUWHPHQWFRQQH[H
Solution 10 :
 3URFpGXUHTXLDIILFKHOHVFRPSRVDQWHVIRUWHPHQWFRQQH[HV
G
XQJUDSKH0QEUV QEUV 
YRLG&RPSRVDQWHVB)RUB&RQ
^LQWLMN
LQWFIF>QEUV@
)HUPHWXUH
IRUL LQEUVL
IRUM MQEUVM)>L@>M@ )>L@>M@ )>M@>L@
IRUL LQEUVL)>L@>L@ 
 $IILFKDJHGHVFRPSRVDQWHVIRUWHPHQWFRQQH[HV 
IRUL LQEUVLFIF>L@ 
N 
IRUL LQEUVL
LIFIF>L@^
N
SULQWIΗŽŵƉŽƐĂŶƚĞĨŽƌƚĞŵĞŶƚĐŽŶŶĞdžĞŶƵŵйĚĐŽŶƚŝĞŶƚůĞƐƐŽŵŵĞƚƐ͗ͰŶΗ͕Ŭ
IRUM MQEUVMLI)>L@>M@ ^
SULQWIGM
FIF>M@ 
`
SULQWI?Q
`
`









Ϯϳϵ

Références bibliographiques additionnelles .

Références bibliographiques additionnelles

S 'MHOORXO %28&+,+$ $OJRULWKPLTXHHWSURJUDPPDWLRQHQ3DVFDO&RXUVDYHF

H[HUFLFHV FRUULJpV (GLWLRQV 8QLYHUVLWDLUHV (XURSpHQQHV &RS\ULJKW ‹ 
,QWHUQDWLRQDO %RRN 0DUNHW 6HUYLFH /WG 0HPEHU RI 2PQL6FULSWXP
3XEOLVKLQJ*URXS,6%1S
S 'MHOORXO %28&+,+$ 3URJUDPPDWLRQ2ULHQWpH2EMHWHQ-DYD (GLWLRQ HUUDFKDG
6LGL%HO$EEHV$OJpULH6HPHVWUH,6%1S
S 'MHOORXO%28&+,+$ ,QLWLDWLRQjO·$OJRULWKPLTXHHWjOD3URJUDPPDWLRQHQ3DVFDO
(GLWLRQ HUUDFKDG 6LGL %HO $EEHV $OJpULH 6HPHVWUH  ,6%1 
S
S 'MHOORXO%28&+,+$1RWLRQV$YDQFpHVVXUO·$OJRULWKPLTXHHWOD3URJUDPPDWLRQHQ
3DVFDO (GLWLRQ HUUDFKDG 6LGL %HO $EEHV $OJpULH 6HPHVWUH  ,6%1
S
S 'DPLHQ %(57+(7 9LQFHQW /$%$787 $OJRULWKPLTXH  SURJUDPPDWLRQ HQ
ODQJDJH&YRO6XSSRUWVGHFRXUV /LFHQFH $OJRULWKPLTXH HW 3URJUDPPDWLRQ
,VWDQEXO7XUTXLHSSFHO!
S 'DPLHQ %(57+(7 9LQFHQW /$%$787 $OJRULWKPLTXH  SURJUDPPDWLRQ HQ
ODQJDJH &  YRO  6XMHWV GH WUDYDX[ SUDWLTXHV /LFHQFH $OJRULWKPLTXH HW
3URJUDPPDWLRQ,VWDQEXO7XUTXLHSSFHO!
S 'DPLHQ %(57+(7 9LQFHQW /$%$787 $OJRULWKPLTXH  SURJUDPPDWLRQ HQ
ODQJDJH &  YRO  &RUULJpV GH WUDYDX[ SUDWLTXHV /LFHQFH $OJRULWKPLTXH HW
3URJUDPPDWLRQ,VWDQEXO7XUTXLHSSFHO!
S &ODXGH'(/$112<$SSUHQGUHjSURJUDPPHUHQ7XUER&(GLWLRQV&+,+$%²
(<52//(6S
S &ODXGH '(/$112< 3URJUDPPHU HQ ODQJDJH & FRXUV HW H[HUFLFHV FRUULJpV H
pGLWLRQe',7,216(<52//(6,6%1S
S 5pP\ 0$/*28<5(65LWD =5285 HW)DELHQ )(6&+(7 ,QLWLDWLRQ j
O
DOJRULWKPLTXHHWjODSURJUDPPDWLRQHQ&&RXUVDYHFH[HUFLFHVFRUULJpV (GLWHXU
'XQRGHpGLWLRQMXLQ,6%1S

ϮϴϬ

INDEX .

INDEX

Ζ ;

(guillemet simple)ͼϭϵ͕Ϯϲ͕ϯϭ «;parenthèses)ͼϭϭ͕ϯϯ͕ϱϵ͕ϭϮϵ͕

ϭϯϬ͕ϭϯϰ

͊
Ύ
(non logique)ͼϯϰ
 (différent)ͼϯϯ (multiplication)ͼϭϭ͕Ϯϱ͕Ϯϲ͕ϯϮ
(pointeur)ͼϭϯϴ͕ϮϬϱ

Η
͕
 (guillemet double)ͼϭϴ͕Ϯϳ͕ϭϬϯ
(virgule)ͼϭϲ͕ϭϮϵ

η
͘
GHILQHͼϮϰ͕Ϯϱ͕ϯϲ
LQFOXGHͼϭϴ͕ϯϭ (accès au champ)ͼϮϬϵ

й ͬ

(code de format)ͼϭϵ͕Ϯϵ͕ϯϬ͕ϯϵ͕ (division)ͼϭϭ͕Ϯϱ͕Ϯϲ͕ϯϮ

ϭϬϯ  « (commentaire)ͼϮϳ͕ϯϲ
(modulo)ͼϮϱ͕ϯϮ (commentaire)ͼϯϲ

Θ ͖

(adresse)ͼϮϬ͕ϭϬϰ͕ϭϯϴ͕ϭϵϬ͕ϮϬϳ (point-virgule)ͼϭϲ͕Ϯϳ͕ϱϵ͕ϭϲϮ͕ϭϲϲ
(et bit-à-bit)ͼϯϰ
(et logique)ͼϯϰ
Ϯϴϭ

INDEX .

 (inférieur ou égal)ͼϭϭ͕ϯϯ͕ϮϬϲ
Ͱ
!(différent)ͼϭϭ͕ϮϬϲ

?(caractère spécial)ͼϭϴ͕ϭϴϱ
с
Δ
(affectation)ͼϭϴ͕Ϯϲ͕ϯϯ͕ϯϵ
(égal)ͼϭϭ͕ϮϬϲ
A(ou exclusif bit-à-bit)ͼϯϰ
(égal)ͼϭϴ͕ϯϯ͕ϯϵ

΂
х
^«`(accolades)ͼϭϴ͕ϱϵ͕ϳϰ
!(supérieur)ͼϭϭ͕ϯϯ͕ϮϬϲ
! (supérieur ou égal)ͼϭϭ͕ϯϯ͕ϮϬϲ
ͮ !!(décalage à droite)ͼϯϱ

_(ou bit-à-bit)ͼϯϰ
8
__(ou logique)ͼϯϰ

&(affectation)ͼϭϲ͕Ϯϲ
Ε
¤
a(complément à un)ͼϯϰ

.(opposé)ͼϯϮ

н .(soustraction)ͼϭϭ͕Ϯϱ͕Ϯϲ͕ϯϮ
..(décrémentation)ͼϰϭ
.!(accès au champ)ͼϮϬϵ
(addition)ͼϭϭ͕ϭϲ͕Ϯϱ͕Ϯϲ͕ϯϮ
(identité)ͼϯϮ͕ϰϬ
(incrémentation)ͼϰϬ


ф DEVͼϭϯϮ
accès directͼϭϴϲ
accès formatéͼϭϴϲ
(inférieur)ͼϭϭ͕ϯϯ͕ϮϬϲ
accès non-formatéͼϭϴϲ
(décalage à gauche)ͼϯϱ
accès par blocͼϭϴϲ͕ϭϴϵ
ϮϴϮ

INDEX .

accès séquentielͼϭϴϲ booléenͼϭϭ͕ϯϮ͕ϯϯ

Ackermannͼϭϰϴ %RROpHQͼϮϲ
adresse d¶une variableͼϮϱ boucle infinieͼϳϯ͕ϳϰ͕ϳϳ
adresse mémoireͼϮϰ͕ϭϯϴ͕ϭϲϰ͕ϮϬϱ boucle Pourͼϳϱ
affectationͼϮϲ͕ϭϲϮ͕ϭϲϱ͕ϮϬϲ boucle Répéterͼϳϰ
algorithmeͼϭϱ boucle Tant queͼϳϯ
$OJRULWKPHͼϭϲ bouclesͼϳϯ
algorithmiqueͼϭϱ boucles imbriquéesͼϳϳ
DOOHUj«ͼϲϮ brancheͼϮϱϰ
allocation dynamiqueͼϭϯϵ͕ϮϬϱ͕ϮϬϲ EUHDNͼϲϮ͕ϳϳ
$OORXHUͼϮϬϲ bufferͼϭϴϯ͕ϭϴϲ
année bissextileͼϲϰ byteͼϭϮ
arbreͼϮϱϰ͕Ϯϲϵ
arbre binaireͼϮϱϱ
arbre binaire completͼϮϱϴ 
arbre binaire de rechercheͼϮϱϵ
arbre binaire dégénéréͼϮϱϵ caractèreͼϭϮ͕ϯϬ
arbre binaire équilibréͼϮϲϭ &DUDFWqUHͼϮϲ
arbre binaire ordonnéͼϮϱϵ caractères spéciauxͼϭϴ
arbre des appelsͼϭϰϯ carte mèreͼϭϬ
arbre n-aireͼϮϱϱ cas trivialͼϮϭϲ
arcͼϮϱϰ͕Ϯϲϵ case mémoireͼϮϱ͕ϮϬϲ
DUFWJͼϭϭ castͼϯϳ
arêteͼϮϱϰ CD-ROMͼϭϮ͕ϭϯ
argumentsͼϭϮϴ celluleͼϮϬϴ
arité de l¶arbreͼϮϱϱ chaîne de caractèresͼϮϳ͕ϭϬϯ
ASCIIͼϭϮ͕ϯϬ chaîne miroirͼϭϰϴ
assembleurͼϮϭ champsͼϭϲϭ͕ϭϲϰ͕ϭϴϰ͕ϮϬϵ
assignationͼϮϲ FKDUͼϯϬ͕ϯϭ
automatiqueͼϭϬ cheminͼϮϲϵ
clavierͼϭϮ
clé USBͼϭϮ͕ϭϯ͕ϭϴϯ
 codeͼϮϰ
code binaireͼϮϭ
bibliothèqueͼϭϯϮ code de formatͼϭϵ
BIOSͼϭϮ code machineͼϮϭ
bitͼϭϮ code sourceͼϮϭ
blocͼϱϵ͕ϭϮϲ͕ϭϮϵ͕ϭϯϱ͕ϭϲϭ commentaireͼϯϲ
Ϯϴϯ

INDEX .

compilateurͼϮϭ͕ϯϱ͕ϭϯϬ dépassement de capacitéͼϯϱ

complément à unͼϯϱ dépilementͼϮϮϭ
complexité spatialeͼϯϬ déroulement d¶un algorithmeͼϰϮ͕ϰϳ
complexité temporelleͼϯϬ désallocationͼϮϬϱ
composantes fortement connexesͼϮϳϭ 'pVDOORXHUͼϮϬϲ
compteurͼϳϲ dichotomieͼϵϳ
conditionͼϱϴ͕ϳϱ disque durͼϭϮ͕ϭϯ͕ϭϴϯ
FRQVWͼϮϱ͕ϯϲ GR«ZKLOH«ͼϳϱ
constante littéraleͼϯϲ donnéesͼϮϰ͕ϭϮϴ
constante symboliqueͼϯϲ GRXEOHͼϮϵ
constantesͼϮϰ͕ϭϲϲ͕ϭϲϳ duplicate case valueͼϲϮ
constantes textuellesͼϯϲ DVDͼϭϯ
constates numériquesͼϯϲ
FRQWLQXHͼϳϳ
conversionͼϯϳ 
conversion expliciteͼϯϳ
conversion impliciteͼϯϳ écranͼϭϮ
corps de l¶algorithmeͼϮϰ͕Ϯϳ (FULUHͼϭϲ͕Ϯϳ
corps de la procédureͼϭϮϵ effet de bordͼϭϮϵ
FRVͼϯϵ͕ϭϯϮ empilementͼϮϮϭ
CPUͼϮϭ (PSLOHUͼϮϮϭ
critère d¶arrêtͼϭϰϯ emplacement de mémoireͼϮϰ
FW\SHKͼϭϭϭ enfilementͼϮϮϯ
cycleͼϮϲϵ ENIACͼϭϬ
cylindreͼϭϮ enregistrementͼϮϬϴ
en-têteͼϭϮϵ͕ϭϯϬ
(QWLHUͼϮϱ
 entrées-sortiesͼϮϳ͕ϯϵ
HQXP«ͼϭϲϲ
débordement de pileͼϭϰϰ énumérationͼϭϲϲ
débordement de tableauͼϵϯ énumération des étapesͼϭϲ͕Ϯϳ
'pEXWͼϭϲ͕Ϯϳ (2)ͼϭϯϭ͕ϭϴϱ
décalage à droiteͼϯϱ équation du second degréͼϲϰ
décalage à gaucheͼϯϱ équations logiquesͼϭϭ
déclarationͼϮϰ͕Ϯϱ͕ϰϭ erreur d¶exécutionͼϮϭ͕ϯϯ͕ϮϬϴ
décrémentationͼϳϰ͕ϳϲ͕ϮϬϲ erreur de compilationͼϮϭ͕ϯϯ͕ϰϬ͕ϱϲ͕
défilementͼϮϮϯ ϲϮ͕ϭϬϯ͕ϭϯϰ
dégradation de l¶informationͼϯϳ ErrorͼϮϭ
Ϯϴϰ

INDEX .

espace mémoireͼϮϱ͕ϯϱ͕ϭϰϰ͕ϮϬϱ forme graphiqueͼϮϱϱ

(7ͼϭϭ͕Ϯϲ͕ϯϰ forme parenthèséeͼϮϱϱ
et bit-à-bitͼϯϱ ISULQWIͼϭϴϴ
expressions arithmétiquesͼϭϭ͕Ϯϲ ISXWFͼϭϴϳ
expressions logiquesͼϭϭ͕Ϯϲ͕ϱϴ͕ϳϯ ISXWVͼϭϴϴ
H[WHUQͼϭϯϳ framesͼϭϯϵ
IUHDGͼϭϴϵ
IUHHͼϮϬϲ
& IVFDQIͼϭϴϴ
IVHHNͼϭϵϬ
factorielleͼϳϴ͕ϭϰϮ͕ϭϰϱ IWHOOͼϭϵϭ
)$8;ͼϭϭ͕Ϯϲ͕ϯϮ͕ϯϯ fuite de mémoireͼϮϬϴ
IFORVHͼϭϴϱ IZULWHͼϭϴϵ
IHRIͼϭϴϳ
fermeture transitiveͼϮϳϭ
IJHWFͼϭϴϲ '
IJHWVͼϭϴϳ
Fibonacciͼϳϵ͕ϭϬϴ͕ϭϰϳ gestion dynamiqueͼϮϬϲ
fichierͼϭϱ͕ϭϴϯ gestion statiqueͼϮϬϲ
fichier d¶en-têteͼϭϯϮ JHWFKDUͼϯϭ
fichiers binairesͼϭϴϲ͕ϭϴϵ JHWVͼϭϬϱ
fichiers textesͼϭϴϲ͕ϭϴϵ JRWR«ͼϲϯ
FIFOͼϮϮϮ grapheͼϮϲϵ
fileͼϮϮϮ͕ϮϮϯ graphe acycliqueͼϮϲϵ
),/(ͼϭϴϰ͕ϮϮϯ graphe connexeͼϮϲϵ
fils droitͼϮϱϱ graphe fortement connexeͼϮϲϵ
fils gaucheͼϮϱϱ graphe orientéͼϮϲϵ
)LQͼϭϲ͕Ϯϳ graphe pondéréͼϮϲϵ
Flagͼϵϳ
IORDWͼϮϵ
fonctionͼϭϯϬ͕ϭϯϲ͕ϭϲϴ ,
fonction variadiqueͼϭϰϮ
fonctions de bas niveauͼϭϴϯ HARDWAREͼϭϬ
fonctions de haut niveauͼϭϴϯ hauteur d¶un arbreͼϮϱϰ
fonctions mathématiquesͼϭϭ͕ϯϵ header fileͼϭϯϮ
IRSHQͼϭϴϰ heapͼϮϬϴ
IRU«ͼϳϲ
formatageͼϭϮ
Ϯϴϱ

INDEX .

lvalueͼϯϲ͕ϵϯ
/

identificateurͼϮϰ͕Ϯϳ͕ϯϱ͕ϭϬϯ͕ϭϲϲ D
LI«ͼϱϵ
LI«HOVH«ͼϲϬ
maillonͼϮϬϴ
incrémentationͼϳϰ͕ϳϲ͕ϮϬϲ
PDLQͼϭϳ͕ϭϯϰ͕ϭϯϴ
indentationͼϯϲ
PDOORFͼϮϬϲ
indiceͼϳϰ͕ϵϰ͕ϵϲ͕ϭϬϰ
mantisseͼϮϵ
informationͼϭϬ
PDWKKͼϯϵ͕ϭϯϮ
informatiqueͼϭϬ
matriceͼϭϬϮ
initialisationͼϭϵ͕ϵϲ͕ϭϲϯ
matrice d¶adjacenceͼϮϳϬ
instruction expressionͼϰϭ
mediumͼϭϯϵ
instructionsͼϮϬ͕ϱϵ͕ϭϮϴ
mémoireͼϭϭ
LQWͼϭϴ͕Ϯϵ
mémoire auxiliaireͼϭϮ
itérationͼϳϱ
mémoire centraleͼϭϭ
itérativeͼϭϰϮ
menuͼϲϰ
mode caractèreͼϭϴϲ
mode chaîneͼϭϴϲ
>
moduleͼϭϮϴ
mot des feuillesͼϮϱϰ
langage de description d¶algorithmeͼ
mots clésͼϯϲ͕ϭϯϭ
ϭϱ
mots réservésͼϯϲ
langage de programmationͼϭϲ͕ϭϳ
langage machineͼϮϭ
language Cͼϭϳ E
LDAͼϭϱ
lienͼϮϱϰ͕Ϯϲϵ
niveauͼϮϱϰ
LIFOͼϮϮϬ
Q°XGͼϮϬϴ͕Ϯϱϰ͕Ϯϲϵ
/LUHͼϭϲ͕Ϯϳ
Q°XGIHXLOOHͼϮϱϰ
lisibilité du code sourceͼϯϲ
Q°XGILOVͼϮϱϰ
liste chaînéeͼϮϬϱ͕ϮϬϴ͕Ϯϱϱ
Q°XGIUqUHͼϮϱϰ
liste circulaireͼϮϯϭ
Q°XGSqUHͼϮϱϰ
liste d¶adjacenceͼϮϲϵ
Q°XGUDFLQHͼϮϱϰ
liste doublement chaînéeͼϮϭϳ
nomͼϮϰ͕ϯϱ͕ϭϮϵ͕ϭϯϬ͕ϭϲϲ
OQͼϭϭ
nombre d¶apparitionͼϭϬϵ͕ϭϭϬ
ORQJͼϮϵ
nombre premierͼϭϬϴ͕ϭϰϰ
ORQJGRXEOHͼϮϵ nombres consécutifsͼϭϬϴ
Ϯϴϲ

INDEX .

121ͼϭϭ͕Ϯϲ paramètres effectifsͼϭϮϵ͕ϭϯϬ͕ϭϯϴ

notation scientifiqueͼϮϵ paramètres formelsͼϭϮϵ͕ϭϯϬ͕ϭϯϴ
18//ͼϭϴϰ͕ϮϬϴ parcours en largeurͼϮϳϭ
parcours en profondeurͼϮϱϳ͕Ϯϳϭ
parcours infixéͼϮϱϴ
K parcours postfixéͼϮϱϴ
parcours préfixéͼϮϱϳ
octetͼϭϮ pas de progressionͼϳϱ
opérandesͼϭϭ passage des paramètresͼϭϯϳ
opérateur conditionnelͼϰϭ passage par adresseͼϭϯϴ͕ϭϰϭ͕ϭϲϰ
opérateur d¶adressageͼϮϬϳ passage par référenceͼϭϯϴ
opérateur de référençageͼϮϬϳ passage par valeurͼϭϯϴ͕ϭϲϰ
opérateurs arithmétiquesͼϭϭ͕Ϯϱ͕Ϯϲ͕ passage par variableͼϭϯϴ
ϯϮ PCͼϭϬ
opérateurs binairesͼϯϮ périphériquesͼϭϮ
opérateurs bit-à-bitͼϯϰ permutationͼϰϰ͕ϱϯ͕ϭϰϲ
opérateurs d¶affectation élargieͼϰϭ perte de précisionͼϯϳ
opérateurs de comparaisonͼϭϭ͕Ϯϱ͕Ϯϲ͕ PGCDͼϳϵ͕ϭϰϴ
ϯϯ͕ϮϬϲ pileͼϭϯϵ͕ϭϰϰ͕ϭϰϲ͕ϮϮϬ
opérateurs logiquesͼϭϭ͕ϯϯ pisteͼϭϮ
opérateurs unairesͼϯϮ poidsͼϮϲϵ
opération arithmétiqueͼϮϬ point d¶appelͼϭϮϲ͕ϭϯϬ
opération de départͼϳϱ point décimalͼϯϲ
opération logiqueͼϮϬ pointeurͼϵϱ͕ϭϯϴ͕ϭϴϰ͕ϮϬϱ͕ϮϬϴ
opérationsͼϮϬ͕Ϯϰ portée d¶une variableͼϰϭ͕ϭϯϱ
opérations de baseͼϮϲ 3RXU«ͼϳϱ
ordinateurͼϭϬ SRZͼϯϵ͕ϭϯϮ
ordre de forceͼϯϳ SULQWIͼϭϴ͕Ϯϳ͕ϭϬϯ͕ϭϯϭ͕ϭϯϵ
ordre de prioritéͼϭϭ͕ϯϯ͕ϯϴ procédureͼϭϮϵ͕ϭϯϲ͕ϭϲϯ
organigrammeͼϮϴ procédure appelanteͼϭϯϰ
28ͼϭϭ͕Ϯϲ͕ϯϰ procédure appeléeͼϭϯϰ
ou bit-à-bitͼϯϱ processeurͼϭϭ
ou exclusifͼϯϱ produit matricielͼϭϬϵ
profondeurͼϮϱϰ
programmation modulaireͼϭϮϴ
W programmeͼϭϳ͕ϮϬ
programme appelantͼϭϯϬ
paramètresͼϭϮϴ͕ϭϮϵ͕ϭϯϵ programme principalͼϭϳ
Ϯϴϳ

INDEX .

prototypeͼϭϯϰ sommetͼϮϱϰ͕Ϯϲϵ
pseudo-codeͼϭϱ sous-programmeͼϭϮϲ͕ϭϮϴ
SXWFKDUͼϯϭ sous-programme appelantͼϭϯϰ
SXWVͼϭϴ͕ϭϬϯ VSULQWIͼϭϬϲ
VTUWͼϯϵ͕ϭϯϮ
VVFDQIͼϭϬϲ
Z stackͼϭϯϵ͕ϮϮϭ
stack overflowͼϭϰϰ
RAMͼϭϭ͕ϭϮ͕ϭϯ VWDWLFͼϭϯϳ
Recherche dans un tableauͼϵϳ VWGDUJKͼϭϰϮ
recherche dichotomiqueͼϵϳ VWGLRKͼϭϴ͕ϯϭ͕ϭϴϰ͕ϭϴϵ
récursionͼϭϰϮ VWGOLEKͼϭϯϮ͕ϮϬϳ͕ϮϬϴ
récursivitéͼϭϰϮ VWUFDWͼϭϬϱ
5pHOͼϮϱ VWUFPSͼϭϬϱ
règle de troisͼϭϯ VWUFS\ͼϭϬϰ
répertoireͼϭϱ VWULFPSͼϭϬϲ
5pSpWHU«ͼϳϰ VWULQJKͼϭϬϰ
UHWXUQͼϭϯϬ VWUOHQͼϭϬϰ
ROMͼϭϮ VWUQFDWͼϭϬϱ
VWUQFPSͼϭϬϲ
VWUQFS\ͼϭϬϰ
^ VWUQLFPSͼϭϬϲ
VWUXFW«ͼϭϲϮ
VFDQIͼϭϴ͕Ϯϳ͕ϭϬϰ͕ϭϯϭ͕ϭϯϵ
structureͼϭϲϭ͕ϮϬϴ
secteurͼϭϮ
structure conditionnelle composéeͼϱϵ
segment de donnéesͼϭϯϵ
structure conditionnelle multipleͼϲϬ
6HORQ«ͼϲϬ
structure conditionnelle simple ͼϱϴ
sens d¶associativitéͼϯϯ͕ϯϵ
structures conditionnellesͼϱϴ
séquenceͼϱϴ͕ϳϯ
structures de contrôleͼϮϲ
VKRUWͼϮϵ
structures récursivesͼϮϬϴ͕Ϯϱϰ
6L«ͼϱϴ VZLWFK«ͼϲϭ
6L«6LQRQ«ͼϱϵ système d¶exploitationͼϭϰ
VLJQHGͼϮϵ
VLQͼϭϭ͕ϯϵ͕ϭϯϮ
VL]HBWͼϭϴϵ d
VL]HRIͼϯϱ͕ϵϲ͕ϭϵϬ͕ϮϬϲ
smallͼϭϯϵ tableauͼϵϯ͕ϭϰϬ͕ϮϬϱ
SOFTWAREͼϭϬ tableau à deux dimensionsͼϭϬϮ
Ϯϴϴ

INDEX .

tableau de chaînes de caractèresͼϭϬϳ XQVLJQHGͼϮϵ

tableau de situationͼϰϮ͕ϰϳ
taille d¶un arbreͼϮϱϰ͕Ϯϱϴ
tamponͼϭϴϯ͕ϭϴϱ s
WDQͼϯϵ͕ϭϯϮ
7DQWTXH«ͼϳϯ YDBDUJͼϭϰϮ
tasͼϭϯϵ͕ϮϬϴ YDBOLVWͼϭϰϮ
technique de Flagͼϵϳ YDBVWDUWͼϭϰϮ
tinyͼϭϯϵ valeurͼϮϰ
WRORZHUͼϭϭϭ valeur absolueͼϭϯϮ
WRXSSHUͼϭϭϭ valeur finaleͼϳϲ
traitementͼϭϬ͕Ϯϰ valeur initialeͼϭϵ͕ϳϲ
transposée d¶une matriceͼϭϬϵ variable de contrôleͼϳϱ
transtypageͼϯϳ variable locale statiqueͼϭϯϳ
tri à bullesͼϭϬϭ variable pointéeͼϮϬϲ
tri d¶un tableauͼϭϬϬ variablesͼϮϰ
tri par sélectionͼϭϬϬ 9DULDEOHVͼϭϲ
troncatureͼϯϵ variables globalesͼϭϯϱ͕ϭϯϲ͕ϭϯϳ͕ϭϯϵ
typeͼϮϰ͕Ϯϱ͕ϭϮϵ͕ϭϯϬ variables localesͼϭϯϱ͕ϭϯϴ͕ϭϯϵ
type logiqueͼϭϭ vecteurͼϭϬϮ
type numériqueͼϭϭ͕Ϯϱ virgule flottanteͼϮϵ
type symboliqueͼϮϲ YRLGͼϭϮϵ
W\SHGHIͼϭϲϭ 95$,ͼϭϭ͕Ϯϲ͕ϯϮ͕ϯϯ
types personnalisésͼϭϲϭ
types simplesͼϮϱ
types structurésͼϮϲ͕ϵϯ t

WarningͼϮϭ͕ϭϯϰ
h ZKLOH«ͼϳϯ

UALͼϭϭ
UCͼϭϭ y
unionͼϭϲϰ
XQLRQ«ͼϭϲϱ ;25ͼϯϱ
unité centraleͼϭϬ

Ϯϴϵ

Buy your books fast and straightforward online - at one of world’s
fastest growing online book stores! Environmentally sound due to
Print-on-Demand technologies.
Buy your books online at
www.morebooks.shop
Achetez vos livres en ligne, vite et bien, sur l'une des librairies en
ligne les plus performantes au monde!
En protégeant nos ressources et notre environnement grâce à
l'impression à la demande.
La librairie en ligne pour acheter plus vite
www.morebooks.shop
KS OmniScriptum Publishing
Brivibas gatve 197
LV-1039 Riga, Latvia [email protected]
Telefax: +371 686 204 55 www.omniscriptum.com
View publication stats