Algorithmique Bouchiha

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 26,739
1 author:
Djelloul Bouchiha
Centre Universitaire de Naama
82 PUBLICATIONS 345 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
Ontology alignment revision View project
All content following this page was uploaded by Djelloul Bouchiha on 17 February 2023.
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>Ͳ^
ĚũĞůůŽƵů͘ďŽƵĐŚŝŚĂΛƵŶŝǀͲƐďĂ͘Ěǌ͖ďŽƵĐŚŝŚĂ͘ĚũΛŐŵĂŝů͘ĐŽŵ

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

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

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

ŚĂƉŝƚƌĞϭϭ͗>ĞƐŐƌĂƉŚĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϲϵ
ϭ͘/ŶƚƌŽĚƵĐƚŝŽŶ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϲϵ
Ϯ͘ĠĨŝŶŝƚŝŽŶƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϲϵ
ϯ͘ZĞƉƌĠƐĞŶƚĂƚŝŽŶĚ[ƵŶŐƌĂƉŚĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϲϵ
ϯ͘ϭ͘>ŝƐƚĞĚ[ĂĚũĂĐĞŶĐĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϲϵ
ϯ͘Ϯ͘DĂƚƌŝĐĞĚ[ĂĚũĂĐĞŶĐĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϮϳϬ
ϰ͘WĂƌĐŽƵƌƐĚ[ƵŶŐƌĂƉŚĞ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϳϭ
ϰ͘ϭ͘WĂƌĐŽƵƌƐĞŶůĂƌŐĞƵƌĚ[ĂďŽƌĚ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϳϭ
ϰ͘Ϯ͘WĂƌĐŽƵƌƐĞŶƉƌŽĨŽŶĚĞƵƌĚ[ĂďŽƌĚ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϳϭ
ϱ͘ǆĞƌĐŝĐĞƐĐŽƌƌŝŐĠƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϮϳϮ
ϱ͘ϭ͘ǆĞƌĐŝĐĞƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘ϮϳϮ
ϱ͘Ϯ͘ŽƌƌŝŐĠƐ͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘͘Ϯϳϯ

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ġƚĞĚĞ>ͬ
ŝƐƋƵĞ
ŚĂƌŝŽƚ
^µµ[µ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}Puu[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Η>Ă ƐŽŵŵĞ ĚĞ йĚ Ğƚ йĚ ĞƐƚ͗ йĚ Η͕ ǆ͕ Ǉ͕ ǌ
par SULQWIΗ>ĂƐŽŵŵĞĚĞйĚĞƚйĚĞƐƚ͗йĚΗ͕ǆ͕Ǉ͕ǆнǇ. 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é-
Ϯϰ
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/ ^ ϭϰϰϲϬ ϯ͘ϭϰ
ϭϰϰϲϭ
ƌĂǇŽŶ ^ ϭϰϰϲϮ
ƐƵƌĨĂĐĞ ^ ϭϰϰϲϯ
ϭϰϰϲϰ
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 :
Ϯϱ

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$,.
Ϯϲ

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\RQ2.
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
Ϯϳ

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 :
ĠďƵƚ
ĐƌŝƌĞ;ΗŽŶŶĞǌůĂǀĂůĞƵƌĚƵƌĂǇŽŶ͗ΗͿ͖
>ŝƌĞ;ƌĂǇŽŶͿ͖
µ(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
Ϯϴ
^
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
Ϯϵ

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
ϯϬ

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.
ϯϭ

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.
ϯϮ

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 :
ϯϯ

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$,.
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.
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
ϯϰ

!! 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 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.
ϯϲ

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\SHH[SUHVVLRQ
Exemple 2 :
LQFOXGHVWGLRK!
ϯϳ

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
ϯϴ

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
ϯϵ

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

Exemple :
LQFOXGHVWGLRK!
PDLQ
^
IORDW[
SULQWII[
`
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
ϰϬ

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!EPD[&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
ϰϭ

^
LQW[
[
^'pEXWGXEORFGDQVOHTXHOODYDULDEOH\SHXWrWUHXWLOLVpH
LQW\
\ [
SULQWIGG[\
`)LQGXEORF
`
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.
ϰϮ

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.
ϰϯ

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 :
x QS
x Q! S
x Q!T
x T Q!S
x F!F
x F!Q
x F!QFS
x F!Q FS
Exercice 17 :
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
ϰϰ

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 :
LQFOXGHVWGLRK!
PDLQ
^
XQVLJQHGVKRUWD E
SULQWIGGDE!!
`
Exercice 21 :
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 ;
ϰϱ

 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
Organigramme :

1 >C. /EC?
$ >?
1 >C2 /EC?
$ >
?
V=

1 >C*4HCF4?
@

Déroulement de lalgorithme :
Pour le déroulement de lalgorithme dans le cas de a=7 et b=19, on va noter les
opérations comme suit :
Opération Notation

+=2(+A6+*
B+.+/5=1 1
4
+1 2

+=2(+A7+/C
B*+.+/5=1 3
4
+-1 4
)&,$1 5

+=](I++=0*(I1 6
Le tableau suivant (tableau de situation) correspond au schéma dévolution
détat des variables, opération par opération :
Variable - *(I
Affichage
Opération (effectué par l¶opération Ecrire)
2(+A6+*
B+.+/5

2(+A7+/C
B*+.+/5

H ](I++
Solution 3 :
Algorithme :
%7

!(
)*+ /

-+
3+ (**+06(7/
0*(I++0-0-0-1
23-/

+=2(+A(
(*-+ 5=1
4
+-0-0-1

&*, *,*,"1
-+./&*, *,*,"1
)
**
&
$"1

+=4 (**+7+ + (
(*-+ + 5=0 (**+1

+=4+6(7/
7+ + (
(*-+ + 5=06(7/
1

+=4*(I++7+ + (
(*-+ + 5=0*(I++1
#

Programme C :
:
/7+& 7
(9)%
*

;
<( (**+06(7/
0*(I++0-0-0-1
6
<=2(+A(
(*-+ 5E=1
<=><><><=0?-0?-0?-1
(**+---1
6(7/
---1
*(I++ (**+1
6
<=4 (**+7+ + (
(*-+ + 5><E=0 (**+1
6
<=4+6(7/
7+ + (
(*-+ + 5><E=06(7/
1
6
<=4*(I++7+ + (
(*-+ + 5><E=0*(I++1
@
Solution 4 :
Algorithme :
!(
)*+ +J7(/-+J
6+

-+

+-0 0701
23-/

+=+A/(*-+5=1
4
+-1
&&*,*,1
+&*,1
/&"*,1

+=4+ 3=0 1

+=4+7(/-+=071

+=4+
6+=01
#

Programme C :
:
/7+& 7
(9)%
*

;

-0 0701
6
<=2(+A/(*-+5E=1
%8

<=>7=0?-1
--1
7-1
-1
6
<=4+ 3>7E=0 1
6
<=4+7(/-+>7E=071
6
<=4+
6+>7E=01
@
Solution 5 :
Algorithme :
!(
)*+< /+

-+
3+6/0.0 1

+-1
23-/

+=2(+A+6
C/

+)( C+ 5=1
4
+6/1

+=2(+A+(*-+7
+ 5=1
4
+-1

+=2(+A+/C7+!5=1
4
+.1
//&&*,-*,-/1

+=4+6
C(/+ C+ + 5=0 1
#

Programme C :
:
/7+& 7
(9)%
*

;
<(6/0.0 1

-1
6
<=2(+A+6
C/

+)( C+ 5=1
<=><=0?6/1
6
<=2(+A+(*-+7F
+ 5=1
<=>7=0?-1
6
<=2(+A+/C7+!5=1
<=><=0?.1
-6/-6/.1
6
<=4+6
C(/+ C+ + 5><=0 1
@
Solution 6 :
Algorithme :
!(
)*+ 6)++
K( +
6
9H1

-+
3+ 0!
+0(1
23-/

+="(7/
+A.+/7/I(5=1
%:

4
+ 1
0.
&-.111
2 &$"-.1111

+=!
+=0!
+1

+=(/*+=0(1
#

Programme C :
:
/7+& 7
(9)%
:7+<
+6
9H
*

;
<( 0!
+0(1
6
<="(7/
+A.+/7/I(5=1
<=><=0? 1
!
+6
1
(96
1
6
<=!
+><E=0!
+1
6
<=(/*+><=0(1
@
Solution 7 :
Algorithme :
!(
)*+
+

-+
3+0-0 0L+
*0!
+061
23-/

+=2(+A(/+/7/ ^35=1
4
+1

+=2(+A(/+/7/ ^3-5=1
4
+-1

+=2(+A(/+/7/ ^3 5=1
4
+ 1
'
.&,&
-&'
.$
0.
&--6-6 U1

+=L3
*B+=0L+
*1

+=!
+=0!
+1
#

Programme C :
:
/7+& 7
(9)%
:
/7+&*)9)%
*

;
<(0-0 0L+
*0!
+061
6
<=2(+A(/+/7/ ^35=1
<=><=0?1
6
<=2(+A(/+/7/ ^3-5=1
<=><=0?-1
6
<=2(+A(/+/7/ ^3 5=1
'

<=><=0? 1
L+
*- 1
6L+
*1
!
+ W666-6 1
6
<=L3
*B+><E=0L+
*1
6
<=!
+><=0!
+1
@
Solution 8 :
Algorithme :
!(
)*+ + +/
K( +
6
9H1

-+
3+ 0!+0!
+1
23-/

+="(7/
+A+I(5=1
4
+ 1

+="(7/
+AF++7+3 5=1
4
+!+1
0.
&-.110*3
$"41

+=!
+=0!
+1
#

Programme C :
:
/7+& 7
(9)%
:7+<
+6
9H
*

;
<( 0!+0!
+1
6
<="(7/
+A+I(5=1
<=><=0? 1
6
<="(7/
+AF++7+3 5=1
<=><=0?!+1
!
+6
!+H'1
6
<=!
+><=0!
+1
@
Solution 9 :
Algorithme :
!(
)*+K(.+
(J#J(JK

-+
3+K0#1
23-/

+=2(+A+*63/++7+3 #)+)+
5=1
4
+#1
5&6471

+=4+*63/++7+3 K+
/ =0K1
#

Programme en C :
:
/7+& 7
(9)%
'

*

;
<(K0#1
6
<=2(+A+*63/++7+3 #)+)+
5=1
<=><=0?#1
K'9H#1
6
<=4+*63/++7+3 K+
/ ><=0K1
@
Programme en C pour la conversion inverse :
:
/7+& 7
(9)%
*

;
<(K0#1
6
<=2(+A+*63/++7+3 K+
/ 5=1
<=><=0?K1
#K'9H1
6
<=4+*63/++7+3 #)+)+
><=0#1
@
Solution 10 :
Algorithme :
!(
)*+<

-+
3+C0<C1
23-/

+=+A/(*-+5=1
4
+C1
%8&8"$"881

+=#=0C0==0<C1
#

Programme C :
:
/7+& 7
(9)%
*

;
<(C0<C1
6
<=+A/(*-+5=1
<=><=0?C1
<CCCC1
6
<=#>9<>9<=0C0<C1
@
Solution 11 :
Algorithme :
!(
)*+K /J)/+/

-+
3+)01
23-/

+=+A/+7/3+5=1
4
+1
9&:;6< //1
'!


+=P/+/=0)1
#

Programme C :
:
/7+& 7
(9)%
*

;
<()01
6
<=+A/+7/3+5=1
<=><=0?1
)99[1
6
<=P/+/><=0)1
@
Programme C : calcul du temps en fonction de la hauteur
:
/7+& 7
(9)%
:
/7+&*)9)%
*

;
<()01
6
<=+A/+)/+/5=1
<=><=0?)1
W)9[1
6
<=+*6 ><=01
@
Solution 12 :
Permutation en utilisant une variable intermédiaire :
Algorithme :
!(
)*+L+*/+

-+

+C0I0A1
23-/

+=2(+A.+/7+C5=1
4
+C1

+=2(+A.+/7+I5=1
4
+I1
=&81
8&)1
)&=1

+=!6B 6+*/
(5=1

+=C=0C1

+=I=0I1
#

Programme C :
:
/7+& 7
(9)%
*

;

C0I0A1
6
<=2(+A.+/7+C5=1
<=>7=0?C1
'#

6
<=2(+A.+/7+I5=1
<=>7=0?I1
AC1
CI1
IA1
6
<=!6B 6+*/
(5E=1
6
<=C>7E=0C1
6
<=I>7=0I1
@
Permutation sans variable intermédiaire :
Algorithme :
!(
)*+L+*/+

-+

+C0I1
23-/

+=2(+A.+/7+C5=1
4
+C1

+=2(+A.+/7+I5=1
4
+I1
8&8)1
)&8I1
8&8I1

+=!6B 6+*/
(5=1

+=C=0C1

+=I=0I1
#

Programme C :
:
/7+& 7
(9)%
*

;

C0I1
6
<=2(+A.+/7+C5=1
<=>7=0?C1
6
<=2(+A.+/7+I5=1
<=>7=0?I1
CCI1
ICI1
CCI1
6
<=!6B 6+*/
(5E=1
6
<=C>7E=0C1
6
<=I>7=0I1
@
Solution 13 :
Algorithme :
!(
)*+ (.+
(

-+

+ + 0)0*0 1
23-/
'%


+="(7/
+A+(*-+7+ + (7+ 5=1
4
+ + 1
&*
&>41
&*
&>"4$41
9&*
&$"41
1 >FC>?ECFFC>?FCFFC >?FCFFC>?C?
#

Programme C :
:
/7+& 7
(9)%
*

;

+ 0)0*0 1
6
<="(7/
+A+(*-+7+ + (7+ 5=1
<=>7=0? + 1
) + H''1
* + >H''H'1
+ >H'1
. >CD>?ED>?D >?FD>?CFFFF?
@
Solution 14 :
Le type et la valeur de chacune des expressions suivantes :
N W Type :(, valeur :
N C Type :<(, valeur :9''''
N >6W Type :(, valeur :
N >6 Type :
, valeur :'
Solution 15 :
Le type et la valeur de lexpression suivante :
CType :<(, valeur : HH9''''
Solution 16 :
N &6 Type :
, valeur : '
N %6Type :
, valeur :
N %W Type :
, valeur :
N W%6Type :(, valeur :
N % Type :
, valeur : '
N %Type :
, valeur :
N % &6 Type :
, valeur :
N %?? &6Type :
, valeur : '
Solution 17 :
N % SS & Type :
, valeur :
N W??Type :
, valeur :
N W??'Type :
, valeur : '
''

N CW Type :<(, valeur : 9''''

Solution 18 :
Solution 19 :
N Mieux présenter le programme C :
:
/7+& 7
(9)%
*

;

1
<?1
6
<=>76(/7(/-+>7=001
@
N Si on enlève la déclaration
, une erreur de compilation surgit :
/7+ +7.
N Si on remplace lidentificateur par
<, une erreur de compilation
surgit refusant dutiliser
< comme identificateur, car
< est un mot
clé.
Solution 20 :
Le programme C affiche :
Solution 21 :
Le programme C affiche :

'[
[
Solution 22 :
Programme C :
:
/7+& 7
(9)%
*

;
) 1
6
<=6+A/ B+5=1
<=> =0? 1
6
<=4+ (7+!,K""7/ B+> + >79=0 0 1
@
Solution 23 :
Programme C :
:
/7+& 7
(9)%
*

;

00W/(
+1
<(< 01
) 1
6
<=2(+A7+/C+
+ 5E=1
<=>7>7=0?0?1
'6

W/(
+1
6
<=L
++
B+7/W/(
+5>7E=0W/(
+1
< <(W/(
+1
6
<=L
+<
(
+7/W/(
+5><E=0< 1
6
<=2(+A/(*-+5=1
<=><=0?1

< >H1
6
<=4+ B+(-+/+ 5> =0 1
@
Avec Q, Q, O, le programme affiche :
2(+A7+/C+
+ 5

''
L
++
B+7/W/(
+5
L
+<
(
+7/W/(
+5'9H'''
2(+A/(*-+5''
4+ B+(-+/+ 5!
'7

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 : ,
K(7

(&,3W/+ +%
Cette opération est lue comme suit : Si la condition est vérifiée ( !"), alors la
séquence dopérations sexécute.
La condition est une expression logique qui retourne la valeur !" ou #!$.
Lexpression peut être simple (condition simple) ou composée (plusieurs
conditions composées avec des opérateurs logiques , et ).
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 73-/ et <
. Si la séquence contient une seule opération, alors les mots
73-/ et <
ne sont pas obligatoires.
La structure conditionnelle simple peut être représentée dans un organigramme
comme suit :
050 5&+
>3 ?
<
Voyons les exemples suivants :

N ,
$%'
+$1
On affiche la valeur de $ si elle est supérieure à '.
N ,
$%'73-/
+$&1<

On affiche la valeur de $ et on affecte la valeur de $ à N, si $ est
supérieure à '.
N ,
$%'$&
+$1
On affiche la valeur de $ si elle est prise entre ' et .
N ,
$%',
$&
+$1
Cet exemple est équivalent à lexemple précédent, sauf que cette fois-ci
on utilise des tests imbriqués.
N ,
$&',
$%
+C1
'8

Dans cet exemple, la valeur de $ nest jamais affichée, car il ny a aucun
cas qui satisfait la condition.
En C, la structure conditionnelle simple sécrit sous la forme :
<K(7

(&M( %
Exemple :
<$%'6
<=>7=0$1
Remarques :
NDans un programme C, on utilise le terme bloc au lieu de séquence. Le bloc
est constitué donc dune ou plusieurs instructions.
NLa condition est obligatoirement mise entre et . Chaque instruction du
bloc doit se terminer par un point-virgule (1).
NSi le bloc contient plus dune instruction, alors les deux accolades ; et @
sont obligatoires pour délimiter la suite dinstructions. Les accolades sont
facultatives sil ny a quune seule instruction.
NSi on met un point-virgule juste après la condition, le compilateur considère
que le bloc de
< est constitué d*-$ )$*,$ (-)"!*"(%- !($-6 7 !
exemple :
<C%'16
<=-(D(/=1
ici, le 6
< ne se trouve pas dans le
<, mais à lextérieur, et par
conséquent, il sera exécuté quelle que soit la valeur de C.
NComme il ny 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 : ,
(7

(&,3W/+ +%,
(&,3W/+ +%
Cette opération est lue comme suit : Si la condition est vérifiée ( !"), alors les
opérations de la ,3W/+ + sont exécutées. Dans le cas contraire, ce sont les
opérations de la ,3W/+ + qui vont être exécutées.
Les mots 73-/ et <
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 :
050 5&+
>3 ?
< ! <
Soit lexemple suivant :

,
$%'
+$1
,
(
+=.+/( +63+=1
':

Dans cet exemple, la valeur de $ est affichée si elle est supérieure à ', sinon
on affiche le message : .+/( +63+
En C, on aura :
<C%'6
<=>7=0C1
+ +6
<=.+/( +63+=1
Remarques :

Si nous avions une suite dinstructions dans un bloc, alors on aurait dû
utiliser les deux accolades ; et @.

Le + + se rapporte toujours au .% le plus proche. Pour casser ce rapport,
il est possible dutiliser ; et @. Par exemple, dans le cas de :

<C%';
<C&'6
<=>7=0C1@
+ +6
<=.+/( +63+=1
le + + suit le premier
< et non pas le deuxième.
4. Structure conditionnelle multiple
La structure conditionnelle multiple, appelée aussi lalternative classifiée ou le
choix multiple, permet de comparer un objet (expression) à toute une série de
valeurs, et dexécuter une séquence dopérations parmi plusieurs, en fonction
de la valeur effective de lobjet. Une séquence par défaut peut être prévue dans
le cas où lobjet nest é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 à lexpression. La structure
conditionnelle multiple se présente comme suit :
,+(+C6+
(
73-/
+/5&,3W/+ +%
+/5&,3W/+ +%

+/5&,3W/+ +%
23</5&,3W/+ +673</%
<

Ceci est équivalent à :
,
+C6+
(+/&,3W/+ +%
,
(,
+C6+
(+/&,3W/+ +%

,
(,
+C6+
(+/&,3W/+ +%
,
(&,3W/+ +673</%
La structure conditionnelle multiple peut être représentée dans un
organigramme comme suit :
6

>3 ? 5&+ <
050
>3 !? 5&+ < !

050
050 >3 ? 5&+ <

< .
Dans lexemple suivant, la valeur de $ est affichée en lettres, si elle est égale à
ou , sinon on affiche un message :
,+($
73-/
+/5
+==1
+/5
+=2+/C=1
23</5
+=+/ /6_7+/C(/
<_/=1
<

Remarques :
- Dans lopération de choix multiple, lordre de présentation ne change rien.
- Le cas défaut est facultatif.
En C, ça sécrit :
8
)$
;
+56
<==1-+V1
+56
<=2+/C=1-+V1
7+</56
<=+/ /6_7+/C(/
<_/=1
@
Ou bien :
8
)$
;
+5;6
<==1-+V1@
+5;6
<=2+/C=1-+V1@
7+</5;6
<=+/ /6_7+/C(/
<_/=1@
@
Remarques :
- En langage C, lexpression et les valeurs à choisir doivent être de type

ou ).
6

- Linstruction -+V termine lexécution de linstruction englobante

( 8
)) dans laquelle elle apparaît. En cas doubli de -+V, les
instructions des cas suivants seront aussi exécutées.
Par exemple, en labsence de -+V, et pour $, linstruction :
8
)$
;
+56
<==1
+56
<=2+/C=1
7+</56
<=+/ /6_7+/C(/
<_/=1
@
affiche : 2+/C+/ /6_7+/C(/
<_/
Maintenant, pour lexemple :
8
)$
;
+5
+56
<=>7=0$1-+V1
7+</56
<=+/ /6_7+/C(/
<_/=1
@
Le traitement est le même (laffichage de la valeur de $) pour $égale à
ou $ égale à.
- Pour une souplesse de programmation, il est possible de mettre :
:7+<
+.'

8
)
;6
+.?
+.?
+.?
@
Une modification de . se résume à une seule intervention au niveau de
la directive :7+<
+.
- Si vous dupliquez les cas, par exemple :
8
)$
;
+56
<=-(D(/=1-+V1
+56
<=*+
=1-+V1
7+</56
<=+/ /6_7+/C(/
<_/=1
@
Vous aurez une erreur de compilation de la forme duplicate case value.
5. Le branchement
Il est possible deffectuer un saut direct vers une opération en utilisant une
opération de branchement de la forme +_&3
W/++%.
Exemple :
!(
)*+<<
)+J-J6(

<

-+

+"1
6!

23-/
4
+"1
,
"&'+_+
W1

+"1
+
W5
+=]+
=1
#

En C, ça sécrit :
:
/7+& 7
(9)%
*

;

"1
<=>7=0?"1

<"&'((+
W1
6
<=>7E=0"1
+
W56
<=]+
=1
@
On note quil est déconseillé dutiliser linstruction de branchement, et cela
pour réduire la complexité des programmes en termes de temps.
6.1. Exercices
Exercice 1 :
Ecrire un algorithme qui demande un nombre à lutilisateur, et linforme
ensuite si ce nombre est positif ou négatif. Si le nombre vaut zéro, on le
considère positif. Représenter lalgorithme par un organigramme, ensuite le
traduire en C.
Exercice 2 :
Ecrire un algorithme qui affiche la valeur absolue dun nombre réel lu à partir
du clavier. Traduire lalgorithme en C.
Exercice 3 :
Ecrire un algorithme qui compare deux nombres réels lus à partir du clavier.
Traduire lalgorithme en C.
Exercice 4 :
Ecrire un algorithme qui permet de dire si un nombre lu à partir du clavier est
pair ou impair. Traduire lalgorithme en C.
Exercice 5 :
Ecrire un algorithme qui affiche le résultat dun étudiant (accepté ou rejeté) à
une matière, sachant que cette matière est évaluée par une note doral
(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 lalgorithme en C.
Exercice 6 :
Ecrire un algorithme permettant de déterminer le plus grand de trois nombres
réels lus à partir du clavier. Traduire lalgorithme en C.
6#

Exercice 7 :
Ecrire un algorithme qui demande deux nombres à lutilisateur, et linforme
ensuite si le produit est positif, négatif ou nul. Attention ! On ne doit pas
calculer le produit. Traduire lalgorithme 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, lutilisateur doit introduire
les facteurs a, b et c. Traduire lalgorithme en C.
Exercice 9 :
Ecrire un algorithme qui demande dentrer un nombre entre 1 et 7, et donne le
-%8 .* 9%*! %!!$)'%-. -" ) 8$.( .(8 -:$6 $- *"(,() -" , )"!*"*!$
conditionnelle multiple. Traduire lalgorithme en C.
Exercice 10 :
Ecrire un algorithme permettant à partir dun menu affiché, deffectuer la
somme, le produit ou la moyenne de trois nombres. Nous appelons menu,
lassociation dun numéro séquentiel aux différents choix proposés par un
programme. Traduire lalgorithme en C.
Exercice 11 :
Ecrire un algorithme permettant de déterminer si lannée A est bissextile. On
doit savoir que si A nest pas divisible par 4, lannée nest pas bissextile. Si A
est divisible par 4, lannée est bissextile, sauf si A est divisible par 100 et non
pas par 400. Traduire lalgorithme en C. Tester votre programme pour les
années 111, 1984, 1900 et 800.
Exercice 12 :
Ecrire un algorithme permettant deffectuer la transformation des coordonnées
cartésiennes (x,y) en coordonnées polaires (r,t). Cette transformation se fait par
les formules :
N r2 = x2+y2
N Si x = 0 alors : t = pi/2 si y > 0 ; t = - pi/2 si y < 0 ; t nexiste pas si y = 0.
N Sinon t = arctg (y/x) auquel il faut ajouter pi si x<0.
6.2. Corrigés
Solution 1 :
Algorithme :
!(
)*+6(

<J+
<

-+

+1
23-/

+=+A/(*-+5=1
4
+1
,
%'
+=K+(*-++ 6(

<9=1
6%

,
(
+=K+(*-++ 3
<9=1
#

Organigramme :

1 >C1
EC?
$ >?
5&+ 0
IH
1 >C3
1 >C3

. C? C?
@

Programme C :
:
/7+& 7
(9)%
*

;

1
6
<=+A/(*-+5=1
<=>7=0?1

<%'6
<=K+(*-++ 6(

<9=1
+ +6
<=K+(*-++ 3
<9=1
@
Solution 2 :
Algorithme :
!(
)*+.+/J- (/+

-+
3+$0J- 1
23-/

+=+A/(*-+5=1
4
+$1
2 A,&1
B.2 A,!2 A,&J- 1

+=4.+/- (/+7+=0$0=+ =0J- 1
#

Programme C :
:
/7+& 7
(9)%
*

;
<($0J- 1
6
<=+A/(*-+5=1
6'

<=><=0?$1
J- $1

<J- &'J- J- 1
6
<=4.+/- (/+7+><+ ><=0$0J- 1
@
Solution 3 :
Algorithme :
!(
)*+ (*6
(

-+
3+$0N1
23-/

+=+A7+/C(*-+ $+N5=1
4
+$0N1
,
$N
+$0==0N1
,
(,
$%N
+$0=+ /63
+/_=0N1
,
(
+$0=+
<3
+/_=0N1
#

Programme C :
:
/7+& 7
(9)%
*

;
<($0N1
6
<=+A7+/C(*-+ $+N5E=1
<=><><=0?$0?N1

<$N6
<=><><=0$0N1
+ +
<$%N6
<=><+ /63
+/_><=0$0N1
+ +6
<=><+
<3
+/_><=0$0N1
@
Solution 4 :
Algorithme :
!(
)*+6
J
*6

-+

+$1
23-/

+=+A/(*-+5=1
4
+$1
,
$>'
+$0=+ /(*-+6
9=1
,
(
+$0=+ (*-+
*6
9=1
#

Programme C :
:
/7+& 7
(9)%
*

;

$1
6
<=+A/(*-+5=1
<=>7=0?$1

<$>'6
<=>7+ /(*-+6
9=0$1
+ +6
<=>7+ /(*-+
*6
9=0$1
66

@
Solution 5 :
Algorithme :
!(
)*++./
(

-+
3++0(0*(I1
23-/

+=+A(+7+F+C*+3
5=1
4
++1

+=+A(+7+F+C*+(5=1
4
+(1
)&*
*$"1
,
*(I%'
+= +63=1
,
(
+=+D+3=1
#

Programme C :
:
/7+& 7
(9)%
*

;
<(+0(0*(I1
6
<=+A(+7+F+C*+3
5=1
<=><=0?+1
6
<=+A(+7+F+C*+(5=1
<=><=0?(1
*(I+(1

<*(I%'6
<= +63=1
+ +6
<=+D+3=1
@
Solution 6 :
Algorithme :
!(
)*+6/ J7

-+
3+C0I0A061
23-/

+=+A(
(*-+ 5=1
4
+C0I0A1
,
C%I+C%C=-3&81
B.**B.)C=-3&)1
B.**-3&=1

+=4+6/ 77+ (
(*-+ + 5=061
#

Programme C :
:
/7+& 7
(9)%
*

;
<(C0I0A061
6
<=+A(
(*-+ 5E=1
<=><><><=0?C0?I0?A1
67


<C%I??C%A6C1
+ +
<I%A6I1
+ +6A1
6
<=4+6/ 77+ (
(*-+ + 5><=061
@
Solution 7 :
Algorithme :
!(
)*++ /J6(7/

-+

+*01
23-/

+=+A7+/C(*-+ 5=1
4
+*01
,
*''

+=4+6(7/
7+=0*0=+=00=+ /9=1
,
(,
*%'%'*&'&'

+=4+6(7/
7+=0*0=+=00=+ 6(

<9=1
,
(
+=4+6(7/
7+=0*0=+=00=+ 3
<9=1
#

Programme C :
:
/7+& 7
(9)%
*

;

*01
6
<=+A7+/C(*-+ 5E=1
<=>7>7=0?*0?1

<*'SS'
6
<=4+6(7/
7+>7+>7+ /9=0*01
+ +
<*%'??%'SS*&'??&'
6
<=4+6(7/
7+>7+>7+ 6(

<9=0*01
+ +6
<=4+6(7/
7+>7+>7+ 3
<9=0*01
@
Solution 8 :
Algorithme :
!(
)*+WJ7+J7++

-+
3+0-0 070C0C0C1
23-/

+=+A+ .+/ 0-+ 7+F3W/
(5=1
4
+0-0 1
7&,, 1
,
7%'73-/
8 &-¾( 1
8&-¾( 1

+=4F3W/
(6( B7+7+/C
+ 5=1

+=C=0C0=C=0C1
<

68

,
(,
7'73-/
8&-1

+=4F3W/
(6( B7+/+
+5=1

+=C=0C1
<

,
(
+=4F3W/
(+6( B7+6 7+
+ 9=1
#

Programme C :
:
/7+& 7
(9)%
:
/7+&*)9)%
*

;
<(0-0 070C0C0C1
6
<=+A+ .+/ 0-+ 7+F3W/
(5E=1
<=><><><=0?0?-0? 1
7-- 1

<7%';
C- W71
C- W71
6
<=4F3W/
(6( B7+7+/C
+ 5E=1
6
<=C><0C><=0C0C1
@
+ +
<7';
C-1
6
<=4F3W/
(6( B7+/+
+5E=1
6
<=C><=0C1
@
+ +6
<=4F3W/
(+6( B7+6 7+
+ 9=1
@
Solution 9 :
Algorithme :
!(
)*+D(/

-+

+(1
23-/

+=+A+/*3(7/D? 6B
+.E6F.*&9
5=1
4
+(1
,+((
73-/
5
+=,*+7
=1
5
+=2
* )+=1
5
+=4/7
=1
5
+=]7
=1
5
+=]+ +7
=1
H5
+=`+/7
=1
5
+=+7+7
=1
23</5
+=/*3(( +639=1
<

#

6:

Programme C :
:
/7+& 7
(9)%
*

;

(1
6
<=+A+/*3(7/D(/? 6B
+.E6F.*&9
?G
<=>7=0?(1
8
)(
;
+56
<=,*+7
=1-+V1
+56
<=2
* )+=1-+V1
+56
<=4/7
=1-+V1
+56
<=]7
=1-+V1
+56
<=]+ +7
=1-+V1
+H56
<=`+/7
=1-+V1
+56
<=+7+7
=1-+V1
7+</56
<=/*3(( +639=1
@
@
Solution 10 :
Algorithme :
!(
)*+*+/

-+
3+-0-0-1

+K)(
C1
23-/

+=+A(
(*-+ 5=1
4
+-0-0-1
!<<
)+7/*+/+

+7/ )(
C

+=6(/*/
6

(=1

+=6(/ (**+=1

+=6(/*(I++=1

+=(+ )(
C5=1
4
+ )(
C1
,+( )(
C
73-/
51 >C$.
ECF
J
!J
#?
51 >C$
ECF
G
!G
#?
51 >C$4
ECF>
G
!G
#?)#?
23</5
+=K)(
C
(+ R=1
<

#

Programme C :
:
/7+& 7
(9)%
*

;
<(-0-0-1

K)(
C1
7

6
<=+A(
(*-+ 5E=1
<=><><><=0?-0?-0?-1
!<<
)+7/*+/+

+7/ )(
C
6
<=6(/*/
6

(E=1
6
<=6(/ (**+E=1
6
<=6(/*(I++E=1
6
<=(+ )(
C5=1
<=>7=0?K)(
C1
8
)K)(
C
;
+5. >C$.
EDCF
J
!J
#?
K
+5. >C$
EDCF
G
!G
#?
K
+5. >C$4
EDCF>
G
!G
#?)#?

K
7+</56
<=K)(
C
(+ R=1
@
@
Solution 11 :
Algorithme :
!(
)*+-
+C
+

-+

+!1
23-/

+="(7/
+AF3+5=1
4
+!1
,
!>'

+=4F3+=0!0=F+ 6 -
+C
+9=1
,
(,
!>'''!>'''

+=4F3+=0!0=F+ 6 -
+C
+9=1
,
(
+=4F3+=0!0=+ -
+C
+9=1
#

Programme C :
:
/7+& 7
(9)%
*

;

!1
6
<="(7/
+AF3+5=1
<=>7=0?!1

<R!>'
6
<=4F3+>7F+ 6 -
+C
+9=0!1
+ +
<!>'''??R!>'''
6
<=4F3+>7F+ 6 -
+C
+9=0!1
+ +6
<=4F3+>7+ -
+C
+9=0!1
@
Après test :
On a obtenu : F+ 6 -
+C
+9; [ + -
+C
+9;
''F+ 6 -
+C
+9; et[''+ -
+C
+9
7

Solution 12 :
Algorithme :
!(
)*+K+
+JL(
+
K( +
L
91

-+
3+C0I001
23-/

+="(7/
+AF-
+C5=1
4
+C1

+="(7/
+AF(7(3+I5=1
4
+I1
&¥6 $ E 7 $ 1
,
C'
,
I%'
+==00=+=06
1
,
(,
I&'
+==00=+=06
1
,
(
+==00=+F+C
+6 9=1
,
(73-/
/&&/3)$81
B.8!/&/-.1

+==00=+=01
<

#

Programme C :
:
/7+& 7
(9)%
:
/7+&*)9)%
:7+<
+L
9
*

;
<(C0I001
6
<="(7/
+AF-
+C5=1
<=><=0?C1
6
<="(7/
+AF(7(3+I5=1
<=><=0?I1
W6(8C06(8I01

<C'
<I%'6
<=><+><=00L
1
+ +
<I&'6
<=><+><=00L
1
+ +6
<=><+F+C
+6 9=01
+ +;
IC1

<C&'L
1
6
<=><+><=001
@
@
7!

Les boucles .
Chapitre 4 : Les boucles
1. Introduction
Lorsquon veut répéter une opération ou une suite dopérations plusieurs fois
dans un algorithme, il est possible dutiliser des structures répétitives
(itératives) appelées les boucles. Il existe trois types de boucles : W/+,
363+ et L(/.
2. La boucle Tant que
Format général : W/+K(7

(&,3W/+ +%
Cette structure permet la répétition dune séquence dopérations tant que la
condition est satisfaite (= !"). 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 #!$) 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
73-/ et <
sont obligatoires. Dans le cas dune seule opération, le 73-/ et
<
sont optionnels.
La boucle W/+ est représentée dans un organigramme comme suit :
050 5&+
>3 ?
<
Lexemple suivant permet dafficher les valeurs de à ' :

.& 1
W/+
&'73-/

+
1
.&. 1
<

En C, la boucle W/+ sexprime comme suit :
1
8)
+
&';
6
<=>7E=0
1

1
@
Remarques :
N En langage C, dans une instruction 8)
+, la condition doit être délimitée
par et . Chaque instruction du bloc doit se terminer par un point-virgule
(1).
7#

Les boucles .
N 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.
N Condition vraie veut dire que la valeur de lexpression est non nulle.
Condition fausse veut dire que la valeur de lexpression est '.
3. La boucle Répéter
Format général : 363+&,3W/+ +%`/ W/_K(7

(
Cette structure permet la répétition dune ou plusieurs opérations jusquà ce
quune condition soit vérifiée (= !"). Pour éviter la boucle infinie, il faut que
la condition puisse changer de valeur (avoir la valeur !").
La boucle 363+ peut être représentée dans un organigramme comme suit :
<
050
5&+
>3 ?
Reprenons lexemple permettant dafficher les valeurs de à ' :

.&
363+
73-/

+
1
.&.
<

`/ W/_
%'1
Le tableau suivant récapitule les différences entre les boucles W/+ et
363+ :
Condition Condition
Boucle Nombre d¶exécutions
d¶exécution pour quitter
nest pas connu davance, mais elle
Condition = Condition = peut ne jamais être exécutée si la
&"4.
!" #!$
condition = #!$ dès le départ.
Condition = Condition = nest pas connu davance, mais elle

3'3"
#!$ !" est exécutée au moins une fois.
Remarques :
NPour la boucle W/+ et 363+, on utilise souvent une variable, dite
indice, initialisée à une valeur initiale avant dexécuter la boucle. A
lintérieur de la boucle, lindice sera incrémenté (en ajoutant une valeur à la
valeur courante), ou décrémenté (en diminuant la valeur courante) pour
atteindre la condition darrêt de la boucle.
7%

Les boucles .
NUne itération est la réalisation dun cycle complet de boucle. Ceci inclut le
test de la condition et lexécution de la séquence. Ceci est valable pour
toutes les boucles.
NEn C, il nexiste pas une boucle 363+ proprement dite. Il existe une
instruction qui fait presque le même travail. Il sagit de linstruction +
8)
+, mais en réalité, cest un simple échange de position entre le bloc
dinstructions et la condition de la boucle 8)
+ (W/+), permettant
ainsi lexécution du bloc dinstructions au moins une seule fois, sauf que la
condition darrêt est la même que la boucle 8)
+, i.e. condition = #/C.
Lexemple précédent devient ainsi :

1
7(;
6
<=>7E=0
1

1
@8)
+
&'1
4. La boucle Pour
Format général :
L(/ 63
( 7+ 736 1 K(7

( 1 L 7+ 6(+
(
&,3W/+ +%
Avec :
1. Opération de départ : cest 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 sagit généralement dune ou plusieurs initialisations.
2. Condition : cest une condition testée avant dexécuter la séquence. Si la
condition est vérifiée (= !"), on exécute la séquence. Si la condition nest
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 lexécution de la séquence.
Après avoir exécuté lopé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 #!$
pour quon puisse quitter la boucle. Généralement, il sagit 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 L(/ est le suivant :
' &-/
& A.*./. +1 (*6+/ & .J<
+1
&-/
&&-/
.*&H
*/!,3W/+ +%
Ou bien :
' &-/
& A.*./.
&-/
C A%.*

&-/
&&-/
73 3*+&,3W/+ +%
Cette structure permet de répéter lexécution dune séquence dopérations pour
toutes les valeurs dune variable de contrôle ( (*6+/) à partir dune valeur
7'

Les boucles .
initiale (.J

+) à une valeur finale (.J<
+). Après chaque
exécution de la séquence, la variable de contrôle est incrémentée dune unité
(
3*+), ou décrémentée dune unité (73 3*+). 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
+.

Dans la séquence dune boucle L(/, le compteur (variable de contrôle)
peut être utilisé, mais il ne doit jamais être modifié à lintérieur de la
boucle.

La valeur initiale, la valeur finale et lincrément peuvent être des
expressions numériques.
La boucle L(/ peut être représentée dans un organigramme comme suit :
5. .
050 5&+
>3 ?
<
".
Gardons le même exemple permettant dafficher les valeurs de à ' :

'.& 1
&'.&.
+
1
En C, la boucle L(/ sexprime comme suit :
<(
1
&'1

6
<=>7E=0
1
Ou bien : <(
1
&'1
6
<=>7E=0
1
Ou même : <(
1
&'1
6
<=>7E=0
1
Remarques :

En langage C, si le bloc dinstructions de la boucle <( 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 <(
1
&'1
&M( % la
variable
aura la valeur .

En langage C, le format général suivant peut être utilisé :
<(&" /
( 7+ 736% 1 &K(7

( %1 &L 7+
6(+
(%&M( %
avec (1) &" /
(7+736% (généralement une initialisation) est
exécutée une seule fois au début de la boucle ; (2) la K(7

( est
évaluée au début de chaque itération ; (3) Une modification indiquant un
L 7+6(+
( est exécutée à la fin de chaque itération.
76

Les boucles .

Linstruction -+V sert à interrompre le déroulement de la boucle, en
passant à linstruction qui suit cette boucle. Par exemple, la boucle :
<(
1
&1
;

<
-+V1
6
<=>7=0
1
@
affiche :
On note ici quaprès avoir quitté la boucle, la variable
aura la valeur .

Linstruction (
/+ permet de passer au tour de boucle suivant. Par
exemple, la boucle :
<(
1
&1
;

<
(
/+1
6
<=>7=0
1
@
affiche :

Il est possible dinitialiser/modifier plusieurs variables dans la boucle <(
en même temps. Ces initialisations/modifications sont séparées par des
virgules. Par exemple, <(C0I'1C&I1C0I&M( % permet
de répéter le bloc dinstructions cinq fois.

Linstruction <(11&M( % est une boucle infinie dont on ne pourra
sortir que par une instruction -+V.
5. Les boucles imbriquées
Les boucles peuvent être imbriquées les unes dans les autres. Une boucle
W/+ peut contenir une autre boucle W/+, une autre boucle 363+, ou
une autre boucle L(/, 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.
Lalgorithme suivant permet dafficher les tables de multiplication de jusquà
' :
!(
)*+-(/ + J
*-
W/++

-+

+
0D1
23-/
'.& 1
&'.&. +H,/
D& 1
W/+D&'73-/

+
0==0D0==0
D1
D&D 1
#

#

Lorganigramme correspondant à lalgorithme précèdent est le suivant :
77

Les boucles .

V
050 5&+
LH
V
@
LH 5&+
050
1 > FCJCFFCHCF J?
V=
V=
Programme C :
:
/7+& 7
(9)%
*

;

0D1
<(
1
&'1
;
D1
8)
+D&';
6
<=>7>7>7E=0
0D0
D1
DD1
@
@
@
6.1. Exercices
Exercice 1 :
Ecrire des algorithmes permettant de calculer la somme de la suite des nombres
(n est un entier positif lu à partir du clavier) en utilisant les
boucles W/+, 363+ et L(/. Représentez chaque algorithme par
lorganigramme correspondant.
Exercice 2 :
Ecrire un algorithme qui calcule la factorielle dun nombre entier n strictement
positif, sachant que :

, et que 0! = 1. Traduire lalgorithme en
C.
Exercice 3 :
Ecrire un algorithme qui calcule la nième puissance entière dun entier x par
multiplications successives du nombre par lui-même. Traduire lalgorithme en
C.
78

Les boucles .
Exercice 4 :
Ecrire un algorithme qui demande à lutilisateur un nombre compris entre 1 et 3
jusquà ce que la réponse convienne. Traduire lalgorithme en C.
Exercice 5 :
Ecrire un algorithme qui demande un nombre de départ, et qui ensuite affiche
les dix nombres suivants. Traduire lalgorithme 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 lalgorithme 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 lalgorithme en C.
Note : Le PGCD peut être calculer en utilisant lalgorithme itératif dEuclide
qui prend dabord le reste de la division de m par n, puis le reste de la division
de n par ce premier reste, etc., jusquà ce quon 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) à lutilisateur, par
lintermédiaire dune sorte de menu à choix multiple, dafficher la valeur
minimale, la valeur maximale, la somme ou la moyenne des nombres entrés, ou
encore de quitter le programme. Traduire lalgorithme en C.
Exercice 9 :
Ecrire un algorithme permettant de lire la suite des prix des achats dun client
(en dinars entiers positifs). La suite se termine par un zéro. Lalgorithme doit
permettre de calculer la somme quil doit, lire la somme quil paye, et simuler
la remise de la monnaie en affichant les textes « 10 DA », « 5 DA » et « 1 DA »
autant de fois quil y a de coupures de chaque sorte à rendre. Traduire
lalgorithme 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.
Exercice 11 :
Ecrire un programme C permettant dafficher un triangle rempli détoiles,
sétendant sur un nombre de lignes lu à partir du clavier, et se présentant
comme dans cet exemple :
7:

Les boucles .
2(+A+(*-+7+
+ 5

Exercice 12 :
1. Que fait le programme C suivant ?
:
/7+& 7
(9)%
*

;

C1
8)
+;
<=>7=0?C1

<C-+V1
@
@
2. Que devient-il si on enlève linstruction -+V ?
3. Que se passe t-il si on remplace 8)
+ par 8)
+' ?
6.2. Corrigés
Solution 1 :
Algorithmes :
Algorithme Tant que :
!(
)*+ (**+J /
+

-+

+
00 (**+1
23-/

+=2(+A/(*-+5=1
4
+1
,
%'73-/

&1
.& 1
W/+
&73-/

&
.1
.&.
<

+=4 (**+7+ /
+=0 (**+1
<

,
(
+=4+(*-+7(
\+6(

<9=1
#

Algorithme Répéter :
!(
)*+ (**+J /
+

-+

+
00 (**+1
23-/

+=2(+A/(*-+5=1
4
+1
8

Les boucles .
,
%'73-/

&1
.& 1
363+
73-/

&
.1
.&.
<

D/ W/_
%1

+=4 (**+7+ /
+=0 (**+1
#

,
(
+=4+(*-+7(
\+6(

<9=1
#

Algorithme Pour :
!(
)*+ (**+J /
+

-+

+
00 (**+1
23-/

+=2(+A/(*-+5=1
4
+1
,
%'73-/

&1
'.& 1
&.&.
&
.1

+=4 (**+7+ /
+=0 (**+1
<

,
(
+=4+(*-+7(
\+6(

<9=1
#

8

Les boucles .
Organigrammes :
Organigramme Tant que :

1 >C
EC?
$ >?
5&+ 0
I
V
V 1 >C$
B
. C?
5&+ 0
LH
V= 1 >C$

HCF?
V=
@

8!

Les boucles .
Organigramme Répéter :

1 >C
EC?
$ >?
5&+ 0
I
V
V 1 >C$
B
. C?
V=
V=
0 5&+
I
1 >C$
HCF?
@

8#

Les boucles .
Organigramme Pour :

1 >C
EC?
$ >?
5&+ 0
I
V
1 >C$
B
V . C?
5&+ 050
LH
V=
1 >C$
V= HCF?
@

Solution 2 :
Algorithme :
!(
)*+< (
++

-+

+
00< (
++1
23-/

+=+A/(*-+5=1
4
+1
,
&'

+=4< (
++7F/(*-+3
<F+C
+6 9=
,
(73-/
%&/.

& 1
'.& .!C*.&. %&/.

&%&/.

.1

+=4< (
++7+=00==0< (
++1
<

#

Programme C :
:
/7+& 7
(9)%
8%

Les boucles .
*

;

00< (
++1
6
<=+A/(*-+5=1
<=>7=0?1

<&'
6
<=4< (
++7F/(*-+3
<F+C
+6 9=1
+ +;
< (
++1
<(
1
&1
< (
++< (
++
1
6
<=4< (
++7+>7>7=00< (
++1
@
@
Solution 3 :
Algorithme :
!(
)*+6/
+

-+

+0
1
3+C06/
1
23-/

+=3. / 2. . =1

+="(7/
+A+(*-+3+C5=1
4
+C1

+="(7/
+AF+C6( 7+C+
+6(

<5=1
4
+1
-.&
.&
W/+
&73-/
-.&-.81
.&. 1
<

+=46/
+=00=
B*+7+=0C0=+ =06/
1
#

Programme C :
:
/7+& 7
(9)%
*

;

0
1
<(C06/
1
6
<=3. / 2. . E=1
6
<="(7/
+A+(*-+3+C5=1
<=><=0?C1
6
<="(7/
+AF+C6( 7+C+
+6(

<5=1
<=>7=0?1
6/
1

1
8)
+
&;
6/
6/
C1

1
8'

Les boucles .
@
6
<=46/
+>7
B*+7+><+ ><=00C06/
1
@
Solution 4 :
Algorithme :
!(
)*+.+/JJ

-+

+1
23-/
363+
73-/

+=+A/(*-++++5=1
4
+1
,
&%

+=,

++(3+9 + (**+ +AR=1
,
(
+=(*-+ +639=1
<

`/ W/_%&1
#

Programme C :
Comme il nexiste pas une structure qui correspond exactement à la boucle
363+en C, nous allons utiliser linstruction +I9.
comme suit :
:
/7+& 7
(9)%
*

;

1
7(;
6
<=+A/(*-++++5E=1
<=>7=0?1

<&SS%
6
<=,

++(3+9 + (**+ +ARE=1
+ +6
<=(*-+ +639=1
@
8)
+&SS%1
@
Solution 5 :
Algorithme :
!(
)*+<<
)+J'J /
.

-+

+0
1
23-/

+=+A/(*-+5=1
4
+1

+=4+ '(*-+ /
. (5=1
'.&* 1
&'.&. &.
.1
#

Programme C :
86

Les boucles .
:
/7+& 7
(9)%
*

;

0
1
6
<=+A/(*-+5=1
<=>7=0?1
6
<=4+ '(*-+ /
. (5E=1
<(
1
&'1
6
<=>7E=0
1
@
Solution 6 :
Algorithme :
!(
)*+-+J*/
6

(

-+

+0
1
23-/

+=+A/(*-+5=1
4
+1

+=4-+7+*/
6

(7+=00=+ 5=1
'.& .!C .&. &.
*EJ8JE.EJCJE*.1
#

Programme C :
:
/7+& 7
(9)%
*

;

0
1
6
<=+A/(*-+5=1
<=>7=0?1
6
<=4-+7+*/
6

(7+>7+ 5E=01
<(
1
&'1
6
<=>7C>7>7E=00
0
1
@
Solution 7 :
Algorithme :
!(
)*+L/ JZ7J2
.
+/JK(**/

-+

+*000-00LZK21
23-/

+C0"A32
C1

+="(7/
+A+6+*
+(*-+5=1
4
+*1

+="(7/
+A+7+/C
B*+(*-+5=1
4
+1
&
,&*
&>,
W/+'73-/
&,
,&1
&>,
87

Les boucles .
<

'K5F&,1

+=4+LZK27+=0*0=+=00=+ =0LZK21
#

Programme C :
:
/7+& 7
(9)%
*

;

*000-00LZK21
6
<C0"A32
MC1
6
<="(7/
+A+6+*
+(*-+5=1
<=>7=0?*1
6
<="(7/
+A+7+/C
B*+(*-+5=1
<=>7=0?1
*1
-1
>-1
8)
+R';
-1
-1
>-1
@
LZK2-1
6
<=4+LZK27+>7+>7+ >7=0*00LZK21
@
Solution 8 :
Algorithme :
!(
)*+ / J*+/

-+

+
0 )(
C1
3+ 00*(I++0*

*/*0*C
*/*1
23-/

+=+A / +
.+*+7+ (*-+ 6(

< 9=1

+=+A/(*-+3
<6(/<

9=1
4
+1
,
%'73-/
&*1
.*.&*1
8.&*1
.& 1
363+
73-/
4
+1
,
%'73-/
B.*!.*..*.&*1
B.*8.8.&*1
&*1
.&. 1
<

88

Les boucles .
<

D/ W/_&'1
)
**
&$.1
363+
73-/

+=K)(

+A++5=1

+=5*

*/*=1

+=5*C
*/*=1

+=5 (**+=1

+=5*(I++=1

+='5 (6=1

+=+A.(+ )(
C5=1
4
+ )(
C1
K )(
C
73-/
5
+=4+*

*/*+ 5=0*

*/*1
5
+=4+*C
*/*+ 5=0*C
*/*1
5
+=4 (**++ 5=0 1
5
+=4*(I+++ 5=0*(I++1
'5
23</5
+=K)(
C( +639=1
<

<

`/ W/_ )(
C'1
<

#

Programme C :
:
/7+& 7
(9)%
*

;

0 )(
C1
<( 00*(I++0*

*/*0*C
*/*1
6
<=+A / +
.+*+7+ (*-+ 6(

< 9E=1
6
<=+A/(*-+3
<6(/<

9E=1
<=><=0?1

<%';
1
*

*/*1
*C
*/*1

1
7(
;
<=><=0?1

<%';

<&*

*/**

*/*1

<%*C
*/**C
*/*1
1

1
@
8:

Les boucles .
@
8)
+%'1
*(I++
1
7(
;
6
<=K)(

+A++5E=1
6
<=5*

*/*E=1
6
<=5*C
*/*E=1
6
<=5 (**+E=1
6
<=5*(I++E=1
6
<='5 (6E=1
6
<=+A.(+ )(
C5=1
<=>7=0? )(
C1
8
) )(
C
;
+56
<=4+*

*/*+ 5><E=0*

*/*1
-+V1
+56
<=4+*C
*/*+ 5><E=0*C
*/*1
-+V1
+56
<=4 (**++ 5><E=0 1-+V1
+56
<=4*(I+++ 5><E=0*(I++1
-+V1
+'5-+V1
7+</56
<=K)(
C( +639E=1
@
@
8)
+ )(
CR'1
@
@
Solution 9 :
Algorithme :
!(
)*+! )

-+

+6
C0 (**+0]0 + +0-'20-20-21
23-/

&1

+=2(+A+ 6
C0++*
+A6/'5=1
363+
73-/

+=+A/6
C5=1
4
+6
C1
,
6
C
&
-.81
<

`/ W/F_6
C'1

+=(/ 7+.+A5=0 (**+0=2!=1

+=](.+ 35=1
4
+]1
1
/
&L (**+1
:

Les boucles .
M, F&1
/
$ 1
M,F&1
/
> $1
M, F&1
/
>

+= +*
+7+*(
+5=1

+=L
B + 7+'2!5=0-'21

+=L
B + 7+2!5=0-21

+=L
B + 7+25=0-21
#

Programme C :
:
/7+& 7
(9)%
*

;

6
C0 (**+0]0 + +0-'20-20-21
(**+'1
6
<=2(+A+ 6
C0++*
+A6/'5E=1
7(
;
6
<=+A/6
C5=1
<=>7=0?6
C1

<6
C%' (**+ (**+6
C1
@
8)
+6
CR'1
6
<=(/ 7+.+A5>72!E=0 (**+1
6
<=](.+ 35=1
<=>7=0?]1
+ +] (**+1
-'2 + +'1
-2 + +>'1
-2 + +>1
6
<= +*
+7+*(
+5E=1
6
<=L
B + 7+'2!5>7E=0-'21
6
<=L
B + 7+2!5>7E=0-21
6
<=L
B + 7+25>7E=0-21
@
Solution 10 :
Algorithme :
!(
)*+<
-(

-+

+0<
-(06+7'06+70
1
23-/

+=2(+A/+
+5=1
4
+1
B.*C%.,&1
B.**B.*C %.,& 1
,
(,
%73-/
-
+&
-
+ &
'.&1
&.&. +H,/
%.,&-
+-
+
:

Les boucles .
-
+&-
+
-
+ &%.,
<

<

+=#
-(
=00==0<
-(1
#

Programme C :
:
/7+& 7
(9)%
*

;

0<
-(06+7'06+70
1
6
<=2(+A/+
+5=1
<=>7=0?1

<'<
-('1
+ +
<<
-(1
+ +
<%;
6+7''1
6+71
<(
1
&1
;
<
-(6+7'6+71
6+7'6+71
6+7<
-(1
@
@
6
<=#
-(
>7>7=00<
-(1
@
Solution 11 :
Programme C :
:
/7+& 7
(9)%
*

;

0
0D1
6
<=2(+A+(*-+7+
+ 5=1
<=>7=0?1
<(
1
&1
;
<(D1D&
1D6
<==1
6
<=E=1
@
@
Solution 12 :
1. Le programme permet de lire une série de valeurs, jusquà introduire la
valeur 1.
2. Boucle infinie.
3. Le bloc nest 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 dautres
types dits structurés (complexes). Un type structuré est tout type défini à base
dautres types. Commençant par le type quon 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 dun ensemble
déléments de même type de données.
Format général : I6+J7(3+ (*J-X
+J-Y1
Un tableau possède un nom ((*J-). Il est aussi caractérisé par sa taille, i.e.
le nombre déléments ou encore le nombre de cases (
+J-). Le type des
éléments du tableau est indiqué par I6+J7(3+ .
Par exemple, pour déclarer un tableau (+ de dix éléments réels, on met :
3+(+X'Y1
Cet exemple nous a permis de substituer la déclaration de 10 variables (+',
(+ 6 (+ de type 3+ par une seule structure, à savoir le tableau
(+.
En C, on écrit : <((+X'Y1
La capacité dun tableau (le nombre déléments que peut contenir un tableau)
ne peut pas être changée au cours dexécution dun 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 :
:7+<
+
+J-'
*

;
<((+X
+J-Y1
6
Remarques :
S Les cases dun tableau sont numérotées de ' à
+J- en langage
C.
S Le nom du tableau désigne ladresse où débute le tableau en mémoire, i.e.
(+ est équivalent à ?(+X'Y.
S Le nom du tableau ne peut pas figurer à gauche dune affectation (lvalue).
S Si vous utilisez le tableau hors de ses limites, il ny aura pas derreur de
compilation. On appelle ça, débordement ou dépassement de tableau. Cest
lun des bugs de la programmation en C.
S Pour la manipulation des tableaux, on utilise fréquemment les boucles.
:#

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

par le nombre de valeurs énumérées dans linitialisation. Par exemple,
<( (+XY ;'90 @ 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
(+, avec 10 éléments, peut être représenté comme suit :
0
,
1
6
5
7
<
9
8
*
Un élément du tableau est accessible par sa position (indice) dans le tableau. Le
tableau (+ est un tableau à une seule dimension, là où chaque élément est
accessible par un seul indice. Par exemple, M/
NO&6 permet daffecter
la valeur '9 à la première case du tableau. Le tableau (+ devient:
0 0)17
,
1
6
5
7
<
9
8
*
Lindice peut être exprimé directement comme un nombre en clair. Il peut aussi
correspondre à une valeur dune variable ou à une expression calculée.
:%

Soit par exemple : En C :

!(
)*++C+J- *

-+ ;

+XY1
XY1

+$1
$1
23-/ $1
& X'Y1
NO&P X$Y[1
NO& < X$Y1
X$ O& @
#

Après lexécution des opérations de lalgorithme, le tableau peut être
représenté comme suit :
0 9
, 5
1 ,8
6
5
Une représentation plus proche à la réalité est la suivante : (Voir encore la
section 2 du chapitre 2)
!3!(#
0**8
0*** ,000
C0D ,000 9
C,D ,00, 5
C1D ,001 ,8
C6D ,006
C5D ,005
,007
Avec, le contenu de la case correspond à ?X'Y qui est égale à '''; le nom
du tableau est donc un pointeur vers le premier élément (contient son
adresse).
:'

Remarques :
NEn C, lindice peut être aussi de type caractère, compte tenu des règles de
conversion implicite. Par exemple, XF!FHY est équivalent à XY.
NLorsquon applique
A+(< à une variable de type tableau, lopérateur
renvoie lespace mémoire total que ce tableau occupe, i.e. son nombre
déléments multiplié par lespace mémoire occupé par un seul élément.
Exercice 1 : (Création, initialisation et édition dun tableau)
Problème : Ecrire un algorithme permettant de créer un tableau de dix entiers,
dinitialiser ses éléments à ', ensuite de les afficher. Traduire lalgorithme en
C.
Solution :
!(
)*+

J-

-+

+X'Y1

+
1
23-/
'.&.!C;.&. N.O&1
'.&.!C;.&. &.
N.O1
#

Le programme C :
:
/7+& 7
(9)%
*

;

X'Y1

1
<(
'1
&1
X
Y'1
<(
'1
&1
6
<=>7E=0X
Y1
@
Ou bien :
:
/7+& 7
(9)%
*

;

X'Y;'0'0'0'0'0'0'0'0'0'@0
1
<(
'1
&1
6
<=>7E=0X
Y1
@
Exercice 2 : (Création, lecture et affichage dun 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
lalgorithme en C.
Solution :
!(
)*+
+J-

-+

+X'Y1

+
1
23-/
:6

'.&.!C;.&. Q.

N.O1
'.&.!C;.&. &
+X
Y1
#

Le programme C :
:
/7+& 7
(9)%
*

;

X'Y1

1
<(
'1
&1
<=>7=0?X
Y1
<(
'1
&1
6
<=>7E=0X
Y1
@
Exercice 3 : (Recherche dans un tableau)
Problème : Ecrire un algorithme permettant la recherche dun nombre lu à
partir du clavier dans un tableau de dix réels. Traduire lalgorithme 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 à #!$ (drapeau baissé), et qui
aura la valeur !" dès quun événement attendu se produit (drapeau levé). La
technique de Flag peut être utilisée dans le problème de recherche et dans
nimporte 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. Sils 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 sarrête
quand il ne reste plus de place là où rechercher, et on déclare que le nombre
recherché nexiste pas dans le tableau.
Algorithme de la recherche en utilisant la technique de Flag :
!(
)*+ + )+ )+J#

-+
3+]M ,X'Y1
3+M 1
M((3+#1

+
1
23-/

+=+A+ 33*+ 7/-+/5=1
'.&.!C;.&. Q.
MRLS1BN.O1

+=+A+(*-+_+ )+ )+5=1
:7

4
+M 1
7 3&70T1
'.&.!C;.&. B.MRLS1BN.OCMS17 3&210(1
,
#
+M 0=<
6
+7/-+/9=1
,
(
+M 0=+<
6 6
+7/-+/9=1
#

Programme C :
:
/7+& 7
(9)%
*

;
<(]M ,X'Y1
<(M 1

#1

1
6
<=+A+ 33*+ 7/-+/5E=1
<(
'1
&1
<=><=0?]M ,X
Y1
6
<=+A+(*-+_+ )+ )+5=1
<=><=0?M 1
#'1
<(
'1
&1

<]M ,X
YM #1

<#6
<=><<
6
+7/-+/9=0M 1
+ +6
<=><+<
6 6
+7/-+/9=0M 1
@
Linconvénient du programme précédent est que la recherche continue jusquau
dernier élément, même si lélément recherché a été trouvé auparavant. Un
programme optimisé est donc le suivant :
:
/7+& 7
(9)%
*

;
<(]M ,X'Y1
<(M 1

#1

1
6
<=+A+ 33*+ 7/-+/5E=1
<(
'1
&1
<=><=0?]M ,X
Y1
6
<=+A+(*-+_+ )+ )+5=1
<=><=0?M 1
#'1

'1
8)
+
&??R#

<]M ,X
YM #1
+ +
1

<#6
<=><<
6
+7/-+/9=0M 1
+ +6
<=><+<
6 6
+7/-+/9=0M 1
@
Algorithme de la recherche dichotomique :
!(
)*+ + )+ )+J7
)((*
W/+

-+
:8

3+]M ,X'Y1
3+M 1
M((3+ 1

+
0,/60"<0]

+/1
23-/

+=+A+ 33*+
3 7/-+/5=1
'.&.!C;.&. Q.
MRLS1BN.O1

+=+A+(*-+_+ )+ )+5=1
4
+M 1
B-&;1
(*%&1
1RT2&70T1
W/+ ,/6%"<73-/
L. .
&B-(*%$1
B.MS1CMRLS1BNL. .
O 1RT2&210(1
B.**B.MS1!MRLS1BNL. .
OB-&L. .
1
B.**(*%&L. .
1
#

,

+M 0=+C
+7 +-+/9=1
,
(
+M 0=F+C
+6 7 +-+/9=1
#

Programme C :
:
/7+& 7
(9)%
*

;
<(]M ,X'Y1
<(M 1

1

0,/60"<0]

+/1
6
<=+A+ 33*+
3 7/-+/5E=1
<(
'1
&1
<=><=0?]M ,X
Y1
6
<=+A+(*-+_+ )+ )+5=1
<=><=0?M 1
,/61
"<'1
'1
8)
+R ??,/6%"<;
]

+/,/6"<1

<M ]M ,X]

+/Y 1
+ +
<M &]M ,X]

+/Y,/6]

+/1
+ +"<]

+/1
@

< 6
<=><+C
+7 +-+/9=0M 1
+ +6
<=><+C
+6 7 +-+/9=0M 1
@
Remarque : On note que la recherche dichotomique contient la technique de
Flag, car on a besoin dun test darrêt au cas où lélément recherché est trouvé.
::

2.2. Tri d¶un tableau

Problème : Soit un tableau de N entiers rangés nimporte 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 dun tableau consiste à mettre en bonne position le premier
élément, cest-à-dire le plus petit, puis, on met en bonne position lélément
suivant, et ainsi de suite, jusquau dernier.
!(
)*+
J-J6J ++
(

-+

+X'Y1

+C0
0D1
23-/

+=2(+A+ 33*+ 7/-+/5=1
'.&.!C;.&. Q.
N.O1
'.&.!C<.&.
'D&. D!C;D&D B. N.O NDO+H,/
8& N.O1
N.O& NDO1
NDO&81
<

+=(

+ 33*+ 7/-+/
35=1
'.&.!C;.&. &.
N.O1
#

Programme C :
:
/7+& 7
(9)%
*

;
X'Y1

C0
0D1
6
<=2(+A+ 33*+ 7/-+/5E=1
<(
'1
&1
<=>7=0?X
Y1
<(
'1
&[1

<(D
1D&1D
<X
Y%XDY;
CX
Y1
X
YXDY1
XDYC1
@

6
<=(

+ 33*+ 7/-+/
35E=1
<(
'1
&1
6
<=>7E=0X
Y1
@
Algorithme de tri à bulles :
Lidée de départ du tri à bulles consiste à se dire quun tableau trié en ordre
croissant est un tableau dans lequel tout élément est plus petit que celui qui le
suit.
!(
)*+
J-J-/+

-+

+X'Y1

+
0C1
M((3+L+*/1
23-/

+=2(+A+ 33*+ 7/-+/5=1
'.&.!C;.&. Q.
N.O1
363+
73-/
'
/&70T1
'.&.!C<.&. B. N.O N. O+H,/
8& N.O1
N.O& N. O1
N. O&81
'
/&210(1
<

<

`/ W/_(L+*/1

+=(

+ 33*+ 7/-+/
35=1
'.&.!C;.&. &.
N.O
#

Programme C :
:
/7+& 7
(9)%
*

;

X'Y1

0C1

L+*/1
6
<=2(+A+ 33*+ 7/-+/5E=1
<(
'1
&1
<=>7=0?X
Y1
7(
;
L+*/'1
<(
'1
&[1

<X
Y%X
Y;
CX
Y1
X
YX
Y1
X
YC1
L+*/1
@
@

8)
+L+*/1
6
<=(

+ 33*+ 7/-+/
35E=1
<(
'1
&1
6
<=>7E=0X
Y1
@
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 :
I6+J7(3+ (*J-X
+J7
*YX
+J7
*Y1
Où
+J7
* et
+J7
* représentent respectivement la taille de la
première et la deuxième dimension.
Lexemple suivant permet de déclarer un tableau de réels nommé (+ à deux
dimensions 3 * 5 :
3+(+XYXY1
En C, on écrit : <((+XYXY1
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 (+ à deux dimensions
Dans ce cas-là, un élément du tableau est accessible par deux indices. Par
exemple, si on met M/
NONO&6 et M/
N ONO&P6P, le tableau (+
devient :
'
' '9
9

Remarques :
NOn peut déclarer et initialiser au même temps un tableau à deux dimensions
comme suit :
<( (+XYXY ;;'90 0 0 H0 9@0 ;0 '0 0 9H0
9@0;'9H0H0'09H0@@1
ou bien :
<( (+XYXY ;'90 0 0 H0 90 0 '0 0 9H0 90
'9H0H0'09H0@1
NLes 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, <((+XYXYXYXY1
NOn utilise parfois le terme vecteur pour désigner un tableau à une
dimension, et le terme matrice pour désigner un tableau à deux dimensions.
N(+ contient ladresse du premier élément, i.e., (+ est équivalent à
?(+X'YX'Y. En plus, les notations suivantes sont équivalentes : (+X'Y
et ?(+X'YX'Y, (+XY et ?(+XYX'Y, (+XY et ?(+XYX'Y.
!

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 dun tableau de caractères
de longueur fixe. Dans ce tableau, le caractère FE'F, correspondant à la valeur
', indique la fin de la chaîne de caractères.
Ainsi : ) )XY permet denregistrer une chaîne de 14 caractères
maximum (15- 1 pour le 0 indiquant la fin de la chaîne).
En C, avec ) )XY=-(D(/=, la chaîne de caractères ) peut être
représentée de la manière suivante :
' H [ '
- ( D ( / E'
Ceci est équivalent à : ) )XY;F-F0F(F0FF0FDF0F(F0F/F0
FF0FE'F@1
Remarques :
NDans dautres langages, tels que Pascal et Java, une chaîne de caractères est
déclarée par le mot clé ,
.
NEn C, une chaîne constante doit être mise entre deux guillemets doubles
pour la distinguer dun identificateur de variable, comme déjà vu pour la
chaîne =-(D(/=.
NComme 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 dautres 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.
NIl est possible de déclarer une chaîne de caractères sans spécifier la longueur
de départ de la façon suivante : ) )XY=!)*+7=. De cette façon, la
chaîne fera exactement la longueur nécessaire pour stocker !)*+7 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 saffiche grâce à la fonction 6
< et le format > .
Ainsi, 6
<=> =0 ) affiche : -(D(/
Remarques :
N6
< appartient à la bibliothèque 7
(9). Si on utilise 6
< sans
spécifier la bibliothèque 7
(9), le compilateur C signale un [Warning].
NRappelons que 6/ ) est équivalente à 6
<=> E=0 ).
#

NLa fonction 6/ , elle aussi, appartient à la bibliothèque 7

(9).
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, 6
<=> =0 )XY affiche :
Longueur d¶une chaîne de caractères :
La longueur dune chaîne de caractères sobtient par la fonction +
(appartenant à la bibliothèque
9)). Le ' de fin de chaîne nest pas
compté dans cette longueur.
Ainsi, 6
<=>7=0 + ) affiche :
Affectation :
Pour affecter une valeur à une variable chaîne de caractères, il est possible
dutiliser la fonction 6I& %0&%. Cette fonction nous impose dajouter
le fichier den-tête
9):
Ainsi, 6I )0=!
=affecte la valeur =!
= à la chaîne ).
Remarques :
N La chaîne & % doit être suffisamment grande pour accueillir &%. Si on ne
respecte pas cette règle, la réaction du programme dépond du compilateur
C utilisé.
N Laffectation )=!
= nest 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 6I& %0&%0 fait le même travail que 6I, sauf
quelle se limite au premiers caractères de &%. Si dépasse la longueur de
&%, alors le FE'F de &% sera aussi copier dans & %, et 6I devient
équivalente à 6I.
Ainsi, 6I )0 0 remplace les deux premiers caractères de ) par les
deux premiers de .
Lecture :
Si lon souhaite lire une chaîne directement au clavier, on peut utiliser la
fonction < :
Ainsi, <=> =0 ) permet de lire la chaîne de caractères ) à partir du
clavier.
Remarques :
NNous navons pas mis ? avant ) dans <=> =0 ), car ) lui-même
représente ladresse du premier caractère de la chaîne.
%

N <=> =0? )X'Y ferait la même chose que <=> =0 ).
N < appartient à la bibliothèque 7
(9). Si on utilise < sans
spécifier la bibliothèque 7
(9), le compilateur C signale un [Warning].
NEn utilisant <, la chaîne de caractères saisie ne peut comporter ni
espaces, ni tabulations.
La fonction gets :
La fonction + permet de lire une chaîne de caractères validée par la touche
Entrée. Attention ! La touche Entrée elle-même nest pas enregistrée dans le
tableau de caractères.
Ainsi, + ) permet de lire la chaîne de caractères ) à partir du clavier.
Remarques :
NA la différence de <, la fonction + 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é dutiliser + au lieu de
< pour lire les chaînes de caractères à partir du clavier.
NLa fonction + , elle aussi, appartient à la bibliothèque 7
(9).
La fonction strcat :
La fonction & %0&% de la bibliothèque
9) ajoute la chaîne
&% à la chaîne & % (on appelle cela une concaténation). La taille de & % doit
être suffisamment grande pour contenir aussi le contenu de &%.
Ainsi, )0 ajoute à ).
On peut dire aussi que )0 retourne la concaténation des deux
chaînes ) et .
La fonction strncat :
La fonction & %0&%0 ajoute les premiers caractères de la chaîne
&% à la fin de la chaîne & %.
Ainsi, )0 0 ajoute les deux premiers caractères de à la fin de
la chaîne ).
La fonction strcmp :
La fonction *6& %0&% de la bibliothèque
9) compare les
chaînes de caractères & % et &% de manière lexicographique et fournit un
résultat :
N nul (') si & % est égale à &%.
N négatif () si & % précède &%.
N positif () si & % suit &%.
Ainsi, *6=!!=0=!!= renvoit ', *6=!!=0=MM= renvoit æ, et
*6=MM=0=!!= renvoit .
'

Remarques :
N *6& %0&%0 limite la comparaison aux premiers caractères
des deux chaînes.
N
*6& %0&% 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.
N
*6& %0&%0 combine les deux fonctions *6 et
*6.
Les fonctions sprintf et sscanf :
La fonction :
6
<& )a+
-+%0& )a*
+
%/3
E!
8- E!
8-E
convertit un ou plusieurs nombres en une chaîne de caractères.
Ainsi,

6
< )0=>7=0 permet de convertir lentier en
chaîne de caractères et la stocker dans la variable ). À larrivée, ) contiendra
la chaîne de caractères ==, et
contiendra la longueur de cette chaîne ().
La fonction < fait le contraire.
Ainsi, pour

<=999H=0=><><><=0?0?-0? , les
variables réelles , - et contiendront respectivement 9, 9 et 9H, et
contiendra (le nombre de variables remplies avec succès).

Exemple :
:
/7+& 7
(9)%
:
/7+&
9)%
*

;
) )XY=-(D(/=1
) XY=!)*+7=1
6
<=> E=0 )1
6
<=> E=0 )XY1
)XYFE'F1
6
<=> E=0 )1
6
<=>7E=0 + )1
6I )0=!
=1
6
<=> E=0 )1
)0 1
6
<=> E=0 )1
6I )0 01
6
<=> E=0 )1
)0 01
6
<=> E=0 )1
6
<=>7E=0 *6 )0 1

6
< )0=>7=01
6
<=> >7E=0 )0
1
<(0-0 1

<=999H=0=><><><=0?0?-0? 1
6
<=><><><E=00-0 1
@
6

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 : )-XYX'Y. On accède à
chacune des chaînes en utilisant lélément -X
Y du tableau, et on accède à
nimporte quel caractère j de la chaîne i par -X
YXDY.
4.1. Exercices
Exercice 1 :
Soit lalgorithme :
!(
)*+$

-+

+,/
+XY1
+
1
23-/
B./
NO&B./
N O& 1
'.&1
&H.&.
B./
N.O&B./
N.Y,/
+X
Y1
#

Représentez le tableau ,/
+ après lexécution des opérations de lalgorithme
$.
Exercice 2 :
Ecrire un algorithme, ensuite le programme C, permettant de calculer la
somme, le produit et la moyenne dun tableau de dix réels.
Exercice 3 :
Ecrire un algorithme qui lit un tableau de 10 entiers, et affiche ensuite les
éléments dindice impair. Traduire lalgorithme 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.
7

Exercice 5 :
Ecrire un algorithme permettant laffichage des deux plus petits éléments dun
tableau de dix entiers. Traduire lalgorithme 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
dafficher ce dernier. Traduire lalgorithme en C.
Note : Chaque élément du troisième tableau est calculé par laddition des deux
éléments des tableaux 1 et 2 ayant la même position, comme le montre
lexemple suivant :
Si Tableau 1 contient : , , ', , , , , , , ,
et Tableau 2 contient : , , [, , , , H, H, , ,
alors Tableau 3 va contenir : , , [, H, ', ', , ', , [.
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 lalgorithme en C.
Note : Les nombres consécutifs sont des nombres entiers qui se suivent, comme
par exemple , , , , , H 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 lalgorithme 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 lalgorithme 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 lalgorithme 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 dentiers à deux
dimensions (3*5), dinitialiser ses éléments à zéro, ensuite de les afficher.
8

Exercice 12 :
Soit lalgorithme :
!(
)*+$$

-+

+XYXY1

+V0*1
23-/
'U&1V&U&U
L(/&1*&& NUONO&U1
#

Représentez le tableau après lexécution des opérations de lalgorithme $$.
Exercice 13 :
Ecrire un algorithme permettant de remplir un tableau dentiers à deux
dimensions (3*5) à partir du clavier, et de déterminer le nombre dapparition
dune certaine valeur saisie par lutilisateur. Traduire lalgorithme en C.
Exercice 14 :
Ecrire un algorithme qui calcule la transposée dune matrice dentiers (3*3).
Note : La transposée dune 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 lexemple suivant :
'
La transposée de la matrice : H est :
' H
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 lalgorithme 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
lexemple suivant :
H ' H

'
' ' ' '
Exercices 16 :
En utilisant une boucle <(, écrire un programme C qui remplit un tableau de
10+1 caractères avec les lettres de lalphabet en commençant par F!F (code
ASCII H). Le tableau devra donc contenir ceci :
' H [ '
F!F FMF FKF F2F FF F#F FZF FPF F"F F`F '
Dans le même programme :
N Faites afficher la chaîne de caractères ainsi obtenue ;
:

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

K B+/*3('5!.
K B+/*3(5M.

Exercice 17 :
Quaffiche le programme C suivant si vous saisissez au clavier les deux mots :
=
+ += et =
<(*
W/+= ?
:
/7+& 7
(9)%
:
/7+&
9)%
*
;
) )
+X[Y1[' B+ FE'F
) )
+X[Y1
6
<=+/
+A++.(+ )a+7+ B+ 5=1
+ )
+1
7+
W/+_ <=> =0 )
+1
(/ <=> =0? )
+X'Y1
6I )
+0 )
+1+
(_F(7+RRR
6
<= )a+./5> E=0 )
+1
6I )
+0==1+(6 )
+==1RRRRRRR
)
+0=!)*+7=1
6
<=+/
+A++.(+ )a+7+ B+ 5=1
+ )
+1
)
+0 )
+1
)
+0=]()*+7!
999=1
6
<= )a+./5> E=0 )
+1
@
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 dapparition dun caractère lu à partir du
clavier.
Exercice 20 :
Ecrire un programme C qui supprime toutes les lettres F+F dune 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 dau plus 29 caractères et
qui laffiche à lenvers.
Exercice 22 :
Ecrire un programme C qui calcule la somme des codes ASCII des caractères
dune 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 lindicatif. On admettra que lutilisateur ne fournit

que des verbes réguliers (se terminant par =+=), et quil ne fournira pas des
verbes tels que =*+=.
Tester votre programme avec le verbe = /+=.
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 dun caractère en majuscule est
(/66+ (7+ !,K"" 7/ B+. La fonction de conversion dun
caractère en minuscule est ((8+ (7+!,K""7/ B+. Toutes les
deux appartiennent à la bibliothèque I6+9).
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 tableau,/
+ peut être représenté donc comme suit :
0 0
, ,
1 ,
6 1
5 6
7 7
< 8

Solution 2 :
!(
)*+,(*J](IJL(7/
J-

-+
3+X'Y1

+
1
3+ (**+06(7/
0*(I++1
23-/

+=2(+A+ 33*+ 7/-+/5=1
'.&.!C;.&. Q.
N.O

&
-+./&
'.&.!C;.&. +H,/

&
N.O

-+./&-+./ N.O

<

)
**
&
$

+=4 (**+=0 (**+1

+=4+6(7/
=06(7/
1

+=4*(I++=0*(I++1
#

Programme C :
:
/7+& 7
(9)%
*

;
<(X'Y1

1
<( (**+06(7/
0*(I++1
6
<=2(+A+ 33*+ 7/-+/5E=1
<(
'1
&1
<=><=0?X
Y1
(**+'1
6(7/
1
<(
'1
&1
;
(**+ (**+X
Y1
6(7/
6(7/
X
Y1
@
*(I++ (**+'1
6
<=4 (**+><E=0 (**+1
6
<=4+6(7/
><E=06(7/
1
6
<=4*(I++><=0*(I++1
@
Solution 3 :
Algorithme :
!(
)*+++*+ J
*6

-+

+X'Y1

+
1
23-/

+=2(+A+ 33*+ 7/-+/5=1
'.&.!C;.&. Q.
N.O1

+=(

+ 33*+ 7(F
7
++
*6
5=1
'.&.!C;.&. B..>C &.
N.O1
#

Programme C :
:
/7+& 7
(9)%
*
;

X'Y1

1
6/ =2(+A+ 33*+ 7/-+/5=1
<(
'1
&1
<=>7=0?X
Y1
6/ =(

+ 33*+ 7(F
7
++
*6
5=1
<(
'1
&1

<
>6
<=>7E=0X
Y1
!

@
Solution 4 :
!(
)*+]C]
J-

-+

+X'Y1

+*C0*
06( J*
06( J*C0
1
23-/

+=2(+A+ 33*+ 7/-+/5=1
'.&.!C;.&. 4
+X
Y1
8& NO1
-A8&1
'.& .!C;.&. B.8! N.O+H,/
8& N.O1
-A8&.1
<

.*& NO1
-A.*&1
'.& .!C;.&. B..* N.O+H,/
.*& N.O1
-A.*&.1
<

+C$2 HCF2FC.. CF.N21

+C$ HCF FC.. CF.N 1
#

Programme C :
:
/7+& 7
(9)%
*

;

X'Y1

*C0*
06( J*
06( J*C0
1
6
<=2(+A+ 33*+ 7/-+/5E=1
<(
'1
&1
<=>7=0?X
Y1
*CX'Y1
6( J*C'1
<(
1
&1

<*C&X
Y;
*CX
Y1
6( J*C
1
@
*
X'Y1
6( J*
'1
<(
1
&1

<*
%X
Y;
*
X
Y1
6( J*

1
@
6
<C$2 HD.. DMCF2F.N21
6
<C$ HD.. DCF F.N 1
@
#

Solution 5 :
Algorithme :
!(
)*+]
J-

-+

+X'Y1

+*
0*
0
1
23-/

+=2(+A+ 33*+ 7/-+/5=1
'.&.!C;.&. Q.
N.O
.* & NO
.*& N O
'.&1
&.&.
,
*
%.*+H,/B..* N.O.* & N.O%.*
B.**B..* N.O.*& N.O

+=4+ 7+/C.+/ *

*+ (5=1
,
*
&*

+*
0==0*
1
,
(
+*
0==0*
1
#

Programme C :
:
/7+& 7
(9)%
*

;

X'Y1

*
0*
0
1
6
<=2(+A+ 33*+ 7/-+/5E=1
<(
'1
&1
<=>7=0?X
Y1
*
X'Y1
*
XY1
<(
1
&1

<*
%*
;
<*
%X
Y*
X
Y1@
+ +
<*
%X
Y*
X
Y1
6
<=4+ 7+/C.+/ *

*+ (5E=1

<*
&*
6
<=>7>7=0*
0*
1
+ +6
<=>7>7=0*
0*
1
@
Solution 6 :
Algorithme :
!(
)*+,(**+J-

-+

+X'Y0X'Y0X'Y1

+
1
23-/

+=2(+A+ 33*+ 7/
+-+/5=1
'.&.!C;.&. Q.
N.O1

+=2(+A+ 33*+ 7/
B*+-+/5=1
'.&.!C;.&. Q.
N.O1
'.&.!C;.&. "N.O& N.O N.O1

+=(

+-+/,(**+5=1
%

'.&.!C;.&. &.

"N.O1
#

Programme C :
:
/7+& 7
(9)%
*

;

X'Y0X'Y0X'Y1

1
6
<=2(+A+ 33*+ 7/
+-+/5E=1
<(
'1
&1
<=>7=0?X
Y1
6
<=2(+A+ 33*+ 7/
B*+-+/5E=1
<(
'1
&1
<=>7=0?X
Y1
<(
'1
&1
X
YX
YX
Y1
6
<=(

+-+/,(**+5E=1
<(
'1
&1
6
<=>7E=0X
Y1
@
Solution 7 :
Algorithme :
!(
)*+(*-+ J ( + /
<

-+

+XY1

+
1
M((3+K( 1
23-/

+=+A+ .+/ 5=1
'.&1
&H.&. +H,/

+=+A+(*-+b=0
0=5=1
4
+X
Y1
<

5*&210(1
'.&1
&.&.
,
X
Y&%X
Y 5*&70T1
,
K(
+=4+ (*-+ ( ( 3 /
< 9=1
,
(
+=4+ (*-+ + (6 ( 3 /
< 9=1
#

Programme C :
:
/7+& 7
(9)%
*

;

XY1

1

K( 1
6
<=+A+ .+/ 5E=1
<(
'1
&H1
;
6
<=+A+(*-+b>75=0
1
<=>7=0?X
Y1
@
K( 1
'

<(
'1
&1

<X
YRX
YK( '1

<K( 6
<=4+ (*-+ ( ( 3 /
< 9=1
+ +6
<=4+ (*-+ + (6 ( 3 /
< 9=1
@
Cette solution est sans doute la plus spontanée, mais elle présente le défaut
dexaminer la totalité du tableau, même lorsquon découvre dès le départ deux
éléments non consécutifs. Aussi, dans le cas dun 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 L(/ par la boucle W/+ suivante :
.&1
W/+K(
&
,
X
Y&%X
Y 5*&70T1
B.**.&. 1
En C :

'1
8)
+K( ??
&

<X
YRX
YK( '1
+ +

1
Solution 8 :
Algorithme :
!(
)*+#
-(

K( +
*C'1

-+

+<
-(X*CY1

+0
1
23-/

+=2(+A/+
+5=1
4
+1
,
&*C73-/
%.,NO&
%.,N O&
'.&.!C*.&.
%.,N.O&%.,N.Y<
-(X
Y1

+=#
-(
=00==0<
-(XY1
<

#

Programme C :
:
/7+& 7
(9)%
:7+<
+*C'
*

;

<
-(X*CY1

0
1
6
<=2(+A/+
+5=1
6

<=>7=0?1

<&*C;
<
-(X'Y'1
<
-(XY1
<(
1
&*C1
<
-(X
Y<
-(X
Y<
-(X
Y1
6
<=#
-(
>7>7=00<
-(XY1
@
@
Solution 9 :
Algorithme :
!(
)*+,/66
*+J++*+J-

-+

+X'Y1

+
0D1
23-/

+=,

+ 33*+ 7F/-+/7+7
C+
+ 5=1
'.&.!C;.&. Q.
N.O

+C. ,.. >. :?EC1
4
+D1
'.&D1
&.&. N.O& N. O
N;O&1

+C$
./.. CF1
'.&.!C;.&. &.
N.O
#

Programme C :
:
/7+& 7
(9)%
*

;

X'Y1

0D1
6
<=,

+ 33*+ 7F/-+/7+7
C+
+ 5E=1
<(
'1
&1
<=>7=0?X
Y1
6
<C. ,.. >. :?EC1
<=>7=0?D1
<(
D1
&[1
X
YX
Y1
XY'1
6
<C$
./.. DMCF1
<(
'1
&1
6
<=>7E=0X
Y1
@
Solution 10 :
Algorithme :
!(
)*+VJ6+*
+
K( + V'1

-+

+XVY1

+
0-0
71
M((3+L+*
+1
23-/
7

.*+&1
*,&1
W/+
7&V73-/
'
.
&210(1
.&1
W/+
&-L+*
+
,
->
&%'
.
&70T1
B.**.&. 1
,
L+*
+73-/
X
7O&*,1
.*+&.*+ 1
<

*,&*, 1
<

+=4+ =0V0=6+*
+ (*-+ 6+*
+ (5=1
'.&1
&V.&. &.
N.O1
#

Programme C :
:
/7+& 7
(9)%
:7+<
+V'
*
;

XVY1

0-0
71

L+*
+1

7'1
-1
8)
+
7&V;
L+*
+1

1
8)
+
&-??L+*
+

<->
'L+*
+'1
+ +

1

<L+*
+;
X
7Y-1

7
71
@
--1
@
6
<=4+ >76+*
+ (*-+ 6+*
+ (5E=0V1
<(
'1
&V1
6
<=>7E=0X
Y1
@
Solution 11 :
Algorithme :
!(
)*+"
J*
+

-+

+XYXY1

+
0D1
23-/
'.&1
&.&.
8

'D&1D&D&D N.ONDO&1

+=(

*
+

3+5=1
'.&1
&.&.
'D&1D&D&D &.
N.ONDOE==1
#

Programme C :
:
/7+& 7
(9)%
*

;

XYXY1

0D1
<(
'1
&1

<(D'1D&1DX
YXDY'1
6/ =(

*
+

3+5=1
<(
'1
&1
;
<(D'1D&1D6
<=>7=0X
YXDY1
6
<=E=1
@
@
Solution 12 :
Cet algorithme remplit un tableau dentiers à deux dimensions 4*2, de la
manière suivante :
X'0'Y '1 X'0Y 1 X0'Y 1 X0Y 1 X0'Y
1X0Y1X0'Y1X0Y1
Le tableaupeut être représenté donc comme suit :
'
' '

Solution 13 :
Algorithme :
!(
)*+-J66

-+

+XYXY1

+
0D0C0-1
23-/

+=2(+A+ .+/ 7+*
+5=1
'.&1
&.&.
'D&1D&D&D Q.
N.ONDO1

+C
O.. EC1
4
+C1
*,&1
'.&1
&.&.
'D&1D&D&D
B.8C N.ONDO0 *,&*, 1

+C$
O.. CF2FC HCF
1
:

#

Programme C :
:
/7+& 7
(9)%
*

;

XYXY1

0D0C0-1
6
<=2(+A+ .+/ 7+*
+5E=1
<(
'1
&1
<(D'1D&1D <=>7=0?X
YXDY1
6
<C
O.. EC1
<=>7=0?C1
-'1
<(
'1
&1

<(D'1D&1D
<CX
YXDY--1
6
<C$
O.. D HDCF2F
1
@
Solution 14 :
Algorithme :
!(
)*+ 6( ++J*
+

-+

+XYXY1

+
0D0C1
23-/

+=2(+A+ 33*+ 7+*
+5=1
'.&.!C.&.
'D&D!CD&D Q.
N.ONDO

+=]
+

+5=1
'.&.!C.&.
'D&D!CD&D &.
N.ONDO
'.&.!C .&.
'D&. D!CD&D +H,/
8& N.ONDO
N.ONDO& NDON.O
NDON.O&8
<

+=]
+ 6( 3+5=1
'.&.!C.&.
'D&D!CD&D &.
N.ONDO
#

Programme C :
:
/7+& 7
(9)%
*

;

XYXY1

0D0C1
6
<=2(+A+ 33*+ 7+*
+5E=1
<(
'1
&1
<(D'1D&1D <=>7=0?X
YXDY1
6
<=]
+

+5E=1
!

for(i=0;i<=2;i++){
for(j=0;j<=2;j++) printf("%d ", T[i][j]);
printf("\n");
}
for(i=0;i<=1;i++) for(j=i+1;j<=2;j++)
{
x = T[i][j] ;
T[i][j] = T[j][i] ;
T[j][i] = x ;
}
printf("Matrice transposée : \n");
for(i=0;i<=2;i++){
for(j=0;j<=2;j++) printf("%d ", T[i][j]);
printf("\n");
}
}
Solution 15 :
Algorithme :
Algorithme produit_matriciel
Variables
Entier mat1[3][3], mat2[3][3], produit[3][3] ;
Entier i, j, k, x, s ;
Début
Ecrire("Donnez les éléments de la première matrice :") ;
Pour (i ← 0; i<= 2; i ← i+1)
Pour (j ← 0; j<= 2; j ← j+1) Lire(mat1[i][j]);
Ecrire("Donnez les éléments de la deuxième matrice :") ;
Pour (i ← 0; i<= 2; i ← i+1)
Pour (j ← 0; j<= 2; j ← j+1) Lire(mat2[i][j]);
Pour (i ← 0; i<= 2; i ← i+1)
Pour (j ← 0; j<= 2; j ← j+1) début
s ← 0 ;
Pour (k ← 0; k<=2; k ← k+1) s ← s+mat1[i][k] * mat2[k][j];
produit[i][j] ← s ;
fin
Ecrire("Résultat du produit matriciel :") ;
Pour (i ← 0; i<= 2; i ← i+1)
Pour (j ← 0; j<= 2; j ← j+1) Ecrire(produit[i][j]) ;
Fin.
Programme C :
#include <stdio.h>
main()
{
int mat1[3][3], mat2[3][3], produit[3][3] ;
int i, j, k, x, s ;
printf("Donnez les éléments de la première matrice :\n") ;
for(i=0;i<=2;i++)
for(j=0;j<=2;j++) scanf("%d", &mat1[i][j]);
printf("Donnez les éléments de la deuxième matrice :\n") ;
121
<(
'1
&1

<(D'1D&1D <=>7=0?*X
YXDY1
<(
'1
&1
<(D'1D&1D;
'1
<(V'1V&1V *X
YXVY*XVYXDY1
6(7/
X
YXDY 1
@
6
<= 3 /7/6(7/
*

+5E=1
<(
'1
&1

<(D'1D&1D6
<=>7E=06(7/
X
YXDY1
@
Solution 16 :
Programme C :
:
/7+& 7
(9)%
:
/7+& 7
-9)%
*
;
' B+ '7+<
7+ )a+
)-XY1

'1 (*6+/
+*6
+7/-+/.+ + B+
<(
'1
&1

-X
YH
1(/-X
YF!F
1
!D(/7/'7+<
7+ )a+
-X'Y'1
!<<
)+7+ )a+
6
<=-5> E=0-1
,/7F/+/+
+
6
<=E=1
!<<
)+7+ ) /7+ B+
<(
'1
&'1

6
<=K B+/*3(>75> E=0
0-X
Y1
@
Solution 17 :
+/
+A++.(+ )a+7+ B+ 5
+ +
)a+./5
+ +
+/
+A++.(+ )a+7+ B+ 5
<(*
W/+
)a+./5!)*+7
<(*
W/+]()*+7!
999
Solution 18 :
Programme C :
:
/7+& 7
(9)%
:
/7+&
9)%
*

;
)KPXY0KPXY1
6
<=2(+A6+*
B+ )a+5=1
+ KP1
!!

6
<=2(+A7+/C
B*+ )a+5=1
+ KP1

< *6KP0KP6
<=> > =0KP0KP1
+ +6
<=> > =0KP0KP1
@
Solution 19 :
Programme C :
:
/7+& 7
(9)%
:
/7+&
9)%
*

;
)KPX'Y1
)K1

-0
1
6
<=2(+A/+ )a+7+ B+ *C
*/*5=1
+ KP1
6
<=+A/ B+5=1
<=> =0?K1
-'1
<(
'1
& +KP1

<KPX
YK--1
6
<C$/D..D =D CF3F
F3(1
@
Solution 20 :
Programme C :
:
/7+& 7
(9)%
*
;
) )
+X'Y1

0D1
6/ =2(+A/+ )a+7+ B+ 5=1
+ )
+1

'1
8)
+ )
+X
YRFE'F

< )
+X
YF+F
<(D
1 )
+XDYRFE'F1D )
+XDY )
+XDY1
+ +

1
6/ CP =./.. /OOEC1
6/ )
+1
@
Solution 21 :
Programme C :
:
/7+& 7
(9)%
:
/7+&
9)%
*
;
) )
+X'Y1

1
6/ =2(+A/+ )a+7+ B+ 5=1
+ )
+1
6/ =4.(

<<
)3+_F+.+ 5=1
!#

<(
+ )
+1
%'1

6
<=> =0 )
+X
Y1
@
Solution 22 :
Programme C :
:
/7+& 7
(9)%
*
;
) )
+X'Y1

0 1
6
<=2(+A/+ )a+7+ B+ 5=1
+ )
+1
'1
<(
'1
& + )
+1
)
+X
Y1
6
<=4 (**+7+ (7+ !,K"">7=0 1
@
Solution 23 :
Programme C :
:
/7+& 7
(9)%
:
/7+&
9)%
*
;
).+-+X'Y0 )X'Y1
6I )0==1
6
<=2(+A/.+-+7/6+*
+(/6+5=1
+ .+-+1
)0.+-+0 +.+-+1
6
<C3
D. O EMCF
1
6
<=`+> +E=0 )1
6
<=/> + E=0 )1
6
<="+> +E=0 )1
6
<=(/ > ( E=0 )1
6
<=(/ > +AE=0 )1
6
<=" + > +E=0 )1
@
Avec le verbe = /+=, le programme affiche :
2(+A/.+-+7/6+*
+(/6+5 /+
K(D/
(7/.+-+ /+/63 +7+F
7

<5
`+ /+
/ /+
"+ /+
(/ /(
(/ /+A
" + /+
Solution 24 :
Programme C :
!%

:
/7+& 7
(9)%
:
/7+& I6+9)%
:
/7+&
9)%
*

;
)*( XYX'Y1

0D1
)KPX'Y1
4
++ )a+ 7+ B+
<(
'1
&1
;
6
<=2(+A+*(b>75=0
1
+ *( X
Y1
@
K(.+
+ *( +*D/ /+
<(
'1
&1

<(D'1*( X
YXDYRFE'F1D
*( X
YXDY(/66+*( X
YXDY12 (7

(7+
-(/ +<(0(6+/*++D& +*( X
Y

++ )a+ 6(7+6)-3
W/+
<(
'1
&1

<(D
1D&1D

< *6*( X
Y0*( XDY;
6IKP0*( X
Y1
6I*( X
Y0*( XDY1
6I*( XDY0KP1
@
!<<
)+
+7+ *(
3
6
<=(

+7+ *( 6B +
5E=1
<(
'1
&1
6/ *( X
Y1
@
Solution 25 :
:
/7+& 7
(9)%
:
/7+&
9)%
*

;
)X'YXY1

1
6
<=,

+ )a+ 7+ B+ 5E=1
<(
'1
&1
<=> =0X
Y1
6
<=4+ 7+
+ B+ 7+ )a+ 5E=1
<(
'1
&1

6
<C$ /=DDMCF9Q RF9Q RQ>9Q R?R1
@
!'

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 dappel au niveau du
programme appelant (Programme Principal).
Soit le programme C suivant :
:
/7+& 7
(9)%
*

;

C0I0 1
-(
6
<=2(+A6+*
B+.+/5=1
<=>7=0?C1
6
<=2(+A7+/C
B*+.+/5=1
<=>7=0?I1
CI1
6
<=4 (**+>7E=0 1
-(
6
<=2(+A6+*
B+.+/5=1
<=>7=0?C1
6
<=2(+A7+/C
B*+.+/5=1
<=>7=0?I1
CI1
6
<=4 (**+>7E=0 1
@
Pour réduire le code de ce programme, il est possible dutiliser un sous-
programme (dans cet exemple une procédure) comme suit :
:
/7+& 7
(9)%

C0I0 1
.(
7 (**+23<

(7+6( 37/+
;
6
<=2(+A6+*
B+.+/5=1
<=>7=0?C1
6
<=2(+A7+/C
B*+.+/5=1
<=>7=0?I1
CI1
6
<=4 (**+>7E=0 1
@
*
L(**+L

6
;
(**+1L(
766+
!6

(**+1L(
766+
@
Notons ici que les variables ont été déplacées avant la procédure pour
quelles soient accessibles aussi bien au niveau de la procédure quau
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.
:
/7+& 7
(9)%
*

;

C0I0 06071
6
<=2(+A6+*
B+.+/5=1
<=>7=0?C1
6
<=2(+A7+/C
B*+.+/5=1
<=>7=0?I1
CI1
6
<=4 (**+>7E=0 1
6CI1
6
<=4+6(7/
>7E=061
7CI1
6
<=47
<<3+ +>7E=071
@
Pour plus dorganisation, 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 :
:
/7+& 7
(9)%

C0I0 06071
.(
7 (**+
;
CI1
6
<=4 (**+>7E=0 1
@
.(
76(7/

;
6CI1
6
<=4+6(7/
>7E=061
@
.(
77
<<++ +
;
7CI1
6
<=47
<<3+ +>7E=071
@
*
L(**+L

6
;
6
<=2(+A6+*
B+.+/5=1
!7

<=>7=0?C1
6
<=2(+A7+/C
B*+.+/5=1
<=>7=0?I1
(**+1
6(7/
1
7
<<++ +1
@
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é dun en-tête, dune partie
données et dune partie instructions. Le programme de calcul de la somme peut
être écrit comme suit :
:
/7+& 7
(9)%
.(
7 (**+
;

C0I0 1
6
<=2(+A6+*
B+.+/5=1
<=>7=0?C1
6
<=2(+A7+/C
B*+.+/5=1
<=>7=0?I1
CI1
6
<=4 (**+>7E=0 1
@
*

;
(**+1
(**+1
@
Un sous-programme avec paramètres :
Dans le cas où on a des blocs qui se ressemblent en termes dinstructions, mais
ils utilisent des variables différentes, on peut utiliser un sous-programme avec
des paramètres (arguments).
:
/7+& 7
(9)%
*

;

C0I0A0)0 1
6
<=2(+A6+*
B+.+/5=1
<=>7=0?C1
6
<=2(+A7+/C
B*+.+/5=1
<=>7=0?I1

!
6
<=2(+A7+/C.+/ 5E=1
<=>7>7=0?A0?)1
" #
!8

!

@
Pour réduire le code de ce programme, il est possible dutiliser un sous-
programme (procédure, dans cet exemple) avec deux paramètres. On obtient
alors le programme suivant :
:
/7+& 7
(9)%
C0I0A0)0 1
$ %!
&
%
!
'
*

;
6
<=2(+A6+*
B+.+/5=1
<=>7=0?C1
6
<=2(+A7+/C
B*+.+/5=1
<=>7=0?I1
!
6
<=2(+A7+/C.+/ 5E=1
<=>7>7=0?A0?)1
" #!
@
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 dabsence de paramètres,
les parenthèses doivent être mises vides.
La déclaration : .(
7 (**+ % nest pas acceptée.
Les paramètres C, I et A, ) sont dits effectifs, fournis lors de linvocation du
sous-programme. Les paramètres , - sont dits formels, apparaissant lors de la
déclaration du sous-programme.
Les paramètres formels et effectifs dun même sous-programme, dans le même
programme, doivent être de même nombre, tout en respectant lordre 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 dinstructions regroupées
sous un nom, et qui réalise un traitement particulier dans un programme
lorsquon lappelle (effet de bord).
En C, une procédure est appelée directement dans un programme par son nom.
En C, len-tête de la procédure comporte le nom de la procédure précédé par le
mot clé .(
7, et suivi éventuellement de paramètres mises entre parenthèses.
Ensuite, nous avons le corps de la procédure qui est un bloc dinstructions
implémentant le traitement réalisé par cette procédure.
!:

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

résultat au programme appelant.
En C, le point dappel dune fonction apparaît souvent dans une expression
(partie droite dune affectation, dans un 6
< ou dans une condition), mais
il est possible dappeler une fonction directement comme sil sagit dune
procédure.
En C, len-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 lintérieur du corps de la fonction, le mot
clé +/ est suivi du résultat retourné par cette fonction. Le résultat peut être
une simple valeur ou toute une expression. +/ interrompe la fonction et
rend la main au programme appelant.
Remarques :
NSi le type dun sous-programme nest pas indiqué, le compilateur suppose
quil sagit dune fonction à résultat entier.
NLexpression après +/ 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.
NSi on ne met pas un +/ dans une fonction, le compilateur C ne déclare
pas une erreur, mais ceci peut mener à des résultats inattendus ou erronés.
NSi vous trouvez dans un autre document lécriture .(
7*
, ne vous en
faites pas, cest 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 :
:
/7+& 7
(9)%
C0I0 1
!23<

(7+<(
(
&

(5. 2G4.
H2G4
'
*
L(**+L

6
;
6
<=2(+A6+*
B+.+/5=1
<=>7=0?C1
6
<=2(+A7+/C
B*+.+/5=1
<=>7=0?I1
!
6
<=4 (**+>7E=0 15.
#

. >C$HDMCF>??.

H>?
@
Le mot clé +/ à 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 :
:
/7+& 7
(9)%
,/6
0
-
;
C1

<%-C1
+ +C'1
+/C1
@
*

;

C0I1
6
<=2(+A6+*
B+.+/5=1 <=>7=0?C1
6
<=2(+A7+/C
B*+.+/5=1 <=>7=0?I1

<,/6C0I6
<=>7+ /63
+/+_>7=0C0I1
+ +6
<=>7+ /63
+/+_>7=0I0C1
@
Ce programme permet de comparer deux nombres entiers en indiquant quelle
est la valeur supérieure.
La fonction ,/6 du programme précédent peut être écrite comme suit :
,/6
0
-
;

<%-+/1
+ ++/'1
@
Remarques :
NSi on appelle une fonction directement comme une procédure, sans quelle
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 nexécute pas le programme.
NMalgré quelle soit souvent appelée directement comme une procédure,
6
< est une fonction entière appartenant à la bibliothèque 7
(9), et
qui retourne le nombre de caractères affiché en cas de succès, ou bien une
valeur négative en cas déchec. <, elle aussi, est une fonction qui
retourne le nombre de variables affectées par la saisie en cas de succès, ou
bien # (qui a généralement la valeur ) en cas dechec de lecture.
#

En C, il existe aussi plusieurs fonctions appartenant à la bibliothèque *)9)

permettant de faire des calculs mathématiques, telles que 6(8, W, ( ,
,
, etc.
La fonction - appartient à la bibliothèque 7
-9).
Le programme C suivant affiche : 4.+/- (/+7+
:
/7+& 7
(9)%
:
/7+& 7
-9)%
*

;
6
<=4.+/- (/+7+>7E=0- 1
@
Exercice : Ecrire votre propre fonction - . Nommez la !- (/+. La fonction
!- (/+ doit retourner la valeur absolue dun paramètre entier.
Solution :
:
/7+& 7
(9)%
!- (/+
;

<&'1
+/1
@
*

;
C1
6
<=2(+A/+.+/5=1
<=>7=0?C1
6
<=4.+/- (/+7+>7+ >7E=0C0!- (/+C1
@
Fichier d¶en-tête (bibliothèque) :
Nous avons souvent utilisé dans ce cours le terme bibliothèque pour référencer
les fichiers den-tête (header file), tels que 7
(9), *)9), etc. En fait, une
bibliothèque nest rien dautre quun ensemble de fonctions et/ou procédures
stockées dans un fichier (9)) qui est invoqué en tant que fichier den-tête
(header file) dans un programme C.
Ci-dessous, un exemple de création dune bibliothèque en C :
1. Ecrire le code :

,(**+
C0
I
;
+/CI1
@

2
<<++ +
C0
I
;
+/CI1
@
2. Sauvegardez le fichier sous le nom Operations.h, pour dire que cest un
header file.
3. Dans le même répertoire, écrire le programme C :
:
/7+& 7
(9)%
#!

:
/7+=6+
( 9)=;..

/5.
*

;

C0I1
6
<=2(+A6+*
B+.+/5=1
<=>7=0?C1
6
<=2(+A7+/C
B*+.+/5=1
<=>7=0?I1
6
<=,(**+>7E=0,(**+C0I1
6
<=2
<<++ +>7=02
<<++ +C0I1
@
4. Sauvegarder, compiler et exécuter votre programme.
Remarque : Lappel de la bibliothèque au niveau du programme a été fait par
:
/7+=6+
( 9)= pour dire quil sagit dun fichier den-tête du
répertoire courant. Pour appeler le fichier par :
/7+&6+
( 9)%, il
faut le sauvegarder dans le répertoire où le compilateur C stocke ce genre de
fichiers.
Appel d¶un sous-programme :
Contrairement à dautres langages, en C, on ne peut pas définir un sous-
programme à lintérieur dun autre. Tous les sous-programmes sont au même
niveau, cest-à-dire que chaque sous-programme peut appeler un autre, comme
cest le cas dans lexemple suivant :
:
/7+& 7
(9)%
(**+
0
-#(
(66+3+
;
+/-1
@
.(
7<<
)+
+0
<L( 37/+66++
;
6
<=>7>7>7E=0+0<0 (**++0<1
6
<=>7>7>7E=0+0<06(7/
+0<1
@
6(7/

0
7#(
(66+3+
;
+/ 71
@
*
L(**+L

6
;

C0I1
6
<=2(+A6+*
B+.+/5=1
<=>7=0?C1
6
<=2(+A7+/C
B*+.+/5=1
<=>7=0?I1
<<
)+C0I1
@
##

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

i.e. défini après le sous-programme appelant. Comme cest le cas dans le
programme précédent là où la procédure appelante <<
)+ appelle la
procédure appelée 6(7/
. 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
(*
), alors il doit être déclaré comme montré dans lexemple suivant :
:
/7+& 7
(9)%
.(
7<<
)+J (**+
+0
<1 . F F
B. .
*
L(**+L

6
;

C0I1
6
<=2(+A6+*
B+.+/5=1
<=>7=0?C1
6
<=2(+A7+/C
B*+.+/5=1
<=>7=0?I1
<<
)+J (**+C0I1!66+7+6( 37/+
@
.(
7<<
)+J (**+
+0
< . F F
B..
;
6
<=>7>7>7E=0+0<0+<1
@
Remarques :
NSi une fonction ou procédure est mise après *
sans déclaration, ceci
est sanctionné par un [Warning] signalé par le compilateur.
NLa déclaration de la procédure <<
)+J (**+ peut être mise à lintérieur
du *
avant lappel de la procédure.
NDans la déclaration dune procédure, quand len-tête est mis complet avec
ses types de paramètres, il est dit prototype, comme cest le cas dans
lexemple précédent. La déclaration peut donc ne pas comporter de
paramètres.
3. Les variables locales et les variables globales
:
/7+& 7
(9)%
1
.(
7 (**+
;

C0I1
6
<=2(+A6+*
B+.+/5=1
<=>7=0?C1
6
<=2(+A7+/C
B*+.+/5=1
#%

<=>7=0?I1
CI1
@
*

;
-(
(**+1
6
<=4 (**+>7E=0 1
-( =
(**+1
6
<=4 (**+>7E=0 1
@
Les variables C et I sont dites variables locales. Elles ne peuvent être utilisées
quau niveau du sous-programme. La variable est dite variable globale. Les
variables globales peuvent être utilisées au niveau des sous-programmes et au
niveau du programme principal.
Remarques :
NLes paramètres dun sous-programme se comportent de la même manière
que les variables locales de ce sous-programme.
NSi les variables globales sont déclarées après le programme quil 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, lendroit où la
déclaration dune variable est faite, influence directement la portée de la
variable (le bloc dans lequel il est possible daccéder à la variable), comme
illustré dans lexemple suivant :
*

;

!1

-+ +
-+ 5!
;

M1

-+ +
-+ 5!0M
;

K1

-+ +
-+ 5!0M0K
@
@
;

1

-+ +
-+ 5!0
@
@
Notons quune variable peut être déclarée dans nimporte quel bloc dans un
programme C.
#'

Deux identificateurs identiques :

Pour enlever lambiguïté, il est préférable déviter dutiliser le même
identificateur comme variable locale et globale au même temps. Voyons
lexemple suivant :
:
/7+& 7
(9)%

1
.(
7,
;

1

1
6
<=
>7E=0
1
@
*

;

'1
,1
6
<=
>7=0
1
@
Le programme affiche:

'
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.
:
/7+& 7
(9)%
C0I1
,
0
-
;
+/-1
@
*

;
6
<=2(+A6+*
B+.+/5=1
<=>7=0?C1
6
<=2(+A7+/C
B*+.+/5=1
<=>7=0?I1
6
<=,(**+>7=0,C0I1
@
La fonction , peut être remplacée par une procédure , en ajoutant une variable
globale, et cela comme suit :
:
/7+& 7
(9)%
C0I0)1
$,
0
-
;
)-1
@
#6

*

;
6
<=2(+A6+*
B+.+/5=1
<=>7=0?C1
6
<=2(+A7+/C
B*+.+/5=1
<=>7=0?I1
* !
6
<=,(**+>7=0)1
@
Variable locale statique :
Il est possible dattribuer un emplacement permanent à une variable locale, en
la déclarant par le mot clé
. Sa valeur se conserve donc dun appel au
suivant. Soit lexemple :
:
/7+& 7
(9)%
.(
7<
;

1

1
6
<=>7E=0
1
@
*
L(**+L

6
;

1
<('1&1< 1
@
Ce programme affiche :

Remarques :
NUne 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.
NElle est automatiquement initialisée par 0.
NLe mot
, employé sans indication de type, est équivalent à

.
NUne déclaration dune variable globale précédée par le mot clé +C+
précise que cette variable a été déjà définie dans un autre fichier source.
Une telle déclaration neffectue aucune réservation despace mémoire.
4. Le passage des paramètres
:
/7+& 7
(9)%
.(
7 )+
IL( 37/+
;
I1
@
#7

*
L(**+L

6
;

"1
"'1
)+"1
6
<=>7=0"1
@
Ce programme comporte une procédure )+ déclarée avec un paramètre
formel I. Le programme principal *
contient une variable locale ",
passée comme paramètre effectif à la procédure )+. La valeur qui sera
affichée en sortie est '.
Malgré que le paramètre ait changé au niveau de la procédure, ce changement
na pas été transmis au programme principal. Ce type de passage de paramètres
est dit par valeur.
Voyons un deuxième exemple :
:
/7+& 7
(9)%
.(
7 )+
I4. F F4

4.
;
I1.
-+6(
3+6I+c(
.+/
@
*

;

"1
"'1
)+?"15../
+
6
<=>7=0"1
@
I est un paramètre formel de la procédure )+. Le symbole indique le
type pointeur. Ce symbole est utilisé pour transmettre la valeur de la variable
pointée par I 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 dune variable, elle
contient son adresse. Donc lors de lappel de la procédure, on met comme
paramètre effectif une adresse dune 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 :
NQuand on utilise le passage par valeur, il est possible dinvoquer le sous-
programme par des paramètres effectifs exprimés sous forme dexpressions,
par exemple, )+", )+6
#8

NPour la fonction 6
<, les paramètres sont passés par valeur. Pour la
fonction <, les paramètres sont passés par adresse.
Représentation graphique de la pile :
La zone mémoire réservée pour lexécution dun programme C dans la RAM
est constituée de plusieurs parties, parmi lesquelles on cite :
N Segment de données : variables globales.
N Pile : variables locales et paramètres.
N Tas : allocation dynamique, qui sera étudiée ultérieurement.
La répartition de lespace 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 dune ou plusieurs boites
(frames). Dans chacune de ces boites sont stockées, entre autres, les variables
locales et les paramètres dune 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 )+ peut être représentée comme suit :
# #
/+&2, /+&2, /+&2,

= 0 = , #& = ,
''
# '(/3. #"!&" '(/3.
!#& !#& !#& !#&
>!
0 0 0 0
La pile avec la procédure )+ peut être représentée comme suit :

# # #
/+&21 /+&21 /+&21

= E = E
#& = E
''
# '(/3. #"!&" '(/3.
!#& !#& !#& !#&

0 0 , ,
Remarquez bien quen C, le programme principal (*

) est traité comme
une simple fonction.
Exercice :
1.Quaffiche le programme C suivant ?
#:

:
/7+& 7
(9)%
C0I0,(*1
.(
7,
0
-
;,(*-1
-1
-1
@
*

;C1I1
,C0I1
6
<=>7>7>7=0C0I0,(*1
@
2.Quaffiche programme précédent si :
a) on remplace la procédure par :
.(
7,
0
-
;,(*-1
-1
-1
@
et on lappelle par : ,C0?I1
b) on remplace la procédure par :
.(
7,
0
-
;,(*-1
-1
-1
@
et on lappelle par : ,?C0I1
c) on remplace la procédure par :
.(
7,
0
-
;,(*-1
-1
-1
@
et on lappelle par : ,?C0?I1
Solution :
1.Le programme affiche :
2.Le programme affiche :
Pour ,
0
- :
- Pour ,
0
- :
Pour ,
0
- :
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 quune variable de type tableau correspond à
ladresse du premier élément (lélément 0) de ce tableau. Donc, le passage dun
%

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

lappeler par ?.
:
/7+& 7
(9)%
.(
7

+
XY
;
X'Y'1XY'1XY'1XY'1
@
*

;

XY;'000H@1

'1

+1* ..F.
>S9?9 B
<(
'1
&1
6
<=>7E=0X
Y1
@
'
'
'
'

Remarque : Quand on passe un tableau comme paramètre dun sous-
programme, il est possible de ne pas préciser la taille de ce tableau. La
déclaration .(
7

+
XY est donc aussi correcte. Il est aussi
possible de mettre la déclaration .(
7

+
.
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 dafficher ses
paramètres jusquà atteindre le paramètre ayant comme valeur .
:
/7+& 7
(9)%
:
/7+& 79)%
.(
7+

60 )60999
;
.J
761

6.1
6
<=>7E=061
6
<=> E=061
.J 76061
6..J760
1
8)
+6.R;
6
<=>7E=06.1
6..J760
1
@
@
%

*

;
6/ =L+*
++
5=1
+
0F F00001
6/ =2+/C
B*++
5=1
+
0FF001
@
L+*
++
5

2+/C
B*++
5

Le type .J
identifie une liste de variables. La fonction .J permet
de se pointer juste après un argument fixe. La fonction .J permet de
récupérer largument en cours selon un type donné, et passer à largument
suivant. .J
, .J et .J appartiennent à la bibliothèque
79).
Remarque : On appelle fonction variadique, une fonction qui peut prendre un
nombre variable de paramètres. 6
< et < 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 sappelle elle-même.
5.2. Exemple (Calcul de la factorielle)
La factorielle dun 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 :
<

;

0<1
<1
<(
1
&1
<<
1
+/<1
@
%!

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 :
<

;
<1

<'<1
+ +<< 1
+/<1
@
Ou bien :
<

;
<'+/1
+ ++/< 1
@
Remarques :
NToute solution itérative peut être transformée en solution récursive, et vice
versa.
NLappel dune fonction à lintérieur delle-même est dit appel récursif.
Lappel récursif dans la fonction récursive < est < .
Une fonction ou une procédure récursive doit vérifier les deux conditions
suivantes :
1.Lexistence dun critère darrêt. Le critère darrêt dans la fonction
récursive < est '.
2.Les paramètres de lappel récursif doivent converger vers le critère darrêt.
Arbre des appels :
Larbre des appels est une représentation graphique des appels récursifs.
Larbre des appels de la fonction récursive < pour n = 3 peut être représenté
comme suit.
>#?
AA

H#J >!? <

AA
H!J >? 1
AA ,
HJ >?
>HH?H ,

%#

Remarques :
NLutilisation de la récursivité est coûteuse en termes despace mémoire.
Comme illustré par larbre des appels, le contexte de la fonction < 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.
NLarbre des appels devient plus complexe quand la fonction sappelle elle-
même plus dune fois.
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 lutilisateur donne successivement les deux nombres : 9 et 2.
Exercice 2 :
Ecrire un programme C qui affiche le code ASCII dun 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 nest pas premier et la
valeur 1 lorsquil est premier.
Note : On dit quun nombre entier positif est premier sil possède exactement
deux diviseurs positifs : 1 et lui-même. 0 et 1 ne sont pas des nombres premiers.
Voici quelques nombres premiers ; 6
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 dun 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 dun
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 dafficher la somme de deux entiers et la
concaténation de deux chaînes de caractères en utilisant une procédure.
%%

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. Lutilisateur doit faire un
choix à partir dun 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 limpôt défini comme suit : pour un ménage X avec un
revenu total R et un nombre n de membres du foyer, limpôt est donné par :
N 10% de R si R/n < 500 DA
N 20% de R si R/n >= 500 DA
Ecrire un programme C qui lit R et n au clavier, puis affiche limpôt et le
revenu net en utilisant les deux fonctions suivantes :
1. Une fonction "*6( qui calcule le montant de limpôt en fonction de R et n.
2. Une fonction +.+/+ qui calcule le revenu net dun ménage après
paiement de limpôt en fonction de R et n.
Exercice 10 :
Quaffiche le programme C suivant ?
:
/7+& 7
(9)%
1
.(
7<
6
;
6
<=>7>7E=0061
@
.(
7*
L(**+L

6
;

1
< 1
@
Exercice 11 :
Quel est le résultat dexécution des deux programmes suivants ?
:
/7+& 7
(9)% :
/7+& 7
(9)%

1

1

*6

*6

; ;
6
<=>7E=01 6
<=>7E=01
1 1
@ @
*
*

; ;

1
1
8)
+
&'; 8)
+
&';
%'


*6
1
*6?
1

1

1
@ @
@ @
Exercice 12 :
Quaffichent les deux programmes suivants ?
Programme 1 Programme 2
:
/7+& 7
(9)% :
/7+& 7
(9)%

<
0
-
<
0
-
; ;
1 1
+/-1 +/-1
@ @
.(
7*
.(
7*

; ;

0D0C1

0D0C1

'1
'1
D'1 D'1
C<
0D1 C<?
0?D1
6
<C HDFHDF2HDCF FF21 6
<C HDFHDF2HDCF FF21
@ @
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 lutilisateur 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 dun
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 dun vecteur ;
2. recherche de la position de la première occurrence de lélément minimum
dun 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.
%6

Exercice 17 :
Ecrire une fonction qui calcule la somme des éléments dun tableau dentiers de
taille quelconque.
Exercice 18 :
En utilisant la notion de sous-programme, essayez de réduire la taille du
programme C suivant :
:
/7+& 7
(9)%
*

;

C0I0A0 1
6/ =2(+A(
(*-+ 5=1
<=>7>7>7=0?C0?I0?A1
CI1
6
<=>7>7>7E=0C0I0 1
IA1
6
<=>7>7>7E=0I0A0 1
AC1
6
<=>7>7>7E=0A0C0 1
@
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 :
.(
7L

;

<%';
6
<=>7E=01
L1
6
<=>7E=01
@
@
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 larbre des appels de la fonction pour n=4.
%7

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 :
N Si m<0 ou n<0 : A(m, n) = 0 ;
N Si m=0 : A(0, n) = n+1 ;
N Si n=0 : A(m, 0) = A(m-1, 1) ;
N 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 dune chaîne de caractères
lue à partir du clavier en utilisant une fonction récursive.
La chaîne miroir de =-(D(/= est =/(D(-=.
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 :
.(
7 (*6+
;

1
<(
1
&'1
6
<=>7E=0
1
@
Exprimez cette procédure par une autre récursive, faisant le même travail.
6.2. Corrigés
Solution 1 :
Programme C :
:
/7+& 7
(9)%

7
.J+
0
-
;
+/-1
@
*

;

C0I1
6
<=2(+A6+*
B+.+/5=1
<=>7=0?C1
%8

6
<=2(+A7+/C
B*+.+/5=1
<=>7=0?I1
6
<=>7>7>7=0C0I07
.J+C0I1
@
Représentation de la mémoire :
# #
#%F&" #%F&" #%F&"
* * 7
'' 1 1 #& 1
# 5 >(&/"#(&
>(&/"#(& #"!&"
!#& !#& !#& !#&
: * : * : * : *
= 1 = 1 = 1 = 1

Solution 2 :
:
/7+& 7
(9)%

!,K"" )
;
+/1
@
*

;
) 1
6
<=2(+A/ B+5=1
<=> =0? 1
6
<=K(7+!,K""7/ B+> + >7=0 0!,K"" 1
@
Solution 3 :
:
/7+& 7
(9)%

6+*
+

;

60
1
<(
1
&1

<>
'6'1

<&+/'1
+/61
@
*

;

C1
6
<=2(+A/(*-++
+6(

<5=1
<=>7=0?C1

<6+*
+C6
<=>7+ /(*-+6+*
+9=0C1
+ +6
<=>7F+ 6 /(*-+6+*
+9=0C1
%:

@
Ou bien :
:
/7+& 7
(9)%

6+*
+

;

6'0
1
<(
1
&1

<>
'61

<6R+/'1
+ ++/1
@
*

;

C1
6
<=2(+A/(*-++
+6(

<5=1
<=>7=0?C1

<6+*
+C6
<=>7+ /(*-+6+*
+9=0C1
+ +6
<=>7F+ 6 /(*-+6+*
+9=0C1
@
Solution 4 :
:
/7+& 7
(9)%
<(*(I++<(0<(-0<(
;
+/- 1
@
*

;
<(C0I0A1
6
<=2(+A(
(*-+ 5E=1
<=><><><=0?C0?I0?A1
6
<=4*(I++7+ (
(*-+ ><=0*(I++C0I0A1
@
Solution 5 :
:
/7+& 7
(9)%
<( /< +<(0<(-
;
+/-1
@
*

;
<(01
6
<=2(+A(/+/++/5E=1
<=><><=0?0?1
6
<=4 /< +><=0 /< +01
@
Solution 6 :
:
/7+& 7
(9)%

W/(0*(71
.(
7W/(J*(7
0
-
'

;
W/(-1
*(7>-1
@
*

;

60W1
6
<=2(+A6+*
B+.+/5=1
<=>7=0?61
6
<=2(+A7+/C
B*+.+/5=1
<=>7=0?W1
W/(J*(760W1
6
<=>7>7>7+>7>>>7>7=060W0W/(060W0*(71
@
Solution 7 :
:
/7+& 7
(9)%
:
/7+&
9)%
.(
7 (*J (
0
-0 ) X'Y0 ) X'Y
;
6
<=4+3 /7+ (**+>7E=0-1
6
<C$ HDCF>F!?1
@
*

;

C0I1
) )X'Y0 )X'Y1
6
<=2(+A7+/C(*-+ 5E=1
<=>7>7=0?C0?I1
6
<=2(+A7+/C )a+ 7+ B+ 5E=1
<=> > =0 )0 )1
(*J (C0I0 )0 )1
@
Solution 8 :
Programme C avec une fonction :
:
/7+& 7
(9)%

< (
C
;

0<1
<1
<(
1
&C1
<
1
+/<1
@
*

;

0-0 0 )(
C1
6
<=2(+A(
+
+ 5E=1
<=>7>7>7=0?0?-0? 1
6
<=6+A6(/ /+< (
++7+5>7E=01
6
<=6+A6(/ /+< (
++7+5>7E=0-1
'

6
<=6+A6(/ /+< (
++7+5>7E=0 1
<=>7=0? )(
C1
8
) )(
C
;
+5
<%'. >C$ DD CFF>??
+ +6
<=K /
*6(
-+9=1-+V1
+5
<-%'. >C$ DD CF
F>
??
+ +6
<=K /
*6(
-+9=1-+V1
+5
< %'. >C$ DD CFF>??
+ +6
<=K /
*6(
-+9=1-+V1
7+</56
<=K)(
C
.
7+R=1
@
@
Programme C avec une procédure :
:
/7+& 7
(9)%

O1
.(
7< (
C
;

0<1
<1
<(
1
&C1
<
1
O<1
@
*

;

0-0 0 )(
C1
6
<=2(+A(
+
+ 5E=1
<=>7>7>7=0?0?-0? 1
6
<=6+A6(/ /+< (
++7+5>7E=01
6
<=6+A6(/ /+< (
++7+5>7E=0-1
6
<=6+A6(/ /+< (
++7+5>7E=0 1
<=>7=0? )(
C1
8
) )(
C
;
+5
<%';>?. >C$ DD CFFT?@
+ +6
<=K /
*6(
-+9=1-+V1
+5
<-%'U>
?. >C$ DD CF
FT?V
+ +6
<=K /
*6(
-+9=1-+V1
+5
< %'U>?. >C$ DD CFFT?V
+ +6
<=K /
*6(
-+9=1-+V1
7+</56
<=K)(
C
.
7+R=1
@
@
Solution 9 :
:
/7+& 7
(9)%
<("*6(<( 0

;

< &''9'+/'9 1
'!

+ ++/'9 1

@
<( +.+/+<( 0

;
+/ "*6( 01
@
*

;
<(C1

I1
6
<=2(+A++.+/(5=1
<=><=0?C1
6
<=2(+A+(*-+7+*+*-+ 7/<(I+5=1
<=>7=0?I1
6
<C+.HDF-0HDCF+.>2F4?F-0>2F4?1
@
Solution 10 :

Solution 11 :
Le premier programme affiche :

Le deuxième programme affiche :

H

Solution 12 :
Le premier programme affiche :
'0D'0CH'
Le deuxième programme affiche :
'0D'0CH'
Solution 13 :
Programme C :
:
/7+& 7
(9)%
.(
76+*/+
0
-
;

1
1
-1
- 1
@
'#

*

;

C0I1
6
<=2(+A.+/7+C5=1
<=>7=0?C1
6
<=2(+A.+/7+I5=1
<=>7=0?I1
6+*/+?C0?I1
6
<=C>70I>7=0C0I1
@
Représentation de la mémoire :
# #
'!." '!." '!."
E: E: E:
'' E= E= E=

#&
# '(/3. #"!&" '(/3.
!#& !#& !#& !#&
: * : * : 1 : 1
= 1 = 1 = * = *
Solution 14 :
:
/7+& 7
(9)%
.(
7

0
-0<(
;
-'1
'1
@
*

;

C0I1
<(A1

?C0?I0?A1
6
<=C>7 I>7E=0C0I1
6
<=A><=0A1
@
Solution 15 :
:
/7+& 7
(9)%

(*06(71
.(
7 (*J6(7J-
XY
;

V1
(*'1
<(V'1V&1V (*XVY1
'%
6(71
<(V'1V&1V6(7XVY1
@
*

;

XY1

1
6/ =2(+A+
W33*+ 7/-+/5=1
<(
'1
&1
<=>7=0?X
Y1
(*J6(7J-1
6
<=,(**+>7L(7/
>7=0 (*06(71
@
Solution 16 :
:
/7+& 7
(9)%
:7+<
++(*-+7+ 33*+ 7F/-+/

X+Y0X+Y0X+Y1

1
#(
(7+ /7+ (**+7F/-+/

(**+J-
X+Y
;

(*'1
<(
'1
&+1
(*X
Y1
+/ (*1
@
@ . /. O

6(
C0
X+Y
;

60'1

'1
8)
+
&+??R

<X
YC;6
11@+ +
1
+/61
@
@ . O

6( J*

X+Y
;

*
X'Y1
<(
1
&+1

<*
%X
Y*
X
Y1
+/6( *
01
@
L( 37/+7F77

(7+7+/C-+/C
.(
777J-
!X+Y0
MX+Y
;
<(
'1
&+1
X
Y!X
YMX
Y1
@
*

;
6
<=2(+A+ 33*+ 7/6+*
+-+/5E=1
<(
'1
&+1
<=>7=0?X
Y1
''

6
<=2(+A+ 33*+ 7/7+/C
B*+-+/5E=1
<(
'1
&+1
<=>7=0?X
Y1
6
<C$ .
HDMCFN
>9?1
6
<C$. .
EDMCF.N >9?1
6
<=4F77

(7+ 7+/C-+/C7(+5E=1
77J-01
<(
'1
&+1
6
<=>7E=0X
Y1
@
Solution 17 :
(*
XY0
-
;

'0
1
<(
'1
&-1
X
Y1
+/ 1
@
Solution 18 :
:
/7+& 7
(9)%

1
.(
7 (*
0
-
;
-1
6
<=>7>7>7E=00-0 1
@
*

;

C0I0A0 1
6/ =2(+A(
(*-+ 5=1
<=>7>7>7=0?C0?I0?A1
(*C0I1
(*I0A1
(*A0C1
@
Solution 19 :
Ce problème peut être subdivisé en trois sous-problèmes :
1.Déterminer le max dun tableau.
2.Déterminer le min dun tableau.
3.Déterminer la position dune valeur.
Voici le programme C :
:
/7+& 7
(9)%

-X'Y1

*C0*
0
1
.(
7*C
*/*
;
*C-X'Y1
<(
1
&1

<*C&-X
Y*C-X
Y1
@
.(
7*

*/*
'6

;
*
-X'Y1
<(
1
&1

<*
%-X
Y*
-X
Y1
@

6(

(
C
;

6( 1
<(
'1
&1

<-X
YC6(
1
+/6( 1
@
*

;
6/ =2(+A+ 33*+ 7/-+/5=1
<(
'1
&1
<=>7=0?-X
Y1
*C
*/*1
*

*/*1
6
<C$2 DF. DMCF2F. >2?1
6
<C$ DF. DCF F. > ?1
@
Solution 20 :
Pour un entier positif n, la procédure L permet dafficher 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 :
:
/7+& 7
(9)%

6/
+
C0
I
;

06/
1
<(
1
&I1
6/
C1
+/6/
1
@
*

;

061
6
<=2(+A/(*-+5=1
<=>7=0?1
6
<=2(+A6/
+5=1
'7

<=>7=0?61
6
<=>76/
+>7>7=00606/
+061
@
Programme C utilisant une fonction récursive :
:
/7+& 7
(9)%

6/
+
C0
I
;

6/
1

<I'6/
1
+ +6/
C6/
+C0I1
+/6/
1
@
*

;

061
6
<=2(+A/(*-+5=1
<=>7=0?1
6
<=2(+A6/
+5=1
<=>7=0?61
6
<=>76/
+>7>7=00606/
+061
@
La fonction récursive 6/
+ peut être aussi écrite comme suit :

6/
+
C0
I
;

<I'+/1
+ ++/C6/
+C0I1
@
Solution 22 :
:
/7+& 7
(9)%

<
-(

;

<1

<'SS<1
+ +<<
-(<
-(1
+/<1
@
*

;

C1
6
<=+A/+.+/5=1
<=>7=0?C1
6
<=#
-(>7>7=0C0<
-(C1
@
La fonction récursive <
-( peut être aussi écrite comme suit :

<
-(

;
<'SS+/1
+ ++/<
-(<
-(1
@
'8

Solution 23 :
:
/7+& 7
(9)%

! V+*
C0
I
;

<C&'SSI&'+/'1
+ +
<C'+/I1
+ +
<I'+/! V+*C01
+ ++/! V+*C0! V+*C0I1
@
*

;

*01
6
<=2(+A*5=1
<=>7=0?*1
6
<=2(+A5=1
<=>7=0?1
6
<=! V+*>70>7>7=0*00! V+**01
@
Solution 24 :
Programme C utilisant une fonction récursive :
:
/7+& 7
(9)%
:
/7+&*)9)%

,(**+

;

<&'+/'1
+ ++/6(80,(**+1
@
*

;
6
<=>7=0,(**+H1
@
Programme C utilisant une fonction itérative :
:
/7+& 7
(9)%
:
/7+&*)9)%

,(**+

;

0#'1
<(
1
&1
#6(8
01
+/#1
@
*

;
6
<=>7=0,(**+H1
@
Solution 25 :
:
/7+& 7
(9)%
:
/7+&
9)%
) )
+X'Y0*
(
X'Y1
':

)]" ) )X'Y
;

< + )'SS + )+/ )1
+ +;
) X'Y; )X + )Y0FE'F@1=
/ /
) X'Y;FE'F@1=/
0]" 6I 0 )0 + )1
6I*
(
0 1
+/*
(
1
@
@
*

;
6
<=2(+A/+ )a+7+ B+ 5=1
<=> =0 )
+1
6
<C$= DDCF F*+-> ?1
@
Solution 26 :
LZK2
*0

;

1
8)
+*>R';
*>1
*11
@
+/1
@
La version récursive de cette fonction peut être écrite de la manière suivante :
LZK2
*0

;

<*>'+/1
+ ++/LZK20*>1
@
Solution 27 :
.(
7 (*6+

;

<
'6
<=>7E=0
1
+ +;
6
<=>7E=0
1
(*6+
1
@
@
La procédure récursive (*6+ sera invoquée dans le programme principal
par : (*6+1
6

Les types personnalisés .
Chapitre 7 : Les types personnalisés
1. Introduction
Les types quon a vus jusquà maintenant (entier, réel, caractère, booléen,
tableau et chaîne de caractères) sont prédéfinis, c.-à-d. quils 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 quil
veut à ces types. La déclaration dun nouveau type doit précéder son utilisation.
Pour donner un nom à un type, on utilise I6+7+<.
Dans lexemple suivant, le programmeur a préféré dutiliser le mot
+ au
lieu de
pour déclarer des entiers :
:
/7+& 7
(9)%
I6+7+<

+123<

(7F/(/.+/I6+
+
*

;

+C0I1
6
<=2(+A6+*
B+.+/5=1
<=>7=0?C1
6
<=2(+A7+/C
B*+.+/5=1
<=>7=0?I1
6
<=,(**+>7E=0CI1
@
Dans ce cas-là, le type
+ est tout simplement synonyme de
. 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 dinstructions là où il a été défini. Dans lexemple précédent, le
nouveau type
+ peut être utilisé par tout dans le programme C. Si nous
avions, par exemple .*#/)-
+
%.*/*/.
@, le type
+
naurait pu être utilisé quà linterieur 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 quil 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 :
6

/ &(*J / /+%
;
&I6+J7(3+ %& )*6%
&I6+J7(3+ %& )*6%

&I6+J7(3+ %& )*6%
@1
Remarques :
NLa définition dun type structure se termine par un point-virgule après
laccolade fermante.
NLespace 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 dune structure 6+ (+ contenant les champs (*,
6+(* et + :
/ 6+ (+
;
)(*X'Y1
)6+(*X'Y1
)(+1
@1
Pour déclarer une variable de type 6+ (+, on met par exemple :
/ 6+ (+6++1
Dans ce cas, la variable 6++ prendra 22 octets en mémoire.
Pour éviter de reprendre / 6+ (+ chaque fois quon déclare une
variable de ce type, il est possible de mettre :
I6+7+< / 6+ (+
;
)(*X'Y1
)6+(*X'Y1
)(+1
@L+ 1
L+ 6++1
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 :
6++9(*, 6++96+(* et 6++9+. La composante obtenue se comporte
exactement comme toute variable de même type que le champ considéré.
On peut mettre, par exemple : 6++9+H1
Remarques :
NUne structure peut être passée comme paramètre dune fonction ou
procédure.
NLa seule opération quon peut appliquer sur une structure sans passer par ses
champs est laffectation. Par exemple, si nous avions ! et M deux variables
6!

de type L+ , nous aurions pu avoir dans notre programme les affectations

!MouM!.
NLinitialisation dune structure peut être effectuée à la déclaration, par
exemple : L+ 6++;=!)*+7=0=!
=0@1
NIl était aussi possible de déclarer des variables lors de la définition de la
structure, par exemple :
/ 6+ (+
;
)(*X'Y1
)6+(*X'Y1
)(+1
@6++1
Ou même :
/
;
)(*X'Y1
)6+(*X'Y1
)(+1
@6++1
Exemple :
:
/7+& 7
(9)%
I6+7+< / 6+ (+
;
)(*X'Y1
)6+(*X'Y1
)(+1
@L+ 1
.(
7!<<
)+L+ L;
6/ =(

+
<(*
( 7/6B+5=1
6
<=> E> E>7=0L9(*0L96+(*0L9+1
@
*

;
L+ 6++1
6
<=2(+A+(*7/6B+5=1
<=> =06++9(*1
6
<=2(+A+63(*7/6B+5=1
<=> =06++96+(*1
6
<=2(+AFd+7/6B+5=1
<=>7=0?6++9+1
!<<
)+6++1
@
Le programme C précédent permet de lire les informations dune variable 6++
de type structure L+ . Il permet ensuite dafficher ces informations en utilisant
une procédure permettant laffichage des champs dune variable de type L+
déjà défini.
6#

Remarques :
NIl est possible de déclarer un tableau dont les éléments sont de type
structure, par exemple, L+ X'Y. Laccès au premier élément du tableau
seffectuera, par exemple, comme suit : X'Y9+.
NAu niveau de la procédure !<<
)+, 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. .(
7"
L+ L. Laccès à un champ au
niveau de cette procédure se fait par L%+ ou par L9+, et lappel au
niveau du programme principal se fait par "
?6++.
Soit lexemple :
:
/7+& 7
(9)%
I6+7+< / 6+ (+
;
)(*X'Y1
)6+(*X'Y1
)(+1
@L+ 1
.(
7"
L+ L;
L%+1(/-
+ L9+1
@
*

;
L+ 6++1
"
?6++1
6
<=4d+7/6B++ 5>7=06++9+1
@
Le programme affiche :4d+7/6B++ 5
4. Le type union
Lunion 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 ny a quun seul champ qui peut prendre une valeur.
A la différence dune structure qui est un type de données complexe
hétérogène, lunion est un type simple hétérogène : simple à cause de lunicité
de la valeur ; lhétérogénéité vient du fait que cette valeur peut être de
différents types.
On ne peut manipuler quun seul champ à la fois au détriment des autres
champs, i.e., une variable de type union ne peut prendre quune seule valeur de
ses champs à un moment donné.
Le type union a pour objectif de permettre au programmeur dutiliser une seule
variable de différentes manières sans perdre de lespace mémoire.
Format général en C :
6%

/
(&(*J/
(%
;
&I6+J7(3+ %& )*6%
&I6+J7(3+ %& )*6%

&I6+J7(3+ %& )*6%
@1
Remarques :
NLa définition dun type union se termine par un point-virgule après
laccolade fermante.
NLespace mémoire réservé pour une variable de type union est égal à
lespace mémoire réservé pour le champ le plus grand, i.e, le champ qui
prend le plus despace par rapport aux autres champs.
Exemple :
On peut définir une union dont les éléments peuvent être soit
, soit <(,
comme suit :
/
(7
;

1
<(C1
@1
Pour déclarer une variable de type /
(7, on met par exemple :
/
(771
La variable 7 prendra 4 octets en mémoire (la taille du type <().
Pour éviter de reprendre /
(7 chaque fois quon déclare une variable de
ce type, il est possible de mettre :
I6+7+</
(7
;

1
<(C1
@21
271
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 : 79
ou 79C.
On peut mettre, par exemple : 79
H. Si on met par la suite 79C[, la
valeur H sera perdue.
Remarques :
NUne union peut être passée comme paramètre dune fonction ou procédure.
NLa seule opération quon peut appliquer sur une union sans passer par ses
champs est laffectation. Par exemple, si nous avions ! et M deux variables
de type 2, on aurait pu trouver dans notre programme les affectations : !
Mou M!.
6'

Exemple :
:
/7+& 7
(9)%
I6+7+</
(7
;

1
<(C1
@21
*

;
271

)(
C1
6
<=(/+A.(/ ++/+
+(//3+5=1
<=>7=0? )(
C1
8
) )(
C
; +5 <=>7=0?79
16
<=>7=079
1-+V1
+5 <=><=0?79C16
<=><=079C1-+V1
7+</56
<=K)(
C
(+ R=1
@
@
Le programme C précédent permet, à travers un menu affiché, de lire une
variable 7 de type 2, 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 dun 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 :
+/*&(*J+/*%# E EE *@1
Remarques :
NLa définition dun type énumération se termine par un point-virgule après
laccolade fermante.
NLespace mémoire réservé pour une variable de type énumération est
généralement égal à lespace nécessaire pour le stockage dun entier.
Exemple :
Voici la déclaration dun type énumération !
* représentant différentes
sortes danimaux :
+/*!
*;
(0++6)0 )0
<+@1
Pour déclarer une variable de type!
*, on met par exemple :
+/*!
*!1
La variable ! peut prendre comme valeur soit
(, ++6), ) ou

<+.
Pour éviter de reprendre +/*!
* chaque fois quon déclare une variable
de ce type, il est possible de mettre :
66

I6+7+<+/*!
*;
(0++6)0 )0
<+@!
*1
!
*!1
Remarques :
NLes valeurs dun type +/* correspondent par défaut à des constantes
entières ', , ... Donc,
( correspond à ', ++6) à , etc. On peut
redéfinir ces valeurs tout en gardant de préférence leur ordre croissant, par
exemple : +/* !
* ;
(0 ++6)0 )0
<+'@ 1
Comme ça,
( correspond à ' (valeur prise par défaut), ++6) à ,
) aura H (suivant de , son prédécesseur), et
<+ aura '. Dans ce
cas, les deux écritures .% 0CC&9/ #@ et .% 0CC4 #@ seront
équivalentes.
NUne variable de type énumération se comporte comme celle de type entier.
On peut faire une affectation (eg. !
( et !' sont équivalentes),
une boucle (eg. %0C .*0!C3.%
0#@), choix multiple
(eg. I./&9 0 # &
.*? &

-9*/? @), une
comparaison (eg.
(&++6) retourne pour dire !"), un
affichage (eg. 6
<=4
(5>7=0
(affiche : '), une lecture (eg.
<=>7=0?!), un passage en paramètre dune fonction ou procédure,
etc.
Exemple :
:
/7+& 7
(9)%
I6+7+<+/*!
*;
(0++6)0 )0
<+@!
*1
!
*,

+K)(
C
;

)(
C1
6/ C3
E> ?F> .?F!>?#> ?EC1
<=>7=0? )(
C1
8
) )(
C
;
+
(5+/
(1-+V1
+++6)5+/++6)1-+V1
+ )5+/ )1-+V1
+
<+5+/
<+1-+V1
7+</56
<C3 2 WP. 2 MC1
+/
(1
@
@
*

;
!
*!1
!,

+K)(
C1

<! )6
<=!
*7(*+
W/+9=1
+ +6
<=!
* /.+9=1
@
67

Dans ce programme, nous avons défini un type énumération !

* avec un
ensemble danimaux. Nous avons défini une fonction de type !
*. La fonction
retourne une valeur de type !
* selon un nombre saisi au choix. Au niveau du
programme principal, nous avons déclaré une variable ! de type !
* qui aura
sa valeur selon le nombre saisi au clavier, et selon cette valeur, le programme
va nous indiquer sil sagit dun animal sauvage ou domestique.
6.1. Exercices
Exercice 1 :
Présentez en C les types structures suivants :
N Un nombre complexe est défini par une partie réelle et une partie
imaginaire.
N Une date est composée dun numéro de jour (1..31), dun numéro de mois
(1..12) et dune année.
N 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).
N Une identité décrivant le nom, le prénom et la date de naissance.
N 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 à :
N Une partie réelle dune variable X de type complexe.
N Jour dune variable Y de type date.
N Mois de la date de début dune variable Z de type stage.
N Année de la date de naissance dune variable G de type identité.
N Jour de la date naissance du premier auteur dune variable H de type fiche
bibliographique.
Exercice 2 :
Ecrire un programme C permettant de définir un type structure dit 6++
possédant les champs (* de type chaîne de caractères, 7+J
de type
chaîne de caractères, -J+< de type entier, et
+J+< de type chaîne de
caractères. Le programme doit permettre de lire et dafficher les informations
dune variable 6++ de type structure déjà défini.
Exercice 3 :
Reprendre lexercice 2, mais cette fois-ci en modifiant la structure 6++ comme
suit : le champ 7+J
doit être à son tour défini en tant que type structure
possédant les champs : D(/, *(
, et ++. Le champ
+J+< doit être
déclaré en tant que tableau de chaînes de caractères.
68

Exercice 4 :
Reprendre lexercice 2, mais cette fois-ci en utilisant une procédure qui reçoit
en paramètre une variable de type enregistrement (6++), puis, elle laffiche.
Exercice 5 :
En utilisant le type structure 6++ défini dans lexercice 2, essayez cette fois de
déclarer dans un programme C deux variables 6++ et 6++ de type 6++, de
lire uniquement le nombre denfants des deux pères, et de calculer et dafficher
le nombre total denfants.
Exercice 6 :
Ecrire un programme C permettant de déclarer un tableau de cinq éléments de
type structure 6++ défini dans lexercice 2, de lire ses éléments, de les
afficher, et enfin dafficher le nombre total denfants.
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 dafficher 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 6(
défini comme suit :
/ 6(
;

/*1
<(C1
<(I1
@1
Le programme doit afficher lensemble des informations précédentes. Notons
que le programme doit utiliser une procédure pour la lecture et une autre pour
laffichage.
Exercice 9 :
Définir une structure (*-+
(+ 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 daffichage avec un paramètre passé par
valeur. On écrira aussi des fonctions de multiplication et daddition de deux
rationnels. Pour laddition, 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 dafficher leur multiplication
et addition.
6:

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 L+/ contenant toutes les informations
relatives à un panneau de bois.
2. Ecrire des procédures de saisie et daffichage dun panneau de bois.
3. Ecrire une fonction qui calcul le volume en mètres cubes dun panneau.
Exercice 11 :
Un grossiste en composants électroniques vend quatre types de produits :
N Des cartes mères (code 1) ;
N Des processeurs (code 2) ;
N Des barrettes de mémoire (code 3) ;
N 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 L(7/
qui code un produit.
2. Ecrire des procédures de saisie et daffichage des données dun produit.
3. Ecrire une procédure K(**7+ qui permet à un utilisateur de saisir les
données dun produit (appel de la procédure de saisie). Lutilisateur saisit
aussi la quantité commandée du produit. La procédure affiche toutes les
données du produit (procédure daffichage), ainsi que le prix total à payer
pour effectuer la commande.
4. Le programme principal fait appel à seulement la procédure K(**7+.
Exercice 12 :
Luniversité 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 D(/+/ et +W/
6+ correspondants.
2) Ecrivez une procédure

JD(/+/ permettant de saisir les
caractéristiques dun joueur. Le paramètre doit être passé par adresse.
3) En utilisant la procédure précédente, écrivez une procédure

J+W/
6+ permettant de saisir les caractéristiques dune équipe. Le
paramètre doit être passé par adresse.
4) Ecrivez le programme *
qui crée et remplit un tableau de quatre
équipes en utilisant la procédure

J+W/
6+.
5) Ecrivez les procédures <<
)+JD(/+/ et <<
)+J+W/
6+ pour
afficher à lécran les équipes et leurs joueurs.
7

6) Complétez le programme *
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 nexiste 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 *(
permettant de représenter les 12 mois
de lannée.
2) Ecrivez une procédure !<<
)+J*(
permettant dafficher le mot
correspondant au numéro du mois passé en paramètre.
3) Ecrivez une procédure ,

J+ ++ demandant à un utilisateur de
remplir le tableau des recettes mensuelles.
4) Ecrivez le programme principal *
qui appelle ,

J+ ++ et
affiche la somme des recettes de lanné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 dun feu permettant la gestion de la circulation
dans un carrefour, ensuite de lire une variable entière et dafficher à quelle
couleur cette valeur correspond.
6.2. Corrigés
Solution 1 :
:
/7+& 7
(9)%
23
(7+ I6+
I6+7+< / (*-+J (*6+C+;
<(LJ+++1
<(LJ
*

+1
@(*-+J (*6+C+1
I6+7+< / 7+;
)(D(/1
)(*(
1

++1
7

@2+1
I6+7+< / +;
)

/+X'Y1
2+7+J7+-/07+J<
1

-J6 +1
@,+1
I6+7+< /
7+
+;
)(*XY1
)6+(*XY1
2+7+J
1
@"7+
+1
I6+7+< / <
)+J-
-
(;
)
+X'Y1
"7+
+/+/ X'Y1
2+7+J6/
(1
"7+
++7
+/1
)/*J",MX'Y1
@#
)+J-
-
(1
23
(7+ .
-+
(*-+J (*6+C+$1
2+N1
,+O1
"7+
+Z1
#
)+J-
-
(P1
*
;
;/2.
$ 2.
$9LJ+++1
N9D(/1
O97+J7+-/9*(
1
Z97+J
9++1
P9/+/ XY97+J
9D(/1
@
Solution 2 :
:
/7+& 7
(9)%
I6+7+< / 6++;
)(*X'Y1
)7+J
X'Y1

-J+<1
)
+J+<X''Y1
@L++1
L++6++1
*
;
6
<=2(+A+(*7/6B+5=1
<=> =06++9(*1
6
<=2(+A7+7+
+7/6B+5=1
<=> =06++97+J
1
6
<=2(+A+(*-+7F+< 7/6B+5=1
<=>7=0?6++9-J+<1
6
<=2(+A
+7+ +< 7/6B+5=1
7!

<=> =06++9

+J+<1
6/ =(

+
<(*
( ( + +6B+5=1
6
<C0EDF EDF0
OEDMCF. F
. N F.
N1
6
<=4
+7+ +< 5> =06++9
+J+<1
@
Solution 3 :
:
/7+& 7
(9)%
I6+7+< / 7+;
)(D(/1
)(*(
1

++1
@2+1
I6+7+< / 6++;
)(*X'Y1
2+7+J
1

-J+<1
)
+J+<X'YX'Y1
@L++1
L++6++1

1
*
;
6
<=2(+A+(*7/6B+5=1
<=> =06++9(*1
6/ =2(+A7+7+
+7/6B+5=1
6
<=`(/5=1 <=>7=0?6++97+J
9D(/1
6
<=](
5=1 <=>7=0?6++97+J
9*(
1
6
<=!3+5=1 <=>7=0?6++97+J
9++1
6
<=2(+A+(*-+7F+< 7/6B+5=1
<=>7=0?6++9-J+<1
6/ =2(+A
+7+ +< 5=1
<(
1
&6++9-J+<1
;
6
<=2(+A+(*7+F+</*>75=0
1
<=> =06++9
+J+<X
Y1
@
6/ =(

+
<(*
( ( + +6B+5=1
6
<C0EDF ED)D)DF0
OEDMCF
. F. N F. N F
. N F.
N1
6/ =(

+7+ + +< 5=1
<(
1
&6++9-J+<1
6
<=> E=0
6++9
+J+<X
Y1
@
Solution 4 :
:
/7+& 7
(9)%
I6+7+< / 6++;
)(*X'Y1
)7+J
X'Y1
7#


-J+<1
)
+J+<X''Y1
@L++1
L++6++1
.(
7!<<
)+L++$;
6/ =(

+
<(*
( ( + +6B+5=1
6
<C0EDF EDF0
OEDMCFX F
X N FX
N1
6
<=4
+7+ +< 5> =0$9
+J+<1
@
*
;
6
<=2(+A+(*7/6B+5=1
<=> =06++9(*1
6
<=2(+A7+7+
+7/6B+5=1
<=> =06++97+J
1
6
<=2(+A+(*-+7F+< 7/6B+5=1
<=>7=0?6++9-J+<1
6
<=2(+A
+7+ +< 7/6B+5=1
<=> =06++9
+J+<1
!<<
)+6++1
@
Solution 5 :
:
/7+& 7
(9)%
I6+7+< / 6++;
)(*X'Y1
)7+J
X'Y1

-J+<1
)
+J+<X''Y1
@L++1
L++6++06++1

(**+1
*
;
6
<=2(+A+(*-+7F+< 7/6+*
+6B+5=1
<=>7=0?6++9-J+<1
6
<=2(+A+(*-+7F+< 7/7+/C
B*+6B+5=1
<=>7=0?6++9-J+<1
(**+6++9-J+<6++9-J+<1
6
<=(*-+(7F+< + 5>7=0 (**+1
@
Solution 6 :
:
/7+& 7
(9)%
I6+7+< / 6++;
)(*X'Y1
)7+J
X'Y1

-J+<1
)
+J+<X''Y1
@L++1
L++6++ XY1

D0-1
7%

*
;
-'1
<(D'1D&1D;
6
<=2(+A+(*7/6B+/*>75=0D1
<=> =06++ XDY9(*1
6
<=2(+A7+7+
+7/6B+/*>75=0D1
<=> =06++ XDY97+J
1
6
<=2(+A+(*-+7F+< 7/6B+/*>75=0D1
<=>7=0?6++ XDY9-J+<1
-6++ XDY9-J+<1
6
<=2(+A
+7+ +< 57/6B+/*>75=0D1
<=> =06++ XDY9
+J+<1
@
6
<CMP ./EMCF1
<(D'1D&1D;
6
<CP ./DMCF1
6
<=(*5> E=06++ XDY9(*1
6
<=47+7+
+5> E=06++ XDY97+J
1
6
<=4+(*-+7F+< 5>7E=06++ XDY9-J+<1
6
<=4
+7+ +< 5> E=06++ XDY9
+J+<1
@
6
<=4+(*-+(7+< >7=0-1
@
Solution 7 :
:
/7+& 7
(9)%
:7+<
+*C'
I6+7+< / 7
7;
)(*X'Y1
<((+1
@K7
71
K7
7
+X*CY1
<( (**+0*(I1

1
*
;
(**+'1
,

+ (* ++ (+ 7+ 7
7
<(
'1
&*C1
;
6
<=,

+(*7/ 7
7b>75=0
1
<=> =0
+X
Y9(*1
6
<=,

(+7/ 7
7> 5=0
+X
Y9(*1
<=><=0?
+X
Y9(+1
(**+
+X
Y9(+1
@
!<<
)+*(I++7+ (+ 7+ 7
7
*(I (**+*C1
6
<C$4 ,DMCF41
; IH,4
6/ CP IH,4C1
<(
'1
&*C1

7'


<
+X
Y9(+%*(I
6
<CDDMCF Q R F Q R 1
@
Solution 8 :
:
/7+& 7
(9)%
:7+<
+-JL
I6+7+< / 6(
;

/*1
<(C1
<(I1
@L(
1
L(
X-JLY1

1
.(
74
+;
<(
'1
&-JL1
;
6
<C O DEMCF 1
6
<=/*3(5=1 <=>7=0?X
Y9/*1
6
<=C5=1 <=><=0?X
Y9C1
6
<=I5=1 <=><=0?X
Y9I1
@
@
.(
7!<<
)+;
<(
'1
&-JL1
;
6
<CP O DEMCF 1
6
<C0 EDFM2EDFM4EDMCF9Q R F9Q R 2F9Q R 41
@
@
*
;
6/ ="(7/
++
<(*
( 7+ 33*+ =1
4
+1
6/ =(

+
<(*
( 7+ 33*+ =1
!<<
)+1
@
Solution 9 :
:
/7+& 7
(9)%
I6+7+< /
(+;

/*++/07+(*
+/1
@(*-+
(+1
(*-+
(+$0N0]0!1
.(
7,

;
6/ =+A+/*3+/++73(*
+/7+$5=1
<=>7>7=0?$9/*++/0?$97+(*
+/1
6/ =+A+/*3+/++73(*
+/7+N5=1
<=>7>7=0?N9/*++/0?N97+(*
+/1
@
.(
7!<<
)+(*-+
(+;
6
<=/*3+/5>7E23(*
+/5>7E=0
9/*++/097+(*
+/1
76

@
(*-+
(+]/
6
+0
- F0
- ;
(*-+
(+1
9/*++/*9/*++/9/*++/1
97+(*
+/*97+(*
+/97+(*
+/1
+/1
@
(*-+
(+!77

(+0
- F0
- ;
(*-+
(+1
9/*++/*9/*++/97+(*
+/
9/*++/*97+(*
+/1
97+(*
+/*97+(*
+/97+(*
+/1
+/1
@
*
;
6/ ="(7/
+$+N=1
,

1
6/ =!<<
)+$+N=1
!<<
)+$1
!<<
)+N1
6/ =E4*/
6

(7+$6N7(+5=1
]]/
6
+$0N1
6
<=E/*3+/>7E23(*
+/>7E=0
]9/*++/0]97+(*
+/1
6/ =E4F77

(7+$+N7(+5=1
!!77

(+$0N1
6
<=E/*3+/>7E23(*
+/>7E=0
!9/*++/0!97+(*
+/1
@
Solution 10 :
:
/7+& 7
(9)%
I6+7+< / 6+/;
<((/+/0+/0+6
+/1
)(I6+1
@L+/1
L+/$1
.(
7,

;
6
<=+A(/+/+*

*B+ 7/6+/5=1
<=><=0?$9(/+/1
6
<=+A+/+*

*B+ 7/6+/5=1
<=><=0?$9+/1
6
<=+AF36
+/+*

*B+ 7/6+/5=1
<=><=0?$9+6
+/1
6
<C14... FB!BEC1
<=>7=0?$9I6+1
@
.(
7!<<
)+L+/L;
6
<C$ /.EDMCF" 1
6
<C$ /.EDMCF" 1
77

6
<C$O . /.EDMCF" . 1
6
<=4+I6+7/6+/5=1
8
)L9I6+;
+'56
<=L
E=1-+V1
+56
<=K)\+E=1-+V1
+56
<=P\+E=1-+V1
7+</56
<=I6+
(/RE=1
@
@
<((/*+L+/6;
+/69+/69(/+/69+6
+/+1
@
*
;
6/ ="(7/
+/L+/=1
,

1
6/ =!<<
)++L+/=1
!<<
)+$1
6
<CMJJJJP/
.HDCFP>X?1
@
Solution 11 :
:
/7+& 7
(9)%
I6+7+< / 6(7/
;
)(I6+1
/
+7
+<++ +1
<(6
C1
/
+7
W/
+J7
6(1
@L(7/
1
L(7/
$1
.(
7,

;
6
<C14.. /F!.FC1
6
<=-++*3*(
+(/ +6)
W/+5=1
<=>7=0?$9I6+1
6
<=+A3<+3 +7/6(7/
5=1
<=>7=0?$9+<++ +1
6
<=+A+6
C7/6(7/
5=1
<=><=0?$96
C1
6
<=+AW/
37
6(
-+7/6(7/
5=1
<=>7=0?$9W/
+J7
6(1
@
.(
7!<<
)+L(7/
L;
6
<=4+I6+7/6(7/
5=1
8
)L9I6+;
+56
<=K+*B+E=1-+V1
+56
<=L( + +/E=1-+V1
+56
<=M++*3*(
+E=1-+V1
+56
<=K+6)
W/+E=1-+V1
7+</56
<=I6+
(/RE=1
@
6
<=43<3+ +7/6(7/
5>7E=0L9+<++ +1
78

6
<=4+6
C7/6(7/
5><E=0L96
C1
6
<C$ . EDMCF" N .1
@
.(
7K(**7+;
6/ ="(7/
+/6(7/
=1
,

1
/
+7
W1
6
<=+AW/
3 (**73+5=1
<=>7=0?W1
6/ =!<<
)++6(7/
=1
!<<
)+$1

<W&$9W/
+J7
6(
6
<C" 2,.4. HDCFX . 2J1
+ +6
<CY .
. WWC1
@
*
;
K(**7+1
@
Solution 12 :
:
/7+& 7
(9)%
:7+<
+
I6+7+< / D(/+/
;
)(*X'Y1
)6+(*X'Y1
)(+1
)(
.+/1
@`(/+/1
I6+7+< / +W/
6+
; )(*X'Y1
`(/+/D(/+/1
`(/+/D(/+/1
@W/
6+1
.(
7,

JD(/+/`(/+/D
;6
<=+A+63(*5=1 <=> =0D%6+(*1
6
<=+A+(*5=1 <=> =0D%(*1
6
<=+AFd+5=1 <=>7=0?D%+1
6
<=+A+
.+/5=1 <=>7=0?D%
.+/1
@
.(
7,

J+W/
6+W/
6++
;6
<=+A+(*5=1 <=> =0+%(*1
6/ =`(/+/5=1
,

JD(/+/?+%D(/+/1
6/ =D(/+/5=1
,

JD(/+/?+%D(/+/1
@
.(
7!<<
)+JD(/+/`(/+/D
;6
<=EL3(*5> E=0D96+(*1
6
<=E(*5> E=0D9(*1
7:

6
<=E!+5>7E=0D9+1
6
<=E
.+/5>7E=0D9
.+/1
@
.(
7!<<
)+J+W/
6+W/
6++
;6
<=(*5> E=0+9(*1
6/ =`(/+/5=1
!<<
)+JD(/+/+9D(/+/1
6/ =`(/+/5=1
!<<
)+JD(/+/+9D(/+/1
@
*

;W/
6+-XY1

0D1
<(
'1
&1
;
6
<=W/
6+>75E=0
1D
1
,

J+W/
6+?-XDY1
@
6/ =(

+7+ 3W/
6+ =1
<(
'1
&1
;
6
<=W/
6+>75E=0
1
!<<
)+J+W/
6+-X
Y1
@
@
Solution 13 :
Le type adéquat pour représenter cette information est le type : /
(.
/
(
+
; )( +
*++ 1
<(*++ 1
@1
Solution 14 :
:
/7+& 7
(9)%
I6+7+<+/*M4;#!4,0 @M((+1
*

;

XY1

M 1
M((+#1

1
6
<=+A+ 33*+ 7/-+/5E=1
<(
'1
&1
<=>7=0?X
Y1
6
<=+A+(*-+_+ )+ )+5=1
<=>7=0?M 1
##!4,1
'1
8)
+
&??R#
<X
YM # 1
+ +
1

<#6
<=>7<
6
+7/-+/9=0M 1
+ +6
<=>7+<
6 6
+7/-+/9=0M 1
@
8

Solution 15 :
:
/7+& 7
(9)%
I6+7+<+/*;D0
<+.0* 0.0*
0D/
0D/
0(/0 +60( 0(.07+ @*(
1
.(
7!<<
)+J*(
*(
*
; 8
)*
; +D56
<=`.
+=1-+V1
+<+.56
<=#3.
+=1-+V1
+* 56
<=] =1-+V1
+.56
<=!.
=1-+V1
+*
56
<=]
=1-+V1
+D/
56
<=`/
=1-+V1
+D/
56
<=`/
+=1-+V1
+(/56
<=!(/=1-+V1
+ +656
<=,+6+*-+=1-+V1
+( 56
<= (-+=1-+V1
+(.56
<=(.+*-+=1-+V1
+7+ 56
<=23 +*-+=1-+V1
@
@
.(
7,

J+ ++
+ ++ XY
;*(
*1
<(*D1*&7+ 1*
;6
<=+A+ ++6(/=1
!<<
)+J*(
*1
6
<=5=1
<=>7=0?+ ++ X*Y1
@
@
*

;

XY0
0 (**+'1
,

J+ ++ 1
<(
'1
&1
(**+ X
Y1
6
<C$O /HDCF1
@
Solution 16 :
:
/7+& 7
(9)%
I6+7+<+/*D(/;,*+7
02
* )+04/7
0]7
0
]+ +7
0`+/7
0+7+7
@`(/1

/*1
*
;
6/ =+A//*3(7+D(/++'+H5=1
<=>7=0?/*1

</*,*+7
SS/*+7+7

6
<=KF+ /D(/<3
39=1
+ +6
<=K+F+ 6 /D(/<3
39=1
@

8

Solution 17 :
:
/7+& 7
(9)%
I6+7+<+/*<+/;.+0(+0(/+@#+/1

/*1
*
;
6/ =+A//*3(7+D(/++'+5=1
<=>7=0?/*1
8
)/*
;
+.+56/ =#+/.+9=1-+V1
+(+56/ =#+/(+9=1-+V1
+(/+56/ =#+/(/+9=1-+V1
7+</56/ =K)(
C
(+ R=1
@
@
8!

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 lexé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 dinformations 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 dexploitation) 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
Laccè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 dabord 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 daccès au fichier, car ces accès sont
relativement coûteux, surtout en termes de temps.
Ecriture Ecriture
(2!! #/+#
Tampon
Lecture Lecture
RAM 'LVTXHGXUFOp86%RXG¶DXWUHV
8#

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 dautres supports non volatils.
Pour la manipulation des fichiers en C, on utilise une variable de type structure
#"4, qui est définie dans 7
(9). Cette bibliothèque contient également les
fonctions utilisées dans ce chapitre.
Exemple : La déclaration dun pointeur <6 vers un fichier se fait comme suit :
#"4<61
La structure #"4 permet de désigner un fichier. Elle contient plusieurs
champs. On cite en particulier :
N Un pointeur vers ladresse de début du tampon ;
N Un pointeur vers la position courante dans le tampon ;
N La taille du tampon.
2.2. Ouverture d¶un fichier
Pour lire ou écrire dans un fichier, il faut tout dabord louvrir en utilisant la
fonction <(6+ comme suit :
#"4<
)
+<(6+(*J<
)
+0*(7+1
La fonction <(6+ renvoie un pointeur (<
)
+) vers une structure #"4, ou
bien 44 en cas derreur. Le paramètre (*J<
)
+ est une chaîne de
caractères contenant le chemin du fichier à ouvrir, i.e. son emplacement et son
nom. Le paramètre *(7+ 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 :
N== (read) : lecture seule.
Renvoie 44 si le fichier nexiste pas.
N=8= (write) : écriture seule.
Si le fichier existe, son contenu sera réinitialisé.
Sinon, il est créé.
N== (append) : ajout de données à la fin du fichier.
Fichier créé sil nexiste pas déjà.
Sinon, ça permet décrire de nouvelles données après les données
existantes.
Exemple : Lexemple suivant permet louverture en lecture dun fichier appelé
*(J<
)
+9C se trouvant dans le répertoire courant du programme :
#"4<6<(6+=*(J<
)
+9C=0==1
<<644
;
+*++ 7++/
999
@
+ +
;
+*+(*
8%

Les fichiers .

@
Voici comment ouvrir un fichier K5E]I7
E*I<
+9C sous Windows :
#"4<6<(6+=K5EE]I7
EE*I<
+9C=0==1
Notons ici que nous avons utilisé le caractère spécial FEEF pour représenter le
caractère antislash (\), car ce dernier est utilisé en C pour introduire des
caractères spéciaux, tels que FEF, FE6F, etc.
Sous Unix, on peut trouver, par exemple :
#"4<6<(6+=)(*+]I7
*I<
+9C=0==1
Une erreur douverture peut se produire, par exemple, en cas de fichier
inexistant, ou en cas de droits daccès limités.
Lorsquon ouvre un fichier, on récupère un pointeur vers une variable de type
#"4, qui est utilisée pour lire ou écrire le fichier.
Ecriture Ecriture

Lecture
(2!! #/+#
Tampon
Lecture
RAM 'LVTXHGXUFOp86%RXG¶DXWUHV
2.3. Fermeture d¶un fichier
A la fin de la manipulation dun fichier, on le ferme par la fonction < ( +
comme suit :
(*J.< ( +<

)
+1
(*J. est une variable entière. Le paramètre <
)
+ est un pointeur vers
une structure #"4 représentant le fichier à fermer. Si la fonction réussit, elle
renvoie la valeur '. Si elle échoue, elle renvoie la constante # (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 quun comportement
anormal sest produit.
La fermeture dun fichier permet de libérer lespace 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
8'

Les fichiers .
buffer. Donc, en cas doubli de < ( +, 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 <6 se fait comme suit:
C< ( +<61
<C#;
+*++ 7++/

@
+ +;
+*+(*

@
Remarque : La fonction < ( + est souvent appelée directement par son nom
dans un programme C comme une procédure, sans quelle figure dans une
expression.
2.4. Accès au fichier
On distingue deux méthodes daccès au fichier :
1. Accès séquentiel qui consiste à traiter les informations dans lordre où
elles apparaissent, à partir du premier jusquà linformation désirée.
2. Accès direct qui consiste à se placer immédiatement sur linformation
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 dun
fichier :
NAccès non-formaté : on lit/écrit des caractères dans des fichiers textes. On
distingue deux sortes daccè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.
NAccès formaté : on lit/écrit des données typées dans des fichiers textes.
NAccès par bloc : on manipule des séquences doctets, indépendamment de
leur type. Il sagit de travailler avec des fichiers binaires.
Dans ce qui suit, on décrit toutes ces manières daccès aux fichiers, sans oublier
laccès direct.
2.4.1. Lecture/écriture non-formatées en mode caractère
Pour la lecture, on utilise la fonction <+ comme suit :
(7+J <+ <

)
+1
Le paramètre <
)
+ est un pointeur vers une structure #"4 représentant un
fichier déjà ouvert en lecture. La fonction renvoie le code ASCII du caractère
lu, ou bien la constante # en cas derreur.
86

Les fichiers .
Exemple : On affiche le contenu dun fichier déjà ouvert <6 caractère par
caractère comme suit :
<+ <61

8)
+ R#;
6/ ) 1
<+ <61
@
Fin du fichier
<+ renvoie # quand on arrive à la fin du fichier. Le problème est que la
valeur # peut aussi être renvoyée à cause dune autre erreur, par exemple, si
laccès au fichier nest plus possible.
Pour être sûr quon a atteint la fin du fichier, on utilisera la fonction <+(<
comme suit :
(*J.<+(<<
)
+1
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.
<+ <61

8)
+R<+(<<6;
6/ ) 1
<+ <61
@
Pour l¶écriture, on utilise la fonction <6/ comme suit :
(*J.<6/ (7+J 0<

)
+1
La fonction <6/ prend (7+J de type
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 #, par exemple, dans le cas dun disque plein (saturé).
Exemple : On écrit le caractère F!F dans un fichier déjà ouvert en écriture <6
comme suit :
) F!F1
C<6/ 0<61
<C#
;
+*+7+++/

@
2.4.2. Lecture/écriture non-formatées en mode chaîne
Pour la lecture dune une chaîne de caractères, au lieu de lire un seul caractère
à la fois, on utilise la fonction <+ comme suit :
)(*J )<+ )
+0(*-+0<
)
+1
)
+ va contenir la chaîne de caractères lue à partir du fichier (ou plus
exactement à partir du tampon). (*-+ de type
indique le nombre
87

Les fichiers .
maximal de caractères à lire. Le pointeur <

)
+ 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. ? )
+X'Y), ou bien
44 en cas de fin de fichier ou en cas derreur. La fonction <+(< nous permet
dêtre sûrs quon a atteint la fin du fichier.
La fonction <+ tente de lire (*-+ caractères du fichier. Elle rajoute
automatiquement le caractère FE'F à la fin de la chaîne. La lecture est
interrompue si la fonction rencontre le caractère FEF (le FEF est quand même
recopié dans le tampon).
Exemple : On affiche le contenu dun fichier déjà ouvert <6 chaîne par chaîne
comme suit :
)*6XY1
) )<+ *600<61
8)
+ )R44;
6
<=> =0*61
)<+ *600<61
@
Si, par exemple, le fichier contient les deux lignes :
-(D(/
)*+7
Alors, *6 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 dune chaîne est effectuée grâce à la fonction <6/ utilisée comme
suit :
(*J.<6/ )
+0<
)
+1
)
+ étant la chaîne de caractères à écrire dans le fichier. Le paramètre
<
)
+est un pointeur vers un fichier déjà ouvert en écriture. La fonction ne
recopie pas le caractère FE'F terminal. La fonction renvoie une valeur non-
négative en cas de succès, ou bien # en cas derreur.
Exemple : Stocker la chaîne =-(D(/= dans un fichier déjà ouvert en écriture
<6 comme suit :
C<6/ =-(D(/=0<61
<C#
+++/
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 dorganisation, on utilise
les fonctions < < et <6
<, dédiées respectivement à la lecture et à
lécriture dans un fichier.
Elles se comportent comme les fonctions < et 6
<, à la différence du
fait quun paramètre supplémentaire, placé en première position, désigne le
fichier dans lequel on veut lire ou écrire :
88

Les fichiers .
-J.< <<

)
+0<(*0
+J7+ + 1
-J.<6
<<
)
+0<(*0
+J+C6+
( 1
Ces fonctions renvoient le nombre de variables lues ou écrites, ou bien # en
cas derreur (ou de fin de fichier).
Exemple : Lire un <( à partir dun fichier ouvert en lecture comme suit :
<(<1
C< <<60=><=0?<1
<C#
+++/
Notons quà chaque lecture par < <, le pointeur passe automatiquement à la
suite dans le fichier.
Exemple : Ecrire un <( dans un fichier ouvert en écriture comme suit :
<(<91
C<6
<<60=><=0<1
<C#
+++/
Remarque : Les deux types daccès formaté et non-formaté permettent la
manipulation des fichiers textes contenant du texte ASCII. Si nous avions, par
exemple, un fichier texte contenant 9'''', cette information aurait pu être
lue comme :
1) la chaîne de caractères =9''''= en accès non-formaté, ou
2) comme le nombre réel 9 en accès formaté, comme si nous avions
une lecture de chaîne de caractères suivie dune conversion en réel
dans ce deuxième cas.
2.4.4. Lecture/écriture par bloc
Lorsquon veut manipuler de grandes quantités de données dans des fichiers
binaires, sans soccuper de leur type ou de leur organisation, on utilise les accès
par bloc. Ceci est réalisé grâce aux fonctions <+7 et <8
+ :

A+J-J-( J/ <+7?*60
+0(*-+0<
)
+1

A+J-J-( J+
<8
+?*60
+0(*-+0<
)
+1
?*6 correspond à ladresse dun ou plusieurs blocs dinformation.
+ de
type
A+J est la taille dun seul bloc en octets. (*-+ de type
A+J est le
nombre de blocs à lire ou à écrire. <
)
+est un pointeur vers un fichier. Le
type
A+J est défini dans 7
(9) ; il sagit dun entier non-signé.
La fonction <+7 lit
+*(*-+ octets à partir du fichier, et les recopie
dans *6. La fonction <8
+ lit
+*(*-+ octets à partir de *6, et les
recopie dans le fichier. Les deux fonctions renvoient le nombre de blocs
lus/écrits : une valeur inférieure à (*-+ indique donc quune erreur est
survenue au cours du traitement.
Remarques :
NLorsquune variable est écrite dans un fichier binaire, on écrit directement la
valeur exacte de la variable, telle quelle est codée en binaire en mémoire.
Cette manière est plus précise et plus compacte pour stocker des nombres.
8:

Les fichiers .
Par exemple, linformation 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 na besoin que de 4 octets (lespace nécessaire pour le
stockage dun réel dans la mémoire) pour la stocker dans un fichier binaire.
NLorsquon veut lire ou écrire un tableau dans un fichier en mode par bloc,
alors le premier paramètre doit être mis sans ?, tandis quavec une structure,
il faudra utiliser ? pour en obtenir ladresse. Dans ce dernier cas, il est
préférable dutiliser la fonction
A+(< pour déterminer avec certitude la
taille dun bloc.
Exemple : Lire par bloc les cinq premiers caractères dun fichier texte ouvert
en lecture, ensuite les afficher :
) )X'Y1

A+J-<+7 )000<61
<-R
+F++/
+ +6
<=> =0 )1
2.4.5. Accès direct
Toutes les fonctions de manipulation des fichiers quon a vues précédemment
permettent un accès séquentiel au fichier. Pour accéder directement à nimporte
quel point dans un fichier, il est possible dutiliser la fonction < ++V comme
suit :
(*J.< ++V<

)
+0-J( + 0*(7+J
(1
La fonction < ++V possède comme paramètres :
NUn pointeur vers un fichier (<
)
+).
NLe nombre doctets après lesquels on désire se positionner (-J( + ) de
type (. Pour se mettre au début du fichier, cette valeur doit être '.
NLe paramètre *(7+J
( de type
indique la manière dagir 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.
< ++V 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 dun
fichier texte ouvert en lecture :
C< ++V<60
A+(< )0'1
1
<CR'
+++/
+ +; <+ <61
6/ ) 1@
Exemple 2 : Se positionner pour lire le sixième réel à partir dun fichier binaire
là où on a stocké des réels :
C< ++V<60
A+(<<(0'1
<CR'
+++/
:

Les fichiers .
Remarques :
NLorsquon écrit sur un emplacement quon a atteint après < ++V, la donnée
qui existait éventuellement à cet emplacement est effacée et remplacée par
la donnée écrite.
NDans le cas de la création dun fichier en mode direct, dès quon é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.
N Pour avoir la position courante dans le fichier, i.e., après combien doctets
on en est dans le fichier, il est possible dutiliser la fonction <+ de la
forme : (-J( + <+<
)
+1
Remarque importante : Notons que dans ce cours, nous avons essayé de
simplifier lutilisation des fonctions de manipulation des fichiers. Cest
pourquoi, nous avons évité de donner la forme originale (en-tête ou prototype)
des fonctions dans la bibliothèque 7
(9). Par exemple, len-tête (prototype)
de la fonction <(6+ dans la bibliothèque est le suivant :
#"4<(6+ ( )(*J<
)
+0 ( )*(7+1
Alors que son utilisation a été simplifiée dans ce cours comme suit :
#"4<
)
+<(6+(*J<
)
+0*(7+1
Dans cette forme simplifiée, nous avons montré la variable qui va prendre la
valeur de retour de <(6+. Nous avons aussi remplacé les pointeurs par des
chaînes de caractères, car à ce niveau, le lecteur na pas encore maitrisé la
notion de pointeur qui va être étudiée, avec plus de détail, dans le chapitre
suivant.
3.1. Exercices
Exercice 1 :
Ecrire un programme C permettant de stocker le caractère F!F 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 dun fichier texte nommé
<
)
+9C, 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é
<
)
+9C, 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 :
<
)
+9C, 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 :
<
)
+9C, 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 dun fichier existant
<
)
+9C par lecture/écriture en mode caractère.
Exercice 8 :
Par un menu de choix multiple, écrire un programme C permettant de demander
à lutilisateur de lire un fichier texte (<
)
+9C), de créer un nouveau
fichier texte (<
)
+9C) ou dajouter des données à un fichier existant
(<
)
+9C). 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 ++ 9C. Utiliser le mode écriture formatée.
Exercice 10 :
Ecrire un programme C permettant dafficher un nombre réel à partir du fichier
++ 9C. Utiliser le mode lecture formatée.
Exercice 11 :
En utilisant le mode lecture/écriture formatées, on veut stocker les informations
des employés dune entreprise dans un fichier +*6(I+ 9C. 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 =-(D(/= dans
un fichier -( 9C.
Exercice 13 :
Utilisez la lecture par bloc pour lire un bloc de sept caractères à partir du fichier
-( 9C créé dans lexercice précédent.
Exercice 14 :
Ecrire un programme C permettant denregistrer séquentiellement dans un
fichier, dont le nom est lu à partir du clavier, une suite de nombres entiers
quon 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
lexercice précédent. Le nom du fichier étant lu à partir du clavier. Utiliser la
lecture par bloc.
Exercice 16 :
Reprendre lexercice 11, mais cette fois-ci en utilisant lecture/écriture par bloc.
Exercice 17 :
Avec la même structure dun employé définie dans lexercice 11, et en utilisant
lecture/écriture par bloc, on veut stocker les informations des employés dune
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 dun employé définie dans lexercice 11, et en utilisant
lecture/écriture par bloc, on veut stocker les informations de cinq employés
dune 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 lexercice 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 nimporte quel entier du fichier créé
par le programme de lexercice 14. La position du nombre à lire étant lue à
partir du clavier. Utiliser laccès direct.
3.2. Corrigés
Solution 1 :
Programme 1 :
L(**+K6+*+7+ ( V++ B+F!F7 /
<
)
++C+
:
/7+& 7
(9)%
*

; ) 1
C1
#"4<6<(6+=75EE<
)
+9C=0=8=1

<<6R44;
F!F1
C<6/ 0<61

<C#6
<C1K/D 2WMCF1
+ +6
<C<K /D 2 MCF1
< ( +<61
:#

Les fichiers .
@+ +6
<= )+ 7+ 3
(R=1
@
Programme 2:
L(**+K6+*+7+
+/ B+_6
7/
<
)
++C+63 37+
:
/7+& 7
(9)%
*

;

C1
#"4<6<(6+=75EE<
)
+9C=0==1

<<6R44;
C<+ <61

<C#6
<C1/,. 2WMC1
+ +6
<C$/D/,. 2MCF21
< ( +<61
@+ +6
<= )+ 7F(/.+/+R=1
@
Solution 2 :
:
/7+& 7
(9)%
*

;
#"4<6<(6+=<
)
+9C=0==1

<<6R44;

<+ <61
8)
+ R#; 5. Z >W>.??
6/ ) 1
<+ <61
@
< ( +<61
@
+ +6
<="*6(
-+7F(/.
+<
)
+RE=1
@
Solution 3 :
:
/7+& 7
(9)%
*

;
#"4<6<(6+=<
)
+9C=0==1

<<6R44;
)*6XY1
) )<+ *600<61
8)
+ )R44;
6
<=> =0*61
)<+ *600<61
@
< ( +<61
@
+ +6
<="*6(
-+7F(/.
+<
)
+RE=1
@
:%

Les fichiers .
Ou bien :
:
/7+& 7
(9)%
*

;
#"4<6<(6+=<
)
+9C=0==1

<<6R44;
)*6XY1
) )<+ *600<61
8)
+R<+(<<6;
6
<=> =0*61
)<+ *600<61
@
6
<=> =0*61; ..
/
< ( +<61
@
+ +6
<="*6(
-+7F(/.
+<
)
+RE=1
@
Solution 4 :
:
/7+& 7
(9)%
*

;
#"4<6<(6+=<
)
+9C=0=8=1

1 ) 1
C1
<(
1
&1
;
6
<=2(+A/ B+5=1
+ )1(/-
+ <=> =0? 1
+ )1
C<6/ 0<61

<C#6
<C1K/D 2WMCF1
+ +6
<C<K /D 2 MCF1
@
< ( +<61
@
Solution 5 :
:
/7+& 7
(9)%
*

;
#"4<6<(6+=<
)
+9C=0=8=1

1 ) )X'Y1
C1
<(
1
&1
;
6
<=2(+A/+ )a+7+ B+ 5=1
+ )1 (/-
+ <=> =0 )1
C<6/ )0<61

<C#
6
<C1K=/D 2WMCF1
+ +6
<C<K =/D 2 MCF1
@
:'

Les fichiers .
< ( +<61
@
Solution 6 :
:
/7+& 7
(9)%
:
/7+&
9)%
*

;
#"4<6<(6+=<
)
+9C=0=8=1

1 ) )X'Y1
C1
6
<C=/,K 2EC1
+ )1
<(
'1
& + )1
;
C<6/ )X
Y0<61

<C#
6
<C1K/D 2WMCFQ R1
@
< ( +<61
@
Solution 7 :
:
/7+& 7
(9)%
*

;
(/.++<
)
+ (/ +++ /+
#"4 (/ +<(6+=<
)
+9C=0==1

< (/ +R44;
(/.++<
)
+
-++3
/+
#"4
-+<(6+= (6
+9C=0=8=1

(/ + B+6 B+
+3
. )W/+ B+7
-+

<+ (/ +1
C1
<1
8)
+ R#;
C<6/ 0
-+1

<C#;
6
<C1K/D. 2WMCF1
<'1
@
<+ (/ +1
@

<<6
<C3. 2. 2 MC1
+ +6
<= )+ 7+K(6
+RE=1
< ( +
-+1
< ( + (/ +1
@
+ +6
<="*6(
-+7F(/.
<
)
+9CRE=1
@
Solution 8 :
:
/7+& 7
(9)%
.(
74
+J<
)
+
:6

Les fichiers .
;
#"4<6<(6+=<
)
+9C=0==1

<<6R44;
)*6XY1
) )<+ *600<61
8)
+R<+(<<6;
6
<=> =0*61
)<+ *600<61
@
6
<=> =0*61; ..
/
< ( +<61
@
+ +6
<="*6(
-+7F(/.
+<
)
+RE=1
@
.(
7K++J<
)
+
;
#"4<6<(6+=<
)
+9C=0=8=1

1 ) )X'Y1
C1 ) 1
7(;
6
<=2(+A/+ )a+7+ B+ 5=1
<=> =0 )1
C<6/ )0<61

<C#
6
<C1K=/D 2WMCF1
+ +6
<C<K =/D 2 MCF1
6
<=(/+A.(/ D(/+/+/+ )a+(G=1
+ )1
+ )1+ )1
@8)
+ RFF1
< ( +<61
@
.(
7!D(/+J<
)
+
;
#"4<6<(6+=<
)
+9C=0==1

1 ) )X'Y1
C1 ) 1
7(;
6
<=2(+A/+ )a+7+ B+ 5=1
<=> =0 )1
C<6/ )0<61

<C#
6
<C1K=/D 2WMCF1
+ +6
<C<K =/D 2 MCF1
6
<=(/+A.(/ D(/+/+/+ )a+(G=1
+ )1
+ )1+ )1
@8)
+ RFF1
< ( +<61
@
:7

Les fichiers .
*

;

)(
C1
7(;
6
<CM 2EMM$ FMM!3 FC1
6
<CMM#;, MM%Y .MC1
<=>7=0? )(
C1
8
) )(
C;
+54
+J<
)
+1-+V1
+5K++J<
)
+1-+V1
+5!D(/+J<
)
+1-+V1
+5-+V1
7+</56
<=K)(
C
(+ RR=1
@
@8)
+ )(
CR1
@
Solution 9 :
:
/7+& 7
(9)%
*

;
#"4<6<(6+=++9C=0=8=1
<(<1
6
<=2(+A/(*-+3+5=1
<=><=0?<1

C<6
<<60=><=0<1

<CR#6
<C$K / MC1
+ +6
<= )+ 7+ ( V+7 +<
)
+RE=1
< ( +<61
@
Solution 10 :
:
/7+& 7
(9)%
*

;
#"4<6<(6+=++9C=0==1
<(<1

C< <<60=><=0?<1

<CR#6
<C$
,. EDMCF1
+ +6
<= )+ 7++ /+_6
7/<
)
+RE=1
< ( +<61
@
Solution 11 :
:
/7+& 7
(9)%
I6+7+< / +*6(I+;

/*1
)(*X'Y06+(*X'Y1
@*6(I+1
*

;
:8

Les fichiers .
*6(I++1 ) 1
C1
,( V+3
/+7+ +*6(I3
#"4<6<(6+=+*6(I+ 9C=0=8=1
7(;
6
<=2(+A+/*3(7+F+*6(I35=1
<=>7=0?+9/*1
6
<=2(+A+(*7+F+*6(I35=1
<=> =0+9(*1
6
<=2(+A+63(*7+F+*6(I35=1
<=> =0+96+(*1
C<6
<<60=>7E> E> E=0+9/*0+9(*0+96+(*1

<CR#6
<C$K / MC1
+ +6
<= )+ 7+ ( V+7 +<
)
+RE=1
6
<=(/+A.(/ D(/+//++*6(I3(G=1
+ )1
+ )1+ )1
@8)
+ RFF1
< ( +<61
!<<
)++ /+7+ +*6(I3
<6<(6+=+*6(I+ 9C=0==1
C< <<60=>7E> E> E=0?+9/*0+9(*0+96+(*1

<CR#6
<CP .4 K EMC1
8)
+CR#;
6
<=E>7> > E=0+9/*0+9(*0+96+(*1
C< <<60=>7E> E> E=0?+9/*0+9(*0+96+(*1
@
< ( +<61
@
Solution 12 :
:
/7+& 7
(9)%
*

;
#"4<6<(6+=-( 9C=0=8=1

A+J-+<8
+=-(D(/=000<61

<-+6
<=,( V+.+ / B 9E=1
+ +6
<= )+ 7+ ( V+7 +<
)
+-( 9CRE=1
< ( +<61
@
Solution 13 :
:
/7+& 7
(9)%
*

;
#"4<6<(6+=-( 9C=0==1
) )X[Y1

A+J-<+7 )000<61

<-6
<=4 )a+/++ 5> 9E=0 )1
+ +6
<C1,.
2WMC1
< ( +<61
@
::

Les fichiers .
Solution 14 :
:
/7+& 7
(9)%
*

;

C1 )(*<
)
+X'Y1 ) 1
A+J-+0-1
#"4<61
,( V+3
/+7+ +
+
6
<=2(+A+(*7/<
)
+_ 3+5=1
<=> =0(*<
)
+1
<6<(6+(*<
)
+0=8=1

<<6R44;
7(;
6
<=2(+A/+
+5=1
<=>7=0?C1
-+<8
+?C0
A+(<C00<61

<-+6
<=,( V+.+ / B 9E=1
+ +6
<= )+ 7+ ( V+7 +<
)
+RE=1
6
<=(/+A.(/ D(/+//+(*-+(G=1
+ )1
+ )1+ )1
@8)
+ RFF1
< ( +<61
@
+ +6
<="*6(
-+7F(/.
+<
)
+RE=1
@
Solution 15 :
:
/7+& 7
(9)%
*

;

C1 )(*<
)
+X'Y1
A+J-1#"4<61
!<<
)++ /+7+ +
+
6
<=2(+A+(*7/<
)
+_
+5=1
<=> =0(*<
)
+1
<6<(6+(*<
)
+0==1

<<6R44;
6/ =(

+7+ +
+ ( V3 7 +<
)
+5=1
-<+7?C0
A+(<C00<61

<-6
<=E>7E=0C1
8)
+R<+(<<6??-;
-<+7?C0
A+(<C00<61

<-6
<=E>7E=0C1
@
< ( +<61
@
+ +6
<="*6(
-+7F(/.
+<
)
+RE=1
@
Solution 16 :
:
/7+& 7
(9)%
I6+7+< / +*6(I+;
!

Les fichiers .

/*1
)(*X'Y06+(*X'Y1
@*6(I+1
*

;
*6(I++1 ) 1
A+J-+0-1#"4<61
,( V+3
/+7+ +*6(I3
<6<(6+=+*6(I+ 9- =0=8=1
7(;
6
<=2(+A+/*3(7+F+*6(I35=1
<=>7=0?+9/*1
6
<=2(+A+(*7+F+*6(I35=1
<=> =0+9(*1
6
<=2(+A+63(*7+F+*6(I35=1
<=> =0+96+(*1
-+<8
+?+0
A+(<+00<61

<-+6
<=,( V+.+ / B 9E=1
+ +6
<= )+ 7+ ( V+7 +*6(I+ 9- RE=1
6
<=(/+A.(/ D(/+//++*6(I3(G=1
+ )1
+ )1+ )1
@8)
+ RFF1
< ( +<61
!<<
)++ /+7+ +*6(I3
<6<(6+=+*6(I+ 9- =0==1
6/ =(

+7+ +*6(I3 ( V3 7 +<
)
+5=1
-<+7?+0
A+(<+00<61

<-6
<=E>7> > E=0+9/*0+9(*0+96+(*1
8)
+R<+(<<6??-;
-<+7?+0
A+(<+00<61

<-6
<=E>7> > E=0+9/*0+9(*0+96+(*1
@
< ( +<61
@
Solution 17 :
:
/7+& 7
(9)%
:
/7+&
9)%
I6+7+< / +*6(I+;

/*1
)(*X'Y06+(*X'Y1
@*6(I+1
*

;
*6(I++1 ) 1
A+J-+0-1#"4<61
*6(I+*6(I+ X''Y1

0D1
,( V+3
/+7+ +*6(I3
<6<(6+=+*6(I+ 9- =0=8=1
7(;
6
<=2(+A+/*3(7+F+*6(I35=1
!

Les fichiers .
<=>7=0?+9/*1
6
<=2(+A+(*7+F+*6(I35=1
<=> =0+9(*1
6
<=2(+A+63(*7+F+*6(I35=1
<=> =0+96+(*1
-+<8
+?+0
A+(<+00<61

<-+6
<=,( V+.+ / B 9E=1
+ +6
<= )+ 7+ ( V+7 +*6(I+ 9- RE=1
6
<=(/+A.(/ D(/+//++*6(I3(G=1
+ )1
+ )1+ )1
@8)
+ RFF1
< ( +<61
,( V+7+ +*6(I3 7 /-+/7+ / /+
<6<(6+=+*6(I+ 9- =0==1

'1
-<+7?+0
A+(<+00<61

<-;
*6(I+ X
Y9/*+9/*1
6I*6(I+ X
Y9(*0+9(*1
6I*6(I+ X
Y96+(*0+96+(*1

1
@
8)
+R<+(<<6??-;
-<+7?+0
A+(<+00<61

<-;
*6(I+ X
Y9/*+9/*1
6I*6(I+ X
Y9(*0+9(*1
6I*6(I+ X
Y96+(*0+96+(*1

1
@
@
< ( +<61
!<<
)+7+ +*6(I3 _6
7+ +-+/

<
R'6/ CP .4 K EC1
<(D'1D&
1D
6
<CMDDDMCF1.4QR F1.4QR F1.4QR .1
@
Solution 18 :
:
/7+& 7
(9)%
I6+7+< / +*6(I+;

/*1
)(*X'Y06+(*X'Y1
@*6(I+1
*6(I+XY1
*

;
#"4<61

1
<6<(6+=+*6(I+ 9- =0=8=1
!!

Les fichiers .
<(
'1
&1
;
6
<=2(+A+/*3(7+F+*6(I3>75=0
1
<=>7=0?X
Y9/*1
6
<=2(+A+(*7+F+*6(I3>75=0
1
<=> =0X
Y9(*1
6
<=2(+A+63(*7+F+*6(I3>75=0
1
<=> =0X
Y96+(*1
@
<K> ?
.4

<8
+0
A+(<*6(I+00<61
< ( +<61
!<<
)++ /+7/<
)
+7+ +*6(I3
<6<(6+=+*6(I+ 9- =0==1
<+70
A+(<*6(I+00<61
<(
'1
&1
;
6
<=(

+
<(*
( 7+F+*6(I3>75E=0
1
6
<CM0EDF0EDF"EDMCF9Q R F9Q R F9Q R .1
@
< ( +<61
@
Solution 19 :
:
/7+& 7
(9)%
I6+7+< / +*6(I+;

/*1
)(*X'Y06+(*X'Y1
@*6(I+1
*

;
*6(I++1 )(*X'Y1
A+J-1#"4<61
+C
+1
!<<
)++ /+7+ +*6(I3
<6<(6+=+*6(I+ 9- =0==1

<<6R44;
6
<=2(+A+(*7+F+*6(I3W/+.(/ )+ )+A5=1
+ (*1
+C
+'1
-<+7?+0
A+(<+00<61

<-
< *6+9(*0(*';
6/ =(

+
<(*
( 7+F33*++ )+ )35=1
6
<CM0EDF0EDF"EDMCF F F .1
+C
+1
@
8)
+R<+(<<6??-??R+C
+;
-<+7?+0
A+(<+00<61

<-
< *6+9(*0(*';
6/ =(

+
<(*
( 7+F33*++ )+ )35=1
6
<CM0EDF0EDF" EDMCF F F .1
+C
+1
@
@
!#

Les fichiers .

<R+C
+6
<=3*+
(/.-+RE=1
< ( +<61
@+ +6
<="*6(
-+7F(/.
+<
)
+RE=1
@
Solution 20 :
:
/7+& 7
(9)%
*

;

C0I06(

(1 )(*<
)
+X'Y1
A+J-1
#"4<61
!<<
)++ /+7F/+
+
6
<=2(+A+(*7/<
)
+_(/.
5=1
<=> =0(*<
)
+1
6
<=2(+A6(

(7+F+
+_
+5=1
<=>7=0?6(

(1
<6<(6+(*<
)
+0==1

<<6R44;
I< ++V<606(

(
A+(<
0'1

<I';
-<+7?C0
A+(<C00<61

<-6
<=
+5>7E=0C1
@+ +6
<= )+ 7+6(

(+*+RE=1
< ( +<61
@
+ +6
<="*6(
-+7F(/.
+<
)
+RE=1
@
!%

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 dutiliser 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 lexécution
du programme. Les listes chaînées peuvent être étendues pendant lexécution
du programme par lallocation (réservation) dun nouvel espace mémoire quand
cest nécessaire. Elles peuvent être aussi réduites par une désallocation de
lespace non utile. La construction dune liste chaînée consiste à regrouper un
ensemble dobjets é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. Cest une variable qui au lieu de contenir la donnée, contient son
adresse en mémoire.
Format général : &I6+7+7(3+ %(*J6(
+/1
Exemple :
Pour déclarer un pointeur N vers un entier (contient ladresse dun entier), on
met :

-+

+N1
En C, un pointeur est déclaré comme suit :

N1
Si nous avions $ une variable entière ayant comme valeur , et N un pointeur
vers la variable entière $, les deux variables $ et N auraient pu être représentées
en mémoire comme suit :
;

X ! 7
#
%
'
[ 6 !
En fait, cette représentation nest pas tout à fait exacte, car réellement la
mémoire est constituée dun ensemble doctets, chacun est identifié par une
!'

adresse. La case mémoire correspondant à une variable est constituée dun

ensemble doctets selon son type. Ladresse dune variable est ladresse du
premier octet de lespace mémoire réservé (alloué) à la variable.
Un pointeur peut recevoir la valeur dun autre pointeur par une opération
daffectation. 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 dun 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
%'<! "(%-) !(":8<"(1*$))%88$'!%.*("6-$)%-"' ) $'"<$)
Lespace 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 dexploitation. Ç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
lexécution, et on parle dune gestion statique de la mémoire. La gestion
dynamique permet la réservation (allocation) de lespace pendant lexécution
du programme grâce à des variables de type pointeur.
Une variable de type pointeur contient ladresse dune variable dite variable
pointée.
Pour la gestion dynamique de la mémoire, on utilise principalement les deux
procédures :

!(/+6 qui permet de réserver un espace mémoire pour une variable
pointée par le pointeur 6. En C, cest la fonction
*( (*-+J( + , mais on écrit dune façon plus explicite et
sûre : 6&I6+J7(3+ %*(
A+(<&I6+J7(3+ %1
&I6+J7(3+ % étant le type délément vers lequel pointe 6. La fonction
*( retourne ladresse du premier octet réservé.
*( est à lorigine de type .(
7, i.e., *( retourne une adresse,
mais quon ne sait pas sur quel type elle pointe. Cest pourquoi, on
convertira ce .(
7 en un type plus explicite, tel que
, <(, etc.,
en fonction du besoin, et on met (&I6+J7(3+ %).
Pour éviter les erreurs lorsquon exprime la taille de la mémoire à allouer,
on utilisera la fonction
A+(<, qui renvoie la taille en octets dune
donnée du type spécifié en paramètre.

23 (/+6 qui permet de libérer lespace mémoire réservé à une
variable pointée par le pointeur 6. En C, cest <++6. La fonction <++
est souvent appelée directement par son nom dans un programme C
comme une procédure, sans quelle figure dans une expression.
!6

Les deux fonctions, *( et <++, appartiennent à la bibliothèque 7

-9).
Exemple :
!(
)*+6(
+/

-+

+I1
23-/
!(/+I1
)&P

+=4.+/+ 5=0I1
23 (/+I1
#

En C :
:
/7+& 7
(9)%
:
/7+& 7
-9)%
*

;
I1
I
*(
A+(<
1
I1
6
<=4.+/+ 5>7E=0I1
<++I1
@
Le programme C précédent permet de créer une variable I 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 lespace
réservé à la variable pointée.
Voyons ce que fait lexemple C suivant :
:
/7+& 7
(9)%
*

;
I1
C1
C1
I?C16
<=I>7E=0I1
I16
<=C>7E=0C1
<=>7=0?C16
<=C>7E=0C1
<=>7=0I16
<=C>7E=0C1
@
Après avoir déclaré un entier C et un pointeur vers un entier I, le programme C
précédent affecte la valeur à la variable C. Il affecte ladresse de la variable C,
indiquée par ?, à la variable I. Il affiche la valeur de la variable pointée par I
(I). La variable pointée par I aura par la suite . La valeur de C sera donc
, et le programme laffiche : C. Le programme va encore lire au clavier la
valeur de C et lafficher. Ces deux dernières opérations seront répétées deux fois.
Lopérateur de référençage ?, aussi appelé opérateur dadressage, permet de
connaitre ladresse dune variable. Il faut le placer devant la variable
considérée. Par exemple, supposons quon a une variable C déjà déclarée.
Alors, lexpression ?C correspond à ladresse de cette variable.
!7

Voyons encore un autre exemple :

:
/7+& 7
(9)%
*

;
I1
6
<=I>7E=0I1
6
<=I>7E=0I1
6
<=?I>7E=0?I1
@
Cet exemple affichera la valeur de la variable pointée ( I), ladresse de la
variable pointée, i.e. le contenu du pointeur ()C), et ladresse du pointeur,
qui est une adresse dune adresse (V)C).
Remarques :

Pour dire quun pointeur ne pointe vers aucun élément, il faut lui affecter la
valeur 44 de bibliothèque 7
-9). Une fois créé, un pointeur pointe
vers nimporte quel octet de la mémoire. Il est donc recommandé
dinitialiser ce pointeur à 44, sinon on risque davoir une erreur
dexécution.

Les deux fonctions *( et <++ utilisent une zone mémoire appelée
TAS (en anglais Heap). Quand cette zone est pleine, on aura une erreur
dexé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 dun ensemble déléments (maillons, cellules,
-0*.) 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.
I6+7+< / ++*+
;
&I6+J7(3+ % )*61
&I6+J7(3+ % )*61

/ ++*+,/
.1
@+*+1
On parle ici dune structure de données récursive (,/
. étant un pointeur
vers une structure de même type).
Une variable L de type pointeur vers +*+ (+*+ L) peut être
représentée comme suit :
"

!8

Ladresse de lélément est rangée dans la variable L. Lélément contient deux

parties : la partie données contenant les champs : )*6, )*66, et le
pointeur ,/
. contenant ladresse de lélément suivant (successeur). On
accède aux champs de données de lélément de ladresse L comme suit :
L% )*6, L% )*66
On accède à ladresse du successeur par L%,/
..
Remarque : Il ne faut pas confondre entre le point (9) et la flèche (%) pour
accéder aux champs dune structure. Pour accéder aux champs dune variable de
type structure, on utilise un point (eg. $9/*), mais pour accéder aux champs dune
variable de type pointeur vers structure, on utilise une flèche (eg. $%/*).
Exemple :
Soit une liste contenant les chaînes de caractères suivantes classées dans cet
ordre : ==, =] =, =*=, =,M!=, =+* +=.
La liste peut être représentée en mémoire comme suit :
;
9B ' 6

6 5 !
7
8 <;
:
9 0&$$

! * 6
#
Y %
'
6 0 8
Une deuxième représentation facile à être assimilée est la suivante :

5 * 0 <; 9 0&$$
9B Y
!:

Il nest pas possible daccéder directement à un élément quelconque de la liste.

Cest ladresse (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
+ suivante :
I6+7+< / .
+
;
)2+ X'Y1
/ .
+,/
.1
@
+1
2.On déclare deux variables ++ et e/+/+ comme suit :

+++0e/+/+1
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 ++ :
++
+*(
A+(<
+1

Remplir le premier élément de la liste :
6I++%2+ 0==1

A ce niveau, le premier élément et au même temps le dernier. Par
conséquent, la queue pointe vers la tête : e/+/+++1

Le successeur de la queue est 44 : e/+/+%,/
.441
Le tableau suivant décrit le changement détat de la mémoire selon les
instructions du programme :
Instruction Représentation en mémoire
9H>P J?> >P ??

9B
5
.4>9IFC5C?
9B
5
YH9
9B Y
!

5
YI< H0&$$
9B Y
4.Lajout dun 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 :
e/+/+%,/
.
+*(
A+(<
+1

La queue va pointer maintenant vers son successeur :
e/+/+e/+/+%,/
.1

Remplir le nouvel élément de la liste :
6Ie/+/+%2+ 0=] =1

Le successeur de la queue est le 44 : e/+/+%,/
.441
5
YI< H
>P J?> >P ??
9B Y
5
YHYI<
9B Y
5
.4>YIF
C*C? *
9B Y
5
YI< H0&$$ *
9B 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 lajout dun
é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 :
.(
7!D(/+Je )X'Y
;
e/+/+% /
.
+*(
A+(<
+1
e/+/+e/+/+%,/
.1
6Ie/+/+%2+ 01
!

e/+/+%,/
.441
@
Le programme C complet pour créer la liste des villes est alors le suivant :
:
/7+& 7
(9)%
:
/7+&
9)%
:
/7+& 7
-9)%
I6+7+< / .
+
;
)2+ X'Y1
/ .
+,/
.1
@
+1

+++0e/+/+1
L( 37/+7FD(/7F/33*+_<
7+
+
.(
7!D(/+Je )X'Y
;
e/+/+%,/
.
+*(
A+(<
+1
e/+/+e/+/+%,/
.1
6Ie/+/+%2+ 01
e/+/+%,/
.441
@
*

;
K3+++*6
+6+*
+33*+7+
+
++
+*(
A+(<
+1
6I++%2+ 0==1
e/+/+++1
e/+/+%,/
.441
!D(/+++ +7+ 33*+ _
+
!D(/+Je=] =1
!D(/+Je=*=1
!D(/+Je=,M!=1
!D(/+Je=+* +=1
@
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.
L( 37/+7F<<
)+7+ 33*+ 7+
+
.(
7!<<
)+J4
+
;

+L1

1
L++1

'1
8)
+LR44;
6
<=4F33*+/*b>77+
++ 5> E=0
0L%2+ 1

1
LL%,/
.1
@
!!

@
Remarque : Si on remplace la condition (LR44) par (L%,/
.R
44), le dernier élément de la liste ne sera pas affiché.
On peut aussi parcourir une liste chaînée par une boucle <( de la manière
suivante :
L( 37/+7F<<
)+7+ 33*+ 7+
+
.(
7!<<
)+J4
+
;

+L1

1

'1
<(L++1LR441LL%,/
.;
6
<=4F33*+/*b>77+
++ 5> E=0
0L%2+ 1

1
@
@
5.3. Ajouter un élément au début de la liste
Lajout dun élément au début de la liste se fait comme suit :

On réserve un espace mémoire pour une variable L de type pointeur
vers
+ : L
+*(
A+(<
+1

Remplir le nouvel élément pointé par L : 6IL%2+ 01

On effectue lenchaînement du nouvel élément avec la liste
existante : L%,/
.++1

La tête va pointer maintenant vers le nouvel élément : ++L1
instructions de la procédure :
"H>P J?> >P ??

"
P
.4>"IFP?
"
P
"I< H9
" 9B
P
9H"
" 9B
!#

Noubliez 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 lajout dun élément au début de la liste est alors la
suivante :
L( 37/+7FD(/7F/33*+/73-/7+
+
.(
7!D(/+J )X'Y
;
+L1
L
+*(
A+(<
+1
6IL%2+ 01
L%,/
.++1
++L1

<e/+/+44e/+/+++1
@
5.4. Insérer un élément dans la liste
On désir maintenant implémenter une procédure permettant dinsérer un
élément après un autre dans une liste (insérer une ville après ). Pour ce
faire, on aura besoin de déclarer deux variables L et L pointant vers une
ville :
+L0L. Le pointeur L va pointer vers lélément à insérer (un
nouvel élément contenant la ville ). Le pointeur L va nous permettre de
localiser la ville dans la liste. Après ça, on doit suivre les étapes suivantes :

Le successeur de L devient le successeur de L :
L%,/
.L%,/
.1

Le successeur de L devient L lui même : L%,/
.L1
Le tableau suivant décrit ces deux dernières étapes :
"! P!
)J; J) P
"

"! P!
"!I< H
"I< P
"

"! P!
"I< H"! P
"

!%

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

suivante :
L( 37/+7F
+
(7F/+.
+6B 7
+
.(
7" ++J!LJ
+ )X'Y0 )X'Y
;

+L0L1

< *6e/+/+%2+ 0'!D(/+Je1
+ +;
,+6(
+.+ F33*+ (+
L++1
8)
+ *6L%2+ 0R'LL%,/
.1
K3+/(/.+33*+ (+
L
+*(
A+(<
+1
6IL%2+ 01
" 3++(/.+33*+7
+
L%,/
.L%,/
.1
L%,/
.L1
@
@
Remarque : Dans la procédure ci-dessus, on suppose que existe
obligatoirement dans la liste. Il faut donc que cette procédure soit enrichie par
le traitement du cas où nexiste 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 L pointant vers une
ville :
+L. Ensuite, il faut suivre les étapes suivantes :

La variable L sera utilisée pour garder ladresse du premier élément :
L++1

Maintenant, on met à jour ladresse de la nouvelle tête de la liste :
++++%,/
.1

Enfin, on libère lespace mémoire réservé par lancienne tête :
<++L1
instructions de la procédure :

"H9

" 9B

9H9I<
" 9B
!'


>"?

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

suivante :
L( 37/+7+ /66+
(7+\+7+
+
.(
7,/66
*+J
;

+L1

<++R44

<++%,/
.44;
<++++1
++441
e/+/+441
@
+ +;
L++1
++++%,/
.1
<++L1
@
@
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 dun élément de la liste possède un
paramètre indiquant la ville à supprimer. Dans cette procédure, on aura
besoin de déclarer deux variables L et L pointant vers une ville :
+L0
L. Le pointeur L va pointer vers lélément à supprimer. Le pointeur L
pointe juste avant L. Après ça, on doit suivre les étapes suivantes :

Le successeur de L devient le successeur de L :
L%,/
.L%,/
.1

Libérer lespace mémoire occupé par lélément supprimé :
<++L1
Le tableau suivant décrit ces deux dernières étapes :
"! P
)J;
.. J)
"

!6

"! P
"I< H
"!I<
"
"! P
>"!?

"

Noubliez 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 :
L( 37/+7+ /66+
(7F/33*+7+
+
.(
7,/66
*+ )X'Y
;
+L0L1

< *6++%2+ 0',/66
*+J1
+ +;
,+6(
+.+ F33*+ (+
L++1
LL%,/
.1
8)
+ *6L%2+ 0R';
LL1
LL%,/
.1
@
*,\O ,..

<e/+/+Le/+/+L1
,/66
*+F33*+ (+
L%,/
.L%,/
.1
<++L1
@
@
Remarque : Dans la procédure ci-dessus, on suppose que existe
obligatoirement dans la liste. Il faut donc que cette procédure soit enrichie par
le traitement du cas où nexiste 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 laccè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.
!7

Lensemble des villes stockées dans une liste doublement chaînée peut être
représenté comme suit :
0&$$ 5 * 0 <; 9 0&$$
9B 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
+ suivante :
I6+7+< / .
+
;
)2+ X'Y1
/ .
+L+ +7+0,/
.1
@
+1
2.On déclare deux variables ++ et e/+/+ comme suit :

+++0e/+/+1
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 ++ :
++
+*(
A+(<
+1

Remplir le premier élément de la liste :
6I++%2+ 0==1
Le premier élément na pas de précédent, ce qui se traduit par :
++%L+ +7+441

A ce niveau, le premier élément et au même temps le dernier. Par
conséquent, la queue pointe vers la tête : e/+/+++1
Le successeur de la queue est le 44 : e/+/+%,/
.441
9H>P J?> >P ??

9B
5
.4>9IFC5C?

9I"H0&$$ 9B

YH9 5

YI< H0&$$ 9B Y
!8

4.Lajout dun 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 :
e/+/+%,/
.
+*(
A+(<
+1

Le nouvel élément créé sera précédé par la queue :
e/+/+%,/
.%L+ +7+e/+/+1

La queue va pointer maintenant vers son successeur :
e/+/+e/+/+%,/
.1

Remplir le nouvel élément de la liste :
6Ie/+/+%2+ 0=] =1
Le successeur de la queue est le 44 :e/+/+%,/
.441
5
YI< H
>P J?> >P ??
9B Y
5
YI< I"
HY
9B Y
5
YHYI<
9B Y
.4>YIF 5

C*C?
*
YI< H0&$$ 9B 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 lajout dun
é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 :
.(
7!D(/+Je )X'Y
;e/+/+%,/
.
+*(
A+(<
+1
e/+/+%,/
.%L+ +7+e/+/+1
e/+/+e/+/+%,/
.1
6Ie/+/+%2+ 01
e/+/+%,/
.441
@
!:

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

alors le suivant :
:
/7+& 7
(9)%
:
/7+&
9)%
:
/7+& 7
-9)%
I6+7+< / .
+
;
)2+ X'Y1
/ .
+L+ +7+0,/
.1
@
+1

+++0e/+/+1
L( 37/+7FD(/7F/33*+_<
7+
+
.(
7!D(/+Je )X'Y
;e/+/+%,/
.
+*(
A+(<
+1
e/+/+%,/
.%L+ +7+e/+/+1
e/+/+e/+/+%,/
.1
6Ie/+/+%2+ 01
e/+/+%,/
.441
@
*

;K3+++*6
+6+*
+33*+7+
+
++
+*(
A+(<
+1
6I++%2+ 0==1
++%L+ +7+441
e/+/+++1
e/+/+%,/
.441
!D(/+++ +7+ 33*+ _
+
!D(/+Je=] =1
!D(/+Je=*=1
!D(/+Je=,M!=1
!D(/+Je=+* +=1
@
7. Les listes chaînées particulières
En conditionnant laccè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 dune 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 dassiettes.
La pile peut être représentée tout simplement comme suit :
<

!!

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 lexé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 :

*6
+ qui ajoute un nouvel élément au sommet de la pile.

236
+ qui supprime lélément sommet de la pile
Exemple : Dans une pile de caractères contenant initialement les éléments : !,
M et K, on désir empiler encore le caractère 2, ensuite dépiler deux caractères.
Ces opérations peuvent être représentées comme suit :
<

< <
3 3 3
<

; ; ; ;
1. 1.

1 1.
./ . >? ./ . >?
. ./1. >OO?
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 :

Lopération dempilement se traduit par un ajout en tête de la liste
doublement chaînée.

Lopé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
Pour la manipulation dune pile de caractères, on doit suivre les étapes
suivantes :
1.On définit la structure L
+ comme suit :
I6+7+< / 6
+
;
)K1
/ 6
+L+ +7+0,/
.1
@L
+1
!!

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

L
+M +0,(**+1
3.La procédure permettant dempiler un élément dans la pile est la suivante :
L( 37/+6+*+7F+*6
+/33*+7 6
+
.(
7*6
+ )K
;
L
+L1
LL
+*(
A+(<L
+1
L%KK1
L%L+ +7+441
L%,/
.,(**+1

<,(**+R44,(**+%L+ +7+L1
,(**+L1

<M +44M +,(**+1
@
4.La procédure permettant de dépiler un élément de la pile est la suivante :
L( 37/+6+*+7+736
+/33*+7+6
+
.(
72+6
+
;

<,(**+446/ =236
+*+
*6(
-+5L
+
7+9=1
+ +
<,(**+%,/
.44;
6
<=3*+736
35> E=0,(**+%K1
<++,(**+1
,(**+441
M +441
@
+ +;6
<=3*+736
35> E=0,(**+%K1
,(**+,(**+%,/
.1
<++,(**+%L+ +7+1
,(**+%L+ +7+441
@
@
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 lautre 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 dattente à un guichet.
La file peut être représentée tout simplement comme suit :
9B Y
Le premier élément de la file est appelé Tête de la file. Le dernier est appelé
Queue de la file.
!!!

Remarque : Il ne faut pas confondre entre le mot file (en français), et le mot
#"4 (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 lexemple 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 : !, M et K. On
désir ajouter le caractère 2, ensuite supprimer deux caractères. Ces opérations
peuvent être représentées comme suit :
9B Y 9B Y
; 3 ; 3
1 1 ./1 >OO?
9B Y 9B Y
3 3
1 ./ 1 ./
>? >?
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 :

Lopération denfilement se traduit par un ajout en queue de la liste

Lopération de défilement se traduit par la suppression de la tête de la liste

La tête et la queue de la file étant la tête et la queue de la liste doublement
chaînée.
8.1. Exercices
Exercice 1 :
Rappelons que le nom du tableau correspond à ladresse de la première case du
tableau. Rappelons aussi quon peut additionner un entier à un pointeur pour
avoir un nouveau pointeur (ladresse de lemplacement mémoire suivant), donc
un pointeur peut être incrémenté. Exploitez ces propriétés pour dire ce
quaffiche le programme suivant :
:
/7+& 7
(9)%
!!#

*

;

XY;0H00[@1

60
1
<(
'1
&1
;
6
<=>7E=061
61" 3*+++6(
+/7/+/
37(+7+ +
7+33*++
+7 ++C+
+ /
.
@
@
Exercice 2 :
En utilisant la notion de gestion dynamique de la mémoire, et en exploitant le
fait que le nom dun 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 dafficher
le contenu de ce tableau.
Exercice 3 :
:
/7+& 7
-9)%
:
/7+& 7
(9)%
*

;

707071

'06'1
7?1
7?61
771
6
<=>7E=01
71
6
<=>7E=01
7
*(
A+(<
1
761
6
<=>7E=071
@
Exercice 4 :
Expliquez ce que fait le programme suivant, partie par partie :
:
/7+& 7
(9)%
:
/7+& 7
-9)%
*

;

C061
L(
+/
L
+?6
C1
6?C1
6
<=+/6(
3+665>7E=061
L
+?6
!!%

6
*(
A+(<
1

<6R44;
61
6
<=+/6(
3+665>7E=061
<++61
@
4
+
L
+?6
I6+7+< / J+*+
;

.+/1
/ J+*+ /
.1
@+*+1
L
+?66
+*+++0e/+/+1
L
+?66
+++*+*(
A+(<+*+1
++%.+/['1
++% /
.441
e/+/+++1
L
+H?6
e/+/+% /
.+*+*(
A+(<+*+1
e/+/+e/+/+% /
.1
e/+/+%.+/[[1
e/+/+% /
.441
L
+?6
6
<=++>7E=0++%.+/1
6
<=e/+/+>7E=0e/+/+%.+/1
@
Exercice 5 :
Expliquez la différence entre les deux programmes C :
Programme 1 : Programme 2 :
:
/7+& 7
(9)% :
/7+& 7
(9)%
0-0)1
0-0)1
.(
7 )+
C .(
7 )+
C
;C?1@ ;C?1@
*
*

; ;
1-1 1-1
)?-1 )?-1
)+)1 )+?)1
6
<=>7E=0)1 6
<=>7E=0)1
@ @
Exercice 6 :
:
/7+& 7
(9)%
:
/7+&
9)%
:
/7+& 7
-9)%
!!'

I6+7+< / .
+
;
)2+ X'Y1
/ .
+,/
.1
@
+1

+++0e/+/+1
L( 37/+7FD(/7F/33*+_<
7+
+
.(
7!D(/+Je )X'Y
;
e/+/+%,/
.
+*(
A+(<
+1
e/+/+e/+/+%,/
.1
6Ie/+/+%2+ 01
e/+/+%,/
.441
@
L( 37/+7F<<
)+7+ 33*+ 7+
+
.(
7!<<
)+J4
+
;

+L1

1
L++1

'1
8)
+LR44;
6
<=4F33*+/*b>77+
++ 5> E=0
0L%2+ 1

1
LL%,/
.1
@
@
L( 37/+7FD(/7F/33*+/73-/7+
+
.(
7!D(/+J )X'Y
;

+L1
L
+*(
A+(<
+1
6IL%2+ 01
L%,/
.++1
++L1

<e/+/+44e/+/+++1
@
L( 37/+7F
+
(7F/+.
+6B 7
+
.(
7" ++J!LJ
+ )X'Y0 )X'Y
;

+L0L1

< *6e/+/+%2+ 0'!D(/+Je1
+ +;
,+6(
+.+ F33*+ (+
L++1
8)
+ *6L%2+ 0R'LL%,/
.1
K3+/(/.+33*+ (+
L
+*(
A+(<
+1
6IL%2+ 01
" 3++(/.+33*+7
+
!!6

L%,/
.L%,/
.1
L%,/
.L1
@
@
L( 37/+7+ /66+
(7+\+7+
+
.(
7,/66
*+J
;

+L1

<++R44

<++%,/
.44;
<++++1
++441
e/+/+441
@
+ +;
L++1
++++%,/
.1
<++L1
@
@
L( 37/+7+ /66+
(7F/33*+7+
+
.(
7,/66
*+ )X'Y
;

+L0L1

< *6++%2+ 0',/66
*+J1
+ +;
,+6(
+.+ F33*+ (+
L++1
LL%,/
.1
8)
+ *6L%2+ 0R';
LL1
LL%,/
.1
@
*,\O ,..

<e/+/+Le/+/+L1
,/66
*+F33*+ (+
L%,/
.L%,/
.1
<++L1
@
@
*

;
K3+++*6
+6+*
+33*+7+
+
++
+*(
A+(<
+1
6I++%2+ 0==1
e/+/+++1
e/+/+%,/
.441
!D(/+++ +7+ 33*+ _
+
!D(/+Je=] =1
!D(/+Je=*=1
!!7

!D(/+Je=,M!=1
!D(/+Je=+* +=1
!D(/+J=M+ )=1
" ++J!LJ
+=M+ )=0=M
7=1
,/66
*+J1
,/66
*+=] =1
!<<
)+J4
+1
@
Exercice 7 :
Ecrire en C une procédure dajout dun é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 dinsérer un élément après un autre dans
une liste doublement chaînée (insérer une ville après 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 lespace 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 dun é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 indiquant la ville à supprimer.
Exercice 11 :
Ecrire en C une procédure permettant dafficher les éléments de la liste
doublement chaînée (la liste des villes créée dans le cours).
Exercice 12 :
:
/7+& 7
(9)%
:
/7+&
9)%
:
/7+& 7
-9)%
I6+7+< / .
+
;
)2+ X'Y1
/ .
+L+ +7+0,/
.1
@
+1

+++0e/+/+1
L( 37/+7FD(/7F/33*+_<
7+
+
.(
7!D(/+Je )X'Y
;
e/+/+%,/
.
+*(
A+(<
+1
e/+/+%,/
.%L+ +7+e/+/+1
e/+/+e/+/+%,/
.1
6Ie/+/+%2+ 01
!!8

e/+/+%,/
.441
@
L( 37/+7F<<
)+7+ 33*+ 7+
+
.(
7!<<
)+J4
+J
;

+L1

1
L++1

'1
8)
+LR44;
6
<=4F33*+/*b>77+
++ 5> E=0
0L%2+ 1

1
LL%,/
.1
@
@
L( 37/+7F<<
)+7+ 33*+ 7+
+e
.(
7!<<
)+J4
+Je
;

+L1

1
Le/+/+1

'1
8)
+LR44;
6
<=4F33*+/*b>77+
++ 5> E=0
0L%2+ 1

1
LL%L+ +7+1
@
@
L( 37/+7FD(/7F/33*+/73-/7+
+
.(
7!D(/+J )X'Y
;

+L1
L
+*(
A+(<
+1
6IL%2+ 01
L%L+ +7+441
L%,/
.++1

<++R44++%L+ +7+L1
++L1

<e/+/+44e/+/+++1
@
L( 37/+7F
+
(7F/+.
+6B 7
+
.(
7" ++J!LJ
+ )X'Y0 )X'Y
;

+L0L1

< *6e/+/+%2+ 0'!D(/+Je1
+ +;
,+6(
+.+ F33*+ (+
L++1
8)
+ *6L%2+ 0R'LL%,/
.1
K3+/(/.+33*+ (+
!!:

L
+*(
A+(<
+1
6IL%2+ 01
" 3++(/.+33*+7
+
L%,/
.L%,/
.1
L%L+ +7+L1
L%,/
.L1
L%,/
.%L+ +7+L1
@
@
L( 37/+7+ /66+
(7+\+7+
+
.(
7,/66
*+J
;

<++R44

<++%,/
.44;
<++++1
++441
e/+/+441
@
+ +;
++++%,/
.1
<++++%L+ +7+1
++%L+ +7+441
@
@
L( 37/+7+ /66+
(7F/33*+7+
+
.(
7,/66
*+ )X'Y
;

+L1

< *6++%2+ 0',/66
*+J1
+ +;
,+6(
+.+ F33*+ (+
L++1
8)
+ *6L%2+ 0R'LL%,/
.1
*,\O ,..

<e/+/+Le/+/+L%L+ +7+1
,/66
*+F33*+ (+
L%L+ +7+%,/
.L%,/
.1

<L%,/
.R44L%,/
.%L+ +7+L%L+ +7+1
<++L1
@
@
*

;K3+++*6
+6+*
+33*+7+
+
++
+*(
A+(<
+1
6I++%2+ 0==1
++%L+ +7+441
e/+/+++1
e/+/+%,/
.441
!D(/+++ +7+ 33*+ _
+
!D(/+Je=] =1
!#

!D(/+Je=*=1

!D(/+Je=,M!=1
!D(/+Je=+* +=1
!D(/+J=M+ )=1
" ++J!LJ
+=,M!=0=M
7=1
,/66
*+J1
,/66
*+==1
!<<
)+J4
+J1
@
Exercice 13 :
Ecrire un programme C permettant de lire et dafficher 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 dafficher une liste simplement
chaînée. Chaque élément est de type structure L+ (+ contenant les
informations : /* de type entier et (* de type chaîne de caractères. Utilisez
une procédure pour lajout dune 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 ++ et e/+/+ pointant vers L+ (+.
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 lespace mémoire occupé par la
liste des personnes déjà créée dans lexercice 14.
Exercice 16 :
Ecrire en C une fonction entière permettant de calculer la longueur dune liste.
Les éléments de la liste étant de type L+ (+ décrit dans lexercice 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 dun é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 lexercice précédent de telle sorte que cette fonction
retourne un pointeur vers lélément recherché sil existe. Dans le cas contraire,
elle pointe vers le 44.
Exercice 19 :
Ecrire en C une fonction qui retourne un pointeur vers le nième élément de la
liste des personnes. Si dépasse la taille de la liste, la fonction retourne 44.
!#

Si est inférieur à ', la fonction retourne 44 aussi. La fonction doit posséder
comme paramètres la tête de la liste et le numéro dordre, commençant par 0,
de lélément désiré.
Exercice 20 :
Ecrire en C la procédure permettant dinsérer un élément à la kième position dans
une liste de personnes. Si k<=0, lajout sera en tête de la liste. Si V dépasse la
longueur de la liste, lajout 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, cest la tête qui sera supprimée
de la liste. Si le V 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 dafficher 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 dafficher 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 dune liste est de type structure (*-+ contenant une
information : de type entier. Utilisez une procédure pour la création dune
liste. Cette procédure doit posséder la tête et la queue dune liste comme
paramètres. Pour lajout dun é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 dune 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 ++ et e/+/+. La
tête et la queue de la deuxième liste étant captés par deux pointeurs ++ et
e/+/+.
Exercice 25 :
Ecrire en C une fonction qui retourne la somme des éléments dune 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 dune liste de nombres, de créer
deux listes de nombres : la première ayant des nombres impairs, la deuxième
!#!

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 (*-+ 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 cest 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 (*-+ 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 dinsérer un élément dans une liste triée
en ordre croissant. Les éléments de la liste étant de type (*-+ 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 (*-+ 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 lexercice 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 linsertion dun élément avant un autre
dans la liste doublement chaînée créée dans lexercice 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
linsertion.
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 (/* et (*) napparaisse quune seule fois dans cette
liste.
!##

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 :

H

[

Solution 2 :
:
/7+& 7
(9)%
:
/7+& 7
-9)%
*

;
0
01
6
<=2(+A+(*-+7F33*+ 7/-+/5=1
<=>7=0?1

*(
A+(<
1
6/ =2(+A+ 33*+ 7/-+/5=1
<(
'1
&1
<=>7=0?X
Y1
6/ =(

+ 33*+ 7/-+/5=1
<(
'1
&1
6
<=>7E=0X
Y1
@
Solution 3 :

H
H

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 dun é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.
!#%

Solution 5 :
Dans le premier programme, le pointeur C est passé par valeur à la procédure
)+. Lappel de la procédure )+ avec le paramètre effectif ) ne
change pas la valeur de ce dernier, et elle restera ?-. Donc, cest la valeur de -
qui sera affichée, à savoir .
Dans le deuxième programme, le pointeur C est passé par adresse à la
procédure )+, cest pourquoi nous avons mis
C. Lappel de la
procédure )+ avec ?) changera la valeur de ), et elle deviendra ?. Par
conséquent, cest la valeur de qui sera affichée, à savoir .
Solution 6 :
4F33*+/*b'7+
++ 5M
7
4F33*+/*b7+
++ 5
4F33*+/*b7+
++ 5*
4F33*+/*b7+
++ 5,M!
4F33*+/*b7+
++ 5+* +
Solution 7 :
L( 37/+7FD(/7F/33*+/73-/7+
+
7(/-+*+ )a3+7+ .
+
.(
7!D(/+J )X'Y
;

+L1
L
+*(
A+(<
+1
6IL%2+ 01
L%L+ +7+441
L%,/
.++1

<++R44++%L+ +7+L1
++L1

<e/+/+44e/+/+++1
@
Solution 8 :
L( 37/+7F
+
(7F/+.
+6B 7
+
7(/-+*+ )a3+7+ .
+
.(
7" ++J!LJ
+ )X'Y0 )X'Y
;

+L0L1

< *6e/+/+%2+ 0'!D(/+Je1
+ +;
,+6(
+.+ F33*+ (+
L++1
8)
+ *6L%2+ 0R'LL%,/
.1
K3+/(/.+33*+ (+
L
+*(
A+(<
+1
6IL%2+ 01
" 3++(/.+33*+7
+
!#'

L%,/
.L%,/
.1
L%L+ +7+L1
L%,/
.L1
L%,/
.%L+ +7+L1
@
@
Solution 9 :
L( 37/+7+ /66+
(7+\+7+
+7(/-+*+
)a3+7+ .
+
.(
7,/66
*+J
;

<++R44

<++%,/
.44;
<++++1
++441
e/+/+441
@
+ +;
++++%,/
.1
<++++%L+ +7+1
++%L+ +7+441
@
@
Solution 10 :
L( 37/+7+ /66+
(7F/33*+7+
+
7(/-+*+ )a3+7+ .
+
.(
7,/66
*+ )X'Y
;

+L1

< *6++%2+ 0',/66
*+J1
+ +;
,+6(
+.+ F33*+ (+
L++1
8)
+ *6L%2+ 0R'LL%,/
.1
*,\O ,..

<e/+/+Le/+/+L%L+ +7+1
,/66
*+F33*+ (+
L%L+ +7+%,/
.L%,/
.1

<L%,/
.R44L%,/
.%L+ +7+L%L+ +7+1
<++L1
@
@
Solution 11 :
La procédure permettant dafficher la liste des villes doublement chaînée créée
dans le cours de gauche à droite est la suivante :
L( 37/+7F<<
)+7+ 33*+ 7+
+7+ .
+ _
6
7+\+
.(
7!<<
)+J4
+J
!#6

;

+L1

1
L++1

'1
8)
+LR44;
6
<=4F33*+/*b>77+
++ 5> E=0
0L%2+ 1

1
LL%,/
.1
@
@
La procédure permettant dafficher la liste des villes doublement chaînée créée
dans le cours de droite à gauche est la suivante :
L( 37/+7F<<
)+7+ 33*+ 7+
+7+ .
+ _
6
7+W/+/+
.(
7!<<
)+J4
+Je
;

+L1

1
Le/+/+1

'1
8)
+LR44;
6
<=4F33*+/*b>77+
++ 5> E=0
0L%2+ 1

1
LL%L+ +7+1
@
@
Solution 12 :
4F33*+/*b'7+
++ 5]
4F33*+/*b7+
++ 5*
4F33*+/*b7+
++ 5,M!
4F33*+/*b7+
++ 5M
7
4F33*+/*b7+
++ 5+* +
Solution 13 :
:
/7+& 7
(9)%
:
/7+& 7
-9)%

+J+
+
;
60+ /1
6
*(
A+(<
1
6
<=+AF+
+5=1 <=>7=061
+ /61
<++61
+/+ /1
@
*

;
C1
!#7

C
+J+
+1
6
<=(

F+
+5>7E=0C1
@
Solution 14 :
:
/7+& 7
(9)%
:
/7+&
9)%
:
/7+& 7
-9)%
I6+7+< / 6+ (+
;

/*1
)(*X'Y1
/ 6+ (+,/
.1
@L+ (+1
L+ (+++0e/+/+1
L( 37/+7FD(/7F/33*+_<
7+
+
.(
7!D(/+JJe
0 )]X'Y
;

<++44;
K3+++*6
+6+*
+33*+7+
+
++L+ (+*(
A+(<L+ (+1
++%/*1
6I++%(*0]1
e/+/+++1
e/+/+%,/
.441
@
+ +;
!D(/7F/33*+_<
7+
+
e/+/+%,/
.L+ (+*(
A+(<L+ (+1
e/+/+e/+/+%,/
.1
e/+/+%/*1
6Ie/+/+%(*0]1
e/+/+%,/
.441
@
@
L( 37/+7F<<
)+7+ 33*+ 7+
+
.(
7!<<
)+J4
+
;
L+ (+L1
L++1

<LR446/ =(

4+ 33*+ 7+
+5=1
+ +6/ =4
+.
7+9=1
8)
+LR44;
6
<=/*5>70(*5> E=0L%/*0L%(*1
LL%,/
.1
@
@
*

;
++441e/+/+441
!#8

) 0 X'Y1

1
7(;
6
<=(/+A.(/ D(/+/33*+_
+(G=1
+ )1+ )1

< F(F;
6
<=2(+A+/*7+6+ (+_D(/+5=1
<=>7=0?1
6
<=2(+A+(*7+6+ (+_D(/+5=1
<=> =0 1+ )1
!D(/+JJe0 1
@
@8)
+ RFF1
!<<
)+J4
+1
@
Pour obtenir une liste simplement chaînée circulaire, il faut ajouter après la
création de la liste, linstruction : e/+/+%,/
.++1
Solution 15 :
L( 37/+ 7+
-3
( 7+ F+ 6 + *3*(
+ ( /63 6

+7+ 6+ (+
.(
74
-++J4
+
;
L+ (+L1
L++1
8)
+LR44;
++++%,/
.1
<++L1
L++1
@
e/+/+441
@
Solution 16 :
#(
( 7+ / 7+ (/+/ 7+
+ 7+
6+ (+
4(/+/J4
+L+ (+
;L+ (+L1
L1
4'1
8)
+LR44;
41
LL%,/
.1
@
+/41
@
Solution 17 :
#(
( 7+ + )+ )+ 7F/ 33*+ 7
+ 7+
6+ (+
+ )+ )+J4
+
0 )]X'Y0L+ (+
;
!#:

L+ (+L1
L1
C
'1
8)
+LR44??RC

<L%/*?? *6L%(*0]'C
1
+ +LL%,/
.1
+/C
1
@
Solution 18 :
#(
( 7+ + )+ )+ 7F/ 33*+ 7
+ 7+
6+ (+
L+ (+ + )+ )+J4
+
0 )]X'Y0L+ (+
;
L+ (+L0C
1
L1C
441
8)
+LR44??C
44

<L%/*?? *6L%(*0]'C
L1
+ +LL%,/
.1
+/C
1
@
Solution 19 :
#(
( 7+ + )+ )+ 7/
+*+ 33*+ 7+
+ 7+
6+ (+
L+ (+
+*+J+*+J4
+
0L+ (+
;
L+ (+L1

<%'L1
+ +L441

'1
8)
+LR44??&;
LL%,/
.1
1
@
+/L1
@
Solution 20 :
L( 37/+7F
+
(7F/33*+_V
B*+6(

(7

+7+ 6+ (+
.(
7 " ++Jf
0 ) ]X'Y0
V0 L+ (+ 0
L+ (+e
;
L+ (+L0L1
'1
LL+ (+*(
A+(<L+ (+1
L%/*1
6IL%(*0]1
L%,/
.441

<44;
,

++

+*+.
7+
L1eL1
!%

@
+ +

<V&';
!D(/+++7+
+
L%,/
.1
L1
@+ +;
" 3+/33*+7
+
L1
8)
+L%,/
.R44??&V;
LL%,/
.11
@
L%,/
.L%,/
.1
L%,/
.L1

<eLeL1
@
@
Remarque : Le premier élément de la liste possède la position 0. Pour insérer la
personne =]()*+7= dont le numéro est à la position , on appelle la
procédure par : " ++Jf0=]()*+7=00?++0?e/+/+1
Solution 21 :
L( 37/+7+ /66+
(7+33*+7+V
B*+6(

(7

+7+ 6+ (+
.(
7,/66
*+Jf
V0L+ (+0L+ (+e
;
L+ (+L0L1
'1

<44;
,

++

+*+.
7+
6/ =4
+.
7+9,/66+
(
*6(
-+9=1
@
+ +

<V&';
,/66+
(7+++7+
+
L1
L%,/
.1

<eLe1
6
<C1 <.. 0EDF0EDMCF"I0F"I01
<++L1
@+ +

<%,/
.44;
<++1
441
e441
@+ +;
,/66
*+/33*+7+
+
L1
8)
+L%,/
.R44??&V;
LL%,/
.11
!%

@
LL%,/
.1

<LR44L%,/
.L%,/
.1

<eLeL1
6
<C1 <.. 0EDF0EDMCF"I0F"I01
<++L1
@
@
Remarque : De même que pour linsertion, la position du premier élément est 0.
Pour supprimer lélément dont la position est , on met :
,/66
*+Jf0?++0?e/+/+1
Solution 22 :
L( 37/+7++.+ +*+7+
+7+ 6+ (+
.(
7 +.+ +L+ (+0L+ (+e
;
L+ (+L0L1

<R44;
L1
8)
+L%,/
.R44;
LL%,/
.1
L%,/
.L%,/
.1
L%,/
.1
L1
@
eL1
@
@
Remarque : Lappel de la procédure se fait par :
+.+ +?++0?e/+/+1
Solution 23 :
L( 37/+ 3 /
.+ 7F<<
)+ 7+ 33*+ 7+
+
7+ 6+ (+
.(
7!<<
)+J4
+J L+ (+
;

<R44;
6
<=/*5>70(*5> E=0%/*0%(*1
!<<
)+J4
+J %,/
.1
@
@
Remarque : Lappel de la procédure se fait par : !<<
)+J4
+J ++1
Solution 24 :
:
/7+& 7
(9)%
:
/7+& 7
-9)%
I6+7+< / (*-+;

1
/ (*-+,/
.1
@(*-+1
!%!

(*-+++0++0e/+/+0e/+/+1
) 1
L( 37/+7FD(/7F/33*+_
+
.(
7!D(/+J(*-+(*-+e
;
e%,/
.(*-+*(
A+(<(*-+1
ee%,/
.1
6
<=2(+A.+/7+ +33*+5=1
<=>7=0?e%1
e%,/
.441
@
L( 37/+7+ 3
(7F/+
+
.(
7K++J4
+(*-+0(*-+e
;
"

+*+
++ .
7+
441
e441
K3+++*6
+6+*
+33*+7+
+ (/+
(*-+*(
A+(<(*-+1
6
<=2(+A.+/7/6+*
+33*+7+
+5=1
<=>7=0?%1
+ )1
e1
e%,/
.441
7(;
6
<=(/+A.(/ D(/+//+33*+(G=1
+ )1

< F(F!D(/+J(*-+?e1
+ )1
@8)
+ RFF1
@
L( 37/+7F<<
)+7+ 33*+ 7+
+
.(
7!<<
)+J4
+(*-+
;
(*-+L1
L1
8)
+LR44;
6
<=>7E=0L%1
LL%,/
.1
@
@
*
L(**+6

6
;
6/ =K3
(7+6+*
B+
+=1
K++J4
+?++0?e/+/+1
6/ =EK3
(7+7+/C
B*+
+=1
K++J4
+?++0?e/+/+1
6/ CMJJJJJJJJP . / JJJJJJJJC1
!<<
)+J4
+++1
6/ CMJJJJJJJJP 2 / JJJJJJJJC1
!%#

!<<
)+J4
+++1
@
Solution 25 :
#(
(7+ /7+ (**+7+ 33*+ 7+
+7+
(*-+
,(**+J4
+(*-+
;
(*-+L1
L1
,'1
8)
+LR44;
,L%1
LL%,/
.1
@
+/,1
@
Remarque : Si on veut, par exemple, afficher la somme des éléments de la
première liste de lexercice 24, on met :
6
<=>7=0,(**+J4
+++1
Solution 26 :
L( 37/+7+7
.

(7F/+
+7+(*-+ +7+/C
+
6
++
*6
+
.(
72
.
+J4
+(*-+0(*-+0(*-+e0
(*-+0(*-+e
;
(*-+L1
L1
8)
+LR44;

<L%>'

<44;
(*-+*(
A+(<(*-+1
%L%1
%,/
.441
e1
@
+ +;
e%,/
.(*-+*(
A+(<(*-+1
ee%,/
.1
e%L%1
e%,/
.441
@
+ +
<44;
(*-+*(
A+(<(*-+1
%L%1
%,/
.441
e1
@
+ +;
e%,/
.(*-+*(
A+(<(*-+1
!%%

ee%,/
.1
e%L%1
e%,/
.441
@
LL%,/
.1
@
@
Remarque : Pour utiliser cette procédure dans le programme de lexercice 24,
on peut déclarer quatre nouveaux pointeurs comme variables globales : (*-+
L0eL0"0e". Les deux premiers pointeurs ( L et eL) correspondent à
la liste qui va contenir les nombres pairs, et les deux autres ( " et e")
correspondent à la liste qui va contenir les nombres impairs. Lappel dune telle
procédure au niveau du programme principal se fera, par exemple, par :
2
.
+J4
+++0 ?L0?eL0?"0 ?e". Ensuite, on peut afficher
les deux nouvelles listes par : !<<
)+J4
+L et !<<
)+J4
+".
Solution 27 :
L( 37/+7+ ( 3
(7+7+/C
+ 7+(*-+
.(
7K( J4
+(*-+0(*-+
;
(*-+L1

<R44??R44;
L1
8)
+L%,/
.R44LL%,/
.1
L%,/
.1
@
@
Remarque : Cette procédure peut être invoquée dans le programme de
lexercice 24, par exemple, par :K( J4
+?++0++1
Solution 28 :
L( 37/+7+
7F/+
+7+(*-+
.(
7
J4
+(*-+
;
(*-+L0L1

C1
L1
8)
+L%,/
.R44;
LL%,/
.1
8)
+LR44;

<L%%L%;
CL%1
L%L%1
L%C1
@
LL%,/
.1
@
LL%,/
.1
!%'

@
@
lexercice 24, par exemple, par :
J4
+?++1
Solution 29 :
L( 37/+ 7F
+
( 7F/ 33*+ 7 /+
+
3+ 7+
(*-+
.(
7" ++J
0(*-+
;
(*-+L0L1
K3++(/.+33*+
L(*-+*(
A+(<(*-+1
L%1
L%,/
.441
4+ (g+(/.+33*++
<3
+/_\+

<&%;
L%,/
.1
L1
@
+ +;
4+ (g+(/.+33*++ /63
+/_W/+/+
L1
8)
+L%,/
.R44LL%,/
.1

<%L%L%,/
.L1
+ +;
" +
(7
+
L1
8)
+%L%,/
.%LL%,/
.1
L%,/
.L%,/
.1
L%,/
.L1
@
@
@
Remarque : Supposant que ++ du programme de lexercice 24 pointe vers
une liste triée. Pour insérer la valeur dans cette liste, on met :
" ++J0?++1
Solution 30 :
L( 37/+7+</
(7+7+/C
+ 7+(*-+
.(
7#/
(+J4
+ (*-+0(*-+
;
(*-+L0L1
8)
+R44;
" (++6+*
+33*+7+7+/C
B*+
+
L1
%,/
.1
L%,/
.441
$\O ,B. /
!%6


<L%&%;
L%,/
.1
L1
@
+ +;
$\O . ,. /
L1
8)
+L%,/
.R44LL%,/
.1

<L%%L%L%,/
.L1
+ +;
" +
(7+F33*+
(37 6+*
B+
+
L1
8)
+L%%L%,/
.%LL%,/
.1
L%,/
.L%,/
.1
L%,/
.L1
@
@
@
@
Remarque : Supposant que ++ et ++ du programme de lexercice 24
pointent vers deux listes triées. Pour fusionner ces deux listes, on peut mettre :
#/
(+J4
+ ?++0++1
Solution 31 :
:
/7+& 7
(9)%
:
/7+&
9)%
:
/7+& 7
-9)%
I6+7+< / 6+ (+
;

/*1
)(*X'Y1
/ 6+ (+L+ +7+0,/
.1
@L+ (+1
L+ (+++0e/+/+1
L( 37/+7FD(/7F/33*+_<
7+
+
.(
7!D(/+JJe
0 )]X'Y
;

<++44;
K3+++*6
+6+*
+33*+7+
+
++L+ (+*(
A+(<L+ (+1
++%/*1
6I++%(*0]1
++%L+ +7+441
e/+/+++1
e/+/+%,/
.441
@
+ +;
!D(/7F/33*+_<
7+
+
e/+/+%,/
.L+ (+*(
A+(<L+ (+1
e/+/+%,/
.%L+ +7+e/+/+1
!%7

e/+/+e/+/+%,/
.1
e/+/+%/*1
6Ie/+/+%(*0]1
e/+/+%,/
.441
@
@
L( 37/+7F<<
)+7+ 33*+ 7+
+
.(
7!<<
)+J4
+
;
L+ (+L1
L++1

<LR446/ =(

4+ 33*+ 7+
+5=1
+ +6/ =4
+.
7+9=1
8)
+LR44;
6
<=/*5>70(*5> E=0L%/*0L%(*1
LL%,/
.1
@
@
*

;
++441e/+/+441
) 0 X'Y1

1
7(;
6
<=(/+A.(/ D(/+/33*+_
+(G=1
+ )1+ )1

< F(F;
6
<=2(+A+/*7+6+ (+_D(/+5=1
<=>7=0?1
6
<=2(+A+(*7+6+ (+_D(/+5=1
<=> =0 1+ )1
!D(/+JJe0 1
@
@8)
+ RFF1
!<<
)+J4
+1
@
Pour obtenir une liste doublement chaînée circulaire, il faut ajouter après la
création de la liste, les instructions :
e/+/+%,/
.++1++%L+ +7+e/+/+1
Solution 32 :
L( 37/+ 7F
+
( 7/ 33*+ . / /+ 7 /+

+7(/-+*+ )a3+7+6+ (+
.(
7" ++J!JL+ (+ 0F0Q!RF 0!F0!Q!R
;
L+ (+L0L1
;

<++%/*/?? *6++%(*0(';
LL+ (+*(
A+(<L+ (+1
L%/*/1
!%8

6IL%(*0(1
L%L+ +7+441
L%,/
.++1
++%L+ +7+L1
++L1
@
+ +;
,+6(
+.F33*+L
L++1
8)
+>"!I< I0WH0!?SS>.>"!I< I0F0!?WH?
LL%,/
.1
K3+/(/.+33*+ (+L
LL+ (+*(
A+(<L+ (+1
L%/*/1
6IL%(*0(1
" 3++(/.+33*+7
+
L%L+ +7+L1
L%,/
.L%,/
.1
L%,/
.%L+ +7+L1
L%,/
.L1
@
@
@
Remarque : Pour que cette procédure fonctionne correctement dans le
programme de lexercice 31, lélément avant lequel on veut faire linsertion
doit exister obligatoirement dans la liste. Il est possible denrichir cette
procédure pour traiter le cas où cet élément nexiste pas dans la liste.
Solution 33 :
L( 37/+ 7+ /66+
( 7+ 33*+ + 7(/-+ 7

+7+ 6+ (+
.(
7,/66
*+J2(/-+L+ (+++
;
L+ (+L0L021

<++R44

<++%,/
.R44;
L++1
8)
+LR44;
LL%,/
.1
8)
+LR44;

<L%/*L%/*?? *6L%(*0L%(*';
2L1LL%,/
.1
2%L+ +7+%,/
.2%,/
.1

<2%,/
.R44
2%,/
.%L+ +7+2%L+ +7+1
<++21
@
+ +LL%,/
.1
@
!%:

LL%,/
.1
@
@
@
lexercice 31, par exemple, par : ,/66
*+J2(/-+?++1
Solution 34 :
:
/7+& 7
(9)%
:
/7+& 7
-9)%
I6+7+< / 6
+
;
)K1
/ 6
+L+ +7+0,/
.1
@L
+1
L
+M +0,(**+1

K)(
C1
)+*+0+6( +1
L( 37/+6+*+7F+*6
+/33*+7 6
+
.(
7*6
+ )K
;
L
+L1
LL
+*(
A+(<L
+1
L%KK1
L%L+ +7+441
L%,/
.,(**+1

<,(**+R44,(**+%L+ +7+L1
,(**+L1

<M +44M +,(**+1
@
L( 37/+6+*+7+736
+/33*+7+6
+
.(
72+6
+
;

<,(**+446/ =236
+*+
*6(
-+5L
+
7+9=1
+ +
<,(**+%,/
.44;
6
<=3*+736
35> E=0,(**+%K1
<++,(**+1
,(**+441
M +441
@
+ +;
6
<=3*+736
35> E=0,(**+%K1
,(**+,(**+%,/
.1
<++,(**+%L+ +7+1
,(**+%L+ +7+441
@
@
L( 37/+6+*+F<<
)+7+ 33*+ 7+6
+
.(
7!<<
)+JL
+
;
!'

L
+L1

<,(**+446/ =!/ /33*+5L
+.
7+9=1
+ +;
L,(**+1
6/ =4+ 33*+ 7+6
+
3 7/ (**+.+ - +5=1
8)
+LR44;
6
<=> E=0L%K1
LL%,/
.1
@
@
@
*

;"

+*+6
++ .
7+
,(**+441M +441
7(;
6/ =e/++63
(73
+A.(/ G=1
6/ =*6
+0236
+0!<<
)+9=1
<=>7=0?K)(
C1+ )1
8
)K)(
C
;
+56
<=2(+A+ B+_+*6
+5=1
+*++ )1+ )1
*6
++*+1
-+V1
+52+6
+1-+V1
+5!<<
)+JL
+1-+V1
7+</56/ =K)(
C(! +63R=1
@
6
<=(/+A.(/ //++ (G=1
+6( ++ )1+ )1
@
8)
++6( +RFF1
@
Solution 35 :
:
/7+& 7
(9)%
:
/7+& 7
-9)%
I6+7+< / <
+
;
)K1
/ <
+L+ +7+0,/
.1
@#
+1
#
+e/+/+0++1

K)(
C1
)+*+0+6( +1
L( 37/+6+*+7FD(/+/33*+_<
+
.(
7!D(/+J#
+ )K
;

<e/+/+44;
++#
+*(
A+(<#
+1
!'

++%KK1
++%L+ +7+441
e/+/+++1
e/+/+%,/
.441
@
+ +;
e/+/+%,/
.#
+*(
A+(<#
+1
e/+/+%,/
.%L+ +7+e/+/+1
e/+/+e/+/+%,/
.1
e/+/+%KK1
e/+/+%,/
.441
@
@
L( 37/+6+*+7+ /66
*+/33*+7+<
+
.(
7,/66
*+J#
+
;

<++446/ =,/66+
(
*6(
-+5#
+
7+9=1
+ +
<++%,/
.44;
6
<=3*+,/66
*35> E=0++%K1
<++++1
++441
e/+/+441
@
+ +;
6
<=3*+ /66
*35> E=0++%K1
++++%,/
.1
<++++%L+ +7+1
++%L+ +7+441
@
@
L( 37/+6+*+F<<
)+7+ 33*+ 7+<
+
.(
7!<<
)+J#
+
;
#
+L1

<++446/ =!/ /33*+5#
+.
7+9=1
+ +;
L++1
6/ C$ BEC1
8)
+LR44;
6
<=> E=0L%K1
LL%,/
.1
@
@
@
*

;
"

+*+<
++ .
7+
++441e/+/+441
7(;
6/ =e/++63
(73
+A.(/ G=1
!'!

6/ =!D(/+0,/66

*+0!<<
)+9=1
<=>7=0?K)(
C1+ )1
8
)K)(
C
;
+56
<C/,, EC1
+*++ )1+ )1
!D(/+J#
++*+1
-+V1
+5,/66
*+J#
+1-+V1
+5!<<
)+J#
+1-+V1
7+</56/ =K)(
C(! +63R=1
@
6
<=(/+A.(/ //++ (G=1
+6( ++ )1+ )1
@
8)
++6( +RFF1
@
!'#

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 sagit dun cas particulier des graphes qui
seront vus dans le chapitre suivant.
2. Définitions
Un arbre : C$)" *-$-)$85,$.$ -0*.) (sommets) reliés par des arcs (liens,
branches ou arêtes) formant une hiérarchie. Un arbre peut être représenté
graphiquement comme suit :
;
3
1 @ A
: 1*$)%88$"%*-0*.!, M, K, 2, , #, Z) possède un certain nombre de fils.
Par exemple, M, K et 2 sont les fils de !. On dit aussi que M, K et 2 sont des
frères. Lorsqu*- -0*. -a pas de fils (ici , #, K et Z), on dit que cest une
feuille de larbre.
=->$!)$8$-": 1*$-0*.'%))#.$*-)$*,'#!$. Par exemple, ! est le père de
M, K et 2 ?$ -0*. ' !"(*,($! 1*( -a pas de père (ici !) est appelé racine de
larbre.

, 3 ,
1 @ A
Niveau ou profondeur : Le niveau de la racine de larbre est égal à . Le
niveau d*--0*. *"!$1*$, ! (-$$)"<@ , *-(>$ *.$)%-'#!$',*) . Par
exemple, pour larbre ci-dessus, ,$) -0*.) , # et Z, sont de même niveau
(niveau ).
Mot des feuilles d¶un arbre : Le mot des feuilles dun arbre est la chaîne
formée, de gauche à droite, des valeurs des feuilles de larbre. Par exemple,
pour larbre ci-dessus, le mot des feuilles est égal à : #KZ.
Taille d¶un arbre : La taille dun arbre est égale au nombre de -0*.).$$"
arbre. La taille dun arbre vide est égale à '. La taille de larbre précédent est
égale à .
Hauteur d¶un arbre : Cest la distance entre la feuille la plus éloignée et la
racine. La hauteur dun arbre vide est égale à '. La hauteur de larbre précédent
est égale à .
!'%

Les arbres .
Un arbre n-aire : Un arbre n-aire $)"*- !5!$'%*!,$1*$,: 1*$-0*. .8$"

au plus n fils. Le n est dit arité de larbre. Larbre 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., cest un arbre
. -),$1*$,*--0*.'$*" >%(! ', ou fils. Il peut être représenté sous forme
graphique ou sous forme parenthèsée.
;
3 ;>>F?F3>1F@??
1 @
@. @./
-) ,$ ) .$) !5!$) 5(- (!$) '%*! : 1*$ -0*. .%--< %- ' !,$ .$ A(,)
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*--0*..$>($-",$A(,)@ *:$.$$-0*. ; le premier frère droit d*--0*.
.$>($-",$A(,).!%(".$$-0*.
Exemple :
Lexemple suivant illustre la transformation dun arbre n-aire en un arbre
binaire équivalent :
;

;
1 3
3
@
1 @ A
A
;
# ;

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
-0*. .$ , ,()"$ $)" *-$ )"!*"*!$ 1*( %-"($-" .$) (-A%!8 "(%-) B )"%C$! $"
.$*/'%(-"$*!)>$!),$)-0*.)A(,)
Larbre A(B(D, ), C(E, F)) peut être représenté par la liste chaînée suivante :
!''

Les arbres .

/#&

0&$$

0&$$ 0&$$ 0&$$ 0&$$ 0&$$ 0&$$
Où racine est une variable de type pointeur contenant l .!$))$.*-0*.! (-$

de larbre.
Exercice : Ecrire le programme C permettant de créer larbre ci-dessus en
utilisant une représentation chaînée.
Solution :
:
/7+& 7
(9)%
:
/7+& 7
-9)%
,/ /+7**W++
-+
I6+7+< / -+;
)K1
/ -+#J/ )+0#J7(
1
@!-+1
!-+
+1
$'&H+
+JD/+J*%. 3&9
X**W+$
.(
7!D(/+J#Z!-+ 0 )K
;
%#J/ )+!-+*(
A+(<!-+1
%#J/ )+%KK1
%#J/ )+%#J/ )+441
%#J/ )+%#J7(
441
@
$'&H+
+JD/+J*%. +./X**W+$
.(
7!D(/+J#2!-+ 0 )K
;
%#J7(
!-+*(
A+(<!-+1
%#J7(
%KK1
%#J7(
%#J/ )+441
%#J7(
%#J7(
441
@
L(**+L

6
*
;
K3+++*6

+7+F-+

+!-+*(
A+(<!-+1

+%KF!F1

+%#J/ )+441

+%#J7(
441
!D(/+++ +7+ 33*+ _F-+
!D(/+J#Z
+0FMF1
!D(/+J#Z
+%#J/ )+0F2F1
!D(/+J#2
+0FKF1
!'6

Les arbres .
!D(/+J#Z
+%#J7(
0FF1
!D(/+J#2
+%#J7(
0F#F1
@
3.4. Parcours d¶un arbre binaire
Dans ce cours, on sinté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)
->()("$*--0*., ensuite son fils gauche, ensuite son fils droit.
Exemple :
Soit larbre suivant :
;
3
1 @ A (
+ ] ^ $ *
Cet arbre peut être traité (en parcours préfixé) dans lordre suivant : !M"`
#fKZP4]. La procédure C récursive du parcours préfixé dun arbre
binaire sécrit comme suit :
.(
7 Z2!-+
;

< R44;

+ 1
Z2 %#J/ )+1
Z2 %#J7(
1
@
@

+<" -"*-$'!%<.*!$1*($AA$"*$,$"! ("$8$-".<)(!<)*!,$-0*.'!()
comme paramètre.
Exercice : Ecrire en C la procédure permettant dafficher en RGD larbre de
caractères créé précédemment.
Solution :
L( 37/+7F<<
)+7+ 33*+ 7F/-++ Z2
.(
7!<<
)+J Z2!-+
;

< R44;
6
<=> =0 %K1
!<<
)+J Z2 %#J/ )+1
!<<
)+J Z2 %#J7(
1
@
@
!'7

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

!<<
)+J Z2
+1
3.4.2. Parcours infixé (projectif, symétrique ou encore GRD)
On commence par visiter le fils gauche d*--0*.$-)*("$,$-0*.,*(-même,
$-A(-,$A(,).!%(".$$-0*.
Pour l !5!$ '!<<.$-" %- "! ("$ ,$) -0*.) $- ' !%*!) (-A(/< . -) ,ordre
suivant : "`M#f!ZK4P]. La procédure récursive du parcours
infixé dun arbre binaire sécrit comme suit :
.(
7Z 2!-+
;

< R44;
Z 2 %#J/ )+1

+ 1
Z 2 %#J7(
1
@
@
3.4.3. Parcours postfixé (ordre terminal ou GDR)
On commence par visiter le fils gauche d*- -0*. $-)*("$ le fils droit de ce
-0*.$-A(-,$-0*.,*(-même.
Pour l !5!$'!<<.$-" %-"! ("$,$)-0*.)$-' !%*!)'%)"A(/<. -),ordre
suivant : "`f#MZ4]PK!. La procédure récursive du parcours
postfixé dun arbre binaire sécrit comme suit :
.(
7Z2 !-+
;

< R44;
Z2 %#J/ )+1
Z2 %#J7(
1

+ 1
@
@
3.5. Arbres binaires particuliers
3.5.1. Arbre binaire complet
On dit quun arbre binaire est complet )( : 1*$ -0*. *"!$ 1*une feuille
admet deux descendants, et si toutes les feuilles sont au même niveau.
Exemple :
;
3
1 @ A
( + ] ^ $ * 0 5

La taille dun arbre binaire complet est égale à 2n 1, où n est le niveau des
feuilles.
!'8

Les arbres .
3.5.2. Arbre dégénéré

Un arbre est dit dégénéré )("%*),$)-0*.).$$" !5!$%-" *',*)*-A(,)
Exemple :
;

3

1

Un arbre dégénéré est équivalent à une liste simplement chaînée.
3.5.3. Arbre binaire ordonné
Soit une relation dordre (noté <=) définie sur lensemble des valeurs attachées
*/ -0*.) .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 :
!!
' #
! !%
8 % !:
Le parcours infixé de larbre ci-dessus donne : --[------'.
Remarques :
NUn arbre binaire de recherche ne peut pas contenir plusieurs fois la même
valeur.
N: 1*$-0*.$)")*'<!($*!B"%*),$)-0*.))$trouvant dans son sous-arbre
de gauche (s(, $/()"$ $" (-A<!($*! B "%*) ,$) -0*.) )$ "!%*> -" . -) )%-
sous-arbre de droite (sil existe).
N: 1*$-0*.$)"%8'!()$-"!$.$*/-0*.) : (1) son prédécesseur, qui est
le maximum de son sous-arbre gauche (sil existe), et (2) son successeur,
qui est le minimum de son sous-arbre droit (sil existe).
4.1. Exercices
Exercice 1 :
Proposez une structure pour stocker un arbre n-aire contenant des valeurs
entières.
!':

Les arbres .
Exercice 2 :
Transformez larbre n-aire suivant en arbre binaire équivalent.
;
3 1 @ A
( + ] ^ $ *
0 5 " Y
;
6
Exercice 3 :
Ecrire un programme C permettant de créer et dafficher les éléments dun
arbre binaire de caractères. Pour la création d*--0*.*"(,()$D*-$'!%<.*!$
récursive. Pour laffichage, faites le parcours RGD de larbre binaire.
Exercice 4 :
Ecrire en C une fonction récursive booléenne permettant la recherche dun
élément dans un arbre binaire de caractères. La fonction possède comme
' ! 8#"!$) *- '%(-"$*! >$!) *- -0*. .$ ,arbre binaire et un caractère
indiquant lélément recherché.
Exercice 5 :
Modifier la fonction de lexercice précédent de telle sorte quelle retourne un
pointeur vers lélément recherché. La fonction possède comme paramètres un
'%(-"$*! >$!) *- -0*. .$ ,arbre binaire et un caractère indiquant lélément
recherché.
Exercice 6 :
Ecrire en C une fonction qui retourne le niveau d*- -0*. . -) *- !5!$
binaire de caractères. La fonction possède comme paramètres un pointeur vers
*- -0*. .$ , !5!$ 5(- (!$ $" ,$ %-"$-* .* -0*. '%*! ,$1*$, %- .<)(!$
déterminer le niveau.
Exercice 7 :
Ecrire en C une fonction récursive qui retourne le nombre de feuilles dun arbre
binaire. La fonction possède c%88$ ' ! 8#"!$ *- '%(-"$*! >$!) *- -0*. .$
larbre binaire.
Exercice 8 :
Ecrire en C une procédure qui affiche le mot des feuilles dun arbre binaire de
! "#!$)? '!%<.*!$ '%))#.$%88$' ! 8#"!$ *-'%(-"$*!>$!) *--0*.
de larbre binaire.
Exercice 9 :
Ecrire en C une fonction qui retourne la taille dun arbre binaire. La taille dun
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 ve!)*--0*..$,arbre binaire.
!6

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
-0*..$,arbre binaire.
Exercice 11 :
Ecrire en C une fonction qui retourne la hauteur dun arbre binaire. La fonction
'%))#.$%88$' ! 8#"!$*-'%(-"$*!>$!)*--0*..$,arbre binaire.
Exercice 12 :
Ecrire en C une fonction booléenne permettant de dire si un arbre binaire est
équilibré ou non E- !5!$ $)" <1*(,(5!< )( '%*! : *- .$ )$) -0*.) ,
différence entre la hauteur du sous-arbre gauche et la hauteur du sous-arbre
droit est dau plus une unité. La fonction possède comme paramètre un pointeur
>$!)*--0*..$,arbre binaire.
Exercice 13 :
Soit un arbre binaire dentiers dont la structure de chaque élément est décrite
comme suit :
I6+7+< / -+
;

1
/ -+#J/ )+0#J7(
1
@!-+1
Ecrire la fonction qui calcule , )%88$ .$) > ,$*!) .$) -0*.) .un arbre
binaire dentiers. La fonction possède comme paramètre un pointeur vers un
-0*..$,arbre binaire.
Exercice 14 :
Ecrire en C une fonction qui .<"$!8(-$, ',*)@! -.$ > ,$*!.$)-0*.).un
arbre binaire dentiers (décrit dans lexercice 13). La fonction possède comme
' ! 8#"!$*-'%(-"$*!>$!)*--0*..$,arbre binaire.
Exercice 15 :
Ecrire en C une fonction qui détermine la plus petite des va,$*!) .$) -0*.)
dun arbre binaire dentiers. La fonction possède comme paramètre un pointeur
>$!)*--0*..$,arbre binaire.
Exercice 16 :
Ecrire en C une fonction booléenne permettant de dire si un arbre binaire
dentiers est ordonné (arbre de recherche) ou non. La fonction possède comme
' ! 8#"!$*-'%(-"$*!>$!)*--0*..$,arbre binaire.
Exercice 17 :
Ecrire en C une procédure permettant de libérer lespace mémoire occupé par
un arbre binaire dentiers. La procédure possède comme paramètre un pointeur
>$!)*--0*..$,arbre binaire passé par adresse.
!6

Les arbres .
4.2. Corrigés
Solution 1 :
Une première proposition consiste à définir la structure comme suit :

E-$> !( 5,$$-"(#!$%!!$)'%-. -" *%-"$-*.*-0*.

E-" 5,$ *.$'%(-"$*!)>$!),$)-0*.)A(,)
I6+7+< / -+J
+
;

1
/ -+J
+#
X'Y1
@!-+J
+1
On peut également définir la structure comme suit :

E-$> !( 5,$$-"(#!$%!!$)'%-. -" *%-"$-*.*-0*.

E-'%(-"$*!>$!),$-0*.A(,)

E-'%(-"$*!>$!),$-0*.frère.
I6+7+< / -+J
+
;

1
/ -+J
+#
0#++1
@!-+J
+1
Une autre manière pour définir la structure :

E-$> !( 5,$$-"(#!$%!!$)'%-. -" *%-"$-*.*-0*.

E-'%(-"$*!>$!),$-0*.'#!$
I6+7+< / -+J
+
;

1
/ -+J
+L++1
@!-+J
+1
Solution 2 :
Arbre binaire équivalent :
;

( 3
0 +
5 ] 1
^ @
" $ A
Y *

Solution 3 :
:
/7+& 7
(9)%
:
/7+& 7
-9)%
!6!

Les arbres .
I6+7+< / -+;
)K1
/ -+#J/ )+0#J7(
1
@!-+1
!-+
+1
L( 37/+3 /
.+6(/ 3
(7F/-+-

+
.(
7K++J(+/7!-+
; )K0+6( +1
6
<=2(+A.+/7/(+/75=1
K+ )1+ )1
!-+*(
A+(<!-+1
%KK1
%#J/ )+441
%#J7(
441
6
<=4+(+/7> 6( B7+
/<
/ )+(G=0K1
+6( ++ )1+ )1

<+6( +F(FK++J(+/7? %#J/ )+1
6
<=4+(+/7> 6( B7+
/<
7(
(G=0K1
+6( ++ )1+ )1

<+6( +F(FK++J(+/7? %#J7(
1
@
L( 37/+7F<<
)+7+ 33*+ 7F/-++ Z2
.(
7!<<
)+J Z2!-+
;

< R44;
6
<=> =0 %K1
!<<
)+J Z2 %#J/ )+1
!<<
)+J Z2 %#J7(
1
@
@
L(**+L

6
*
;
K3+++*6
F-+
6/ C3

E. O
C1
K++J(+/7?
+1
6/ =(

F-+-

+<<
)3+ Z25=1
!<<
)+J Z2
+1
@
Solution 4 :
#(
(7++ )+ )+7F/33*+7 /-+-

+7+
B+
+ )+ )+J!-+!-+ 0 )K

;

(/.+'1

< R44

< %KK(/.+1
+ +9H-N;
>-I@NF3?__-N;
>-I@N F3?
+/(/.+1
@
!6#

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

lexercice 3, par exemple, comme suit :
< + )+ )+J!-+
+0F,F6/ =C
+=1
+ +6/ =+C
+6 =1
Solution 5 :
#(
(7++ )+ )+7F/33*+7 /-+-

+7+
B+
!-+ + )+ )+J!-+!-+ 0 )K
;
!-+L1
L441

< R44

< %KKL 1
+ +;
L + )+ )+J!-+ %#J/ )+0K1

<L44L + )+ )+J!-+ %#J7(
0K1
@
+/L1
@
< + )+ )+J!-+
+0F,FR446/ =C
+=1
+ +6/ =+C
+6 =1
Solution 6 :
$7*&/.*Y.+H/
.*

*.
+J**W+7 /-+
-

+7+ B+

.+/J(+/7!-+ 0 )K0
6
;

''1)) 2 .

< R44

< %KK61
+ +
<>0 N0>-I@N F3F.G?L0 N0>-I@NF3F.G??

.+/J(+/7 %#J7(
0K061
+ +
.+/J(+/7 %#J/ )+0K061
+/1
@
Remarque : ?$ -0*. K doit exister dans larbre.6 veut dire le niveau du
père ; lors de linvocation de la fonction dans le programme,6 aura'. Pour
afficher' !$/$8',$,$-(>$ *.*-0*. + -"%88$> ,$*!,$ ! "#!$ F!F,
on met : 6
<C$ /O;OEDCF0 N0>- FO;OF1
Solution 7 :
#(
(7+ /7/(*-+7+<+/
+ 7/-+-

+
7+ B+
-J#+/
+ J!-+!-+
;

-1
!6%

Les arbres .

< 44-'1
+ +
< %#J/ )+44?? %#J7(
44-1
+ +0
H0
N@ N;
>-I@N?G0
N@ N;
>-I@N ?
+/-1
@
. >C$
O
EDCF0
N@ N;
>- ??
Solution 8 :
L( 37/+W/
<<
)++*(7+ <+/
+ 7/-+-

+7+
B+
.(
7](J#+/
+ J!-+!-+
;

< R44

< %#J/ )+44?? %#J7(
44
6/ ) %K1
+ +;
](J#+/
+ J!-+ %#J/ )+1
](J#+/
+ J!-+ %#J7(
1
@
@
Remarque : Cette procédure peut être invoquée dans le programme C de
lexercice 3, par exemple, comme suit : ](J#+/
+ J!-+
+1
Solution 9 :
#(
(W/
/+
+7/-+-

+7+
B+

+J!-+!-+
;
1

< 44'1
+ +9HG9 N;
>-I@N?G9 N;
>-I@N ?
+/1
@
6
<=4
+7+-++ 5>7=0
+J!-+
+1
Solution 10 :
#(
(W/
73+*
+
/-++ 73333(/(
2++++J!-+!-+

;

2++++1
2++++1

< R44

< %#J/ )+R44?? %#J7(
R442++++'1
+ +HN;
>-I@N?SSN;
>-I@N ?
+/2++++1
@
!6'

Les arbres .

<2++++J!-+
+6/ =23333=1
+ +6/ =(73333=1
Solution 11 :
#(
(W/
73+*
+)/+/7F/-+-

+
P/+/J!-+!-+

;

P0P1
P'1
P'1

< R44;
PP/+/J!-+ %#J/ )+1
PP/+/J!-+ %#J7(
1
@

<P%P+/P1
+ ++/P1
@
6
<C$
EDCF(N;
>- ?1
Solution 12 :
#(
(W/
73+*
+
/-++ 3W/

-3(/(
W/

-+J!-+!-+
;
+W/

-+1
+W/

-+1
< R44

<>
>(N;
>-I@N?(N;
>-I@N ??I?+W/

-+'1
+ +
H1
N;
>-I@N?SS1
N;
>-I@N ?
+/+W/

-+1
@
<W/

-+J!-+
+6/ =W/

-3=1
+ +6/ =(3W/

-3=1
Solution 13 :
#(
(W/
/+ (**+7+ 33*+ 7F/-+
-

+7+
+
,(**+J!-+!-+

;

,1

< 44,'1
+ +<H-IPG<N;
>-I@N?G<N;
>-I@N ?
+/,1
@
!66

Les arbres .
Remarque : Après avoir créé un arbre binaire dentiers, la fonction peut être
invoquée dans le programme C, par exemple, comme suit :
6
<=,(**+-+5>7=0,(**+J!-+
+1
Solution 14 :
#(
(W/
73+*
++*C
*/*7 /-+-

+
7+
+
]CJ!-+!-+

;
]C1
< R44;
]C %1
< %#J/ )+R44

<]C&]CJ!-+ %#J/ )+]C]CJ!-+ %#J/ )+1

< %#J7(
R44

<]C&]CJ!-+ %#J7(
]C]CJ!-+ %#J7(
1
@
+/]C1
@
Remarque : Larbre binaire dentiers ne doit pas être vide. La fonction peut être
6
<=]C-+5>7=0]CJ!-+
+1
Solution 15 :
#(
(W/
73+*
++*

*/*7 /-+-

+
7+
+
]
J!-+!-+
;
]
1
< R44;
]
%1

< %#J/ )+R44

<]
%]
J!-+ %#J/ )+]
]
J!-+ %#J/ )+1

< %#J7(
R44

<]
%]
J!-+ %#J7(
]
]
J!-+ %#J7(
1
@
+/]
1
@
Remarque : Larbre binaire dentiers ne doit pas être vide. La fonction peut être
6
<=]
-+5>7=0]
J!-+
+1
Solution 16 :
#(
(W/
73+*
+
/-+-

+7+
+ +
(7(3(/(
7(+J!-+!-+

;
71
71
< R44;
!67

Les arbres .

< %#J/ )+R44
<]CJ!-+ %#J/ )+% %7'1

< %#J7(
R44
<]
J!-+ %#J7(
& %7'1
77(+J!-+ %#J/ )+??7(+J!-+ %#J7(
??71
@
+/71
@
Remarque : Cette fonction peut être invoquée dans le programme C, par
exemple, comme suit :
<7(+J!-+
+6/ =7(3=1
+ +6/ =((7(3=1
Solution 17 :
L( 37/+7+
-3
(7+F+ 6 +*3*(
+( /636/
-+-

+
.(
74
-++J!-+!-+
;
!-+L 1

<LR44;
4
-++J!-+?L%#J/ )+1
4
-++J!-+?L%#J7(
1
<++L1
@
441
@
Remarque : Cette procédure peut être invoquée dans le programme C comme
suit : 4
-++J!-+?
+1
!68

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 -0*.) (sommets) reliés par des liens (arcs). Ce
nest plus un arbre dès quil existe deux parcours différents pour aller au moins
d*--0*.B*- *"!$
Un graphe est connexe lorsquil est possible de trouver au moins un parcours
'$!8$"" -".$!$,($!,$)-0*.).$*/B.$*/*- !5!$$)"*- @! ':$%--$/$ ;
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 dune 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.
0 , 1
6 5 7 <
Exemple dun graphe orienté

Un graphe est dit acyclique sil 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 !) %F ,$ -0*. (5,$ .un arc
%!!$)'%-. * -0*. )%*!$ .$ ,arc suivant, mais pas nécessairement pour le
dernier arc du chemin. La longueur dun chemin est égale au nombre darcs 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 dadjacence 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.
!6:

Les graphes .
0 , 6
, 5
1 7 5
6 ,
5 6
7 7
<
La liste dadjacence représentant le graphe présenté précédemment

La structure, permettant de représenter le graphe, est définie en C comme suit :
:7+<
+-
I6+7+< / /
;

,(**+1
/ / ,/
.1
@,/ 1

,/ ZX- Y1
3.2. Matrice d¶adjacence
Une autre solution consiste à numéroter les N sommets et utiliser une matrice
carrée N*N dite matrice dadjacence, avec la valeur 0 sil ny a pas un lien
$-"!$,$)-0*.)i et j, et la valeur 1 s(,+ *-,($-$-"!$$).$*/-0*.)7%*!
des graphes non orientés, la matrice est symétrique par rapport à la diagonale.
' H
' ' ' ' ' '

' ' ' ' ' '
' ' ' ' '
' ' ' ' ' '
' ' ' ' ' '
' ' ' ' ' '
H ' ' ' ' ' ' '
La matrice dadjacence représentant le graphe présenté précédemment
Cette matrice peut être déclarée en C comme suit :
:7+<
+-
]X- YX- Y1

!7

Les graphes .
Une représentation par matrice est surtout intéressante lorsquil y a beaucoup

de liens (graphe presque complet). La représentation par liste dadjacence étant
moins gourmande en mémoire pour les graphes comportant peu de liens par
-0*.
La matrice dadjacence permet aussi de calculer le nombre de chemins entre
deux sommets par (Mk)i,j ; avec M la matrice dadjacence et k la longueur du
chemin entre les sommets i et j. A partir de là, on peut déduire quil existe un
chemin entre deux sommets i et j si est seulement si Ni,j <> 0 avec N = M + M2
n. On peut maintenant définir la fermeture transitive dun graphe
commettant un nouveau graphe avec les mêmes sommets, où deux sommets
sont reliés par un arc si et seulement sil 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 dun 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 dadjacence concentre sur les
liens entre les sommets. Si chaque sommet du graphe est associé à un ensemble
dinformations, 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 quon 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 lordre de visite des
-0*.);' !%*!)$-'!%A%-.$*!.abord ou parcours en largeur dabord.
4.1. Parcours en largeur d¶abord
Dans le parcours en largeur dabord, un sommet s est fixé comme origine et
lon 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
dabord permet de visiter les sommets dans lordre suivant : ', , , , , , H.
4.2. Parcours en profondeur d¶abord
Le principe du parcours en profondeur dabord est de visiter tous les sommets
en allant dabord du plus profondément possible dans le graphe.
Par exemple, à partir du sommet 0, le parcours du graphe précédent en
profondeur dabord permet de visiter les sommets dans lordre suivant : ', , ,
, , , H.
!7

Les graphes .
5.1. Exercices
Exercice 1 :
Ecrire un programme C permettant de créer et dafficher le graphe du cours en
utilisant une liste dadjacence.
Exercice 2 :
Ecrire un programme C permettant de créer le graphe du cours en utilisant une
matrice dadjacence, 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 dadjacence à partir de la liste dadjacence déjà créée.
Exercice 4 :
Ecrire en C une procédure permettant d AA(:$! ,$) -0*.) .* @! ':$
implémenté sous forme de matrice dadjacence en utilisant la stratégie du
parcours en largeur dabord à partir du sommet numéro 0.
Exercice 5 :
Ecrire en C une procédure permettant d AA(:$! ,$) -0*.) .* @! ':$
implémenté sous forme de matrice dadjacence en utilisant la stratégie du
parcours en profondeur dabord à partir du sommet 0.
Exercice 6 :
Ecrire un programme C permettant de créer et dafficher un graphe de -
sommets représenté par une matrice dadjacence M(nbrs*nbrs). - étant une
constante indiquant le nombre de sommets. Le programme doit utiliser deux
procédures : une pour la création et une autre pour laffichage. Vous pouvez
choisir, par exemple, nbrs = 5.
Exercice 7 :
Ecrire en C une fonction booléenne permettant de tester lexistence dun
chemin entre deux sommets dun graphe représenté par une matrice
dadjacence M(nbrs*nbrs).
Exercice 8 :
Ecrire en C une procédure permettant de déterminer la fermeture transitive dun
graphe représenté par une matrice dadjacence M(nbrs*nbrs).
Exercice 9 :
Ecrire en C une fonction permettant de dire si un graphe représenté par une
matrice dadjacence M(nbrs*nbrs) est fortement connexe ou non.
Exercice 10 :
Ecrire en C une procédure permettant de déterminer et dafficher les
composantes fortement connexes dun graphe représenté par une matrice
dadjacence M(nbrs*nbrs).
!7!

Les graphes .
5.2. Corrigés
Solution 1 :
:
/7+& 7
(9)%
:
/7+& 7
-9)%
:7+<
+-
23<

(7+
+7F7D + +
I6+7+< / /
;

,(**+1
/ / ,/
.1
@,/ 1
,/ ZX- Y1

1
,/ L1
L( 37/+7FD(/7F/ / + +/_/ (**+
.(
7!D(/+J,/
,0
!7D;

<ZX,Y44;
ZX,Y,/ *(
A+(<,/ 1
ZX,Y%,(**+!7D1
ZX,Y%,/
.441
@+ +;
LZX,Y1
8)
+L%,/
.R44LL%,/
.1
L%,/
.,/ *(
A+(<,/ 1
LL%,/
.1
L%,(**+!7D1
L%,/
.441
@
@
L( 37/+7F<<
)+7/6)+
.(
7!<<
)+JZ6)+
;
<(
'1
&- 1
;
6
<=,(**+>7E=0
1

<ZX
YR44;
6
<=E,+ / + +/ (5=0
1
LZX
Y1
8)
+LR44;
6
<=>7=0L%,(**+1
LL%,/
.1
@
6
<=E=1
@
@
@
*
;
"

+
+7F7D + +
<(
'1
&- 1
ZX
Y441
K3
(7/6)+
!7#

Les graphes .
!D(/+J,/ '01

!D(/+J,/ '01
!D(/+J,/ 01
!D(/+J,/ 01
!D(/+J,/ 01
!D(/+J,/ 01
!D(/+J,/ 01
!D(/+J,/ 01
!<<
)+
!<<
)+JZ6)+1
@
Solution 2 :
:
/7+& 7
(9)%
:7+<
+-
23<

(7+*
+7F7D + +
]X- YX- Y1

L( +7/+7F<<
)+7+ 33*+ 7/6)+
.(
7!<<
)+JZ6)+
;

0D1
<(
'1
&- 1
;
6
<=,(**+5>7E=0
1
<(D'1D&- 1D

<]X
YXDY6
<=E,/ + +/5>7E=0D1
@
@
*
L(**+6

6
;
"

+*
+7F7D + +

V01
<(V'1V&- 1V
<('1&- 1]XVYXY'1
K3
(7/6)+
]X'YXY1
]X'YXY1
]XYXY1
]XYXY1
]XYXY1
]XYXY1
]XYXY1
]XYXY1
!<<
)++6)+
!<<
)+JZ6)+1
@
Solution 3 :
L( 37/+7+ <(*
(7F/+
+7F7D + ++
*
+7F7D + +
.(
7 <(*+
;
<(
'1
&- 1
;
!7%

Les graphes .
LZX
Y1
8)
+LR44;
]X
YXL%,(**+Y1
LL%,/
.1
@
@
@
Remarque : Pour tester cette procédure, on doit reprendre le programme de
lexercice 1, tout en supprimant la procédure daffichage du graphe (liste
dadjacence) qui sera remplacée par la procédure daffichage du graphe
(matrice dadjacence) du programme de lexercice 2, sans oublier la déclaration
de cette matrice (
]X- YX- Y). Maintenant, on peut ajouter la
procédure de transformation avec la déclaration de deux variables globales (

et ,/ L). Avant dappeler la procédure <(*+ et afficher la

matrice dadjacence, les éléments de la matrice doivent être initialisés à '.
Solution 4 :
L( 37/+7F<<
)+7+ 33*+ 7/6)+++/
.(
7!<<
)+J4
;

0"*C0"*
1
4+-+/

+
7
W/+YJ**W+H/H+HDX../H**
4+-+/4. (+
+3 /7/6 (/ ++/

+X- Y04X- Y1
"

(
<(
'1
&- 1
;

+X
Y'1
4X
Y'1
@
"*
'1
"*C'1
4X'Y'1

+X'Y1
+*6
+-+/4
8)
+"*C&- ;
<(
'1
&- 1

<]X4X"*
YYX
Y??R

+X
Y;
"*C1
4X"*CY
1

+X
Y1
@
"*
1

<"*
"*C;

'1
8)
+
&- ??

+X
Y
1

<
&- ;
"*C1
4X"*CY
1

+X
Y1
!7'

Les graphes .
@
@
@
<(
'1
&- 1
6
<=>7=04X
Y1
@
Solution 5 :
4+-+/

+73 3 (**+.
-+(-+
7
W/+W/F/
*W+H/H+HDX../H**

+X- Y1

L( 37/+3 /
.+7F<<
)+7+ 33*+ 7F/(+/7+
6(<(7+/
.(
7!<<
)+JL(<J

;

1

<R

+X Y;

+X Y1
6
<=>7=0 1
<(
'1
&- 1

<]X YX
Y
!<<
)+JL(<J
1
@
@
L( 37/+7F<<
)+7+ 33*+ 7/6)+ (*6++
6(<(7+/
.(
7!<<
)+JL(<
;

0-1
"

(7/-+/

+
<(
'1
&- 1

+X
Y'1
7(
;
-'1
<(
'1
&- 1

<R

+X
Y;
!<<
)+JL(<J
1
-1
@
@
8)
+-1
@
Solution 6 :
:
/7+& 7
(9)%
:7+<
+-
]X- YX- Y1

L( 37/+7+ 3
(7/6)+
.(
7K+
(
;

0D1
) 1
<(
'1
&- 1

<(D'1D&- 1D;
!76

Les graphes .
]X
YXDY'1
6
<C12 DD)`CF F1
+ )1+ )1

< F(F]X
YXDY1
@
@
L( 37/+7F<<
)+7+ 33*+ 7/6)+
.(
7!<<
)+JZ6)+
;

0D1
<(
'1
&- 1
;
6
<=,(**+5>7E=0
1
<(D'1D&- 1D

<]X
YXDY6
<=E,/ + +/5>7E=0D1
@
@
*
L(**+6

6
;
K3++6)+
K+
(1
!<<
)++6)+
!<<
)+JZ6)+1
@
Solution 7 :
Déterminer lexistence d*- :$8(- $-"!$ .$*/ -0*.) !$>($-" B ,*,$! ,
somme : M1 + M2nbrs.
Avant dimplémenter la fonction désirée, nous allons déclarer une variable
globale P comme suit :
PX- YX- Y1

La variable P va être utilisée pour stocker le résultat de la puissance de la
matrice ] par une valeur .
Pour des raisons de lisibilité de programme, nous allons diviser le problème en
une procédure qui détermine la puissance de ] par une valeur , ensuite nous
développons la fonction qui détermine lexistence dun lien entre deux
sommets, et cela comme suit :
L( 37/+W/
/+6/
+7+]6+++
3 /7 P
.(
7]J6/
+

;

0D060V0 1

$X- YX- Y1
<(
'1
&- 1

<(D'1D&- 1DPX
YXDY]X
YXDY1
<(616&16;
<(
'1
&- 1

<(D'1D&- 1D;
'1
<(V'1V&- 1V PX
YXVY]XVYXDY1
!77

Les graphes .
$X
YXDY 1
@
<(
'1
&- 1

<(D'1D&- 1DPX
YXDY$X
YXDY1
@
@
4<(
(W/
73+*
+
/
++C
+++7+/C
(**+ (/(
C
+JK)+*

0

;

0D0V0-1

$X- YX- Y1
-'1
<(
'1
&- 1

<(D'1D&- 1D$X
YXDY]X
YXDY1
<(V1V&- 1V;
]J6/
+V1
<(
'1
&- 1

<(D'1D&- 1D$X
YXDY$X
YXDYPX
YXDY1
@

<$X YX YR'-1
+/-1
@
Remarque : Maintenant, pour tester cette procédure dans le programme C de
lexercice 2 ou 6, il est possible de mettre, par exemple :
<C
+JK)+*
06
<C+4 2 C1
+ +6
<C" 2 C1
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 :
#X- YX- Y1

La procédure de la fermeture transitive est la suivante:
.(
7#+*+/+
;

0D1
<(
'1
&- 1

<(D'1D&- 1D

<C
+JK)+*

0D#X
YXDY1
+ +#X
YXDY'1
@
Remarque : Après avoir invoqué cette procédure dans le programme C de
lexercice 2 ou 6, on affiche la matrice # comme suit :
C0I1
<(C'1C&- 1C
<(I'1I&- 1I6
<=#X>70>7Y>7E=0C0I0#XCYXIY1
Solution 9 :
#(
(W/
73+*
+
+6)+]- - +
<(+*+ (+C+(/(
Z6)+J#(JK(

!78

Les graphes .
;

0D0-1
-1
<(
'1
&- 1

<(D'1D&- 1D

<R
D

<RC
+JK)+*

0D??C
+JK)+*
D0
-'1
+/-1
@
Remarque : Après avoir invoqué cette procédure dans le programme C de
lexercice 2 ou 6, on teste si le graphe est connexe ou non comme suit :
<Z6)+J#(JK(6

<=4+6)++ <(+*+ (+C+9=1
+ +6
<=4+6)+F+ 6 <(+*+ (+C+9=1
Solution 10 :
L( 37/+W/
<<
)++ (*6( + <(+*+ (+C+
7F/6)+]- -
.(
7K(*6( + J#(JK(
;

0D0V1

< X- Y1
#+*+/+1
<(
'1
&- 1

<(D'1D&- 1D#X
YXDY#X
YXDY#XDYX
Y1
<(
'1
&- 1
#X
YX
Y1
!<<
)+7+ (*6( + <(+*+ (+C+
<(
'1
&- 1
< X
Y'1
V'1
<(
'1
&- 1

<R < X
Y;
V1
6
<C3.2D EMCFK1
<(D'1D&- 1D
<#X
YXDY;
6
<=>7=0D1
< XDY1
@
6
<=E=1
@
@

!7:

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!
ODQJDJH & YRO 6XMHWV GH WUDYDX[ SUDWLTXHV /LFHQFH $OJRULWKPLTXH HW
3URJUDPPDWLRQ,VWDQEXO7XUTXLHSSFHO!
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
!8

INDEX .
INDEX
Ζ ;
F(guillemet simple)a:F!6F# >parenthèses)aF##F':F!:F

#F#%
͊
Ύ
R(non logique)a#%
R(différent)a## (multiplication)aF!'F!6F#!
(pointeur)a#8F!'
Η
͕
= (guillemet double)a8F!7F#
0(virgule)a6F!:
η
͘
:7+<
+a!%F!'F#6
:
/7+a8F# 9(accès au champ)a!:
й ͬ
>(code de format)a:F!:F#F#:F (division)aF!'F!6F#!

# $$(commentaire)a!7F#6
>(modulo)a!'F#! (commentaire)a#6
Θ ͖
? (adresse)a!F%F#8F:F!7 1(point-virgule)a6F!7F':F6!F66
?(et bit-à-bit)a#%
??(et logique)a#%
!8

INDEX .
&(inférieur ou égal)aF##F!6
Ͱ
&%(différent)aF!6
E(caractère spécial)a8F8'
с
Δ
(affectation)a8F!6F##F#:
(égal)aF!6
U(ou exclusif bit-à-bit)a#%
(égal)a8F##F#:
΂
х
#@(accolades)a8F':F7%
%(supérieur)aF##F!6
%(supérieur ou égal)aF##F!6
ͮ %%(décalage à droite)a#'
S(ou bit-à-bit)a#%
8
SS(ou logique)a#%
&(affectation)a6F!6
Ε
¤
T(complément à un)a#%
.(opposé)a#!
н .(soustraction)aF!'F!6F#!
..(décrémentation)a%
.%(accès au champ)a!:
(addition)aF6F!'F!6F#!
(identité)a#!F%
(incrémentation)a%

ф - a#!
accès directa86
accès formatéa86
&(inférieur)aF##F!6
accès non-formatéa86
&&(décalage à gauche)a#'
accès par bloca86F8:
!8!

INDEX .
accès séquentiela86 booléenaF#!F##

Ackermanna%8 M((3+a!6
adresse dune variablea!' boucle infiniea7#F7%F77
adresse mémoirea!%F#8F6%F!' boucle Poura7'
affectationa!6F6!F6'F!6 boucle Répétera7%
algorithmea' boucle Tant quea7#
!(
)*+a6 bouclesa7#
algorithmiquea' boucles imbriquéesa77

Xa6! branchea!'%
allocation dynamiquea#:F!'F!6 -+Va6!F77
!(/+a!6 buffera8#F86
année bissextilea6% bytea!
arbrea!'%F!6:
arbre binairea!''
arbre binaire completa!'8
arbre binaire de recherchea!':
arbre binaire dégénéréa!': caractèrea!F#
arbre binaire équilibréa!6 K B+a!6
arbre binaire ordonnéa!': caractères spéciauxa8
arbre des appelsa%# carte mèrea
arbre n-airea!'' cas triviala!6
arca!'%F!6: case mémoirea!'F!6
a casta#7
arêtea!'% CD-ROMa!F#
argumentsa!8 cellulea!8
arité de larbrea!'' chaîne de caractèresa!7F#
ASCIIa!F# chaîne miroira%8
assembleura! champsa6F6%F8%F!:
assignationa!6 )a#F#
automatiquea chemina!6:
claviera!
clé USBa!F#F8#
codea!%
code binairea!
bibliothèquea#! code de formata:
BIOSa! code machinea!
bita! code sourcea!
bloca':F!6F!:F#'F6 commentairea#6
!8#

INDEX .
compilateura!F#'F# dépassement de capacitéa#'

complément à una#' dépilementa!!
complexité spatialea# déroulement dun algorithmea%!F%7
complexité temporellea# désallocationa!'
composantes fortement connexesa!7 23 (/+a!6
compteura76 dichotomiea:7
conditiona'8F7' disque dura!F#F8#
( a!'F#6 +I9.
a7'
constante littéralea#6 donnéesa!%F!8
constante symboliquea#6 7(/-+a!:
constantesa!%F66F67 duplicate case valuea6!
constantes textuellesa#6 DVDa#
constates numériquesa#6
(
/+a77
conversiona#7
conversion explicitea#7
conversion implicitea#7 écrana!
corps de lalgorithmea!%F!7
+a6F!7
corps de la procédurea!: effet de borda!:
( a#:F#! empilementa!!
CPUa! *6
+a!!
critère darrêta%# emplacement de mémoirea!%
I6+9)a enfilementa!!#
cyclea!6: ENIACa
cylindrea! enregistrementa!8
en-têtea!:F#

+a!'
entrées-sortiesa!7F#:

*a66
débordement de pilea%% énumérationa66
débordement de tableaua:# énumération des étapesa6F!7
23-/a6F!7 #a#F8'
décalage à droitea#' équation du second degréa6%
décalage à gauchea#' équations logiquesa
déclarationa!%F!'F% erreur dexécutiona!F##F!8
décrémentationa7%F76F!6 erreur de compilationa!F##F%F'6F
défilementa!!# 6!F#F#%
dégradation de linformationa#7 Errora!
!8%

INDEX .
espace mémoirea!'F#'F%%F!' forme graphiquea!''

aF!6F#% forme parenthèséea!''
et bit-à-bita#' <6
<a88
expressions arithmétiquesaF!6 <6/ a87
expressions logiquesaF!6F'8F7# <6/ a88
+C+a#7 framesa#:
<+7a8:
<++a!6
& < <a88
< ++Va:
factoriellea78F%!F%' <+a:
#!$aF!6F#!F## fuite de mémoirea!8
< ( +a8' <8
+a8:
<+(<a87
fermeture transitivea!7
<+ a86 '
<+ a87
Fibonaccia7:F8F%7 gestion dynamiquea!6
fichiera'F8# gestion statiquea!6
fichier den-têtea#! + )a#
fichiers binairesa86F8: + a'
fichiers textesa86F8: 3/a6#
FIFOa!!! graphea!6:
filea!!!F!!# graphe acycliquea!6:
#"4a8%F!!# graphe connexea!6:
fils droita!'' graphe fortement connexea!6:
fils gauchea!'' graphe orientéa!6:
#
a6F!7 graphe pondéréa!6:
Flaga:7
<(a!:
fonctiona#F#6F68 ,
fonction variadiquea%!
fonctions de bas niveaua8# HARDWAREa
fonctions de haut niveaua8# hauteur dun arbrea!'%
fonctions mathématiquesaF#: header filea#!
<(6+a8% heapa!8
%a76
formatagea!
!8'

INDEX .
lvaluea#6F:#
/
identificateura!%F!7F#'F#F66 D
.%a':
.%

a6
maillona!8
incrémentationa7%F76F!6
*
a7F#%F#8
indentationa#6
*( a!6
indicea7%F:%F:6F%
mantissea!:
informationa
*)9)a#:F#!
informatiquea
matricea!
initialisationa:F:6F6#
matrice dadjacencea!7
instruction expressiona%
mediuma#:
instructionsa!F':F!8
mémoirea
a8F!:
mémoire auxiliairea!
itérationa7'
mémoire centralea
itérativea%!
menua6%
mode caractèrea86
mode chaînea86
>
modulea!8
mot des feuillesa!'%
langage de description dalgorithmea
mots clésa#6F#
'
mots réservésa#6
langage de programmationa6F7
langage machinea!
language Ca7 E
LDAa'
liena!'%F!6:
niveaua!'%
LIFOa!!
-0*.a!8F!'%F!6:
4
+a6F!7
-0*.A$*(,,$a!'%
lisibilité du code sourcea#6
-0*.A(,)a!'%
liste chaînéea!'F!8F!''
-0*.A!#!$a!'%
liste circulairea!#
-0*.'#!$a!'%
liste dadjacencea!6:
-0*.! (-$a!'%
liste doublement chaînéea!7
noma!%F#'F!:F#F66
a
nombre dapparitiona:F
(a!:
nombre premiera8F%%
(7(/-+a!: nombres consécutifsa8
!86

INDEX .
aF!6 paramètres effectifsa!:F#F#8

notation scientifiquea!: paramètres formelsa!:F#F#8
44a8%F!8 parcours en largeura!7
parcours en profondeura!'7F!7
parcours infixéa!'8
K parcours postfixéa!'8
parcours préfixéa!'7
octeta! pas de progressiona7'
opérandesa passage des paramètresa#7
opérateur conditionnela% passage par adressea#8F%F6%
opérateur dadressagea!7 passage par référencea#8
opérateur de référençagea!7 passage par valeura#8F6%
opérateurs arithmétiquesaF!'F!6F passage par variablea#8
#! PCa
opérateurs binairesa#! périphériquesa!
opérateurs bit-à-bita#% permutationa%%F'#F%6
opérateurs daffectation élargiea% perte de précisiona#7
opérateurs de comparaisonaF!'F!6F PGCDa7:F%8
##F!6 pilea#:F%%F%6F!!
opérateurs logiquesaF## pistea!
opérateurs unairesa#! poidsa!6:
opération arithmétiquea! point dappela!6F#
opération de départa7' point décimala#6
opération logiquea! pointeura:'F#8F8%F!'F!8
opérationsa!F!% portée dune variablea%F#'
opérations de basea!6 'a7'
ordinateura 6(8a#:F#!
ordre de forcea#7 6
<a8F!7F#F#F#:
ordre de prioritéaF##F#8 procédurea!:F#6F6#
organigrammea!8 procédure appelantea#%
aF!6F#% procédure appeléea#%
ou bit-à-bita#' processeura
ou exclusifa#' produit matriciela:
profondeura!'%
programmation modulairea!8
W programmea7F!
programme appelanta#
paramètresa!8F!:F#: programme principala7
!87

INDEX .
prototypea#% sommeta!'%F!6:
pseudo-codea' sous-programmea!6F!8
6/ )a# sous-programme appelanta#%
6/ a8F# 6
<a6
Wa#:F#!
<a6
Z stacka#:F!!
stack overflowa%%
RAMaF!F#
a#7
Recherche dans un tableaua:7 79)a%!
recherche dichotomiquea:7 7
(9)a8F#F8%F8:
récursiona%! 7
-9)a#!F!7F!8
récursivitéa%! a'
3+a!' *6a'
règle de troisa# 6Ia%
répertoirea'
*6a6
1H-H/
a7%
9)a%
+/a# +a%
ROMa! a'
*6a6
6Ia%
^
*6a6
/&/a6!
<a8F!7F%F#F#:
structurea6F!8
secteura!
structure conditionnelle composéea':
segment de donnéesa#:
structure conditionnelle multiplea6
B
*a6
structure conditionnelle simple a'8
sens dassociativitéa##F#:
structures conditionnellesa'8
séquencea'8F7#
structures de contrôlea!6
)(a!:
structures récursivesa!8F!'%
B.a'8 I./&9a6
B.B.**a': système dexploitationa%

+7a!:

aF#:F#!

A+Ja8: d

A+(<a#'F:6F:F!6
smalla#: tableaua:#F%F!'
SOFTWAREa tableau à deux dimensionsa!
!88

INDEX .
tableau de chaînes de caractèresa7 /

+7a!:
tableau de situationa%!F%7
taille dun arbrea!'%F!'8
tampona8#F8' s
a#:F#!
*/Y
a7# .Ja%!
tasa#:F!8 .J
a%!
technique de Flaga:7 .J a%!
tinya#: valeura!%
((8+a valeur absoluea#!
(/66+a valeur finalea76
traitementaF!% valeur initialea:F76
transposée dune matricea: variable de contrôlea7'
transtypagea#7 variable locale statiquea#7
tri à bullesa variable pointéea!6
tri dun tableaua variablesa!%
tri par sélectiona
-+ a6
troncaturea#: variables globalesa#'F#6F#7F#:
typea!%F!'F!:F# variables localesa#'F#8F#:
type logiquea vecteura!
type numériqueaF!' virgule flottantea!:
type symboliquea!6 .(
7a!:
I6+7+<a6 !"aF!6F#!F##
types personnalisésa6
types simplesa!'
types structurésa!6F:# t
Warninga!F#%
h I9.
a7#
UALa
UCa y
uniona6%
*.*a6' a#'
unité centralea
!8:

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 info@omniscriptum.com
Telefax: +371 686 204 55 www.omniscriptum.com
View publication stats

Algorithmique Bouchiha

Uploaded by

Copyright:

Available Formats

Algorithmique Bouchiha

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Algorithmique Bouchiha

Uploaded by

Copyright:

Available Formats

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

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

Book · April 2020

Re-engineering Web Application towards Web Semantic View project

Ontology alignment revision View project

The user has requested enhancement of the downloaded file.

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

1. Bref historique sur l¶informatique

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

1.5.1. Système d¶exploitation

1.5.2. Fichier et répertoire

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

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

?U Retour chariot

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

Chapitre 2 : Les algorithmes séquentiels simples

1. Parties d¶un algorithme

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

x Les opérateurs arithmétiques classiques : , , , .

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

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

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

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

7.4. Manipulation des booléens

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

!! décalage à droite 11 GàD

Les commentaires améliorent la lisibilité du code.

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

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

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

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

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

N CW Type :<( , valeur : 9''''

Chapitre 3 : Les structures conditionnelles

Voyons les exemples suivants :

Soit lexemple suivant :

>3  ? 5&+ <  

>3  !? 5&+ <  !

050 >3  ? 5&+ <  

- Linstruction - + V termine lexécution de linstruction englobante

Chapitre 4 : Les boucles

Lexemple suivant permet dafficher les valeurs de  à ' :

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

Reprenons lexemple permettant dafficher les valeurs de  à ' :

5.   .

Gardons le même exemple permettant dafficher les valeurs de  à ' :

V=  1  >C$

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

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

Soit par exemple : En C :

' .&.!C;.&. Q.

2.2. Tri d¶un tableau

3. Les chaînes de caractères

NLa fonction 6/ , elle aussi, appartient à la bibliothèque 7

contiendra  (le nombre de variables remplies avec succès).

Le programme C précédent affiche :

3.3. Tableau de chaînes de caractères

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

- + ./&- + ./ N.O

' .&.!C;.&. & .

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

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

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

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

N CW Type :<(, valeur : 9''''

>3 ? 5&+ <

>3 !? 5&+ < !

050 >3 ? 5&+ <

- Linstruction -+V termine lexécution de linstruction englobante

Lexemple suivant permet dafficher les valeurs de à ' :

Reprenons lexemple permettant dafficher les valeurs de à ' :

5. .

Gardons le même exemple permettant dafficher les valeurs de à ' :

V= 1 >C$

'.&.!C;.&. Q.

NLa fonction 6/ , elle aussi, appartient à la bibliothèque 7

contiendra (le nombre de variables remplies avec succès).

-+./&-+./ N.O

'.&.!C;.&. &.

'D&1D&D&D N.ONDO&1

!

. >C$HDMCF>??.

En C, il existe aussi plusieurs fonctions appartenant à la bibliothèque *)9)

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

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

AA

+ ++/'9 1

E: E: E:

'' E= E= E=

Dans ce programme, nous avons défini un type énumération !

<=> =06++9

(*J.< ( +<

buffer. Donc, en cas doubli de < ( +, certaines données risquent de ne pas

(7+J <+ <

<+ <61

<+ <61

(*J.<6/ (7+J 0<

C<6/ =-(D(/=0<61

-J.< <<

(*J.< ++V<

Les deux fonctions, *( et <++, appartiennent à la bibliothèque 7

9B ' 6

9H>P J?> >P ??

"H>P J?> >P ??

)J; J) P

"I< H"! P

9H>P J?> >P ??

.4>YIF 5

1. 1.

!D(/+Je=*=1

6/ =!D(/+0,/66

Un arbre n-aire : Un arbre n-aire $)"- !5!$'%!,$1$,: 1$-0*. .8$"

Où racine est une variable de type pointeur contenant l .!$))$.-0.! (-$

+ )+ )+J!-+!-+ 0 )K

2++++J!-+!-+