You are on page 1of 120

ABDELKADER BENHARI ABDELKADER BENHARI ABDELKADER BENHARI ABDELKADER BENHARI

LALGORITHMIQUE LALGORITHMIQUE LALGORITHMIQUE LALGORITHMIQUE






The algorithm is the set of rules and techniques that are involved in the definition and design of algorithms,
that is to say, systematic process of problem solving to describe the steps to the result. In other words, an
algorithm is a finite and unambiguous instructions to give the answer to a problem.

If the instructions of an algorithm executed one after the other, the algorithm is called sequential if they run
at the same time, it is parallel. If the algorithm operates tasks running on a processor network is called
distributed algorithm, or distributed.

The word "algorithm" comes from the name of the mathematician Al Khawarizmi (Latinized Algoritmi in the
Middle Ages), which, in the ninth century wrote the first systematic work on the solution of linear and
quadratic equations.
A.BENHARI 2

Table des matires
INTRODUCTION A LALGORITHMIQUE ........................................................................................................ 4
- Analyse
- Algorithme
- Squelette dun algorithme
- Elment de base
- Schmas algorithmique
APPLICATION ............................................................................................................................................... 13
DEFINITION DES VARIABLES ....................................................................................................................... 14
- Variable destine au calcul
- Variable non destine au calcul
ENTREE DE DONNEES DANS LA MACHINE ................................................................................................ 15
AFFICHAGE DE RESULTATS ......................................................................................................................... 15
CALCULS ........................................................................................................................................................ 15
CONDITIONS ................................................................................................................................................. 15
LES STRUCTURES REPETITIVES ................................................................................................................... 16
LES PROCEDURES ET LES FONCTIONS (SOUS-PROGRAMME).................................................................. 19
- Procdure
- Fonction
LES CHAINES DE CARACTERES .................................................................................................................... 22
- Dfinition
- Concatnation
- Conversions
- Longueur dune chane
- Sous chane dune chane
NOTION DE TABLEAU (OU TABLE OU VECTEUR OU MATRICE ARRAY) ............................................. 24
- Dfinition
- Dclaration du tableau
- Mise ltat initial
- Recherche de donne dans un tableau
LES METHODES DE TRI USUELLES .............................................................................................................. 28
- Tri par insertion
- Tri par slection
- Le tri bulle
- Le tri de shell
- Tri de shell-Metzner
- Tri par vecteur dindice
- Tri par monotonie
LA RECURSIVITE ........................................................................................................................................... 35
- Dfinition
- Principe
LES FICHIERS ................................................................................................................................................. 37
- Dfinition
A.BENHARI 3

- du fichier
- Notion denregistrement
- Dclaration des fichiers en algorithme
- Instruction de manipulation des fichiers
- Application sur les fichiers squentiels
- Les fichiers accs direct
- Les fichiers texte
ALGORITHMES ET STRUCTURE DE DONNEES ........................................................................................... 44
- Les structures arborescentes
- Graphes
- Problme de la recherche
- Problme du tri
- Quicksort
- Heapsort
ALGORITHMES NUMERIQUES .................................................................................................................... 58
- Gnralits
- Systmes linaires Ax=b : mthodes directes
- Factorisation A=LU
- Factorisation PA=LU
- Factorisation A=BB
t
: Cholesky
- Factorisation A=LDL
t
: Crout
SYSTEMES LINEAIRES AX=B : METHODES ITERATIVES ............................................................................. 73
- Principe
- Mthode Jacobi
- Mthode Gauss-Seidel
- Mthode de relaxation
- Mthodes du gradient
PROBLEMES AU MOINDRES CARRES (LINEAIRE) ...................................................................................... 79
- Rgression linaire
- Mthode des quations normales
RESOLUTION DES EQUATIONS NON LINEAIRES ....................................................................................... 81
- Mthode de dichotomie
- Gnralits
- Valeurs propres et vecteurs propres
APPROXIMATION POLYNOMIALE & INTEGRATION NUMERIQUE .......................................................... 85
- Approximations polynomiales
QUATIONS DIFFERENTIELLES .................................................................................................................... 89
- Gnralits
- Mthode de rsolution numrique
- Mthode de Euler
- Mthode du dveloppement de Taylor
- Mthode de Runge - Kutta
EXERCICES CORRIGES .................................................................................................................................. 92
BIBLIOGRAPHIE ......................................................................................................................................... 120

A.BENHARI 4




LALGORITHMIQUE LALGORITHMIQUE LALGORITHMIQUE LALGORITHMIQUE


I. INTRODUCTION A LALGORITHMIQUE

Quest ce quun algorithme ?
"Une suite finie de rgles appliquer dans un ordre dtermin un nombre fini de donnes
pour arriver, en un nombre fini d'tapes, un certain rsultat, et cela indpendamment des
donnes".
Encyclopaedia universalis

I.1. Analyse
Dfinition
La dcomposition dun problme en sous problmes, ensuite des sous problmes en sous
problmes, on arrive ainsi des problmes non dcomposables, ou des tches lmentaires.
Ces tches lmentaires ordonnes forment la succession des tapes qui permettent partir
dune situation initiale daboutir une situation finale qui reprsente la solution du problme
de dpart. Une premire solution peut tre rdige dans un langage non formel (en franais
par exemple), ensuite traduite dans un langage formel (algorithme), partir duquel il est
possible dcrire un programme dans un langage de programmation et de lexcuter sur une
machine.
Dmarche de dcomposition
Nous allons dtailler un exemple qui montre la dmarche de dcomposition et comment
arriver rsoudre un problme sans faire autre chose que de lexprimer par des problmes
plus petits.
Le problme initial : un individu se trouve devant une voiture et doit la faire dmarrer.

Entrer dans la voiture
Dmarrer la voiture

Ouvrir la portire
Monter
Fermer la portire

Faire fonctionner la voiture
Dmarrer la voiture

Mettre la cl dans le contact
Faire un quart de tour, les voyants doivent sactiver
Continuer tourner la cl jusqu ce que la voiture mette un bruit indiquant
ltat de marche normal
A.BENHARI 5


Appuyer sur la pdale dembrayage
Enclencher la premire vitesse
Dsactiver le frein main
Actionner doucement le dmarreur et relcher progressivement lembrayage.

La solution finale est exprime par les tches se trouvant en bas du schma. Cette succession
de tches sappelle un algorithme mais il est ici exprim dans un langage non formel.
La situation initiale : individu, et voiture ouverte (non verrouille).
La situation finale : individu dans la voiture et voiture en tat de marche.

Lalgorithme a besoin de certains renseignements externes pour pouvoir fonctionner
correctement (voyants, bruit que fait la voitureetc.)
La solution est donne dans le cas o il ny a aucun problme, supposons maintenant que la
voiture ne veut pas dmarrer o quune fois dmarre, le conducteur cale ! Que faire ? Il est
clair que notre algorithme ne rpond plus la question, et quil faut lamliorer pour quil
marche dans toutes les situations possibles.
Nous allons rcrire notre algorithme.
Entrer dans la voiture
Dmarrer la voiture

Ouvrir la portire
Monter
Fermer la portire

Faire fonctionner la voiture
Dmarrer la voiture

Si le conducteur a la cl alors
Tant que la voiture nest pas en tat de fonctionnement normal il faut
Dbut
Mettre la cl dans le contact
Faire un quart de tour, les voyants doivent sactiver
Continuer tourner la cl jusqu ce que la voiture mette un
bruit indiquant ltat de marche normal
Si la voiture ne dmarre pas alors
Retourner la cl dans le sens contraire
Reprendre : Mettre cl dans contact
Fin
Appuyer sur la pdale dembrayage
Enclencher la premire vitesse
Dsactiver le frein main
Actionner doucement le dmarreur et relcher progressivement
lembrayage.
Si la voiture cale alors
Retourner la cl dans le sens contraire
Reprendre : Mettre cl dans contact
Fin si
Sinon
Retourner chercher la cl.
A.BENHARI 6

Reprendre : Mettre cl dans contact
Fin si.

Ce nouvel algorithme permet de refaire certaines actions si elles ne fonctionnent pas
correctement.
I.2. Algorithme
Dfinition
Un algorithme est rdig dans un pseudo-langage et destin une machine abstraite
(virtuelle). Il permet de dcrire formellement toutes les tapes ncessaires qui partir dune
situation initiale, permettent daboutir une situation finale. Cette dernire constitue la
solution qui rsout un problme donn.
Le langage algorithmique est prcis, et suit des rgles qui seront dcrites tout au long de ce
document.
Dmarche : Problme, analyse, algorithme
Pour illustrer la dmarche qui permet dcrire un algorithme nous allons traiter des exemples
concrets
1
er
exemple : Somme de deux entiers
Soit le problme formul dans les termes suivants : crire un algorithme qui calcule la somme
de deux entiers, et affiche le rsultat lcran.
Le problme ici est simple, il sagit de calculer la somme de 2 entiers. Le problme ne prcise
pas o trouver les deux entiers, il est alors possible de supposer que les deux entiers seront
donns par lutilisateur, ce dernier dialogue avec la machine par lintermdiaire du clavier.
On dit alors que les deux entiers seront saisis au clavier. Lnonc ne prcise pas non plus que
faire du rsultat, on suppose alors que ce dernier sera affich sur lcran.

Voici le schma qui rsume notre problme.


Figure Erreur ! Il n'y a pas de texte rpondant ce style dans ce document.-1
Deux donnes seront lentre dune bote qui ralise le calcul et fournit en sortie la somme
de ces deux donnes.
En algorithmique, il est frquent de parler dentre et de sortie.
o Les donnes dun algorithme sont appeles entres : elles sont la base du traitement
des algorithmes.
o Les rsultats dun algorithme sont appels sorties : elles sont le fruit des traitements
faits par les algorithmes et fournissent une rponse au problme pos.
Donne 2
Rsultat
Calcul de Somme
Donne 1
A.BENHARI 7

La bote de la figure Figure Erreur ! Il n'y a pas de texte rpondant ce style dans ce document.-1
reprsente ce que nous allons appeler par la suite un processus de calcul. Ce processus ralise
un traitement simple, qui est le calcul de Donne 1 + Donne 2. Une fois le rsultat obtenu il
sera affich sur lcran.
La totalit du schma est le processus gnral et cest ce quil faut concrtiser par un
algorithme.
Pour crire cet algorithme nous avons besoin de :
1. Accepter Donne 1 et la stocker,
2. Accepter Donne 2 et la stocker,
3. Calculer Donne 1 + Donne 2,
4. Stocker le rsultat,
5. Afficher le rsultat sur lcran.
Nous avons ainsi dcompos le problme comme expliqu dans la section 0, les tches
numrotes de 1 5 sont en fait lalgorithme crit en langage non formel. Il est possible de
noter ici, que chaque problme possde la solution dans sa dcomposition.
Nous allons le traduire dans un langage algorithmique formel, et nous expliquerons les
diffrents mots-cls utiliss au fur et mesure.
Algorithme Somme
Variables
Donne1, Donne2, Rsultat : entier
Dbut
Ecrire (Donner la donne numro 1 )
Lire Donne1
Ecrire (Donner la donne numro 2 )
Lire Donne2
Rsultat = Donne1+Donne2
Ecrire (La somme est : Rsultat)
Fin

I.3. Squelette dun algorithme
Algorithme NomDeLAlgorithme
VAR
//Dclaration de variables manipuls par lalgorithme
Donne1, Donne2, Rsultat : entier
Dbut
//Corps de lalgorithme constitu par les expressions
Fin
Un algorithme est dfini par un entte donnant le nom de lalgorithme, gnralement
explicite. Lentte est suivie par une partie dclarative permettant de dfinir toutes les
donnes qui seront utilises par lalgorithme. Par la suite entre deux mots-cl Dbut et Fin,
nous retrouvons le corps de lalgorithme qui sera constitu par les diffrentes expressions
permettant de rsoudre le problme.
I.4. Elments de base
Types
Les types permettent de donner un domaine de dfinition aux objets manipuls par un
algorithme, par exemple des donnes ncessaires pour un calcul seront dfinies dans le
domaine des rels ou des entiers, un message affich sera dfini dans le domaine des
caractres alphanumriquesetc.

A.BENHARI 8

Il existe 5 types de base en langage algorithmique de programmation :
Les entiers : dfinis dans le domaine des entiers naturels et les entiers relatifs.
Les rels
Les caractres : dfinit tout ce qui est caractre alphanumrique, a .. z , 1 .. 9
ainsi que les caractres spciaux, caractres de ponctuation, etc
Les chanes de caractres : un assemblage de caractres forme une chane.
Les boolens : un boolen permet de dfinir une donne qui ne peut prendre quun avaleur
entre deux : vrai ou faux, ou bien 0 ou 1.
Variables
Les variables servent dclarer des objets ncessaires au bon fonctionnement dun
algorithme. Les variables doivent tre dfinies avant leur utilisation, en gnral en dessous de
lentte de lalgorithme dans une partie qui peut tre distingue par le mot cl VAR. Elles sont
dfinies grce lun des cinq types de base et peuvent accepter une valeur de dbut appele
valeur initiale.
Exemple :

Algorithme Exemple

VAR
Donne1 : entier
Donne2 : entier
Car : caractre
Message : Chane de caractres
VraiOuFaux : boolen
Dbut
// Initialisation des diffrentes variables
Car A
VraiOuFaux Faux
Donne1 10
Donne2 20
.
.
.
Fin

Linitialisation des variables permet de donner ces dernires une premire valeur. Il nest
pas interdit de changer cette valeur par la suite que ce soit par lintermdiaire :
o dune autre affectation,
o dune expression de calcul,
o dune lecture au clavier.
Constantes
Les constantes sont des donnes initialises qui ne changent jamais de valeur pendant toute la
dure de lalgorithme. Elles peuvent seulement tre lues, utilises pour un traitement,
affiches mais jamais modifies

Algorithme Circonfrence
Constantes
PI = 3,14
VAR
Circonfrence : rel
Rayon : rel

A.BENHARI 9

Dbut
Ecrire (Donner le rayon du cercle)
Lire Rayon
Circonfrence PI * (Rayon)
Ecrire (La circonfrence de votre cercle est : Circonfrence)
Fin.
Dans cet algorithme PI ne peut qutre utilise telle quelle, elle ne peut pas tre modifie
dune faon quelconque.
Dclaration
La dclaration sert introduire la donne (variable ou constante)qui sera utilise par
lalgorithme. Lors de la dclaration dune donne il est ncessaire de lui donner un type, et il
est parfois possible de lui affecter une valeur de dpart. Pour les constantes, la valeur de
dpart est obligatoire.
Il existe deux manires de dclarer une variable en pseudo-langage.
NomDeLaVariable [: type de la variable]
Ou bien
[Type de la variable] NomDeLaVariable < Valeur de dpart>
Remarque : Il est conseill de garder le mme type de dclaration dans le mme algorithme.
Exemples :
V1 : entier //Dclaration de V1 de type entier
Entier V2 0 //Dclaration de V2 de type entier avec une valeur initiale gale 0
Entier V3 //Dclaration de V3 de type entier sans valeur initiale
Il est aussi possible de faire des dclarations groupes .
Entier V1, V2, V3 // Dclaration de trois variables de type entier par le biais dune mme
instruction.
Initialisation
Linitialisation dune variable revient une affectation dune premire valeur avant toute
autre utilisation de cette variable. Les instructions dinitialisation peuvent figurer nimporte
o dans lalgorithme, et pas ncessairement au dbut.
Oprateurs
Les oprateurs permettent de modifier des valeurs de donnes lintrieur des expressions.
Nous allons distinguer entre trois types doprateurs en algorithmique. Le type dune donne
dtermine le type des oprateurs qui peuvent lui tre appliqus.
Remarque : certains langages de programmation possdent des oprateurs spciaux.
Oprateurs arithmtiques
Les oprateurs arithmtiques sont tous utiliss en algorithmique pour crire des expressions
arithmtiques pouvant tre affectes des variables numriques. Par exemple pour modifier
certaines valeurs il est ncessaire dutiliser des oprateurs.
Remarque : Il est aussi possible dutiliser loprateur + pour modifier des chanes de
caractres.
+ : permet les additions
- : permet les soustractions.
* : permet la multiplication
/ : permet la division
% ou modulo : le reste de la division entire
A.BENHARI 10

Oprateurs logiques
Les oprateurs logiques sont utiliss pour affecter ou modifier les valeurs des donnes de type
boolen. Il en existe trois :
o NON : appel Non logique, cest un oprateur unaire,
o OU : oprateur binaire appel Ou logique,
o ET : oprateur binaire appel Et logique.
Les trois tableaux ci-dessous rsument les tables de vrit des oprateurs logiques :

Et Vrai Faux
Vrai Vrai Faux
Faux Faux Faux

Ou Vrai Faux
Vrai Vrai Vrai
Faux Vrai Faux

Non Vrai Faux
Faux Vrai
Oprateurs relationnels
Les oprateurs relationnels permettent de comparer des expressions entre elles, le rsultat sera
une expression logique : vraie ou fausse. Ces oprateurs peuvent comparer entre les types
numriques, les types caractres et les types chanes de caractres.
<
<=
=
>
>=
<>
Oprateur Type numrique Type alphanumrique Type chane
<= 2 <= 3 vrai a <= b vrai abc <= acc vrai
<= 32.5<=1 faux 9 <= a vrai zze <= azerty faux
>= 3 > 2 vrai 9 >= a faux aaaaa >= bbbbbbb faux
= 0 = 0 vrai a = b faux aaaa = fffe faux
<>
<
>

Expressions
Les expressions constituent la base de toute instruction algorithmique. Ils existent des
expressions simples et des expressions complexes. Toutes seront tudies dans les sections
suivantes sous la dnomination de schmas algorithmiques.
Dfinition
Une variable ou une constante est une expression.
Les expressions peuvent tre combines grce aux oprateurs et donnent ainsi une nouvelle
expression.
A.BENHARI 11

Les expressions comme nous le verrons plus loin peuvent aussi contenir des appels de
fonctions, ou constituer des appels de procdure.
Les expressions constituent les instructions algorithmiques.

I.5. Schmas algorithmiques
Schma algorithmique simple
Affectation
Laffectation est lexpression de base en algorithmique, elle permet dassocier une valeur
quelconque une variable de lalgorithme. Il est clair que la valeur doit tre du mme type
que la variable.
Laffectation comprend 2 parties spares par le symbole daffectation :
o une partie gauche appele aussi valeur de gauche et constitue par une variable, c'est-
-dire un objet qui peut prendre une valeur,
o une partie droite ou valeur droite constitue par une expression pouvant tre
value.

VAR
V1 : entier
V2 : rel

Dbut
V1 10.5 // Affectation errone
V1 10 // Affectation correcte, on dit que V1 reoit la valeur 10
V2 32.5 // Affectation correcte, V2 reoit 32.5
V2 10 // Affectation correcte, les rels englobent les entiers naturels
V2 25/2 // Affectation correcte, V2 recevra le rsultat du calcul de 25 divis par 2
Fin
Lecture de donnes
Une autre manire daccorder des valeurs des variables est de faire ce quon appelle une
lecture de donnes. La lecture se fait partir dun dispositif dentre, en loccurrence un
clavier. On lappelle aussi saisie ou entre de donnes. Ce procd est utilis chaque fois
quune valeur est requise par lalgorithme et que cette valeur ne peut tre donne que par
lutilisateur, c'est--dire la personne qui utilise le programme. Bien sr dans un algorithme il
ny aura pas de vritable saisie partir du clavier mais seulement une simulation de la saisie.
Lalgorithme simule une demande de donne lutilisateur et laccepte pour la stocker dans
une variable.
Plus tard, lalgorithme sera traduit par un programme, le programme sera compil et les
instructions qui seront excutables par une machine demanderont une saisie relle de la part
de lutilisateur. Ce dernier devra taper une donne du type requis au clavier et valider sa
rponse par un retour chariot.
La syntaxe permettant de lire une donne est la suivante :
Lire NomDeLaVariable

Ecriture de donnes
Lcriture de donnes permet un autre type dinteraction avec lutilisateur : la sortie de
messages ou de rsultats lattention de ce dernier. Lcriture se fait sur un dispositif de sortie
tel que lcran ou limprimante par exemple.
A.BENHARI 12

La syntaxe communment adopte est la suivante :
Ecrire Message
Ecrire Valeur
Incrmentation
Lincrmentation est une expression particulire qui permet daugmenter la valeur dune
variable dune certaine quantit la fois.
V1 V1 + 1
V2 V2 + 2
Dcrmentation
La dcrmentation permet de rduire la valeur dune variable.
V1 V1 - 1
V2 V2 - 2
Schma algorithmique conditionnel
Un schma algorithmique conditionnel donne lalgorithme la possibilit daller dans un sens
plutt que dans un autre. Une condition est value, et partir du rsultat de cette valuation
un choix est fait.
































A.BENHARI 13



II. Application

Ennonc de EXAM1 : on fait passer un examen des tudiant et lon veut dterminer ceux qui
sont admis . Il y a 3 matires : math (coef 3), franais (coef 2) et informatique (coef 5).
Les notes peuvent aller de 0 20. Il y a admission la condition dobtenir la moyenne
c'est--dire 10 sur 20.

Ralisation des spcifications :
3 matires :
maths 3
franais 2
informatique 5
notes 0 20
admis = moyenne de 10/20 minimum

c'est--dire ajourn pour un total de point <100 mais admis pour un total >= 100

Ralisation dun organigramme de programmation ou ordinogramme



Ralisation de lalgorithme
algo exam1 ()
Dbut
Entre des notes
Calcul le total
Si total >= 100
Admis
Ajourn
FIN
Non Oui
A.BENHARI 14

/* dterminer admis ajourn*/
/* 0<= notes <= 20 */
const
entier coefmath 3
entier coeffran 2
entier coefinfo 5
var locales
rel fran, math, info, total
dbut
afficher ( Entrez la note de math = )
saisir (math)
afficher ( Entrez la note de franais = )
saisir (fran)
afficher ( Entrez la note dinformatique = )
saisir (info)
total math*3 + fran*2 + info*5 ou total math*coefmath + fran*coeffran + info*coefinfo
si total >= 100
alors
afficher ( ADMIS )
sinon
afficher ( AJOURNER )
finsi
fin

III. Dfinition des variables
2 types de variables

a. Variable destin au calcul
Entier : peut contenir un nombre entier entre -32 768 et 32 767. Reprsentation binaire pure
en machine
Rel : tous les nombres dont les entiers. Reprsentation virgule flotante.
0,3458.10
4
(mentis et caractristique)
Logique ou boolen :
2 valeurs : vrai et faux

var locales
logique homme
dbut
si homme ou si homme = vrai
alors
afficher ( cest un homme. )





b. Variable non destin au calcul
car : un symbole
chane (longueur) : chane de charactre
A.BENHARI 15


ex :
chane (15) phrase
.
Phrase il y a des nuages

IV. Entre de donnes dans la machine
saisir (nom_variable)

V. Affichage de rsultats
afficher ( libell1 , var1, libell2 , var2, )

VI. Calculs
Symbole daffectation
total math*3
Rgle hirarchique des oprateurs :
- puissance : **
- multiplication et division : * et /
- addition et soustraction : + et
Les parenthse peuvent changer la hirarchie des oprations. Ralisation des oprations dans
la parenthse la plus interne.

VII. Conditions
Excution squentielle des instructions des programmes

Attention au parenthse
si (a=8 et b=3 ou (c=5) ou non d





A.BENHARI 16

VIII. Les structures rptitives


Pour que le programme ne boucle pas indfiniment, il faut continuellement inclure
lintrieur de la boucle une instruction capable de modifier la valeur de lexpression test.


Diffrentes faon de programmer une boucle :
Lors dun dialogue clavier/cran = question pos loprateur
Autres traitement ? (oui/non)
Rponse de loprateur variable = rponse

Analyse du problme : faire n addition de 2 nombre
c a + b


tant que rponse = oui si non
faire
calculer 1 addition
autre calcul ? (oui/non)
saisir la rponse
fin tant que

prog
Dbut


Calculer 1 addition

(c fois)


fin
Saisie de a et b

Addition

Affichage du rsultat

question
A.BENHARI 17



Entrez imprativement dans la boucle : rponse oui
Entrez conditionnelle dans la boucle suivant oprateur :
Afficher (calcul ? (oui/non))

algo rep1()
var locales
entier a, b, c
chane (3) reponse
dbut
afficher ( Voulez-vous faire un calcul ? (oui/non) )
saisir (rponse)
c a + b
tant que rponse = oui
faire
afficher ( entrez a et b )
saisir (a, b)
c a + b
afficher ( rsultat= , c)
afficher ( autre addition ? (oui/non) )
saisir (rponse)
fin tant que
fin

A laide dune marque de fin de travail
algo rep2()
var locales
entier a, b, c
dbut
afficher ( Entrez une valeur pour a ou -1 pour terminer.)
saisir (a)
tant que a <> -1
faire
afficher ( entrez b )
saisir (b)
c a + b
afficher ( rsultat= , c)
afficher ( Entrez a ou -1 pour terminer.)
saisir (a)
fin tant que
fin








A.BENHARI 18

a. A laide dun compteur
Par incrmentation ou dcrmentation

i. Par dcrmentation
algo rep3()
var locales
entier a, b, c, i
dbut
afficher ( Entrez le nombre daddition faire.)
saisir (i)
tant que i > 0
faire
afficher ( entrez a et b )
saisir (a, b)
c a + b
afficher ( rsultat= , c)
ii-1
fin tant que
fin

ii. Par incrmentation
algo rep4()
var locales
entier a, b, c, I, cpt
dbut
afficher ( Nombre daddition.)
saisir (i)
cpt0
tant que i > 0
faire
afficher ( entrez a et b )
saisir (a, b)
c a + b
afficher ( rsultat= , c)
cptcpt+1
fin tant que
fin













A.BENHARI 19

IX. Les procdures et les fonctions (sous-
programme)


Raison des sous programmes :
- rutilisabilit
- lisibilit du programme
- facilit de maintenance
- facilit de mise au point



P1 : entre
P2 : entre-sortie
P3 : sortie

A.BENHARI 20



Une fonction ne retourne quune valeur, ses paramtres doivent tre exclusivement dentre
(passage par valeur uniquement)

Entre = passage de paramtre par valeur
Entre-sortie et sortie : passage par rfrence

Passage par une valeur : on donne au programme une valeur donn














A.BENHARI 21

a. Procdure
Est un sous ensemble indpendant o faisant partie dun programme principale. Elle
communique avec des paramtres entre-sortie, sorties.
Exemple : soit calcul de la somme de 2 nombres : c a + b


procdure somme (a, b, c)
val entier a
val entier b
ref entier c

dbut
ca+b
fin

programme principal
algo pp ()
var locales
entier x, y, z

dbut
afficher ( Entrez une valeur pour x )
saisir (x)
afficher ( Entrez une valeur pour y )
saisir (y)
somme (x, y, z)
afficher ( Le rsultat est , z)
fin

b. Fonction
Une fonction est une sous partie dun programme qui retourne 1 valeur donc une fonction
possde un type.
Elle ne doit possder que des entrs.

Doit contenir la commande retourne (constante, variable, expression arithmtique)






fonction entier fsomme (a,b)
A.BENHARI 22

val entier a
val entier b
var locales
entier c
dbut
ca+b
retourne (c)
fin

dbut
retourne (a+b)
fin


programme principal
algo fpp()
var locales
entier a, b
dbut
afficher ( entrez a et b )
saisir (a,b)
afficher ( Rsultat , fsomme (a,b))
fin

X. Les chanes de caractres
a. Dfinition
Cest un ensemble de caractres affichable. On utilise un code ISO (ASCII) codant 0 127
caractre texte et 128 255 caractres graphiques
- 0 31 caractre de contrle du terminal
- 48 57 chiffre
- 65 A, B
- 97 a, b

caractre alphabtique numrique spciaux

Une chane de caractre = caractre concatn

b. Concatnation
Mise bout bout de caractre pour former une chane
Mise bout bout de plusieurs chanes

Oprateur de concatnation = +
y = il fait chaud // pas de smantique
z = xyaZb2
a = il
b = fait
c = froid
d = chaud
e = humide

y = a + b + d


A.BENHARI 23

c. Conversions
i. Conversions dune chane en entier
Fonction chanant

c 2003
z chainant (c)

d 128
y c + d
y = 2003128

r chainant (d)
r = 128

w = z + v
w = 2131

a chainant (y)
a = 2003128

Si erreur
chainant = Za34 retourne 0
chainant = 34Za retourne 34

ii. Conversion dun entier en chane
Ent chaine (entier) retourne une chane

d. Longueur dune chane
Dfinition de la chane
var locales
chaine (12) a

Longueur effective de la chane
= Longueur de lespace utilis
longueur (chaine) retourne un entier

ex : l longueur (a)

e. Sous chane dune chane
z = Il fait chaud
temperature milieu (z, 9, 5)
temprature = froid

milieu (chaine, num dpart, nombre partir de dpart)



A.BENHARI 24

XI. Notion de tableau (ou table ou vecteur ou
matrice array)
a. Dfinition

Un tableau est un ensemble de valeurs de mme type

Types :
- prdfinis = entier, rel, logique, caractre, chane
- construits = structur, numr

Ex dun tableau dentier
1, 3, 5, 2, 8, 7

en variable
1 3 5 2 8 7
A B C D E F

Tableau t
1

1 3 5 2 8 7 Valeur
1 2 3 4 5 6
Rang dans tableau

t
1
[3] = 5
5 est la valeur de llment de rang 3 du tableau t
1

1 2
1
1 3
2
5 2
3
8 7
t
1
[2ligne,1colone] = 5
rang = 2,1

b. Dclaration du tableau
var locales
type nom_tableau [taille] taille = 1
er
valeur valeur max

Ex : soit un tableau de 50 entiers appel t
1

entier t
1
[1 50]

Soit un tableau de 50 chanes de caractres de 22 caractres
chaine (22) t
2
[1 50]

i. Tableau 1 dimension
On peut le considrer comme linaire
On le remplie avec 1 et 1 seul indice
(vecteur)
Chaque lment est identique

ii. Tableau 2 dimensions, 3, n
A.BENHARI 25

On peut considrer quil sagit dune nature contenant l lignes et c colones

var locales
type nom_tableau [ [1l], [1 c] ]

exemple 3 dimensions
entier t
1
[ [1 m], [1l], [1 c] ]
ensemble de matrice

Du plus haut niveau au plus bas niveau

c. Mise ltat initial
Mettre les donnes dans un tableau correspond au chargement des donnes dans le tableau.
RAZ, RAB, VRAI / FAUX
- Transfert de variables
- Transfert dautre tableau
- Saisie
- Donns de fichiers

Exemple de saisie
algo saisie ()
var locales
entier t
1
[[1..5], [1..3]], l, c

dbut /* -1 pour fin*/
afficher ( entrez un numro de ligne )
saisir (l)
tant que l <> -1
faire
afficher ( entrez un numro de colone )
saisir (c)
afficher ( entrez une valeur pour , l, c)
saisir (t
1
[l,c])
afficher ( Entrez un numro de ligne ou -1 pour quitter
fin tant que
fin

Exemple de fonction avec passage de tableau
fonction entier TOTO (t
1
[], n)
ref entier t
1
[1..n]
val entier n

d. Recherche de donne dans un tableau
i. Recherche par le rang

Ex : afficher (t
1
[3])

ii. Recherche squentielle
1. Sans erreur possible
A.BENHARI 26

C'est--dire lment cherch se trouve toujours dans le tableau


2. Avec erreur possible
En italique dans sch prcdent.
t
1
(0,1)
t
1
(0,1)

procdure rechseq (t
1
[], n atrouve)
ref entier t
1
[1..n]
val entier n
val entier atrouver
var locales
entier i
logique trouve
dbut
trouve faux
i1
tant que (i<=n) et trouve = faux (non trouve)
faire
si t
1
[i]=atrouve
alors
trouve vrai
sinon
i i+1
finsi
fin tant que

si trouve = vrai
alors
afficher ( llment , atrouve, se trouve en , i, positions )
sinon
afficher ( erreur )
fin si
fin


iii. Recherche dichotomique
Attention : Cas particulier pour tableau tries

algo
Dbut
Tableau trouver

Trouver 1 lment
du tableau (t fois)

t
1
(0,1)
t
1
(0,1)

fin
Dbut traitement


Trouv (0,1)


Trouv (0,1)

Inter i
I n+2
Trouve vrai
ii+1
A.BENHARI 27

Principe
Soit un tableau dune suite de 8 nombres.
3 5 8 12 15 27 43 75
1 2 3 4 5 6 7 8

Chercher 15
indice mini = 1
indice maxi = 8
indice mil = (mini + maxi) /2 =4

trouve = 12
indice mini mil +1
indice mil 6

trouve = 27
indice maxi mil - 1
indice mil (5+5) / 2 = 5



procdure dichotomie (t
1
[], n, cherche, trouve, rang)
ref entier t
1
[1..n]
val entier n
val entier cherche
ref logique trouve
ref entier rang

var locales
entier mini, maxi, mil


dbut
mini 1
maxi n
mil (mini + maxi) / 2
tant que mini <= maxi et t
1
[mil] <> cherche
faire
si cherche < t
1
[mil]
alors
maxi mil -1
Tant que
(mini<= maxi)
et cherche <>
trouve
procdure
Dbut


Traiter 1 lment
de partage n fois

t
1
(0,1)
t
1
(0,1)

fin
Cherche < t
1
[mil]
(0,1)

Si cherche < t
1
[mil]
<> (0,1)

Si cherche t
1
[mil]
A.BENHARI 28

sinon
mini mil + 1
finsi
mil (mini + maxi) / 2
fin tant que

si t
1
[mil] = cherche
alors
trouve vrai
rang mil
sinon
trouve faux
finsi
fin



XII. Les mthodes de tri usuelles
a. Tri par insertion
i. Principe
18 5 12 17 14 31 8
1 2 3 4 5 6 7

Comparer un lment au suivant de la liste si cet lment une valeur infrieur, il reste en
place sinon il est chang avec celui qui est de valeur infrieur, il sagit donc pour chaque
lment du tableau de lui mnager une petite place parmi ceux qui sont dj tri en dcalant
vers le haut ceux qui sont plus grand que tri.


ii. Algorithme
procdure tri insre (tab [], n)
rf TIND tab [1..n] TIND correspond un type indtermin
valeur entier n
var locales
entier i,j
TIND temp
logique fin





dbut
i 2
tant que i <= n
faire
temp tab [i]
j i - 1
fin faux
A.BENHARI 29

tant que (j > 0) et (fin = faux)
faire
si temp < tab [j]
alors
tab [j+1] tab [j]
j j 1
sinon
fin vrai
fin
fin tant que
tab [j+1] temp
i i+1
fin tant que
fin



b. Tri par slection
i. Principe
A chaque itration, on choisi le plue petit lment parmi ceux quil reste trier et on le met
sa place.

ii. Algorithme
procdure trislection (tab [], n)
ref TIND tab [1..n]
val entier n
var locales
TIND petit
entier i, ipetit, j
dbut
i 1
tant que i < n
faire
ipetit i
petit tab [ipetit]
j i+1
tant que j <= n
faire
si tab [j] < petit
alors
ipetit j
petit tab [ipetit]
finsi
j j+1
fintantque
tab [ipetit] tab [i]
tab [i] petit
i i+1
fintantque
fin
A.BENHARI 30


iii. Remarque
Cette mthode conduit peu de dcalage. Elle est pourtant moins rapide que la prcdente.

c. Le tribulle
i. Principe
On parcoure le tableau autant de fois quil le faut en comparant les lments qui se suivent et
en les changeant sils ne sont pas dans le bonne ordre. A chaque passage, on peut enlever 1
n puisque lon trouve le dernier du tableau trier.

ii. Algorithme
procdure triballe (tab [], n)
ref TIND tab [1..n]
val entier n
var locales
logique fin
entier i
TIND petit




dbut
fin faux
tant que fin = faux
faire
fin vrai
i 1
tant que i < n
faire
si tab [i] > tab [i+1]
alors
petit tab [i+1]
tab [i+1] tab [i]
tab [i] petit
fin faux
finsi
i i+1
fin tant que
n n 1
fin tant que
fin

iii. Commentaire
Lun des plus mauvais trie si les donnes sont trs disperses par contre, il peut trs bien
convenir pour remettre en ordre des donnes peu tris.

d. Le tri de shell
i. Principe
A.BENHARI 31

Pour limiter les dplacements , on choisi de comparer des lments du tableau dans des
parties de tableau. On choisi au dpart des parties dun pas gale la moiti de la taille du
tableau, chaque lments de la premire moiti est compar un lment de la seconde. Sil
ne sont pas dans le bonne ordre, ils sont chang puis on diminue le pas en continuant
comparer des lments dont la distance est gale au pas. De cette faon, les lments traits
sont dabord des sauts important puis de plus en plus petit jusqu ce que le pas soit gale 1.


ii. Algorithme
h n/2
tant que h >=1
faire
fin vrai
i1
tant que i <= n-h
faire
si tab [i] > tab [i+h]
alors
petit tab [i+h]
tab [i+h] tab [i]
tab [i] petit
fin faux
finsi
i i+1
fin tant que
si fin = vrai
alors
h h/2
fin si
fintantque

iii. Remarque
Mthode plus efficace que la prcdente dans les cas dune grande dispersion.

e. Tri de shell-Metzner
i. Principe
Mme principe que pour le shell, au lieu d utiliser , le triballe, on choisi le tri par insertion
( i+1 chang par i +h).

ii. Algorithme
hn/2
tant que h>=1
faire
ih+1
tant que i<=n
faire
petit a[i]
j i-h
tant que petit < a[j] et j >= 1
A.BENHARI 32

faire
a[j+h]a[j]
jj-h
fin tant
ii+1
fin tant
hh/2
fin tant
iii. Remarque
Tri rput plus rapide que tous les prcdant

f. Tri par vecteur dindice
i. Principe
Mthode ne manipulant pas directement les lments du tableau mais utilisation dun vecteur
dindice qui joue le rle de pointeur

Ex :
Avant tri
Tab
50 2 25 -30 45 1
1 2 3 4 5 6
Indice
1 2 3 4 5 6
1 2 3 4 5 6

Aprs tri
Tab
50 2 25 -30 45 1
1 2 3 4 5 6

Indice
4 6 2 3 5 1
1 2 3 4 5 6

Rsultat : -30, 1, 2, 25, 45, 50

ii. Algorithme
(Avec tri par slection)

ideb1
tant que ieb<n
faire
imin ideb
kideb +1
tant que k<=n
faire
si t[indice[k]] < t[indice[imin]]
alors
imin k
A.BENHARI 33

aux indice [min]
indice [imin] indice [ideb]
indice [ideb] aux
finsi
k k+1
fin tant
ideb ideb +1
fin tant
iii. Remarque
Cette mthode est trs intressante pour manipuler des fichiers de grande taille, on peut donc
les trier sans dplacer lordonne.

g. Tri par monotonie
i. Principe
On part du constat que dans toute suite de nombre entier tri au hasard, on a toujours un
certain nombre dentre eux tri naturellement.

On appelle monotonie, une suite de nombre naturellement tri ?
Exemple :


ii. Algorithme
procedure separation (tab1[], tab2[], tab3[], i1,i2, i3)
ref TIND tab1 [1..i1], tab2 [1..i2], tab3 [1..i3]
ref entier i2, i3
val entier i1

var locales
entier ecrit, i
dbut
ecrit 2
i 1
i2 1
A.BENHARI 34

i3 0
tab2[i2] tab1[1]

tant que i <i1
faire
si ecrit = 2
alors
si tab1[i] < tab1[i+1]
alors
ecrit 2
i2 i2+1
tab2[i2] tab1[i]
sinon
ecrit 3
i3i3+1
tab3[i3]tab1[i]
finsi
sinon
si tab1[i] < tab1[i+1]
alors
ecrit 3
i3 i3+1
tab3[i3] tab1[i]
sinon
ecrit 2
i2i2+1
tab2[i2]tab1[i]
finsi
finsi
ii+1
fintant
fin

procedure fusion (tab1[], tab2[], tab3[], i1,i2, i3)
ref TIND tab1 [1..i1], tab2 [1..i2], tab3 [1..i3]
ref entier i2, i3
val entier i1
var locales
entier I, j, k
dbut
i1
j1
k1
tant que j <= i2 ou k <= i3
faire
si (tab2[j] < tab 3 [k]) et j <= i2
alors
tab1[i]tab2[j]
jj+1
sinon
A.BENHARI 35

si k <= i3
alors
tab1[i] tab3[k]
kk+1
finsi
finsi
ii+1
fintant
fin

algo trimonotonie ()
var locales
entier i1, i2, i3
TIND t1[1..i1], t2[1..i2], t3[1..i3]
dbut
i31
tant que i3 <> 0
faire
sparation (t1[], t2[], t3[], i1, i2, i3)
si i3 <> 0
alors
fusion (t1[], t2[], t3[], i1, i2, i3)
finsi
fintant
fin

XIII. La rcursivit
a. Dfinition
On appelle fonction rcursive une procdure ou une fonction qui sappelle elle mme.

Fonction entier fn(a)
Si condition darrt
-
-
-
retourne (fn(a))
fin

Cette approche permet de simplifier lcriture de certain programme comme les listes chans
et les arbres.
Elle nest pas souhaitable pour tout les programmes
Elle nest jamais la meilleur solution du point de vue temps de traitement et de la place
occup en mmoire.
Ds la construction de lalgorithme, il faut prvoir une action de fin dappel (pour ne pas voir
le programme boucl indfiniment).

b. Principe
Ex1 : soit calculer la factoriel dun nombre.
5x4x3x2x1 = 1200
A.BENHARI 36

1 instant t
n ! = (n-1) ! * n
0 !=1



fonction entier facto (n)
val entier n
dbut
si n=0
alors
retoune (1)
sinon
retourne (facto(n-1)*n)
finsi
fin

algo factorielle ()
var locales
entier n
dbut
afficher ( Quelle factorielle ? )
saisir (n)
afficher ( La valeur est ,facto(n))
fin

En C++

int facto (int n)
{
if (n==0)
return (1)
else
return (facto (n-1)*n)
endif
}

Ex 2: soit la somme des n premiers nombres entiers

fonction entier somme (n)
val entier n
dbut
si n = 0
alors
retoune0
sinon
retourne (somme (n-1) +n)
finsi
fin

A.BENHARI 37


Ex 3 : crire une procdure rcursive qui affiche tous les lments dun tableau dentier dans
lordre croissant de leur indice.



procedure ecrivect (V[], n, i)
val entier V[i..n]
val entier i,n

dbut
si i <= n
alors
affiche (V[i])
ecrivect (V[], n, i+1)
finsi
fin

XIV. Les fichiers
a. Dfinition du fichier
On appelle fichier un ensemble de donn stocker sur un support externe (exp : diskette, CD,
DVD, cest dire autre que la RAM).
Fichier binaire et texte intresse lalgo (surtout binaire).

b. Notion denregistrement
Mdia = disque dur, trieur
On appelle enregistrement un ensemble de donne sur un sujet dtermin. Un enregistrement
est dcrit en informatique par une structure

Ex :
RE tudiant = {numetu, nom, moyenne}
types struct
entier numetu
chaine (30) nom
reel moyenne
fstruct ETU

On met en majuscule les structures pour les diffrencier des autres telque les variables.

A chaque fois que lon veut identifier un fichier on doit dfinir la structure de ce fichier
Cette structure est gnralement dclar en dbut de programme et les caractristiques des
fichiers dans les variables globales.




A.BENHARI 38








Transfert logique


En mmoire centrale, 3 zones de travail ou BUFFERS qui ralise les entre, sortie et travail.

c. Dclaration des fichiers en algorithme
Pour viter les problmes de recopie, nous dclarons les types de fichiers au niveau global
EX : Soit dclarer un fichier client qui contient un numclient 1 nom, 1 adresse, 1 solde de
compte.

types
types struct
entier numroclient
chaine (30) nom
chaine (80) adresse
reel solde
fstruct CLIENT

Aprs dclaration des bibliothque (#iostream.h)

var globale
CLIENT ennrcli /*dclaration dun buffer*/
FICHIER (client) ficli /*dclaration dun fichier construit sur la structure CLIENT*/

ficli est un nom logique




A.BENHARI 39







d. Instruction de manipulation des fichiers
- Ouverture
- Lecture/ criture/ suppression

i. Ouverture, fermeture
1. Ouverture
OUVRE (nom_fichier_logique, nom-fichier_physique , mode_douverture)

nom_fichier_logique : nom pour le programme.
nom-fichier_physique : nom connu pour le systme dexploitation.
mode_douverture :
- lecture
- criture
- Mise Jour (MAJ) {lecture/criture}
- Extension {aprs fin de fichier}

Fonction :
- En ouverture : vrifier que le fichier existe, rserver ensuite un buffer.
- Ouverture en criture : cr le fichier ou lcraser sil existe dj
- En MAJ : modifier directement chaque enregistrement
- En extension : on efface la fin de fichier actuelle pour enregistrer des donnes la
suite de celle qui existe dj.

En algo, on peut utiliser une primitive (fonction) systme qui est fdef (fin de fichier ;
fdef(nom de fichier))



2. Fermeture
fermer (nom de fichier logique)
Libre le buffer cr louverture en criture, enregistrer sur le disque le dernier contenu du
tampon.

ii. Lecture, criture, suppression
Lecture lire (nom fichier logique, nom du buffer)
Ecriture ecrire (nom fichier logique, nom du buffer)

Remarque :
Encli.nom donne du buffer toujours nomm par le prsence du nom du buffer avant le
nom de la donne spar dun point.




A.BENHARI 40






e. Application sur les fichiers squentiels
i. Soit imprimer le contenu dun fichier sur
imprimante
Fichier physique : Fiphy
Fichier logique : fientr

types
type struct
chaine (25) nom
entier nucli
fstruct CLIENT

var globales
CLIENT enrcli
FICHIER (CLIENT) fientr
chaine (25) snom
entier snucli

algo lecseq ()
dbut
ouvre (fientr, Fiphy , lecture)
lire (fientr, enrcli)
tant que non fdef (fientr)
faire
snom enrcli.nom
snucli enrcli.nucli
imprimer ( , snom , , snucli)
fintant
ferme (fientr)
fin

ii. Remarque
Le fichier dentr ne doit pas tre cr partir de lditeur de texte mais laide dun
programme de cration.










A.BENHARI 41







iii. Cration dun fichier squentiel
types
type struct
chaine (25) nom
entier nucli
fstruct CLIENT

var globales
CLIENT enrcli
FICHIER (CLIENT) fisor
chaine (25) tnom
entier tnucli

algo ecriseq ()
dbut
ouvre (fisor, Fiphy , ecriture)
afficher ( entrez un nom ou fin )
saisir (tnom)
tant que tnom <> fin
faire
enrcli.nom tnom
afficher ( entrez un numro )
saisir (tnucli)
enrcli.nucli tnucli
crire (fisor, enrcli)
afficher ( entrez un nom ou fin )
saisir (tnom)
fintant
ferme (fisor)
fin


f. Les fichiers accs direct
Sachant que les supports externes tel que les disques magntiques sont adressable, on va les
utiliser pour retrouver directement des donnes

Remarque : random (ang) = alatoire ou au hasard

Dans tous les cas il faut crer une correspondance entre une des informations de
lenregistrement et le rang de stockage de lenregistrement sur le support externe.

Algorithme de gnration automatique dadresse ou correspondance direct.

Ex : Correspondance direct, rang identifiant externe
A.BENHARI 42

Exemple = numro tudiant = rang de stockage sur le disque





i. Lecture accs directe
types
type struct
chaine (25) nom
entier nucli
fstruct CLIENT

var globales
CLIENT enrcli
FICHIER (CLIENT) filogcli
chaine (25) snom
entier snucli, rang

algo lecdir ()
dbut
ouvre (filogcli, Fiphy , lecture)
afficher ( entrez un numro de client ou 0 pour fin )
saisir (rang)
tant que rang <> 0
faire
positionner (filogcli, rang)
lire (filogcli, eurcli)
snom enrcli.nom
stnucli enrcli.nucli
afficher ( Nom du client : , snom)
afficher ( Numro du client : snucli)
afficher ( entrez un numro de client ou 0 pour fin )
saisir (rang)
fintant
ferme (filogcli)
fin

ii. Cration a accs direct
types
type struct
chaine (25) nom
entier nucli
fstruct CLIENT

var globales
CLIENT enrcli
FICHIER (CLIENT) filogcli
chaine (25) tnom
entier tnucli, rang
A.BENHARI 43


algo ecridir ()
dbut
ouvre (filogcli, Fiphy , ecriture)
afficher ( entrez un numro de client ou 0 pour fin )
saisir (rang)
tant que rang <> 0
faire
afficher ( Entrez nom du client )
saisir (tnom)
enrcli.nom tnom
enrcli.nucli rang
positionner (filogcli, rang)
ecrire (filogcli, enrcli
afficher ( entrez un numro de client ou 0 pour fin )
saisir (rang)
fintant
ferme (filogcli)
fin

g. Les fichiers texte
i. Dfinition
Fichier dont les composantes sont des caractres
TEXTE fitext

On la particularit dtre divis en ligne dont la fin est indiquer par un caractre spciale en
gnral ce caractre et le caractre CR (caracter return).
Un fichier texte fait les conversions de formats de donnes. Les transferts se fond par les
noms de variables et non pas par structure complte. Les entres sorties standards sont
gnralement de ce type (saisir, afficher, imprimer).

Remarque : un fichier texte peut tre cr partir de lditeur de texte




ii. Dclaration dun fichier texte
var
TEXTE nom_du_fichier_texte (logique)

iii. Action sur un fichier texte
1. Ouverture de fichier
ouvre_text (nom_logique, nom_physique , mode douverture)

2. Transfert de donnes
a. Lecture
lire_text (nom_logique, arg1, arg2 )

b. Ecriture
A.BENHARI 44

ecrire_text (nom_logique, arg1, arg2 )

3. Fermeture
ferme_text (nom_logique)





XV. Algorithmes et structure de donnes
a. Les structures arborescentes
Un arbre est un ensemble dlments appels nuds ou sommets organiss de manire hirarchique partir dun
nud distingu appel racine. On repre les nuds de larbre en leur donnant des noms diffrents.
i. Arbres binaires
Un arbre binaire est soit vide, not , soit de la forme < r, B
1
, B
2
> o r est la racine et o B
1
et B
2
sont des
arbres binaires.









On dfinit intuitivement les notions de sous-arbre, de sous-arbre gauche, de fils gauche, de lien gauche et
rciproquement droite. On dfinit encore les notions de pre, de frre, dascendant et de descendant. Les
nuds dun arbre binaire ont au plus deux fils. Un nud interne ou double a 2 fils. Un point simple gauche a
seulement un fils gauche, et rciproquement droite. Un nud externe ou feuille na pas de fils. De faon
gnralise, on qualifie de nud interne, tout nud qui nest pas externe. On appelle les branches de larbre tout
chemin (suite conscutive de nuds) allant de la racine une feuille. Il y a autant de branches que de feuilles. Le
bord gauche est le chemin issu de la racine en suivant les liens gauches, et rciproquement droite.

Les caractristiques dun arbre sont :
- la taille de larbre est le nombre total de nuds.
- la hauteur ou niveau dun nud x est le nombre de lien sur lunique chemin allant de la racine x,
note h(x).
- la hauteur ou profondeur de larbre A, ( ) ( ) { } x h A h
x
max = .
- la longueur de cheminement de larbre A, ( ) ( ) ( ) ( ) A LCI A LCE x h A LC
x
+ = =

avec LCE
la longueur de cheminement extrieure ( )

feuille x
x h et LCI la longueur de cheminement intrieure
( )

interne noeud x
x h .
- la profondeur moyenne externe de A est ( )
( )
feuilles de nombre
A LCE
A PE = .

On donne la signature du type abstrait arbre binaire :

sorte arbre
utilise nud
oprations
r
B
1
B
2
A.BENHARI 45

: arbre
< , , > : nud x arbre x arbre arbre
racine : arbre nud
gauche : arbre arbre
droit : arbre arbre.

Proposition : Soit un arbre binaire de taille n, de profondeur p et possdant f feuilles. Si on examine les cas
extrmes, on obtient que ( )

1 log
2
n p n ; par ailleurs
p
f 2 do ( )
(
f p
2
log .

Reprsentation des arbres en machines : On utilise la structure rcursive des arbres.
1) Dans cette premire reprsentation, le chanage est symbolis par des pointeurs.

type arbre = adresse de nud ;
type nud = structure
val : lment ;
g, d : arbre ;
fin ;
1.
2. Larbre est dtermin par ladresse de la racine. On gre la mmoire dynamiquement pour les oprations de
suppression / insertion.

2) Dans la reprsentation contigu, on simule les chanages par des indices dans un tableau.

type arbre = tableau de 1 N de
structure
val : lment ;
g, d : entier ;
fin ;
3.
4. On utilise lindice 0 pour indiquer quil ny a pas de fils. Larbre est dtermin par une variable entire
contenant lindice de la racine. On va grer les cases libres pour des insertions / suppressions. On chane les
cases libres comme une pile, en utilisant le chanage g et on utilise une variable entire libre pour indiquer
lindice du sommet de pile .
ii. Arbres binaires complets
Un arbre binaire est complet si tous les nuds qui ne sont pas des feuilles ont 2 fils.

Propositions : Un arbre binaire complet ayant n nuds internes possde en tout n+1 feuilles. La dmonstration
se fait simplement par rcurrence. Par ailleurs, on montre quil existe une bijection entre lensemble des arbres
binaires de tailles n, B
n
, et lensemble des arbres binaires complets de taille 2n+1, BC
2n+1
. Principe : on ajoute
des feuilles de sorte que tout nud de larbre ait deux fils. De plus on tablit que
n
n n n
C
n
BC B
2 1 2
1
1
+
= =
+
.
iii. Arbres binaires parfaits, ordre hirarchique
On dit quun arbre binaire est parfait si toutes ses feuilles sont situes sur les deux derniers niveau, lavant
dernier tant complet, et les feuilles du dernier sont le plus gauche possible. Attention ! un arbre binaire parfait
nest pas forcment complet, mais il a toujours au plus un nud simple (le pre de la feuille la plus droite).

On peut reprsenter un arbre binaire parfait de taille n de manire compacte par un tableau n cases. Ceci se fait
en numrotant les nuds de 1 n en partant de la racine, niveau par niveau de gauche droite (ordre
hirarchique). On a les relation gnrales suivantes :
- le pre du nud dindice i est lindice i / 2 (division entire) ;
- le fils gauche dun nud i est, sil existe, lindice 2i ;
- le fils droit dun nud i est, sil existe, lindice 2i+1 ;
- les feuilles sont aux indices > n / 2.

A.BENHARI 46

iv. Parcours en profondeur dun arbre binaire
On considre lopration de parcours qui consiste examiner systmatiquement dans un certain ordre tous les
nuds de larbres pour effectuer un traitement de donnes. Le parcours en profondeur gauche consiste partir
de la racine et tourner autour de larbre en allant toujours le plus gauche possible.

Procdure Parcours(A : arbre) ;
dbut
Si A =
Alors T
0

Sinon
dbut
T
1
;
Parcours(g(A)) ;
T
2
;
Parcours(d(A)) ;
T
3
;
fin ;
fin ;

Chaque nud est visit trois fois. A chaque visite correspond un traitement T
i
et un ordre de parcours. T
1

seffectue avant la descente gauche et dcrit lordre prfixe ou pr-ordre. T
2
seffectue aprs la remonte gauche
et avant la remonte droite, lordre associ est lordre infixe ou symtrique. Le traitement T
3
est ralis aprs la
remonte droite ; les nuds sont parcourus dans lordre suffixe ou post-fixe. On ajoute un traitement particulier
T
0
pour les nuds vides.
v. Arbres gnraux
Un arbre gnral, ou simplement arbre, est une structure arborescente o le nombre de fils nest plus limit 2.
Un arbre A = < r, A
1
, A
2
, , A
n
> est la donne dune racine r et dune suite ventuellement vide de sous-arbres
disjoints. Cette suite est une fort. Un arbre est obtenu en rajoutant un nud racine la fort.

On donne la signature des arbres gnraux :

sorte arbre, fort
utilise nud
oprations
cons : nud x fort arbre
racine : arbre nud
sous-arbre : arbre fort
: fort
ime : fort x entier arbre
longueur : fort entier
insrer : fort x entier x arbre fort

Il ny a plus de notion de fils gauche ou de fils droit. On parle du ime fils dun nud.

Dans un parcours gauche, chaque nud est rencontr une fois de plus que son nombre de fils.

Procdure Parcours(A : arbre) ;
dbut
Si sous-arbre(A) =
Alors T
0

Sinon
dbut
i 1 ;
Rpter
T
i
;
Parcours(ime(sous-arbre(A), i)) ;
i++ ;
Jusqu ce que i > longueur(sous-arbre(A)) ;
A.BENHARI 47

T
i
;
fin ;
fin ;

Lordre prfixe sur les nuds est obtenu en ne faisant quintervenir que T
1
. Lordre suffixe est obtenu en ne
faisant intervenir que T
i
lextrieur de la boucle. Il ny a pas dordre infixe.

Reprsentation des arbres : On reprsente un arbre gnral par des listes chanes dynamiques.

type arbre = adresse de nud ;
type nud = structure
val : lment ;
premier_fils, frre : arbre ;
fin ;
Propositions : Le nombre darbres gnraux de taille n+1 est
n
n
C
n
2
1
1
+
. Par ailleurs, il existe des bijections
entre les forts de taille n, les arbres gnraux de taille n+1, et les arbres binaires de taille n, avec des proprits
intressantes sur les parcours.
b. Graphes
i. Dfinition
Un graphe est un ensemble dobjets modliss par des sommets, et mis en relation (binaire). Ces relations sont
modliss par des arcs ou des artes. Un graphe orient [non orient] est un couple A S G , = o S est un
ensemble fini de sommets, et A un ensemble de paire ordonnes [couple] de sommets appels arcs [artes].
ii. Terminologie
Un graphe simple est sans boucle
1
, et sans liens multiples. Dans un graphe orient, on dit que y est le successeur
de x sil existe un arc qui mne de x vers y ; on dit en outre que y est adjacent x. Pour un graphe orient, on dit
simplement que x et y sont adjacents. Un graphe est dit complet si pour tout couple de sommet il existe un arc
(ou une arte) les joignant. Dans un graphe orient, le demi-degr extrieur [intrieur] dun sommet x, que lon
note ( ) x d
+
[ ( ) x d

], est le nombre darcs ayant x comme extrmit initiale (finale). Le degr de x est
( ) ( ) ( ) x d x d x d
+
+ = . Pour un graphe non orient, on dfinit uniquement le degr dun sommet x ( ) x d .
Dans un graphe orient, on appelle chemin de longueur L une suite de L+1 sommets ( )
L
s s s L
1 0
, telles que
( )
1
,
+ i i
s s forme un arc. Pour un graphe non orient, on parle de chane. Dans un graphe orient [non orient],
un chemin [une chane] dont tous les arcs [artes] sont distincts et tels que les sommets aux extrmits concident
est un circuit [un cycle]. Un graphe orient est fortement connexe si pour toute paire de sommets distincts s et s,
il existe un chemin de s vers s et un chemin de s vers s. Un graphe non orient est connexe, si pour toute paire
de sommets distincts, il existe une chane les joignant. Une composante fortement connexe [connexe] est un
sous-graphe fortement connexe [connexe] maximal.
iii. Graphe et Arbre
En thorie des graphes, un arbre est un graphe non orient, connexe et sans cycle. Soit G un graphe orient, on
appelle racine de G un sommet r tel que, pour tous sommets x distincts de r, il existe un chemin de r vers x. Une
arborescence est un graphe orient G admettant une racine et tel que le graphe obtenu partir de G en enlevant
lorientation soit un arbre.
iv. Signature graphe orient

sorte sommet
utilise boolen, entier

1
lien dun sommet sur lui-mme
A.BENHARI 48

oprations
s : entier sommet
n : sommet entier
arc : sommet x sommet boolen
d
+
: sommet entier
ime_succ : sommet x entier sommet
prem_succ : sommet sommet
succ_suivant : sommet x sommet sommet

Pour les graphes non orients, on dispose de la mme signature en remplaant arc par arte et d
+
par d.
v. Reprsentation des graphes
On aura deux possibilits classiques de gestion de la mmoire : contigu et chane.

Reprsentation contigu : Soit n le nombre de sommet dun graphe ; on dfinit la matrice dincidence de
dimension n x n not G et tel que [ ] vrai j i G = , ssi il existe un arc de i vers j. Si le graphe est non orient la
matrice dincidence est symtrique.

type graphe = tableau[1 n, 1 n] de boolen.

La complexit en espace est en O(n), parcourir les successeurs dun sommet se fait en O(n), savoir si y est le
successeur de x se fait en O(1).

Reprsentation chane : Pour chaque sommet s
i
, on forme la liste dadjacence, qui est la liste chane de tous le
successeur de s
i
.

type graphe = tableau[1 n] dadresse de cellule;
cellule = structure
numro : entier de 1 n;
suivant : adresse de cellule;
fin;

Soit ( )

+
=
x
x d A . La complexit en espace est en n + 2p. Le parcours des successeurs dun sommet
seffectue en ( ) ( ) x d O
+
. La consultation complte est en ( ) A O . Savoir si y est le successeur de x se fait en
( ) ( ) x d O
+
, dans le pire des cas.

Remarque. Le chanage peut tre simul dans un tableau. Pour un graphe non orient, il y a redondance
2

dinformation.
vi. Parcours en profondeur dun graphe orient
Le parcours en profondeur un parcours rcursif, simulable par une pile.
Principe : On utilise une marque (vecteur de n boolens) pour marquer les sommets au fur et mesure quon les
rencontre. A partir dun x de dpart, non marqu, on avance dans le graphe en allant toujours vers un nouveau
successeur non marqu ; les sommets retenus chaque fois sont marqus. Quand on ne peut plus avancer, on
revient au choix prcdent, et on itre la mthode.

Procdure Profondeur(x : sommet) ;
dbut
i n(x) ;
marque[i] vrai ;
pour j de 1 d
+
(x) faire
dbut
y ime_succ(x, j) ;
k n(y) ;

2
y est le successeur de x et rciproquement
A.BENHARI 49

si non marque[k] alors Profondeur(y) ;
fin ;
fin_Profondeur ;

Programme principal
dbut
pour i de 1 n faire marque[i] faux ;
pour i de 1 n faire
si non marque[i] alors profondeur(s(i)) ;
fin.

5. Pour les graphes non orients, on dispose du mme algorithme en remplaant d
+
(x) par d.

Les sommets ne sont marqus quune seule fois et lalgorithme parcourt un fois et une seule les listes
dadjacence : complexit en ( )

+
x
x d , ce qui donne ( ) A O pour les listes dadjacence et ( ) n O pour les
matrices dadjacence.

On considre les arcs x y tels que Profondeur(x) appelle Profondeur(y). Ces arcs couvrants constituent une
fort couvrante constitue darborescences disjointes et dont les racines sont les sommets de dpart. Les graphes
obtenu sans orientation sont des arbres (graphe non orient, connexe et sans cycle). La fort couvrante a autant
darbres recouvrants quil y a de composantes connexes dans le graphe. Ainsi le parcours en profondeur rsout
le test de connexit en temps linaire.
vii. Parcours en largeur
Le parcours par largeur ou par niveau est un parcours itratif qui fonctionne avec une file.
Principe : On part dun sommet x et on visite tous les successeurs y de x ; on ritre lalgorithme sur les sommets
y dans lordre o on les a rencontrs partir de x. On utilise toujours une marque de sommets. On utilise une file
pour grer ce parcours par niveaux.

Procdure Largeur(x :sommet)
dbut
file_vide(file) ;
i n(x) ;
marque[i] vraie ;
ajouter(file, x) ;
tant que non est_vide(file) faire
dbut
y premier(file) ;
retirer(file) ;
pour i de 1 d
+
(y) faire
dbut
z ime_succ(y,i) ;
j n(z);
si non marque[j] alors
dbut
marque[j] vraie;
ajouter(file,z);
fin;

fin ;
fin ;
fin ;

Programme principal
dbut
pour i de 1 n faire marque[i] faux ;
pour i de 1 n faire
si non marque[i] alors Largeur(s(i)) ;
A.BENHARI 50

fin.

On a la mme complexit que pour le parcours en profondeur. Lalgorithme pour un graphe non orient sobtient
simplement en remplaant d
+
par d. On a la mme proprit sur la fort couvrante et les composantes connexes
que pour le parcours en profondeur.
c. Problme de la recherche
i. Introduction
Considrons un ensemble de grande taille ayant des caractristiques communes. On veut faire de manire
optimise des oprations de recherche, dadjonction et de suppression. A chaque lment, on associe une cl
simple (critre unique) : recherche associative. Les bases de donnes traitent des critres plus gnraux et des
cls multiples.
Signature

sorte ensemble
utilise lment, clef
oprations
cl : lment clef
vide : ensemble
ajouter : lment x ensemble ensemble
supprimer : clef x ensemble ensemble
_ _ : clef x ensemble boolen

Remarques :
- Si plusieurs lments ont la mme cl, la recherche fournit une solution quelconque parmi les
possibilits ; sil ny a pas de solutions (chec), on fournit une valeur spciale.
- La suppression commence par une recherche, en cas dchec de la recherche, la suppression laisse
lensemble inchang.
- En gnral, et sil ny a pas ambigut, on confond llment et sa cl.

La complexit fondamentale est celle de la comparaison entre deux cls. Si lensemble des cls est muni dune
relation dordre, on peut les trier avec des algorithmes efficaces. On distingue les mthodes de recherche
squentielle, les mthodes de recherche dichotomique, de hachage, et les mthodes arborescentes.
ii. Arbres binaires de recherche
On reprsente un ensemble ordonn n lments par un arbre binaire n nuds (les nuds sont les lments), et
cest la comparaison avec la valeur dun nud qui va orienter la suite de la recherche.
Un arbre binaire de recherche est un arbre binaire tel que pour tout nud x , les nuds de son sous arbre-gauche
sils en existent ont des valeurs infrieures ou gales celle de x, et les nuds de son sous arbre-droit des valeurs
strictement suprieures ;


6.









ce que lon traduit par g(A) racine(A) < d(A).

On obtient toujours lensemble ordonn par un parcours rcursif gauche symtrique. Il ny a pas unicit de la
reprsentation.
x
x

>x

A.BENHARI 51

iii. Recherche dun lment

rechercher : valeur arbre boolen

On compare llment la valeur de la racine :

- galit succs

x = r rechercher (x , < r , g , d > ) = vraie
7.
- si le sous-arbre slectionn est vide, llment est absent chec

rechercher ( x , ) = faux

- si la valeur est plus petite, on recommence rcurcivement dans le sous-arbre gauche ; et
rciproquement si la valeur est plus grande dans le sous-arbre droit

x < r rechercher (x , < r , g , d > ) = rechercher (x , g )
x > r rechercher (x , < r , g , d > ) = rechercher (x , d )

Complexit : La complexit au pire est en O ( hauteur de larbre ).
iv. Adjonction dun lment aux feuilles

ajout_feuille : arbre valeur arbre

Ladjonction aux feuilles dun lment se ralise en deux tapes :
- tape de recherche pour savoir o insrer le nouvel lment ;
- adjonction elle-mme.

On compare la valeur de llment ajouter celle de la racine pour dterminer si on lajoute sur le sous-arbre
gauche ou droit.

x r ajout_feuille ( < r , g , d > , x ) = < r , ajout_feuille ( g , x ) , d >
x > r ajout_feuille ( < r , g , d > , x ) = < r , g , ajout_feuille ( d , x ) >

Le dernier appel rcursif se fait sur un arbre vide ; on cre un nouveau nud cette place pour le nouvel lment
qui devient donc une feuille.

ajout_feuille ( , x ) = < x , , >

8. On peut construire un arbre binaire de recherche par adjonctions successives aux feuilles.
9.
On donne lalgorithme dadjonction aux feuilles (rcursif) en LDA :

Fonction adjonction_feuille (A : arbre , e : entier ) : arbre
dbut
si est_vide(A)
alors retourner < e , , >
sinon si ( e racine(A) )
retourner < racine(A) , ajout_feuille( g(A) , e ) , d(A) >
sinon
retourner < racine(A) ,g(A) , ajout_feuille( d(A) , e ) >
fin
10.
11. On donne galement une version itrative de lalgorithme ( voire td).
12.
13. La complexit dun adjonction est O ( hauteur de larbre ).
A.BENHARI 52


v. Adjonction dun lment la racine
Soit A un arbre binaire de recherche, on veut ajouter x la racine.

On procde en deux tapes :
- on coupe A en deux arbres binaires de recherche G et D contenant respectivement tous les
lments x et tous ceux > x.
- construire larbre < x , G , D >

voire cours
vi. Suppression dun lment

supprimer : arbre valeur arbre

- recherche de llment supprimer
- suppression qui dpend de la place de llment, selon que le nud est sans fils, avec un seul fils,
ou avec deux fils. La suppression dun nud sans fils est immdiate. Pour la suppression un nud avec un
seul fils, on remplace ce nud par son fils. Pour un nud, avec deux fils, on dispose de deux solutions : soit
on remplace le nud supprimer par le plus grand lment de son sous-arbre gauche, soit on le remplace
par le plus petit lment de son sous-arbre droit.

On donne lalgorithme de suppression en LDA :
14.
Fonction suppression ( A : arbre , e : entier ) : arbre
dbut
% recherche de llment supprimer %
si est_vide(A)
alors retourner erreur
si ( e < racine(A) )
alors retourner < racine(A), suppression( g(A) , e ) , d(A) )
sinon si ( e > racine(A) )
retourner < racine(A), g(A) , suppression( d(A) , e ) )
% suppression %
sinon
si est_feuille(A)
alors retourner
sinon si est_vide(g(A))
retourner d(A)
sinon si est_vide(d(A))
retourner g(A)
sinon
% on ajoute llment le plus droite du sous-arbre gauche %
retourner < max_noeud(g(A)) , retire_max(g(A)), d(A) >

fin

Fonction max_noeud ( A : arbre ) : entier
% retourne le plus grand lment de larbre A, le plus droite %
dbut
si est_vide(d(A))
alors retourner racine(A)
sinon
retourner max(d(A))
fin

Fonction retire_max ( A : arbre ) : arbre
% retourne larbre priv de son plus grand lment %
A.BENHARI 53

dbut
si est_vide(d(A))
alors retourner g(A)
sinon
retourner < racine(A) , g(A) , retire_ max(d(A)) >
fin

La complexit est O ( hauteur de larbre ).
Conclusion, Tri par arbre binaire de recherche
Toutes les oprations ont une complexit dpendant de la hauteur de larbre binaire de recherche. Elle varie
entre O (log n ) pour des arbres quilibrs et O ( n ) pour des arbres dgnrs.

Par consquent, le tri par arbre binaire de recherche, obtenu par un parcours symtrique de larbre, a une
complexit en comparaison dans le pire des cas variant entre O ( n log n ) et O ( n ).
d. Problme du tri
i. Introduction
Le problme du tri est quasiment le plus important en informatique.

Spcification du tri : La donne est une liste n lments ; chaque lment est associe une cl dont la valeur
appartient un ensemble totalement ordonn ; le rsultat est une liste dont les lments sont une permutation de
la liste dorigine, et telle que les valeurs des cls soient croissantes quand on parcourt la liste squentiellement.

Un tri est stable, sil conserve lordre de dpart des lments dont les cls sont gales.

En fonction de la capacit mmoire, on distingue le tri interne (tout en mmoire centrale) et le tri externe
(mmoire centrale + disque). Pour le tri interne, on a des algorithmes qui travaillent sur place, cest--dire sur la
liste de dpart et des algorithmes qui manipulent physiquement une copie. On a des algorithmes diffrents et plus
compliqus quand ils se font sur place.

On compte le nombre de variables auxiliaires pour valuer la complexit en mmoire. Le tri interne, sur place,
avec un nombre constant de variables auxiliaires possde une bonne complexit en espace. On compte le nombre
de comparaisons entre cls et de transferts dlments pour valuer la complexit en temps.

On distingue les mthodes simples et les mthodes plus complexes.
ii. Tri par arbre binaire de recherche
Cest une mthode plus complexe, qui consiste crer larbre binaire de recherche, puis faire un parcours
symtrique, pour obtenir la liste trie.

voire partie sur les arbres binaires de recherche
e. Quicksort
i. Principe
On choisit une des cls de la liste (par exemple, celle du premier lment), et on lutilise comme pivot. On
construit sur place une sous-liste dont les cls sont infrieures ou gales au pivot et une sous-liste dont les cls
sont strictement suprieurs au pivot.





p > pivot pivot
A.BENHARI 54

Le pivot p a alors sa place dfinitive. Et on recommence rcursivement sur chacune des deux sous-listes. A la
fin, la liste est trie par ordre croissant. Remarquons que le choix du pivot est dlicat ; de lui dpend
lquilibrage des deux sous listes.

On suppose donne une procdure

Placer (e/s t : tableau de 1 n entiers , e/ i : entier , e/ j : entier , /s k : entier)

qui effectue le traitement de t entre les indices i et j en fonction du pivot t[i], et qui rend comme rsultat lindice
k o le pivot a t plac et le tableau t ragenc.

La procdure gnrique du quicksort scrit :

Procdure Quicksort (e/s t : tableau de 1 n entiers , e/ i : entier , e/ j : entier)
utilise localement k : entier
dbut
si i < j
alors dbut
Placer (t , i , j , k)
Quicksort (t , i , k - 1)
Quicksort (t , k + 1 , j)
fin

fin

Le tri de la liste complte est obtenu par Quicksort (t , 1 , n).

La procdure Placer : La partition et le placement du pivot ne ncessite quun parcours.







On utilise deux compteurs l et k qui partent des extrmits du sous-tableau, et qui vont lun vers lautre :
- l part de i+1 et avance tant que lon rencontre un lment a.
- k part de j et recule tant que lon rencontre un lment > a.
On change les deux lments et on recommence la progression jusqu ce que les deux compteurs se croisent :
la place dfinitive du pivot est en k, et on y place le pivot a par change avec un lment a.

Si on utilise la procdure Placer sur un sous-tableau qui nest pas la fin de ( x = t[j+1] existe ), alors
llment x est un pivot plac antrieurement. Donc, on a [ ] ] [ , , s t x j i s . Par consquent, cet lment x
va arrter la progression du compteur l. Pour utiliser cette proprit (effet de bord) lors de tous les appels, on
rajoute un terme en t[n+1] qui contiendra un lment plus grand que tous les autres.

15. Procdure Placer (e/s t : tableau de 1 n entiers , e/ i : entier , e/ j : entier , /s k : entier)
16. utilise localement l : entier
17. dbut
18. l i +1
19. k j
20. % boucle : tant que les compteurs ne se croisent pas %
21. tant que l k faire
22. dbut
23. tant que t[k] > t[i] faire k--
24. tant que t[l] t[i] faire l++
25. % on a t[k] t[i] et t[l] > t[i] %
26. si l < k alors dbut
27. changer t[l] et t[k]
28. l++
a

>

> > > x
i l k j j+
1
A.BENHARI 55

29. k--
30. fin
31.
32. fin
33. % on met le pivot sa place dfinitive %
34. changer t[i] et t[k]
35. fin
ii. Complexit
36. Complexit de Placer : Considrons un sous-vecteur p lments, on la pivot aux p - 1 autres lments. On
effectue en tout p + 1 comparaisons.
37.
38. Complexit du Quicksort, au pire: Le graphe des appels du Quicksort est un arbre binaire. La complexit au
pire en nombre de comparaisons est obtenu pour t dj tri est en prenant chaque fois le 1
er
lment comme
pivot. Le graphe des appels sera dgnr (peigne) et va induire une complexit au pire en O ( n ).
39.
40. Complexit du Quicksort, en moyenne : On suppose que les n nombres sont distincts, et que le pivot va
occuper la p
ime
place de la liste trier. On suppose que toutes les places sont quiprobables ; on a la probabilit
1/n davoir le pivot la place p et donc davoir deux sous-listes de taille p - 1 et n - p. On dmontre ( voire
cours + td ) que la complexit en moyenne est en O (2n log n).
iii. Taille de la pile de rcursivit
41. Dans la procdure Quicksort, le 2
me
appel est terminal, ce qui veut dire quon peut le supprimer, et donc
viter des empilements. Comme un seul appel va tre conserv, on leffectuera systmatiquement sur la plus
petite des deux sous-listes. La taille de rcursion sera en O (log
2
n), car on divisera par 2 la taille de la liste
dappel.
42.
Procdure Quicksort (e/s t : tableau de 1 n+1 entiers , e/ i : entier , e/ j : entier)
utilise localement k : entier
dbut
tant que i < j
alors dbut
Placer (t , i , j , k)
% on choisit le plus petit %
si (j - k) > (k - i)
alors dbut
Quicksort (t , i , k - 1)
i k + 1
fin

sinon dbut
Quicksort (t , k + 1 , j)
j k - 1
fin
43. fin

fin

f. Heapsort
3

Cest un tri par slection des minimums successifs bas sur une structure de tas. On va obtenir un tri O (n log n)
comparaisons au pire, sans mmoire auxiliaire.

3
Tri par tas

A.BENHARI 56

i. Arbres partiellement ordonns
Un tri par slection ncessite de savoir localiser et rcuprer efficacement ( en O (1), si possible ) le minimum
parmi les lments non encore placs.
On considre le cas particulier du type abstrait ensemble o les seules oprations sont :
- laccs un lment minimum
- la suppression du minimum
- ladjonction dun nouvel lment
On reprsente cette ensemble par un arbre binaire parfait partiellement ordonn.
44.
Un arbre partiellement ordonn est un arbre tiquet par les valeurs dun ensemble muni dun ordre total, tel
que la valeur associe tout nud soit aux valeurs associes aux fils. La racine contient toujours un lment
minimum, accs en O (1).
45.
1) Adjonction dun lment x
On ajoute dabord x comme une feuille en conservant la structure darbre binaire parfait. Puis, on reconstruit
lordre partiel :

y x
tant que ( y racine ) et ( y < pre(y) ) faire
changer y et pre(y)
46.
2) Suppression du min
Une fois la racine enleve, on place la dernire feuille la racine, pour conserver la structure darbre binaire
parfait. Puis, on reconstruit lordre partiel :

y racine
tant que ( y nest pas une feuille ) et ( y nest pas aux deux fils ) faire
changer y et son fils de valeur minimum

47.
48. La complexit en nombre de comparaisons de ladjonction et de la suppression du minimum est au pire en
O (hauteur de larbre). Par ailleurs, la hauteur dun arbre binaire parfait ayant n nuds est de

n
2
log .

On utilise la reprsentation en tableau (ordre hirarchique) des arbres binaires parfaits. ( voire partie sur les
structures arborescentes) Le tableau forme le tas.

On donne les algorithmes crits en LDA des procdure dadjonction et de suppression du minimum :

Procdure ajouter ( e/s t : tableau de 1 N entiers , e/s n : entier , e/ x : entier )
% ajoute llment x t ayant n lments au moment de lappel %
utilise localement i : entier
dbut
si n < N
alors dbut
n++
t[n] x
i n
tant que ( i > 1 ) et ( t[i] < t[i div 2] ) faire
dbut
changer t[i] et t[i div 2]
i i div 2
fin
fin
sinon crire dbordement du tas
fin

Procdure suppress_min ( e/s t : tableau de 1 N entiers , e/s n : entier , /s min : entier )
% fournit dans min le minimum pour t ayant n > 0 lments %
utilise localement i, j : entiers
A.BENHARI 57

dbut
min t[1]
t[1] t[n]
n--
i 1
% tant que lon est pas sur une feuille %
tant que ( i n div 2) faire
dbut
si ( n = 2i ) ou ( t[2i] < t[2i+1])
alors j 2i
sinon j 2i +1
si ( t[i] > t[j])
alors dbut
changer t[i] et t[j]
i j
fin
sinon exit
fin
fin

ii. Tri par tas
Principe :
- Construire un tas contenant les n lments par adjonction successives ; en O (n log n).
- Tant que le tas nest pas vide, faire supprimer le minimum du tas avec rorganisation, mettre ce
minimum sa place dfinitive ; en O (n log n).

La complexit en comparaison est au pire en O(n log n).

On utilise un seul tableau pour le tas et les valeurs des minimums successifs. Le minimum rcuprer est
toujours dans t[1]. On mettra les minimums successifs la droite du tableau, de la droite vers la gauche. A la fin,
on obtient lensemble dans lordre dcroissant.


49.
50.
51.
52.
53. Procdure heapsort (e/s t : tableau de 1 n entiers)
54. utilise localement p, min : entiers
55. dbut
56. % construction du tas %
57. p 0
58. tant que p < n faire
59. ajouter( t , p , t[p+1] )
60. % tri %
61. tant que p > 1 faire
62. suppress_min ( t , p , min )
t[p+1] min
63. fin
64.
65. Remarque : lincrmentation et la dcrmentation de p est gnr par les procdures en e/s.







tas traiter minimums bien plas min t[n]
A.BENHARI 58

XVI. Algorithmes numriques

a. Gnralits
i. Normes et rayon spectral

Dfinition norme vectorielle :
+
R R x x
n
, a vrifiant :
- 0 0 et 0 = = x x x
- x x . . =
- y x y x + +

Exemple de norme vectorielle :
- Norme 1 :

=
i
i
x X
1

- Norme 2 : X X x X
i
i
,
2
2
= =


- Norme :
i
i
x Sup X =



Proposition : En dimension finie, toutes ces normes sont quivalentes ; en pratique, on choisit celle qui nous
arrange.

Dfinition norme matricielle :
C'est une norme dans l'espace vectorielle M
n
(R), avec en plus B A B A . .

ii. Norme matricielle induite :
A partir d'une norme vectorielle, on construit une norme matricielle induite :
( ) AX Sup
X
AX
Sup A
X ou X X 1 1 0 =
=
|
|

\
|
= .
Notons de plus que 1 = I .
En particulier pour la norme 2, on a la relation : ( ) A A I
t
=
2
avec le rayon spectral.

Proprits :
- X A AX . et B A AB .
- Cas de A symtrique : ( )
i
i
A A max
2
= =
- Dans le cas gnral,
max
2
= A , maximum des valeurs singulires
i i
= avec
i
les valeurs
propres (positives) de la matrice symtrique A A
t
. (?)
- Soit A une matrice carr quelconque n x n. Pour toutes normes de matrice induite, on a ( ) A A .

A.BENHARI 59

iii. Conditionnement dune matrice inversible :
Considrons un systme linaire AX=b. L'exprience de Wilson met un vidence une instabilit des calculs dans
certains cas. Si l'on modifie sensiblement les paramtres de la matrice A, ou du second membre b, on peut
trouver des rsultats compltement diffrends !
- ( )
1
.

= A A A Cond
- ( ) ( ) A Cond A Cond =
- ( ) 1 A Cond avec ( ) 1 = Id Cond
- Soit une matrice Q orthogonale :
2 2
X QX = et ( ) 1 = Q Cond
- Les bons conditionnements sont les petits conditionnements (au mieux 1 pour les matrices orthogonales).
- Pour A symtrique : ( )
min
max
2

= A Cond ; dans la cas gnral : ( )


min
max
2

= A Cond

Thormes sur le conditionnement :

Thorme : ( ) b b X X A B AX + = + = et . On a ( )
b
b
A Cond
X
X

.
Thorme : ( )( ) b X X A A B AX = + + = et . On a ( )
A
A
A Cond
X X
X

.
Remarque : Le conditionnement traduit l'amplification des grandeurs relatives.


iv. Inverse numrique dune matrice :

Soit A une matrice inversible et A
-1
son inverse thorique.
M est un inverse de A du point de vue numrique si :
-
1
1

A
A M
est petit, ce qui correspond M=A
-1

-
A
A M
1
est petit, ce qui correspond A=M
-1

-
Id MA Id AM et
sont petits, ce qui correspond 0 Id - MA et 0 = = Id AM
On s'adapte au calcul que l'on veut faire. Notons que l'on rsout rarement un systme linaire en calculant
l'inverse b A X
1
=
A.BENHARI 60

b. Systmes linaires Ax=b : mthodes
directes
i. Formules de Crammer
Cette mthode ncessite le calcul d'un dterminant, dont la complexit est en n!. La complxit de la formule de
Cramer est en n
2
n!. Par consquent, cette mthode n'est pas utilisable en informatique.

ii. Mthode du pivot de Gauss
la k
me
tape : pour , k i > k Ligne i Ligne
,
,
|
|

\
|

k k
k i
a
a
. On pose
k k
k i
k i
a
a
l
,
,
,
= .
L'algorithme une complexit en
3
3
n
.
Le problme des coefficients diagonaux nuls : il faut permuter les lignes lorsque apparat un zro sur la
diagonale.
Stratgie du pivot maximum partiel :
On permute la k
me
ligne et la i
me
ligne avec i tel que
k l
k l
k i
a Sup a
, ,

= . Pour des raisons de stabilit


numrique, on divise par le terme de la colonne k, qui a la plus grande valeur absolue.
Stratgie du pivot avec seuil :
On effectue une permutation uniquement des <
k k
a
,
. Cependant cette mthode peut tre mise en dfaut. Il
vaut mieux utiliser la mthode du pivot maximum partiel, qui n'est pas vraiment plus coteuse en calcul.
iii. Calcul de linverse
Une ide pour rsoudre le sytme Ax=b serait de calculer linverse de A. En effet, on a b A x
1
= .
Mthode de Shermann Morison
Soit A une matrice n x n, relle inversible, dont on connat linverse A
-1
; soit B une perturbation, on cherche
calculer ( )
1
+ B A .
On dmontre que si
t
XY B = , alors ( ) ( )
1 1 1 1 1 1
. .

+ = + = + BA A c A A B A c I B A , avec
X A Y
c
t 1
1
1

= .
On suppose maintenant que la perturbation ne modifie quun seul en ) , ( j i :
{
{
t
Y
j
X
i
j i e e
E B = = . .
,
.
Notons ( )
n l k
j k
A

=
, 1
,
1
. Alors on trouve ( ) [ ]
i j
l j i k
l k
l k
j i
E A
,
, ,
,
,
1
,
. 1
.



+
= +

.
iv. Elimination de Gauss
On applique la stratgie du pivot partiel maximum, au calcul de linverse.
On considre une matrice A inversible, de dimension n
On rsout n l e Ax
l
= 1 pour , ce qui revient crire I A A =
1
. . On procde par limination de Gauss,
ce qui donne une matrice triangulaire suprieure (complexit en n
3
). Ensuite, on ralise n remontes, une par
vecteur
l
e (complexit en n
2
).
A.BENHARI 61

En rsum, on a
l
e Ax = et MA U e M x U
l
= = avec . . une matrice triangulaire suprieure.
On veut traiter tous les seconds membres en une seule passe ; pour cela on considre la matrice n x 2n suivante :
|
|
|
|
|

\
|
qui aprs calculs donne
|
|
|
|
|

\
|
.

On donne ici un exemple dcriture en langage de description algorithmique :

- Procdure pivot ( k , l : entiers ; OK : boolens )
- Dbut
- Max := ( ) k k A , ;
- l := k ;
- Pour i := k+1 n faire
- Si max < ( ) k i A ,
- Alors
- Dbut
- Max := ( ) k i A , ;
- l := i ;
- Fin ;
- OK := Max > ;
- Fin ;

- Procdure permuter ( k , l : entiers )
- Dbut
- Si l k
- Alors
- Pour j := k 2n faire
- Dbut
- c := ( ) j k A , ;
- ( ) j k A , : = ( ) j l A , ;
- ( ) j l A , := c ;
- Fin ;
- Fin ;

On donne maintenant le programme principal, ralisant le calcul de linverse.

- Dbut
- Initialiser A et lire ;
-
- /* triangularisation */
- Pour k := 1 n faire
- Dbut
- Pivot (k , l , OK ) ;
- Si non(OK)
- Alors
- Dbut
- Ecrire matrice non inversible ;
- Exit echec ;
- Fin ;
- Permuter ( k , l ) ;
- Pour j := k+1 2n faire
- ( ) ( ) ( ) k k A j k A j k A , / , : , = ;
A.BENHARI 62

- Pour i := k+1 n faire
- Pour j := k+1 2n faire
- ( ) ( ) ( ) ( ) j k A k i A k i A j i A , * , , : , = ;
Fin ;
-
- /* n remontes */
- Pour k := 1 n faire
- Pour i := n-1 1 par pas de -1 faire
- Dbut
- s := 0 ;
- Pour j := i+1 n faire
- ( ) ( ) k n j A j i A s s + + = , * , : ;
- ( ) ( ) s k n i A k n i A + = + , : , ;
- Fin ;
- Fin ;

Remarques :
- Choix du pivot : pour des raisons de stabilit numrique, on divise toujours par le terme de la colonne k qui
a la plus grande valeur absolue (Cf. Pivot partiel maximum).
- Recherche du pivot : si la plus grande valeur absolue est infrieure la prcision machine , alors on arrte
en disant que la matrice nest pas inversible prs (test dinversibilit informatique). Cependant, elle peut
trs bien tre inversible du point de vue mathmatique !
c. Factorisation A=LU
Soit A une matrice rgulire, de dimension n.
Lien avec la mthode de Gauss
On applique la mthode de Gauss sans pivoter. U est une matrice triangulaire suprieure relle, telle que
U A J
n k
k
=

= , 1
.
On donne la dfinition des matrices
|
|
|
|
|
|

\
|
=
+
1
1
1
1
,
, 1
k n
k k k
J

O M
avec
k k
k l
k l
a
a
,
,
,
= pour k l > .
On dmontre que linverse des J
k
existe et que

=
n k
k
J L
, 1
1
est une matrice triangulaire infrieure, avec des 1
sur la diagonale. En fait, on a
|
|
|
|
|
|

\
|

=
+

1
1
1
1
,
, 1
1
k n
k k k
J

O M
.
Calcul algorithmique des coefficients de L et de U
On procde par identification en utilisant les proprits de L (triangulaire infrieure avec une diagonale de 1) et
de U (triangulaire suprieure). On cherche un algorithme par ligne donnant les
n j u i j l
j i j i
1 pour les et 1 1 pour
, ,
.

- Pour i := 1 n faire
- Dbut
A.BENHARI 63

- Pour j := 1 i-1 faire
-
j j
j
k
j k k i j i j i
a u l a l
,
1
1
, , , ,
. :
|
|

\
|
=

=
;
- /* avec 1
,
=
i i
l */
-
- Pour j := i n faire
-

=
=
1
1
, , , ,
. :
i
k
j k k i j i j i
u l a u ;
- Fin ;

Remarque : L et U crasent la matrice A.
Cas particulier des matrices structure bande


|
|
|
|
|
|
|
|
|

\
|
O O
O O
O O O
O O O
O O O
O O
O O

- La largeur de la bande est W = P+Q+1
- On ne stocke dans une structure de donne approprie que la bande, soit un O(W.N), ce qui est intressant si
W << N.

Proprit fondamentale :
La bande se conserve par factorisation LU. On parle de structure de donnes statique. En revanche, si on utilise
des techniques de pivotage au cours dune factorisation LU sur une matrice bande, alors la structure bande nest
pas conserve.
On utilise la mthode uniquement dans le cas, o priori on ne pivote pas. La condition suffisante la plus connue
est A matrice diagonale strictement dominante , cest dire

=
>
i j
n j
j i i i
a a n i
, 1
, ,
, 1 .
Cas des matrices symtriques dfinies positives (SDP)
Cf. factorisation Cholesky et Crout.
d. Factorisation PA=LU
P est la matrice des permutations.
L est une matrice triangulaire infrieure dont la diagonale se compose de 1.
U est une matrice triangulaire suprieure.

A.BENHARI 64

Matrice de permutation lmentaire i j :
j ligne
i ligne
1
1
0 1
1
1
1 0
1
1
,

|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|

\
|
=
O
O
O
j i
P

Le produit PA permute les lignes i et j de la matrice A. Le produit AP permute les colonnes i et j de la matrice A.

( complter avec le cours : obtention de la factorisation et utilisation de la factorisation )
A.BENHARI 65

e. Factorisation A=BB
t
: Cholesky
Cette factorisation s'applique pour des matrices A symtriques et positives.
Thorme : Soit A une matrice SDP de dimension n. Il existe une et une seule matrice B triangulaire infrieure,
telle que A=BB
t
.

f. Factorisation A=LDL
t
: Crout
Thorme : Soit A une matrice SDP de dimension n. Il existe une et une seule matrice L triangulaire infrieure et
D diagonale positive, telles que A=LDL
t
.
Remarque : Crout a le mme comportement numrique que Cholesky. Cependant, il est plus utilis car
gnralisable au cas complexe.

Soit A une matrice symtrique dfinie positive (quelconque ?).
L est une matrice triangulaire infrieure de dimension n dont la diagonale se compose de 1.
D est une matrice diagonale de dimension n.

L est en fait la matrice B pour laquelle les termes d'une colonne sont diviss par les coefficients b
ii
. D est la
matrice dont les coefficients diagonaux sont les b
ii

.

i. Algorithme par ligne pour lobtention de la
factorisation
On crit
|
|
|

\
|
=
1
0
0 0 1
, j i
l
L O et
|
|
|

\
|
=
n
d
d
D O
1
.
Il s'agit de calculer les l
i,j
et les d
i
. On a
j ij
j
k
jk k ik j i
d l l d l a + =

=
1
0
,
.
On tablit un algorithme par ligne : Pour la 1
re
ligne, on crit
1 , 1 1
a d = . Supposons maintenant le calcul
effectu jusqu' la ligne i-1 ; le calcul de la ligne i est donn par
( )
j
j
k
jk k ik
j i j i
d
l d l
a l

=
=
1
1
, ,
pour 1 i j et
par ( )

=
=
1
1
2
,
j
k
k ik i i i
d l a d . Ainsi une CNS pour cette factorisation est que les d
i
ne soient pas nuls.

On donne lalgorithme correspondant :

- Pour i de 1 n faire
- Dbut
- Pour j de 1 i-1 faire
- ( )
j
j
k
jk k ik j i j i
d l d l a l / :
1
1
, ,

=
= ;
- /* 1 :
,
=
i i
l */
- ( )

=
=
1
1
2
,
:
j
k
k ik i i i
d l a d ;
- Fin ;
A.BENHARI 66

Remarque : L et D crase la partie triangulaire infrieure de A.

On veut maintenant apporter une amlioration cet algorithme en diminuant les nombres de calcul ; on
conomise les produits
k k i
d l .
,
, que lon stocke pour un i fix dans le vecteur C[k].

On donne lalgorithme modifi :

- Pour i de 1 n faire
- Dbut
- Pour j de 1 i-1 faire
- Dbut
- C[ j] :=

1
1
,
] [ .
j
k
jk j i
k C l a ;
-
j
j i
d
j C
l
] [
:
,
= ;
- Fin ;
-

=
=
1
1
,
] [ . :
j
k
ik i i i
k C l a d ;
- Fin ;

ii. Algorithme par colonne pour lobtention de la
factorisation
Principe : On construit L et D, en procdant par dcomposition successives. On ralise le dcoupage suivant :
|
|
|
|
|

\
|
= =
1
1
1
1
1
1
1
B
d
v
d
v
d
A A
t
, avec v
1
un vecteur colonne de dimension n-1, et B
1
une matrice carr de dim
n-1.
On pose
|
|
|
|
|

\
|
=
1
1
1
1
1
n
I
d
v
O
L ,
|
|
|

\
|

=
1
1
2
B O
O d
A , avec
1
1 1
1 1
.
d
v v
B B
t
= .
Ainsi, on a :
t
L A L A A
1 2 1 1
= = . Puis, en ritrant n-1 fois, il vient : ( )
{
( )
43 42 1
L
43 42 1
L
t
L
t
n
D
n
L
n
L L A L L A A
1 1 1 1 1
= = .
A.BENHARI 67

Le produit des matrices
|
|
|
|
|
|
|

\
|
=
1
1
1
k
k
k
d
v
L
O
O
donnent la matrice finale
|
|
|
|
|

\
|
=
1
1
1
2
2
1
1
L
O
d
v
d
v
L .
Ce qui correspond en effet une factorisation de Crout, car la matrice ( )
i
d D = est bien diagonale et la matrice
L est bien triangulaire infrieure, par construction.

On donne lalgorithme de calcul de L et de D par colonne, qui procde en crasant la partie triangulaire
infrieure de A, (les 1 de la diagonale de L ne sont pas stocks, car on prfre y stocker D) :

- Dbut
- Pour k de 1 n-1 faire
- Pour j de k+1 n faire
- Dbut
-
k k k j
a a d
, ,
:= ;
- Pour i de j n faire d a a a
k i j i j i
. :
, , ,
= ;
- d a
k j
= :
,
;
- Fin ;
- Fin ;

La structure donne dimplmentation serait un vecteur une dimension stockant conscutivement les colonnes
de la partie triangulaire infrieure de A.

Remarque fondamentale :
j i
a
,
est modifi par
k i
a
,
et
k j
a
,
.
iii. Etude du remplissage lors de la factorisation de
matrices SDP creuses
Considrons une matrice A symtrique creuse. On utilise une structure de donne type profil, il est important de
savoir o se trouvent les termes priori non nuls de L.
Une matrice est dite creuse si elle contient un grand nombre de termes nuls. Plus prcisment, on considre
que la matrice est creuse partir du moment, o son pourcentage de termes nuls permet un gain informatique par
rapport un traitement classique qui la considrerait pleine.

Dfinitions :
- Un terme de remplissage apparat en (i,j) au cours de la factorisation si et seulement si 0
,
=
j i
a et
0
,

j i
l . On reformule le problme comme la conservation du creux initial de la matrice.
- l
i,j
est logiquement non nul si 0 que tel 1 1 , ou 0
, , ,

k j k i j i
l l j k k a . Cest dire, la k
me

itration ( ) 1 1 n k un terme
j i
a
,
de la matrice A qui est nul, devient non nul ssi
A.BENHARI 68

0 et 0
, ,

k i k j
a a avec 1 j k . Preuve (algorithme par colonne):
{ {
k k
k j k i
j i j i
a
a a
a a
,
0
, ,
0
,
0
,
.
:
48 47 6

=
= .
- Les l
i,j
logiquement non nuls se trouvent l'intrieur du profil de A.

Exemple de remplissage total :
|
|
|
|
|
|

\
|
=
|
|
|
|
|
|

\
|
=
x x x x x
x x x x
x x x
x x
x
E
x x
x x
x x
x x
x
E
2 1
0 0 0
0 0
0
Le coefficient (3,2) dpend uniquement des coefficients (3,1) et (2,1) qui sont non nuls, par consquent le
coefficient (3,2) devient logiquement non nul : effet de remplissage. Ensuite, le coefficient (4,2) qui dpend des
coefficients (4,1) et (2,1) devient logiquement non nul. () Le coefficient (5,3) dpend des coefficients (5,k) et
(3,k) pour k variant de 1 3-1=2, etc.

Remarque : Ainsi, on voit que le phnomne dpend de lordre selon lequel on excute les itrations, cest dire
de la numrotation des inconnues du systme ! Si lon permute les indices 5 et 1 dans lexemple prcdent, on
obtient la matrice suivante :
|
|
|
|
|
|

\
|
=
x x x x x
x
x
x
x
E
0 0 0
0 0
0
3
qui ne produit pas de remplissage !
La question qui se pose maintenant est de savoir si lon peut trouver une matrice de permutation P, telle que la
factorisation de la matrice PAP
t
cre le moins de remplissage possible ? Il nexiste pas de mthode exacte en
temps raisonnable et on va utiliser des mthodes approches (heuristiques).
A.BENHARI 69

iv. Caractrisation du remplissage par les graphes
On utilise un graphe afin de dterminer quels sont les termes logiquement non nuls qui vont apparatre au cours
du calcul.
Le graphe associ une matrice A symtrique d'ordre n possde n sommets que sont les indices de 1 n des
coefficients de la matrice. Un coefficient non nul est repr dans le graphe par un arc entre les indices de ligne et
de colonne de ce coefficient.

Exemple : Graphe associ la matrice E
1
et la permutation identit :





Considrons une permutation donne telle que ( ) i x
i
= et plaons nous la k
me
itration :
-
trouver le monotone adjacent de
k
x qui est lensemble de tous les sommets lis
k
x avec un numro plus
grand, ( ) ( ) { } possible arte une soit , que et tel ,
k j j k
x x k j x x Madj > =

- rajouter une arte de remplissage pour tout couple de tels sommets non lis entre eux.
- On fait cela dans lordre des k croissants de 1 n-1. A la fin, on obtient le graphe dit dlimination.

Exemple :
- ( ) { }
5 4 3 2 1
, , , x x x x x Madj = remplissage total
- ( ) { } =
2
x Madj pas de remplissage
- ( ) { } =
3
x Madj pas de remplissage
- ( ) { } =
4
x Madj pas de remplissage

Profil ligne
Considrons une matrice SDP A de dimension n.

Dfinition : Pour chaque ligne, on considre la colonne
i
c correspondant au premier terme non nul sur la ligne.
La contribution de la ligne i au profil est { } i j c a P
i j i i
= ,
,
qui sera effectivement stocke par ordre
croissant de colonne (soit 1 +
i
c i coefficients). Le profil ligne est lunion des P
i
pour i variant de 1 n. On a
besoin dun vecteur de dimension n donnant pour tout i la valeur de
i
c .
La taille du profil est

=
+ =
n
i
i
c i m
1
1.

Proprit fondamentale : Le profil ligne se conserve par factorisation (statique). Le remplissage est inclus dans
le profil ligne. Par consquent, on va chercher trouver des numrotations qui tendent minimiser la taille du
profil ligne.

On adapte lalgorithme de factorisation : ( )
( )
j
j
c c k
jk k ik j i j i
d l d l a l
j i
/ :
1
, max
, ,

=
= , ainsi on diminue le volume de
calcul.
Optimisation du profil ligne
Critre approch : On va chercher une numrotation des sommets du graphe

G minimisant le profil A. Pour


cela, on cherche diminuer la taille m. On utilise un critre local : i fix, on va essayer dobtenir
i
c proche
autant que possible de i, ce qui va induire un tassement vers la diagonale.

A.BENHARI 70

Le problme en terme de numrotation sur

G est le suivant : numroter ses voisins avec des numros les plus
proches possibles de i .

v. Numrotation en couches :

On partitionne lensemble des sommets du graphe par rapport leur distance un sommet de dpart x. On
numrote continment selon les couches et le plus grand cart varie comme un O(longueur dune couche). Le
nombre de sommets tant fix, on cherche le sommet x de dpart de telle manire que le nombre de couche
( ) x h gnrs partir de x soit maximum ; ceci aura tendance minimiser la longueur des couches.



Exemple : prenons x = 1, on a h(x) = 1.



Algorithme :
- Choisir x quelconque
- Construire la structure en couche partir de x
- Choisir un sommet y de la couche terminale ayant le moins de voisins et construire les couches partir de ce
nouveau sommet, ncessairement ( ) ( ) x h y h
- Si h(x) > h(y) Alors ritrer, Sinon, on est dans le cas o h(x) = h(y), et y est le point de dpart.









A partir de lexemple prcdent, on choisit y = 2 et on obtient h(y) = 2. En ritrant de nouveau, on obtiendra
pas mieux. Donc on dduit 2 = x .

On applique le changement de numrotation :
Ancien numro i 1 2 3 4 5
Nouveau numro ( ) i
2 1 3 4 5

Ce qui donne la transformation suivante :
|
|
|
|
|
|

\
|
=
|
|
|
|
|
|

\
|
=
x x
x x
x x
x x
x
E
x x
x x
x x
x x
x
E
0 0 0
0 0
0
0 0 0
0 0
0
4 1
.
Limitation du remplissage
Thorme : CNS de cration dune arte de remplissage
Soit

G le graphe numrot associ la matrice A.


Une arte de remplissage ( )
j i
x x , est cre si et seulement si :
- larte est dj prsente dans

G ;
- il existe un chemin allant de
i
x
j
x tel que les numros intermdiaires soient plus petits que ceux des
extrmits.
A.BENHARI 71


Ide de numrotation : Pour mettre en dfaut ce thorme, on utilise des sparateurs topologiques. Cette
mthode consiste sparer deux sous-ensembles A et B par un ensemble C, appel sparateur ; de sorte que tout
chemin allant dun lment de A vers un lment de B passe au moins par un sommet de C. Si on numrote les
sommets de C avec des numros plus grands que ceux affects A et B, alors il ny aura pas darte de
remplissage cres entre les lments de A et ceux de B.




On applique ce principe de numrotation rcursivement par bloc, jusqu tomber sur une grille qui nest plus
sparable. Ce faisant on limite excellemment le remplissage, mais le profil risque dtre mauvais.

Remarque : Il faut une autre structure de donne que celle du profil non adapt. Par ailleurs, il y a aussi une
indpendance des calculs exploitable sur une machine architecture parallle.

Exemple :
On reprend lexemple prcdent






On effectue le changement de numrotation :
|
|
|
|
|
|

\
|
=
|
|
|
|
|
|

\
|
=
x x x x x
x
x
x
x
E
x x
x x
x x
x x
x
E
0 0 0
0 0
0
0 0 0
0 0
0
5 1
et
lon peut vrifier que cette dernire matrice ne se remplie pas du tout !
vi. Utilisation de la factorisation pour rsoudre Ax=b
Il sagit de rsoudre b Ax = en utilisant la factorisation de Cholesky - CROUT : b X ALDL
t
= . On procde
en trois tapes.
- Descente : Posons x DL y
t
= et rsolvons b Ly = , dont la complexit est en
2
2
n
(matrice triangulaire).
On crit un algorithme utilisant un accs par ligne dans la matrice L.

-
1 1
: b y =
;
Pour i de 2 n faire

=
=
1
1
,
i
j
j j i i i
y l b y ;
- Rsolution du systme diagonal : Posons x L z
t
= et rsolvons y Dz = (par n divisions).

- Pour i de 1 n faire
di
y
z
i
i
= ;
- Monte : Rsolvons finalement z x L
t
= , dont la complexit est en
2
2
n
.
On crit un algorithme utilisant un accs par ligne dans L
t
, ce qui revient un accs par colonne dans L.
B A
C
B
A
C
A.BENHARI 72

-
n n
y x = : ;
Pour i de n-1 1 faire

+ =
=
n
i j
j
t
j i i i
x l z x
1
,
: ;

On veut exploiter la symtrie. On ne stocke que L et D ; et on ne stocke pas les 1 de la diagonale de L, qui sont
pris en compte directement dans le calcul.

Considrons le fait que lon stocke les donnes en mmoire de faon mono-dimensionnelle. On va donc tre
oblig de choisir une organisation ligne par ligne, ou colonne par colonne des donnes.
Si lon choisit une organisation ligne par ligne, on saperoit que lalgorithme de descente est bien adapt la
structure de donnes par ligne, tandis que lalgorithme de monte, qui pratique un accs aux donnes par colonne
ne lest pas. Cest pourquoi, il faut crire un algorithme de monte accdant aux donnes par ligne et non plus
par colonne.
- Pour i de 1 n faire
i i
z x = : ;
- Pour i de n 2 par pas de -1 faire
- Pour j de i-1 1 par pas de -1 faire
-
i j i j j
x l x x
,
: = ;
A.BENHARI 73

XVII. Systmes linaires Ax=b : mthodes itratives
a. Principe
i. Mthode itratives classiques :
On cherche obtenir une suite de vecteur ( )
n n
X convergeante vers b X A que telle X = .
En posant N M A = o M est une matrice inversible, on propose la formule de rcurrence
b NX MX
n n
+ =
+1
ou encore b M NX M X
n n
1 1
1

+
+ = . Si X est solution du problme, il vient
que ( ) ( ) ( )
0
1
X X N M X X
n
n
=

. ( ) N M B
1
= est appele la matrice d'itration.
Ainsi pour que X X
n
, il est ncessaire que ( ) 0
1

n
N M .

Remarque : Le cadre normale de convergence des mthodes itratives classiques est : A matrice symtrique
dfinie positive .
ii. Vitesse de convergence :
Thorme : ( ) ( ) 1 ssi 0 < B B
n
n
.

Vitesse de convergence : Considrons la matrice d'itration B symtrique, alors ( ) B B =
2
et l'on obtient
le rsultat suivant : ( )
2
0
2
. x x B x x
k
k
.
En conclusion, le rayon spectral de la matrice d'itration mesure la vitesse de convergence. La convergence est
d'autant plus rapide que le rayon spectral est plus petit. On admettra que ce rsultat ce gnralise aux matrices
quelconques.

b. Mthode Jacobi
Notation :
|
|
|

\
|

=
E
D
F
A
On pose F E N et D M avec + = = = N M A selon le schma ci-dessus. Ce qui donne la formule de
rcurrence suivante : ( ) b D X F E D X
n n
1 1
1

+
+ + = .

Soit ( )
n i
i
k k
x x
, 1 =
= le vecteur itr, on donne lalgorithme donnant
1 + k
x en fonction de
k
x .
- Pour i de 1 n faire
-
(

=

+ =

=
+ i
j
k
n
i j
j i
j
k
i
j
j i
i i
i
k
b x a x a
a
x
1
,
1
1
,
,
1
1


Thorme : Soit A une matrice symtrique, diagonale strictement dominante, c'est dire

>
j i
j i i i
a a
, ,

alors la mthode est convergente car ( ) ( ) 1
1
< +

F E D .

A priori, cette mthode converge pour une matrice A SDP.

A.BENHARI 74

c. Mthode Gauss-Seidel
Boucle directe
On reprend le schma de matrice prcdent et on pose E D M = et F N = . La formule de rcurrence
s'crit : ( ) b FX X E D
n n
+ =
+1
.
On calcule
i
k
x
1 +
, l'i
me
composante du vecteur
1 + k
X :
i
n
i j
j
k j i
j
k
i
j
j i
i
k i i
b x a x a x a + =

+ =
+

=
+
1
, 1
1
1
, 1 ,
.
On propose lalgorithme suivant :

- Pour i de 1 n faire
-
(

+ =

+ =
+

=
+ i
n
i j
j
k j i
j
k
i
j
j i
i i
i
k
b x a x a
a
x
1
, 1
1
1
,
,
1
1

On procde par crasement du vecteur
k
X :
{
t
j
k
i
k
j
k
n j i x x i j x
|
|

\
|
+
+ +
1 , 1 1 ,
cours en calcul
1
calculs dj
1
4 4 3 4 4 2 1
.

Boucle rtrograde
Cette fois, on pose F D M = et E N = .
On propose lalgorithme suivant :

- Pour i de n 1 faire
-
(

+ =

+ =
+

=
+ i
n
i j
j
k j i
j
k
i
j
j i
i i
i
k
b x a x a
a
x
1
1 ,
1
1
,
,
1
1


Conclusion
Thorme : Soit A une matrice symtrique dfinie positive, alors la mthode est convergente
car ( ) ( ) 1
1
<

F E D .

Comparaison : Si A est SDP les mthodes de Jacobi et de Gauss-Seidel convergent, et Gauss-Seidel converge
plus vite que Jacobi car ( ) ( ) ( ) ( ) ( ) E F D F E D L F E D J L J
1 1
1
1 2
ou et avec

= + = = .
d. Mthode de relaxation
Pour cette mthode, on pose E
w
D
M = et F D
w
w
A M N + |

\
|
= =
1
, avec 0 w . On donne la
matrice ditration :
(

+ |

\
|
|

\
|
=

F D
w
w
E
w
D
L
w
1
1
. Ainsi pour 1 = w , on se ramne la mthode de
Gauss-Seidel.

Thorme : Soit A une matrice SDP. Il y a convergence si et seulement si ( ) 1 <
w
L . On dmontre que ceci est
vrai si et seulement si ] [ 2 , 0 w .

Remarque :
- 1 = w : Gauss-Seidel
- 1 < w : Sous-relaxation
- 1 > w : Sur-relaxation


A.BENHARI 75

Boucle directe
On veut calculer
i
k
x
1 +
:
i
i
k i i
n
i j
j
k j i
j
k
i
j
j i
i
k
i i
b x a
w
x a x a x
w
a
+ |

\
|
+ =

+ =
+

=
+ ,
1
, 1
1
1
, 1
,
1
1
. Comme dans Gauss-
Seidel, on note que l'algorithme procde par crasement.

- Pour i de 1 n faire
- ( )
i
i i
n
i j
j
k j i
j
k
i
j
j i
i i
i
k
i
k
b
a
w
x a x a
a
w
x w x
, 1
, 1
1
1
,
,
1
1 +
(

+ =

+ =
+

=
+



Choix de w :
Soit A une matrice symtrique dfinie positive, et tridiagonale par blocs :
|
|
|
|
|

\
|
=
O
O
A .
On cherche un w optimal, c'est dire qui rend ( ) N M
1
minimum. On tablit dans le cas des matrices
tridiagonales :
( )
2
1
1 1
2
L
w
optimal
+
= et ( ) 1 =
optimal w
w L
optimal
.

Note : On utilise aussi cette mthode de faon heuristique pour des matrices qui ne sont pas tridiagonale.


Dichotomie : Si lon cherche
optimal
w par dichotomie, lexprience montre quil faut obligatoirement procd
par valeurs suprieures (la fonction ( )
w
L w a possde pour
optimal
w w > une pente de 1).
valuation du rayon spectral de L :
On crit les itrs de Gauss-Seidel :

+ =
+ =

+
c x L x
c x L x
k k
k k
1 1
1 1
.
.
do ( )
1 1 1
.
+
=
k k k k
x x L x x . On utilise la
mthode de la puissance itre et on dduit : ( )
1
1
1
lim

=
k k
k k
k
x x
x x
L . En pratique, on fait lapproximation
pour des itrs dont lcart a diminu de manire significative.

Schma dimplmentation :
- Soit x
0
donn
- On ralise p itrations avec Gauss-Seidel, on obtient la suite des itres jusqu x
p
partir de laquelle on
value de manire approche ( )
1
L et
optimal
w .
- Puis on applique la mthode de relaxation avec
optimal
w w = .
- On sarrte lorsque lon a atteint la prcision dsire.

Remarque : Toute la difficult rside dans la choix de p. Il faut que le nombre total ditrations soit n << pour
tre comptitif avec Cholesky. Le choix de p se fait au cas par cas.
A.BENHARI 76

e. Mthodes du gradient
4

Principe : mthode de la plus grande descente
Soit A une matrice symtrique dfinie positive.
Thorme : Soit ( ) X b X AX X J , 2 , = . Alors X est solution de b AX = , si et seulement si X ralise
le minimum de J.
En dimension 1, ( ) bx ax x J a A = =
2
et (quation de parabole) ; d'o le minimum de J est
a
b
, ce qui
correspond bien la solution de l'quation linaire b ax = .

Formule de rcurrence : Prenons un X
0
quelconque, et supposons que nous ayons obtenu par itration X
k
.
Considrons la courbe de niveau k ( ) ( ) { }
k
X J X J X = que tel , pour calculer X
k+1
, on se dplace du point X
k
,
appartenant l a courbe de niveau k, dans la direction de son gradient : b AX grad g
k k
= =
2
1
. On donne
ainsi la formule de rcurrence :
k k k k
g X X =
+1
. Il reste maintenant choisir la valeur de
k
, de sorte que
J soit le plus petit possible. On montre que ( ) ( )
k k k k k k k k
X J g g g Ag X J + =
+
, 2 ,
2
1
, donc il faut
prendre
k k
k k
k
g Ag
g g
,
,
= .

On rsume le passage de X
k
X
k+1
:
- b AX g
k k
=
-
k k
k k
k
g Ag
g g
,
,
=
-
k k k k
g X X =
+1


Algorithme du gradient conjugu
Dans cette mthode, on va utiliser un ensemble de directions conjugus.
k
g est la meilleure direction locale,
mais pas long terme, sinon l'algorithme convergerait d'un coup! D'o l'ide, d'apporter une correction pour le
choix de la direction.
On pose
k k k k
d X X + =
+1
avec
1 1
+ =
k k k k
d g d . En rsolvant le systme obtenu, par annulation des
drives partielles pour la fonction J (qui doit tre minimum), on calcule les valeurs des coefficients
1
et
k k
.

On va maintenant rsumer la mthode :
- Initialisation :
0
X quelconque, b AX g =
0 0
, et
0 0
g d = .
- Passage de l'indice k l'indice k+1 : On suppose que l'on connat
k k k
g d X et , , . On calcule
k k
k k
k
d Ad
g g
,
,
= , d'o
k k k k
d X X + =
+1
.

4
Cette partie a t rdige en privilgiant les notes de cours plutt que celle de TD, o les
notations et les mthodes diffrent sur quelques points.

A.BENHARI 77

- On prpare la suite en calculant : b AX Ad g g
k k k k k
+ =
+ + 1 1
ou ;
k k
k k
k
g g
g g
,
,
1 1 + +
= et
k k k k
d g d + =
+ + 1 1
.

Remarque : On dmontre que la correction apporte dans cette mthode est optimale.

Formule par rcurrence : On dmontre aprs coup que cette mthode donne la solution de l'quation linaire au
bout de N itrations ! Par consquent, on pourrait la considrer comme une mthode directe, mais on prfre la
prendre comme une mthode itrative, et s'arrter pour N k quand la prcision est satisfaisante.
Prconditionnement :
Convergence de la formule :
On tablit que :
( )
( )
A
k
A
k
X X
A Cond
A Cond
X X
|
|

\
|
+


0
1
1
. Notons que plus Cond(A) est petit, plus la
convergence est rapide. En particulier, si ( ) 1 = A Cond , alors on converge d'un coup, c'est dire X
0
est dj
solution ! Rappelons : ( ) 1 A Cond . Ici, on voit que la vitesse de convergence va dpendre de la matrice A, et
plus particulirement de son conditionnement. On va alors introduire la notion de prconditionnement.

Transformation :
On cherche rsoudre un autre systme b Y A
~ ~
= ayant mme solution, mais pour lequel la matrice A
~
possde
un meilleur conditionnement.
On considre
t
E E C . = . On pose
t
E A E A

= . .
~
1
et b E b
1
~

= . Ainsi b Y A b AX
~ ~
= = pour
X E Y
t
= .
Remaque : Les algorithmes passant par l'intermdiaire de Y sont dits non transforms. Lorsque Y n'apparat plus
dans le calcul l'algorithme est dit transform.

Algorithme du gradient prconditionn transform :
Prenons un X
0
quelconque, et supposons que nous ayons obtenu par itration X
k
. On pose b AX g
k k
= et
k k
g C h
1
= , ce qui revient rsoudre
k k
g Ch = . Rsolution d'un systme linaire ! Certes. Mais simple,
puisqu'on a suppos auparavant, que l'on avait une factorisation de Cholesky de la matrice C, c'est dire
t
E E C . = (algorithme de complexit n). Ensuite, on calcule
k k
k k
k
h Ah
h g
,
,
~
= . Et on passe de X
k
X
k+1
en
faisant
k k k k
h X X
~
1
=
+
.
Ainsi, on obtient le rsultat fondamental suivant
( )
( )
A
k
A
k
X X
A Cond
A Cond
X X
|
|

\
|
+


0
1
~
1
~
. Il faut prsent
travailler pour que le conditionnement de soit meilleur que celui de A. Or, nous avons pos
t
AE E A
1
~

= ,
par o nous pouvons dduire que ( ) ( ) A C Cond A Cond
1
~

= , car ces deux matrices ont les mmes valeurs
propres.

Choix de C (mthode heuristique) :
- Factorisation incomplte de Cholesky : Lorsque l'on pose
t
BB A = , il peut sur venir un phnomne de
remplissage ! D'o l'ide de raliser une factorisation incomplte R EE A
t
+ = . On ne calcule dans la
matrice E que les 0 que tels
, ,

j i j i
a l , pour lesquels donc on vite le phnomne de remplissage.
Si l'on pose A BB C
t
= = , on obtient un conditionnement de 1 (le meilleur) car Id A C =
1
; cependant il
peut se produire un phnomne de remplissage peut souhaitable. Et si l'on pose Id C = , le conditionnement
n'est pas amlior par rapport celui de A.
A.BENHARI 78

On va alors prendre
t
EE C = (factorisation incomplte de Cholesky), ce qui correspond un compromis
entre le choix d'un bon conditionnement pour et la disparition du phnomne de remplissage.
- Factorisation incomplte de Crout: On peut tout aussi bien utiliser Crout (qui est la mthode propose en
TD). Dans ce cas, R LDL A
t
= et on prend
t
LDL C = .
Voici deux conditions suffisantes chaques lexistence : A est une matrice SDP diagonale dominante, ou
A est une matrice SDP avec j i a
j i
pour 0
,
.
Algorithme du gradient conjugu prconditionn transform
- Factorisation incomplte de Cholesky : R EE A
t
+ = ; on pose
t
EE C =
- Au dpart : On dispose d'un
0
X quelconque, de b AX g =
0 0
, de
0
1
0
g C h

= et de
0 0
h d = .
- Passage de l'indice k l'indice k+1 : On suppose que l'on connat
k k k k
h g d X et , , .
On calcule :
k k
k k
k
d Ad
g g
,
,
= et
k k k k
d X X + =
+1
.
- On prpare la suite en calculant :
- b AX Ad g g
k k k k k
= + =
+ + 1 1
ou
-
1
1
1 +

+
=
k k
g C h (simple rsoudre car factorisation de Cholesky ou de Crout)
-
k k k k
d h d + =
+ + 1 1


Tests d'arrts pour les mthodes itratives
On se donne une prcision 0 > . On voudrait que l'algorithme se termine une fois la prcision atteinte, c'est
dire X X
n
. Cependant, on ne connat pas X ! On utilise par consquent le test
suivant 2
1

+ n n
X X , dont on considre en pratique qu'il est quivalent au premier, mme si cela n'est
qu' demi vrai en thorie (la rciproque est fausse). Il peut y avoir de rare cas o l'algorithme s'arrte, alors que
l'on est loin de la solution !!! Mais faute de mieux
Finalement, on prend comme test d'arrt :
+ n n
X X
1
et /ou =
n n n
g X AX .

Remarque : La mthode du gradient conjugu prconditionn est plus performant en nombre ditration que la
mthode de relaxation avec
optimal
w .
A.BENHARI 79

XVIII. Problmes au moindres carrs (linaire)
a. Rgression linaire
Etant donn une srie de M points ( )
i i
y x , , on cherche une relation de la forme b ax y
i i
+ . On cherche a et
b qui minimise l'erreur

=
M
i
e erreur
2 2
avec ( ) b ax y e
i i i
+ = .
Cas gnral
On tudie un cas plus gnral ( ) ( )

N
i j j i
t x t f . , avec N inconnues
j
x . On a M quations avec N M >> .
On pose ( ) ( )
N M
i j
t A

= et ( ) ( )
M i
t f b = . L'erreur est b Ax . On cherche les
j
x qui minimise cette
erreur

= =
|
|

\
|
=
M i N j
i j ij
b x a b Ax
K K 1
2
1
2
2
.
b. Mthode des quations normales
Thorme
Le vecteur x ralise le minimum de
2
b Ax si et seulement si x est solution de ( ) b A x A A
t t
= (quation
normale). Il existe toujours au moins une solution. La solution est unique si et seulement si le rang de A est N.
Dfauts numriques
On appliquera la mthode des quations normales pour un nombre faible d'inconnues 2, 3, 4 ou 5. Un premier
dfaut est l'imprcision du calcul engendr par le produit matriciel A A
t
. Par ailleurs, si la matrice A est creuse,
A A
t
peut trs bien ne pas l'tre
Mthode de la factorisation QR (rectangulaire)
Dfinition (M > N)
N N M M N M
R Q A

= , avec Q une matrice orthogonale et
|
|

\
|
=

O
R
R
N N
, avec R une matrice triangulaire
suprieure.
Thorme : minimiser
2
b Ax pour N suprieur 3 ou 4
Soit
M
t
c
c
b Q
|
|

\
|
=
2
1
avec
1
c de dimension N. Le vecteur x minimise
2
b Ax si et seulement si x est
solution de
1
c x R = .
A.BENHARI 80

Obtention de la factorisation A = QR par Householder
Dfinition des matrices de Householder
Soit u un vecteur unitaire ( ) 1
2
= u de dimension m. On dfinit la matrice de Householder de dimensio m m
t
m u
u u Id H . 2 = .
u
H est symtrique et orthogonale ( ) 1
2
=
u
H . On note galement

t
m u
v v
Id H
.
=
en posant u v . 2 = .
Proprit fondamentale des matrices de Householder
Soit a un vecteur de dimension m, non nul. Il existe H, une matrice de Householder, telle que
m
O
a H
|
|

\
|
=


avec un rel.

Preuve :
-
2
2
2
a =
- On choisit le signe de : le signe oppos a
1
.
- On pose 0 .
1
2
> = a .
- On choisit
m
i
a
a
v
|
|

\
|
=

1
.
Principe de l'algorithme de factorisation
On veut obtenir la matrice
N M
R

partir de la matrice
0
A A = . On procde colonne par colonne.
On rappelle la gomtrie de
|
|
|
|
|
|
|
|

\
|
=
O
x
R
0
0
2
1
M
O

.

- Occupons nous de la premire colonne de
0
A . Il existe une matrice de Householder
1
H de dimension m
telle que
1 0 1
A A H = , o la premire colonne de
1
A est
|
|
|
|
|

\
|
0
0
1
M

.
A.BENHARI 81

- On s'intresse maintenant la 2
me
colonne. Il existe une matrice de Householder
2
~
H de dimension m-1
telle que
2 1 2
A A H = , avec
|
|

\
|
=
2
2
~
0
0 1
H
H . Ainsi la premire colonne de
2
A reste inchange par
rapport
1
A et l'on a fabriqu la deuxime colonne
|
|
|
|
|
|

\
|
0
0
2
M

x
.
- Il vient K = = = =
2 2 1 1 1 0
A H H A H A A On itre la mthode N fois et il l'on obtient la
factorisation ( )
n n
A H H A L
1
= avec
n
H H Q L
1
= et
n
A R = .
Obtention de
1
c b Q
t
= au cours de l'algorithme de factorisation
En vrit, on peut habilement intgrer le calcul de b Q
t
l'algorithme prcdent. Cela est simple, il suffit de
rajouter une N+1 colonne la matrice initiale, ( ) b A A =
0
. Ainsi aprs N itrations, on obtiendra le rsultat
b Q
t
toujours dans la mme colonne.
Obtention de la factorisation A = QR par Givens
()
XIX. Rsolution des quations non linaires
a. Mthode de dichotomie
Considrons une fonction f en dimension 1. On isole une racine unique dans un intervalle [ ] b a, . On divise
l'intervalle en deux chaque tape, on identifie le sous - intervalle contenant la racine en comparant le signe du
milieu ( ) m f avec ( ) a f . Et on ritre. La prcision obtenue au bout de k itrations est
k
a b
2

. La mthode de
la dichotomie est robuste, mais n'est pas gnralisable la dimension n.

b. Gnralits
i. Mthode convergente, d'ordre p
Une mthode itrative est convergente : X X
n
solution, si
p
n n
X X C X X p C
1
/ , . On dit
que la mthode est dite d'ordre p.
Thorme du point fixe
Soit k-lipschitzienne contractante : ( ) ( )
1 2 1 2
y y k y y avec 1 < k . Soit
0
X et
( )
n n
X X =
+1
. Alors on a X X
n
tel que ( ) X X = .
A.BENHARI 82

- Pour appliquer ce thorme, il suffit de vrifier qu'il existe une boule ( ) X X X B
0
, sur laquelle, on a la
proprit ( ) ( )
1 2 1 2
y y k y y avec 1 0 < < k . L'ingalit des accroissement finis nous donne
( )
( )
j
i
j i c c x
c
c k

= =

, ,
sup sup .
ii. Mthode d'itrations successives pour rsoudre
( ) 0 = X F
Posons ( ) ( ) X F X X = . Si X est point fixe de alors X est solution de ( ) 0 = X F . On dfinit alors la
rcurrence suivante : ( )
n n n
X F X X =
+1
.
Mthode de Newton - tangente
En dimension 1 pour des rels,
( )
( )
n
n
n n
x f
x f
x x

=
+1
. La mthode de la tangente est d'ordre 2. Inconvnient, si
on part d'une certaine boule , la mthode converge, sinon l'algorithme peut osciller et ne pas converger ! Cette
mthode se gnralise la dimension n. Pour des complexes, on peut employer deux fois cette mthode.
Mthode de Newton - Raphson
En dimension n,
n n n
X X =
+1
o ( ) ( ) ( )
n n n
X F X F J = avec ( ) ( )
( )
|
|

\
|

=
j
n i
n
x
X F
X F J
(matrice jacobienne). ( ) ( )
n
X F J est inversible et permet le calcul de
n
chaque itration. Si on part d'une
certaine boule au voisinage de la solution, la mthode est convergente d'ordre 2. Si on fait un choix au hasard
pour
0
X , il faut prvoir un test d'arrt au bout de 100 itrations par exemple pour viter le cas d'oscillations ! La
complexit globale est en n
3
.
iii. Variante si m grand
La complexit globale passe en n
2
aprs la premire utilisation Factorisation PA=LU
Mthode de Bairstow dans le cas des polynmes
On cherche rsoudre ( ) 0 = x P , avec ( )
0
1
1
a x a x x P
n
n
n
+ + + =

K .
Mthode
On cherche + + x x
2
qui divise P. On a ( ) ( ) ( ) ( )
0 1
2
r x r x Q x x x P + + + + = (division euclidienne).
Pour dterminer les coefficients et , on cherche une racine de l'application ( ) ( )
1 0
, , : r r F a .

On veut appliquer la mthode de Newton - Raphston en dimension 2. Il faut d'abord calculer la matrice
jacobienne J : on tablit des formules par rcurrence assez complexes Puis, on applique effectivement la
mthode de Newton - Raphston, partir de ( )
0 0
, , qui donne ( ) , (sous rserve que l'on se trouve
initialement dans une boule suffisamment proche de la solution pour que la mthode soit effectivement
convergente).

Finalement, le polynme + + = x x A
2
1
fournit deux racines de P. On ritre la mthode sur
1
Q tel que
1 1
Q A P = . Cependant, les itrations successives entranent une perte progressive de la prcision.
A.BENHARI 83

Variante
Pour ne pas choisir ( )
0 0
, compltement au hasard, une mthode consiste slectionner une centaine de
couples et choisir, pour dbuter l'algorithme, celui qui rend le polynme minimum.
Amlioration de la prcision
La racine obtenue tant assez proche de la racine relle, on effectue la mthode de la tangente pour amliorer la
prcision. Tous les 4 ou 5 coups, on amliore la prcision avec la prcision avec la mthode de la tangente. Cette
dernire mthode ne s'applique qu'aux racines relles (on applique deux fois la mthode pour les racines
complexes).
Mthode de Bernouilli pour le calcul de la racine dominante si elle est unique
???
c. Valeurs propres et vecteurs propres
Conditionnement
Thorme
Si A est diagonalisable en AP P D
1
= avec P la matrice de passage. Pour tout A , pour toute valeur propre
de A A + , il existe une valeur propre ' de A telle que ( ) A P Cond . Le meilleur cas possible est
A symtrique, la matrice de passage est orthogonale et son conditionnement gale 1.
Bissection de Givens - Householder
Mthode
1. Chercher une matrice tridiagonale semblable A ayant mme valeur propre.
2. Chercher ces valeurs propres.
Tridiagonalisation
Cet algorithme utilise des matrices de Householder. On procde bloc par bloc, en dimension dcroissante.
- A A =
1

- 1
re
tape :
1
1 1 1 2

= H A H A avec
|
|

\
|
= =

1
1
1 1
~
1
H O
O
H H et
1
~
H la matrice de Householder. On
dcoupe
1
A en bloc selon le schma :
|
|

\
|
22 21
12 11
A A
A a
. Par la suite,
( )
|
|

\
|
=
1 22 1 21 1
12 1 11
2
~ ~ ~
~
H A H A H
A H a
A
t
. On sait
trouver
1
~
H tel que
|
|

\
|
=
O
A H
1
21 1
~

avec un rel. Voil ce qui en dfinitive va rendre la matrice
tridiagonale.
- On applique la mme mthode que prcdemment avec une dimension en moins
- On ritre la mthode n fois en totalit. Finalement, on obtient ( ) ( )
1
1 1

=
n n n
H H A H H A K K o
n
A est une matrice tridiagonale semblable A.
Optimisation des calculs
On intgre le calcul de dans la mthode et on optimise le produit des 3 matrices.
- ( )
21 1 , 2 1
. A a Signe =
- 0
1 , 2 1
2
1
> = a
A.BENHARI 84

-
|
|

\
|
=
O
A V
1
21


- V A W
22
1

=
- W V
t

2
1
=
- V W Z =
- K =
t
VZ et K =
t
ZV
- ( )
t t
ZV VZ A H A H + =
22 1 22 1
~ ~

Mthode de recherche des valeurs propres
A partir de la matrice tridiagonale M, on va construire le polynme caractristique dont les racines sont
prcisment les valeurs propres.
-
- Soit b
i
les coefficients diagonaux, et c
i
les coefficients sous-diagonaux. On a ( ) 1
0
= P , ( ) =
1 1
b P et
pour tout n i , ( ) ( ) ( ) ( )
2
2
1 1
=
i i i i i
P c P b P . Attention au cas particulier o un c
i
est nul ! Il faut
distinguer deux polynmes caractristiques.
-
1.
i
P est le polynme caractristique de M
i
o M
i
est la sous-matrice de dimension i extraite de M de telle sorte
que M
n
= M.
2. Le coefficient dominant de P
i
est ( )
i i
1 .
3. Si ( ) 0
0
=
i
P alors ( )
0 1

+ i
P et ( )
0 1

i
P sont de signe oppos.
4. P
i
a exactement i racines relles distinctes qui sparent les i+1 racines de P
i+1
.
Bissection de Givens
Soit un rel. Soit ( ) ( ) ( ) ( ) ( ) { }
i
P signe P signe i E K
1
, , + = . On dfinit ( ) , i N le nombre de
changement de signe dans ( ) , i E . Alors ( ) , i N reprsente le nombre de racines de P
i
qui sont infrieures et
distinctes de .

On ordonne les
i
de manire croissante :
n
< <L
1
. Considrons un intervalle [ ]
0 0
,b a contenant
i
. Soit
2
0 0
b a +
= (bissection). On calcule ( ) , n N . Si ( ) i n N > , , alors [ ] ,
0
a
i
sinon [ ]
0
, b
i
. On
ritre
Une variante pour viter les overflows
()
-
Mthode de la puissance itre
Soit A une matrice quelconque, ventuellement coefficient complexe.
Thorme
Soit A diagonalisable dont la valeur propre
1
(de plus grand module) est unique. Soit
0
q un vecteur non
orthogonal au sous-espace propre gauche
5
associ , tel que 1
0
= q . On suppose
n n
Aq x =
+1
,

5
vecteur propre gauche pour si v v A =
*

A.BENHARI 85

1
1
1
+
+
+
=
n
n
n
x
x
q . Alors, on a :
1
1
1
u q
k
k

|
|

\
|

le vecteur propre associ


1
et
( )
( )
1
1

+
j q
j x
k
k
pour tout j tel
que ( ) 0 j q
k
.
En pratique !
- En pratique l'hypothse "
0
q un vecteur non orthogonal au sous-espace propre gauche
6
associ " n'est
pas ncessaire, car le phnomne d'arrondi permet de s'loigner du cas orthogonal !
- Si A n'est pas diagonalisable, la mthode fonctionne encore, mais la convergence est plus lente.
- En pratique, on choisit la norme infinie, et ( ) 1 , , 1
0
K = q .
Mthode de la dflation
On suppose maintenant que l'on connat
1
et u
1
, avec
n
> >L
1
et la base de vecteur propre ( )
n
u u , ,
1
L .
On cherche
2
et u
2
.
On suppose
*
A A = (A symtrique ?). Le principe est simple, on forme la matrice B tel que
*
1 1 1
u u A B = .
Cette matrice possde les mmes valeurs propres, les mmes vecteurs propres, sauf
1
et u
1
. Par consquent, si
l'on applique la mthode de la puissance itre, on va obtenir
2
et u
2
.

En pratique, on ne calcule pas B La seule diffrence avec la mthode de la puissance itre est dans la formule
( )
1 1
u q A x
k k k
=
+
. (Phnomne d'arrondi compensatoire inverse)

Cette mthode permet en ritrant de trouver
3
,
4
mais pas au del, car il y a rpercussion des erreurs d'arrondi.
Mthode de la puissance itre inverse
Cette mthode permet de calculer la plus petite valeur propre
n
et son vecteur propre u
n
. On prend
1
= A B et
on applique la mthode de la puissance itre B, ce qui donne
n
u et
n

1
.

Pour trouver la valeur propre la plus proche de , on applique la mthode de la puissance itre
Id A B . = , ce qui donne
k
u et
k
.
XX. Approximation polynomiale & Intgration
numrique
a. Approximations polynomiales
i. Polynmes orthogonaux
Soit ( ) ( ) ( )

=
b
a
dx x W x Q x P Q P, avec ( ) 0 x W un poids. Considrons
n
P P P , , ,
1 0
L avec P
i
un
polynme de degrs i. Alors 0 , =
j i
P P pour j i .
Legendre
- [ ] 1 , 1 , ( ) 1 = x W , ( ) ( )

=
1
1
, dx x Q x P Q P .

6
vecteur propre gauche pour si v v A =
*

A.BENHARI 86

- 1
0
= P , ( ) x x P =
1
, ( ) ( ) ( ) x P
n
n
x xP
n
n
x P
n n n 2 1
1 1 2

= .
-
1 2
2 2
+
=
n
P
n
.
Laguerre
- [ [ + , 0 , ( )
x
e x W

= , ( ) ( )

=
0
, dx e x Q x P Q P
x
.
- 1
0
= L , ( ) 1
1
+ = x x L , ( ) ( ) ( ) ( ) ( ) x L n x L x n x L
n n n 2
2
1
1 1 2

=
- ( )
2
2
! n P
n
= .
Hermite
- ( ) ( )

= dx e x Q x P Q P
x
2
, .
- 1
0
= H , ( ) x x H 2
1
= , ( ) ( ) ( ) ( ) x H n x xP x H
n n n 2 1
1 2 2

= .
- ! 2
2
n P
n
n
= .
Tchebychev
-
( ) ( )

+

= dx
x
x Q x P
Q P
2
1
, .
- 1
0
= T , ( ) x x T =
1
, ( ) ( ) ( ) x T x xT x T
n n n 2 1
2

= .
- formule explicite : ( )
( ) ( )
( ) ( )

1 ,
1 , cos cos
1
1
x x nch ch
x x n
x T
n
.
n
T a n zros, [ ] 1 , 1
2
.
1 2
cos |

\
|
=

n
k
x
k

pour n k 1 et n+1 extrema sur [ ] 1 , 1 .
1
cos |

\
| +
=
n
k
x
k
.
- =
2
0
P ,
2
2
=
n
P .
Thormes
- Soit ( ) { } 1 deg / = = =
n n
a et n P P E . Alors
[ ]
( )
[ ]
( ) x P
x T
E P
n
n
n
1 , 1
1
1 , 1
sup
2
sup ,

.
- Soit ( ) ( ) { } = = = P et n P P F
n
deg / avec [ ] 1 , 1 et fix. Alors ,
n
F P
[ ]
( )
( ) [ ]
( ) x P
T
x T
n
n
1 , 1 1 , 1
sup sup

.

- Soit ( ) ( ) { } = = = P et n P P G
n
deg / avec [ ] b a, et fix. Alors ,
n
G P
[ ] [ ]
( ) x P
b a
b a
T
b a
x b a
T
b a
n
n
b a , ,
sup
2
2
.
sup
|

\
|

+
|

\
|

.
A.BENHARI 87

ii. Algorithme de Remes
Soient un intervalle [ ] b a, , et un fonction [ ] ( ) R b a C f , , .
[ ]
( ) x f f
b a,
sup =

. On cherche un polynme P
de degrs infrieur ou gal n tel que

f Q f P pour tout polynme Q de degrs infrieur ou gal
n.
Thorme
On considre
1 1 0 +
< < <
n
x x x L n+2 points de [ ] b a, .
1. ( ) ( ) ( ) ( ) ( ) ( ) ( )
0 0
1 , deg / ! x P x f x P x f i et n P P
i
i i
= (equioscillations)
2. ( ) ( ) ( ) ( )
i i
n i
i i
n i
x Q x f x P x f
+ + 1 0 1 0
max max pour tout Q tel que ( ) n Q deg , c'est--dire que P est la
meilleure approximation pour les points
i
x , mais pas meilleure approximation uniforme.
Corollaire
Posons ( ) ( ) i x P x f
i i
= , . Si

= P f alors

Q f P f pour tout polynme Q de
degrs n. P est la meilleure approximation uniforme sur [ ] b a, .
Algorithme
Du point de vue informatique, on se donne une tolrance 0 > , d'o si

P f , alors pour tout


polynme Q de degrs n +

Q f P f
1. Choisir n+2 points.
2. Si condition vrai, alors fin.
3. Sinon, change : on introduit y en respectant le principe d'oscillation ???
4. On recommence avec la nouvelle famille de points.

On dmontre que l'algorithme converge.
iii. Approximation par interpolation
Considrons n+1 points
n
x x x < < < L
1 0
. Soit P un polynme de degrs n tel que ( ) ( )
i i
x f x P = . Un tel
polynme existe et on dmontre qu'il est unique. On dfinit ( )

=
|
|

\
|

=
n
j k
k k j
k
j
x x
x x
x W
0
un polynme de degrs n.
On a ( )

=
=
j i si
j i si
x W
i j
0
1
. Alors ( ) ( ) ( )

=
=
n
j
j j
x W x f x P
0
.
Formule de Gregory - Newton
Soit h le pas. kh x x
k
+ =
0
. On dfinit ( ) ( ) ( ) x f h x f x f + = , ( ) ( ) x f x f =
2
, On commence
par calculer les ( )
0
x f
i
pour n i 0 . La formule de Gregory - Newton dfinit le polynme P de degrs n
( ) ( ) ( ) ( )
0 0 0
1
x f
n
u
x f
u
x f x P
n

|
|

\
|
+ +
|
|

\
|
+ = K avec
h
x x
u
0

= et ( ) ( ) 1 1
!
1
+ =
|
|

\
|
i u u u
i i
u
L .
Remarquons que si k u x x
k
= = , et
i
k
C
i
u
=
|
|

\
|
. On estime l'erreur ( ) ( )
( )
1
1
1 4
+
+
+

n
n
M
n
h
x P x f avec
A.BENHARI 88

( )
( )

+
+
= x f M
n
n
1
1
.
n
P ne converge pas vers f cause des
n
M . Aussi pour avoir la convergence uniforme
sur [ ] b a, , on ralise l'interpolation sur N sous-segments de longueur
N
a b
avec 5 ou 6 points (en pratique).
Intgration numrique
Si
n
P converge uniformment vers f sur [ ] b a, , alors

b
a
n
P tend vers

=
a
b
f I . On partage l'intervalle [ ] b a,
en N sous-segments [ ]
1
,
+ i i
x x de longueur
N
a b
h

= , avec a x =
0
et b x
N
= .
Stabilit
Les formules sont de la forme ( )

i
i i
x f a avec ncessairement a b a
i
i
=

.
La mthode est stable si pour tout h, il existe A tel que ( ) ( ) A x f a x f a
i
i i i
i
i i
< +

, avec
i
i
sup = .

Thorme : Si 0
i
a alors la formule est stable.
iv. Formule des rectangles
Sur chaque sous-segment [ ]
1
,
+ i i
x x , on approche f avec un polynme de degrs 0, c'est--dire par une constante
gale la valeur milieu. Donc

=
|

\
|
+ =
N
i
i h
h
x f h R
0
2
. On estime l'erreur
( )
2
2
24
h M
a b
R I
h

. Cette
mthode est d'ordre 2, et non d'ordre 1 comme on le croit souvent !
Formule des trapzes
Les polynmes qui interpolent sont de degrs 1, ce sont des droites.
( ) ( )
( )
(

+ + =

=
1
1
0
2 2
N
i
i
N
h
x f
x f x f
h T .
On estime l'erreur
( )
2
2
12
h M
a b
T I
h

. Cette mthode est d'ordre 2 et n'est pas meilleur que celle des
rectangles (sinon moins bonne).
Formule de Simpson
( ) ( ) ( )
)
`

\
|
+ + + + =

=
1
0
0
2
4 2
6
N
i
i i N h
h
x f x f x f x f
h
S . La mthode est d'ordre 4.
v. Spline
Thorme
Soi 1 k . Il existe une et une seule fonction sur [ ]
N
x x ,
1
tel que ( )
i i
y x = . Sur chaque segment
[ ]
1
,
+ i i
x x , est un polynme de degrs 2k-1 avec
( )
( )
i
k
x
2 2
qui existe et
( )
( )
( )
( ) 0
2 2
1
2 2
= =

N
k k
x x ,
de telle sorte donc que soit de classe 2k-2 sur [ ]
N
x x ,
1
.
A.BENHARI 89

XXI. quations diffrentielles
a. Gnralits
Problme de Cauchy
Soit [ ]
M M
R R a x x f +
0 0
, : , continue, telle que ( ) ( ) y x f y x , , a . Etant donne une condition initiale
0
y , on cherche [ ]
M
R a x x y +
0 0
, : de classe C
1
telle que
( ) ( ) ( )
( )

=
=
0 0
,
y x y
x y x f x y
, problme de Cauchy
dimension M et d'ordre 1.

Le problme de Cauchy de dimension M et d'ordre P :
( )
( )
( )
( )
( ) ( )
( )
( )
( )

= = =
=

1
0 0
1
0 0 0 0
1
, , ,
, , , ,
P P
P P
y x y y x y y x y
y y y x g x y
L
L
.
On se ramne au problme de Cauchy d'ordre 1 en posant
( ) |
|
|
|
|

\
|

=
1 P
y
y
y
z
M
, de dimension PM .
Thorme (K - lipschitzienne)
Si il existe K tel que ( ) ( )
2 1 2 1 2 1
, , , , , y y K y x f y x f y y x , alors le problme de Cauchy d'ordre 1
possde une solution unique.
b. Mthode de rsolution numrique
On se place dans le cadre de ce thorme, et l'on cherche calculer une solution. On divise l'intervalle
[ ] a x x +
0 0
, en N de telle sorte que a x x
N
+ =
0
; nh x x
n
+ =
0
avec le pas
N
a
h = . On voudrait que les
n
y soient proches de ( )
n
x y . La formule gnrale employe pour la rsolution numrique des quations
diffrentielles est
( )

+ =
+
0
1
, ,
y
h y x h y y
n n n n
.
Stabilit
On introduit une perturbation,
( )

=
+ + =
+
0 0
1
, ,
y z
h h z x h z z
n n n n n

, et l'on observe le comportement de la
mthode. Posons
n
n
sup = . La mthode est stable si et seulement si A y z A
n n
n
max / .
Consistance
La mthode est consistante si et seulement si
( ) ( )
( ) ( ) 0 , , max
0
1

+
h n n
n n
n
h x y x
h
x y x y
. La
mthode est consistante d'ordre p si et seulement si
( ) ( )
( ) ( )
p
n n
n n
n
Ah h x y x
h
x y x y
A

+
, , max /
1
.
A.BENHARI 90

Convergence
La mthode est convergente si et seulement si ( ) 0 max
0

h n n
n
x y y . Il y a convergence d'ordre p si et
seulement si ( )
p
n n
n
Ah x y y A max / .

Si la mthode est stable et consistante [d'ordre p], alors la mthode est convergente [d'ordre p].
Thorme stabilit
Si il existe K tel que ( ) ( )
2 1 2 1 2 1
, , , , , , , y y K h y x h y x y y x , c'est--dire si est K -
lipschitzienne, alors la mthode est stable.
Thorme consistance
- Si ( ) ( ) y x f y x , 0 , , = , on a consistance d'ordre 1.
- Si de plus, ( ) ( ) y x
x
f
y x
h
,
2
1
0 , , |

\
|

= |

\
|


, alors on a consistance d'ordre 2.
- Si de plus, ( ) ( ) y x
x
f
y x
h
,
3
1
0 , ,
2
2
2
2
|
|

\
|

=
|
|

\
|


, alors on a consistance d'ordre 3.
- Etc.
c. Mthode de Euler
( ) ( ) y x f h y x , , , = , ordre 1, stabilit acquise ( et f lipschitzienne). Intuitivement, on traduit la formule du
taux d'accroissement ( )
h
y y
y x f
n n
n n

=
+1
, . La formule sera donc ( )
n n n n
y x hf y y ,
1
+ =
+
.
d. Mthode du dveloppement de Taylor
( ) ( ) ( ) ( ) K +
|

\
|

+
|

\
|

+ = y x
x
f h
y x
x
f
h y x f h y x ,
! 2 3
1
,
2
1
, , ,
2
, consistante de l'ordre que l'on veut,
stabilit acquise. Mais en pratique les calculs de drives rend la mthode impraticable !
e. Mthode de Runge - Kutta
Ordre 2
On cherche ( ) ( ) ( ) ( ) y x hf y h x f y x f h y x , , , , , + + + = . L'ordre 1 impose 1 = + et l'ordre 2
impose 2 / 1 = = = et .
- Si 1 = , alors 2 / 1 0 = = = et , d'o la formule ( )
|

\
|
+ + + =
+ n n n n n n
y x f
h
y
h
x hf y y ,
2
,
2
1
.
Soit le prdicteur
2 / 1 + n
y , la mthode s'crit :
( )
( )

+ + =
+ =
+ +
+
2 / 1 1
2 / 1
, 2 /
,
2
n n n n
n n n n
y h x hf y y
y x f
h
y y
La mthode est
d'ordre 2, et correspond une amlioration de Euler : le taux d'accroissement est calcul pour le point milieu
( )
2 / 1
, 2 /
+
+
n n
y h x .

- Si 2 / 1 =
A.BENHARI 91

Ordre 4
- ( ) ( )
4 3 2 1
2 2
6
1
, , P P P P h y x + + + =
- ( ) y x f P ,
1
=
- ( )
1 2
.P 2 / , 2 / h y h x f P + + =
- ( )
2 3
.P 2 / , 2 / h y h x f P + + =
- ( )
3 4
.P , h y h x f P + + =
Choix de h
On se donne une tolrance > 0.
- On choisit arbitrairement h et on applique la mthode.
- On recommence avec 2 / h . Si le rsultat obtenu pour un pas divis par 2, est prs celui obtenu pour un
pas de h alors le pas est bon, sinon on ritre. Attention il faut comparer nh x x
n
+ =
0
et
2
. 2
0 2
h
n x x
n
+ = .

A.BENHARI 92

XXII. Exercices

Exercices simples
Exercice 1 :
Ecrire un algorithme dune action qui change deux variables A et B

Action : Echange
Var : A, B, C : rels
Dbut : Ecrire ( Saisissez deux variables )
Lire (A, B)
C <= A
A <= B
B <= C
Ecrire ( les valeurs de , A, et de , B, ont t changes )
Fin


Exercice 2 :
Ecrire une fonction qui donne les carr dun rel

Fonction : carr (x :rel) :rel
Var : x_au_carr
Dbut
x_au_carr <= x*x
retourner x_au_carr
fin

Remarques :

Dans une fonction, la seule variable qui est dfinie est celle du rsultat, les autres sont dfinies dans la fonction
mre, et apparaissent ici en temps quentres.
Dans une fonction, ne pas oublier de retourner le rsultat.


A.BENHARI 93

Exercice utilisant les structures SIALORSSINON et SELONQUE

Exercice 3 :
Ecrire une action qui fournit les flicitations ou lajournement dun lve suivant sa note en utilisant Si-alors-
sinon.

Action : Jury
Var : note : rel
Dbut : lire (note)
Si note <10 alors crire ( ajourn )
Sinon crire ( reu )
Fin

Exercice 4 :
Ecrire un programme qui donne la valeur absolue de 2 rels :

Action : Valeur_absolue
Var : a, b : rels
Dbut : Ecrire ( saisissez 2 rels )
Lire (A, B)
Ecrire les valeurs absolues de A et de B sont : )
Si A<0 alors crire (-A)
Sinon crire (A)
Ecrire ( et )
Si B<0 alors crire (-A)
Sinon crire (A)
Fin

Remarque : on peut aller plus vite en crant une fonction valeur absolue et en faisant appel cette fonction dans
une action :

Fonction : valAbs (x :rel) :rel
Var : absx : rel
Dbut : si x <0 alors absx <= -x
Sinon absx <= x
Retourner absx
Fin

Et
Action : Valeur_absolue2
Var : A, B rels
Dbut : Ecrire ( saisissez 2 rels )
Lire (A, B)
Ecrire ( les valeurs de A et B sont : , valAbs(A), et , valAbs(B))

Exercice 5 :
Faire un programme qui donne le volume dun cylindre en faisant appel une fonction aire dun cercle.

Fonction : aire_cercle (rayon :rel) :rel
Var : Aire : rel
Const : PI=3.14
Dbut : Aire <= PI*rayon*rayon
Retourner (Aire)
Fin

Fonction : volume_cercle (hauteur, rayon :rels) :rel
Var : volume : rel
Dbut : Volume <=aire_cercle (rayon)*hauteur
Retourner volume
Fin
A.BENHARI 94



Exercice 6 :
Ecrire un algorithme permettant de rsoudre une quation du premier degr

Action : premierdegre
Var : a, b, x rels
Dbut : Ecrire ( saisissez les valeurs a et b de lquation ax+b=0 : )
Lire (a, b)
Si a = 0 alors crire ( pas de solution )
Sinon crire ( la solution est x= , -b/a)
Fin


Exercice 7 :
Ecrire un algorithme permettant de rsoudre une quation du second degr en utilisant des si alors..

Action : seconddegr
Var : a, b, c, delta
Dbut : Ecrire ( saisissez les valeurs a, b et c de lquation ax+bx+c=0 : )
Lire (a, b, c)
Si a=0 alors crire ( quation du premier degr )
Sinon delta<=b-4*a*c
Dbut
Si delta>0 alors crire ( les solutions de lquation sont , (-b-sqrt(delta))/(2*a), et , (-
b+sqrt(delta))/(2*a))
Sinon
Dbut
Si d=0 alors crire ( -b/(2a))
Sinon crire ( pas de solutions relles )
Fin
Fin
Fin

Ecrire le mme algorithme avec des selon-que :

Action : seconddegr
Var : a, b, c, delta
Dbut : Ecrire (saisissez les valeurs de a, b et c de lquation ax+bx+c)
Lire (a, b, c)
Si a=0 alors crire ( rsoudre permier degr )
Sinon dbut
Delta <= b-4*a*c
Selon que
Delta > 0 : crire ((-b-sqrt(delta))/(2*a), (-b+sqrt(delta))/(2*a))
Delta = 0 : crire (( -b/(2a))
Sinon crire ( pas de solution relle )
Fin selon
Fin











A.BENHARI 95

Exercice 8
Ecrire un algorithme qui donne la dure de vol en heure minute connaissant lheure de dpart et lheure
darrive.
1) on considre que le dpart et larrive ont lieu mme jour
2) idem mais sans faire les conversions en minutes
3) on suppose que la dure de vol est infrieure 24 heures mais que larrive peut avoir lieu le
lendemain.


1)
Action : DureVol1
Var : h1, h2, m1, m2, hr, mr : entiers
Dbut : Ecrire ( entrer horaire de dpart et darrive )
Lire (h1, m1, h2, m2)
mr <= [h2*60+m2] [h1*60+m1]
hr <= mr/60
mr <= mr%60
Ecrire ( dure de vol : , hr, mr)
Fin

Remarque : lopration % (modulo) permet de calculer le reste de la division entire.

2)
Action : DureVol2
Var : h1, h2, hr, m1, m2, mr : entiers
Dbut : Ecrire ( entrer horaire de dpart et darrive )
Lire (h1, m1, h2, m2)
Si m2>m1 alors
hr <= h2-h1 et mr <= m2-m1
Ecrire (hr, mr)
Sinon
hr <= h2-h1-1 et mr <= m2+60-m1
Ecrire (hr, mr)
Fin


3)
Action : DureVol3
Var : h1, h2, m1, m2, hr, mr : entiers
Dbut : Ecrire ( entrer horaire de dpart et darrive )
Lire (h1, m1, h2, m2)
Si h2>h1 alors
Si m2>m1 alors
hr <= h2-h1 et mr <= m2-m1
Ecrire (hr, mr)
Sinon
hr <= h2-h1-1 et mr <= m2+60-m1
Ecrire (hr, mr)
Sinon
Si m2>m1 alors
hr <= h2-h1+24 et mr <= m2-m1
Ecrire (hr, mr)
Sinon
hr <= h2-h1+24-1 et mr <= m2+60-m1
Ecrire (hr, mr)
Fin




A.BENHARI 96

Exercice 9
1) Ecrire une fonction max3 qui retourne le maximum de trois entiers
2) Ecrire une fonction min3 qui retourne le minimum de trois entiers
3) Ecrire une fonction max2 qui retourne le maximum de deux entiers
4) Ecrire une fonction max3 qui retourne le maximum de trois entiers en faisant appel max2


1)
Fonction : max3(a, b, c : entier) : entier :
Var : max3 : entier
Dbut : Si a>b alors
Si a>c alors max3 <= a
Sinon max3 <= c
Sinon
Si c>b alors max3 <= c
Sinon max3 <= b
Retourner (max3)
Fin

2)
Fonction : min3(a, b, c : entier ) : entier :
Var min3 : entier
Dbut
Retourner (max3(-a, -b, -c))
Fin

3)
Fonction : max2 (a, b : entier) : entier
Var : max2 : entier
Dbut : Si a<b alors max2 <= b
Sinon max2 <= a
Retourner (max2)
Fin

4)
Fonction : max3 (a, b, c : entier) : entier :
Var : max3 : entier
Dbut : max3 <= max2 [max2 (a, b), c)
Retourner (max3)
Fin


Exercice 10
Ecrire avec des Si Alors Sinon une action permettant la saisie dune note n (0n20) et qui affiche la mention
(n16 : TB, n14 : B, n12 : AB, n10 : Passable, n10 : Ajourn)

Action : Mention
Var Note : rel
Dbut : Ecrire ( saisissez une note )
Lire (Note)
Si Note16 alors crire ( TB )
Sinon
Si Note14 alors crire ( B )
Sinon
Si Note12 alors crire ( AB )
Sinon
Si Note10 alors crire ( Passable )
Sinon crire ( ajourn )
Fin

A.BENHARI 97

Alternative : crire le mme programme avec des Selon Que :

Action : Note
Var : Note : rel
Selon que
Note 16 crire ( TB )
Note 14 crire ( B )
Note 12 crire ( AB )
Note 10 crire ( Passable )
Sinon crire ( ajourn )


Exercice 11
Soit lalgorithme suivant :
Action : Permis_voiture
Var : permis, voiture : boolen
Dbut : Ecrire ( avez-vous le permis ? (0/1) )
Lire (permis)
Ecrire ( avez vous une voiture ? (0/1) )
Lire (voiture)
Si non permis ou voiture alors
Si voiture alors crire ( conduisez moi la gare )
Sinon crire ( jai une voiture pas chre )
Sinon
Si voiture alors crire ( vous tes hors la loi )
Sinon crire ( vive le vlo )
fin


1) Ecrire larbre des conditionnelles
2) Corriger les tests pour que tous les cas soient couvert de manire cohrente
3) Faites correspondre les actions et les tests correctement
4) Si possible, crire cet algorithme avec des selon que.

Permis et voiture permis voiture Ni permis ni voiture
gare Vive le vlo Conduisez moi la gare Voiture pas chre
Conduisez moi la gare Voiture pas chre Hors la loi Vive le vlo

En clair, selon lalgorithme propos : si lon a le permis et la voiture on peut amener quelquun la gare ; si lon
a que le permis on dit vive le vlo, si lon na que la voiture on conduit aussi la gare, enfin si lon a ni permis ni
voiture alors on achte une voiture pas chre. Le cas hors la loi nest pas voqu et les correspondance sont
inexactes. Il faut videmment avoir :
- permis et voiture : conduire la gare
- permis : jai une voiture pas chre
- voiture : vous tes hors la loi
- ni voiture, ni permis : vive le vlo

Correction de lalgorithme propos :
Action : Permis_voiture
Var : permis, voiture : boolen
Dbut : Ecrire ( avez-vous le permis ? (0/1) )
Lire (permis)
Ecrire ( avez vous une voiture ? (0/1) )
Lire (voiture)
Si permis ou voiture alors
Si voiture alors crire ( conduisez moi la gare )
Sinon crire ( jai une voiture pas chre )
Sinon
Si voiture alors crire ( vous tes hors la loi )
Sinon crire ( vive le vlo )
A.BENHARI 98



On peut effectivement crire cet algorithme avec des selon-que :
Action : permis_voiture
Var : permis voiture : rel
Dbut : Ecrire ( avez-vous le permis ? (0/1) )
Lire (permis)
Ecrire ( avez vous une voiture ? (0/1) )
Lire (voiture)
Selon que :
Permis et voiture : crire ( conduisez moi la gare )
Permis et non voiture : crire ( jai une voiture pas chre )
Non permis et voiture : ( vous tes hors la loi )
Non permis et non voiture : ( vive le vlo )
Fin


Exercice 12
Ecrire un programme calculatrice permettant la saisie de deux entiers et une opration boolen- ( +, - , / , x ) et
affichant le rsultat. Donner avant cela les spcifications, la solution en langage naturel, les structures de
donnes.

Spcifications :
Donnes : 2 oprandes et un oprateur
Rsultat : rsultat de lopration choisie

Solution en langage naturel : Saisie des donnes, envisager tous les cas : +, - , x, /. Attention la division par
zro qui est impossible

Structure de donnes : 2 oprandes : des entiers
Un oprateur boolen : +, -, * , /

Algorithme :

Action : calcul
Var : a, b : rel op : boolen
Dbut Ecrire ( saisissez le premier entier )
Lire (a)
Ecrire ( saisissez loprateur )
Lire (op)
Ecrire ( saisissez la deuxime variable )
Lire (b)
Selon que :
Op = + : Ecrire (a+b)
Op = * : Ecrire (a*b)
Op = / : Si b= 0 alors crire ( division impossible )
Sinon crire (a/b)
Op = - : Ecrire (a-b)
Fin selon
Fin






A.BENHARI 99

Exercices utilisant les structures rptitives TANT QUE et REPETERJUSQU'A et
POUR
Exercice 13
Ecrire le programme qui affiche la somme dune suite dentiers saisie par lutilisateur se terminant par zro.
Exemple : lutilisateur entre 1, puis 5, puis 2, puis 0 : affiche : 8
1) donner les spcifications
2) donner la solution en langage naturel
3) indiquer les structures de donnes
4) faites lalgorithme

Spcifications :
- donnes : suite de nombre entiers se terminant par zro
- rsultat : la somme de ces entiers

Solution en langage naturel : tant que lentier saisi nest pas zro, lajouter la somme partielle et saisir lentier
suivant.

Structure de donnes :
- entier : entier courant (saisi)
- entier : somme partielle

Algorithme :
Action : Somme Suite
Var : a, s : entiers
Dbut s<=0 Attention : dans une structure tant que ne pas oublier dinitialiser!!!
Lire (a)
Tant que a0 faire
Dbut
s<=s+a
Lire (a)
Fin
Ecrire (s)
Fin


Exercice 14
Ecrire un algorithme qui affiche la moyenne dune suite dentiers se terminant par zro (le zro nentrant pas en
compte dans la moyenne : il est juste la pour indiquer la fin de saisie)
1) donner les spcifications
2) donner la solution en langage naturel
3) indiquer les structures de donnes
4) faites lalgorithme

Spcification :
- donnes : suite dentier se terminant par zro
- rsultat : la moyenne de ces entiers (zro exclu)

Solution en langage naturel :
Tant que lentier saisi diffrent de 0 alors ajouter lentier aux entiers prcdents et faire la moyenne (cest dire
diviser par le nombre dentiers

Structures de donnes :
- entier : entier saisi
- entier : rsultat moyenne

Algorithme :
Action : Moyenne
Var : n, moy, s : entiers
Dbut : moy<=0
s<=0
A.BENHARI 100

Lire (n)
Tant que n0 faire
Dbut
Moy <= moy*s+n)/(s+1)
s<=s+1
lire (n)
fin
Ecrire (moy)
Fin


Exercice 15
Ecrire un algorithme permettant la saisie dune suite dentiers se terminant par zro et vrifier si cette suite
contient deux entiers conscutifs gaux en utilisant les structures tant que.
1) donner les spcifications
2) donner la solution en langage naturel
3) indiquer les structures de donnes
4) faites lalgorithme

Spcifications :
- donnes : suite dentier se terminant par zro
- rsultat : vrai si deux entiers conscutifs, faux sinon.

Solution en langage naturel : comparer lentier courant et le prcdent. Et tant que ils sont diffrents, on continu
la lecture et tant que lentier courant est diffrent de zro.

Structures de donnes :
- entier : nombre courant
- entier : nombre prcdent

Algorithme :
Action : Entiers conscutifs
Var : nc, np : entier
{on dsignera par nc le nombre courant et np le nombre prcdent}
Dbut Lire (nc)
np<=nc-1
{pour tre sur que le nombre courant ne sera pas le mme que le nombre prcdent ds le dpart on affecte la
valeur nc-1 au nombre prcdent. On aurait tout aussi bien pu lui donner la valeur zro)
Tant que nc0 et np nc faire
Dbut
np<=nc
lire (nc)
fin
Si nc0 alors crire ( oui )
Sinon crire ( non )
Fin

Refaire le mme algorithme en utilisant une structure rpter jusqu'
Action : Entiers conscutifs
Var : nc, np : entiers
Dbut
Lire (nc)
Si nc 0 alors Rpter
Dbut
np <= nc
lire (nc)
jusqu' (nc=np ou nc=0)
Si nc=0 alors crire ( oui )
Sinon crire ( non )
Fin
A.BENHARI 101



Exercice 16
Ecrire un algorithme qui affiche le maximum dune suite se terminant par zro
1) donner les spcifications
2) donner la solution en langage naturel
3) indiquer les structures de donnes
4) faites lalgorithme

Spcifications :
- donnes : une suite dentiers se terminant par zro
- rsultat : un entier : le maximum de cette suite

Solution en langage naturel : comparer lentier courant avec le maximum et tant que nc<max on continue, sinon
on affiche la rsultat et on continue, et tant que nc 0

Structures de donnes
- n : entier courant (saisi)
- max : entier max de la suite

Algorithme :
Action : max suite
Var : n, max : entiers
Dbut Lire (n)
Max<=n
Tant que n 0 faire
Dbut
Lire (n)
Si max<n alors max<=n
Fin
Ecrire (max)
Fin


Exercice 17
Ecrire un programme mettant en uvre le jeu suivant :
Le premier utilisateur saisi un entier que le second doit deviner. Pour cela, il a le droit autant de tentatives quil
souhaite. A chaque chec, le programme lui indique si lentier cherch est plus grand ou plus petit que sa
proposition.
Un score indiquant le nombre de coups jous est mis jour et affich lorsque lentier est trouv.
1) donner les spcifications
2) donner la solution en langage naturel
3) indiquer les structures de donnes
4) faites lalgorithme

Spcifications :
- donnes : nombre entier
- rsultat : nombre de tentatives

Solution en langage naturel : saisir un nombre entier par le premier joueur. Tant que le joueur 2 nsaisie, dire si
n est > ou < nombre cherch, incrmenter de 1 et continuer. Quand le rsultat est trouv, afficher le nombre de
tentatives.

Structures de donnes :
- a : nombre saisi par lutilisateur 1
- n : nombre saisi par lutilisateur 2
- t : tentatives

Algorithme :
Action : devinette
A.BENHARI 102

Var : a, n, t : entiers
Dbut : Lire (a)
Lire (n)
t=0
Tant que an faire
Dbut
Si n>a alors crire ( nombre cherch plus petit )
Sinon crire ( nombre cherch plus grand )
t<=t+1
lire (n)
fin
crire (t+1)
fin

Exercice 18
Ecrire un algorithme permettant de calculer le PGCD de deux nombres en utilisant lastuce suivante : soustraite
le plus petit des deux entiers du plus grand jusqu' ce quils soient gaux
Ecrire le mme programme en utilisant lalgorithme dEuclide : dune part en utilisant uniquement les structures
TANT QUE, dautre part en utilisant uniquement les structures REPETER JUSQU'A.

Action : PGCD
Var : a, b entiers
Lire (a, b)
Dbut
a = ValAbs (a)
b = ValAbs (b)
Rpter
Selon que
a>b a<=a-b
a<b b<=b-a
jusqua a=b
crire (a)
Fin

Mme programme avec Euclide et des TANT QUE :
Action : PGCD
Var : a, b, r entiers
Lire (a, b)
r<=a%b
tant que r0 faire
dbut
a<=b
b<=r
r<=a%b
fin
crire (b)
fin

Mme programme avec Euclide et des REPETER JUSQU'A :
Action : PGCD
Var : a, b, r entiers
Lire (a, b)
Rpter r<=a%b
a<=b
b<=r
jusqu' r=0
crire (b)
fin


A.BENHARI 103

Exercice 19
Ecrire avec la commande POUR un algorithme qui permet de faire la somme dune suite de nombre entre par
lutilisateur. Faire la mme chose en comptant par pas de 1.

Action :somme_nombre
Var : k, nb, n, somme : entier
Dbut :
Somme <= 0
Ecrire ( combien voulez-vous entrer de nombres ? )
Lire (nb)
Pour k de 1 nb faire
Dbut
Lire (n)
Somme<=somme + n
Fin
Ecrire (somme)
Fin

Mme programme par pas de 1 :
Action : somme_entier
Var : k, nb, n, somme : entiers
Dbut :
Somme<=0
Ecrire ( combien voulez-vous entrer de nombres ?
Lire (nb)
Pour k de nb 1 par pas de 1 faire
Dbut
Lire (n)
Somme<=somme + n
Fin
Ecrire (somme)
Fin


Exercice 20
Traduire le POUR de lalgorithme suivant en REPETER JUSQU'A :
Action : bidon
Var : k, nb : entiers
Dbut
Lire (nb)
Pour k de 1 nb faire
Ecrire (k)
Fin

Action : Bidon
Var : k, nb : entier
Dbut
Lire (nb)
K<=1
Si nb>0 alors
Rpter crire (k)
K<=k+1
Jusqu k>nb
Fin




Exercice 21
Ecrire une fonction qui fait la somme des entiers compris dans un intervalle.
A.BENHARI 104


Fonction : intervalle (a, b ; entiers) : entier
Var : k, somme : entier
Dbut
Somme <= 0
Pour k de a b faire
Somme<=somme + k
Retourner (somme)
Fin


Exercice 22
Ecrire une fonction multiplication de a et b par addition successives.

Fonction : multiplication (a, b : entiers) : entier
Var : k, produit : entiers
Dbut
produit<=0
Pour k de 1 a faire
Produit<=produit + b
Retourner (produit)
Fin


A.BENHARI 105

Exercices sur les Tableaux

Exercice 23
Ecrire une action qui permette la saisie dun tableau croissant : si T[k]<T[k+1] on enregistre, si T[k]>T[k+1] on
redemande la saisie dun nombre plus grand

Const : MAX=100
Ttype : Ttab=tableau [max]dentier

Action : saisie_tableau_croissant
Var : tab : Ttab, i : entier
Dbut
Lire (Tab[0])
Pour i de 1 MAX-1 faire
Rpter lire (tab[i])
jusqu' tab[i] tab[i-1]
Fin


Exercice 24
Ecrire une fonction retournant le maximum dun tableau de taille n.
Faire le mme algorithme mais qui ne retourne que lindice de la case du tableau contenant le maximum du
tableau.

Fonction : maximum (tab : Tableau dentier n :entier) : entier
Var : max, i : entiers
Dbut
Max <= tab[0]
Pour i de 1 n-1 faire
Si tab[i]>max alors max<=tab[i]
Retourner (max)
Fin


Fonction : maximum (tab : Tableau dentier n :entier) : entier
Var : indice, i, max : entiers
Dbut
Max<=tab[0]
Indice <=0
Pour i de 1 n-1 faire
Si tab[i]>max alors
max<=tab[i]
indice<=i
Retourner (indice)
Fin


A.BENHARI 106

Exercices gnraux sur les actions paramtres

5) Exercice 25
6) Ecrire une fonction Afficher qui affiche a lcran le contenu dun tableau. Ecrire aussi laction
principale qui permettra de comprendre comment fonctionne cette fonction afficher.
7)
8)
9) {Ne pas oublier dindiquer les paramtres du tableau !}
10) Const : MAX : entier=100
11) Type : Ttab : Tableau [MAX] dentier
12)
13) Fonction Afficher (tab : tableau dentiers, n entiers)
14) Var : i entier
15) Dbut :
16) Pour i de 0 n-1
17) Ecrire (tab[i], )
18) Fin
19)
20) Action principale
21) Var t1 t2 : Ttab
22) Dbut
23) T1[0]<=1
24) T1[1]<=3
25) T2[0]<=4
26) T2[1]<=5
27) T2[2]<=7
28) Afficher (T1, 2)
29) Afficher (T2, 3)
30) Fin
31)
32) Rsultat lcran :
33) 1 3
34) 4 5 7
35)
36)
37) Exercice 26
38) Ecrire une fonction qui permet la saisie dun tableau. Faite aussi laction principale qui permettra
daccder a cette fonction saisie mais aussi dafficher dans un second temps le rsultat
39)
40) Fonction : saisie (Stab : tableau dentiers, N :entier)
41) Var : i entier
42) Dbut :
43) Pour i de 0 n-1 faire
44) Lire (tab[i])
45) Fin
46)
47) Action principale
48) Var : tabl : Ttab
49) Dbut
50) Saisie (toto, 10)
51) Afficher (toto, 10)
52) Fin
53)
54) Ou afficher est la fonction de lexercice 1.
55)
56)
57)
58)
59)
A.BENHARI 107

60) Exercice 27
61) Ecrire une fonction qui calcule le nombre dinversion dun tableau de taille n (cest dire i<j et
tab[i]>tab[j] pour tout i et j.)
62)
63) Fonction inversion (tab : tableau dentiers, N entier)
64) Var : j, C, i entiers
65) Dbut
66) C<=0
67) Pour i de 0 n-2 faire
68) Dbut
69) Pour j de i+1 n-1 faire
70) Si tab[i]>tab[j] alors C<=C+1
71) Fin
72) Retourner ( C )
73) Fin
74)
75)
76) Exercice 28
77) Ecrire une action qui affiche les n premiers lments de la suite dfinie par u
0
=1 et u
n+1
=somme de k=0
jusqu' n de (u
k
*u
n-k
)
78) Aide : stocker les lments dans un tableau toto avec toto[0]=1. Puis on utilise une boucle imbrique
pour calculer toto[n+1]=somme k=0 k=n de toto[k]*toto[n-k].
79)
80) Action Suite (E : d :entier)
81) Var : toto : Ttab, i, k : entiers
82) Dbut :
83) Toto[0]<=1
84) Pour I de 1 d-1 faire
85) Toto[i]<=0
86) Pour k de 0 n-1 faire
87) Toto[i]<=toto[i]+toto[k]+toto[i-1-k]
88) Afficher (toto, d)
89) Fin
90)
91)
92) Exercice 29
93) Voyons maintenant quelques exercices rudimentaires de changements dans un tableau
94) Ecrire une action permettant de remplacer toutes les occurrences de x par y dans un tableau de taille n.
95) Ecrire un algorithme qui change les valeurs des cases i et j dans un tableau.
96) Ecrire un programme qui inverse un tableau. (exemple : 1 5 6 7 3 devient 3 7 6 5 1)
97)
98) Action : Remplacer (E : x : entier, E : y : entier, ES tab : tableau dentiers, E : n : entier)
99) Var : i :entier
100) Dbut
101) Pour i de 0 n-1 faire
102) Si tab[i]=x alors tab[i]<=y
103) Fin
104)
105)
106) Action : Echanger (E : i : entier, E : j : entier, ES : tab : tableau dentier, E : n :entier)
107) Var : temp
108) Dbut
109) Si i<n ET j<n alors
110) Temp<=tab[i]
111) Tab[I]<=tab[j]
112) Tab[j]<=temp
113) Fin
114)
115)
116) Action : inverser (ES : tab : tableau dentiers, E : n : entier)
A.BENHARI 108

117) Var : i :entier
118) Dbut
119) Pour i de 0 n/2 1 faire
120) Echanger (i, n-1-in tab, n)
121) {ou Echanger est la deuxime action de cet exercice}
122)
123) Fin
124)
125)
A.BENHARI 109

Entits : types structurs
1 Explications 1 :
2 Les types structurs sont :
- les tableaux (voir les exercices prcdents)
- les entits (ou lon regroupe plusieurs types sous un mme objet)
3
4 Exemple :
5 Etudiant (nom, groupe, note)
6 Type : Etd : entit (
7 Nom : chane de caractre ;
8 Groupe : caractre ;
9 Note : entier ;
10 ) ;
11
12 Pour faire appel ce type dentit on fera dans la fonction :
13 Var : Tetd toto ;
14 Toto.nom=alex
15 Toto.groupe=A
16 Toto.note=15
17 Ecrire ( ltudiant , toto.nom, du groupe , toto.groupe, a eu , toto.note)
18
19
20 Exercice 30
21 Proposer une entit de donnes pour stocker un point dans le plan
22
23 Type : Tpoint=Entit (
24 abs : entier ;
25 ord : entier ;
26 )
27
28
29 Exercice 31
30 Ecrire les en-ttes des fonctions/actions suivantes :
- saisie dun point
- affichage dun point
- calcul de la distance entre deux points
- projection dun point sur laxe des abscisses
31 Ecrire ensuite les algorithmes de ces fonctions.
32 Faire une action principale qui demande la saisie de deux points, calcule la distance entre ces deux points et
affiche les rsultats.
33
34 Action SaisieTpoint (S : P : Tpoint) {Tpoint a t dfini lexercice 30}
35 Dbut
36 Lire (P.abs)
37 Lire (P.ord)
38 Fin
39
40 Action AfficherTpoint (E : P : Tpoint)
41 Dbut
42 Ecrire ( ( , P.abs, ; , P.ord, ) )
43 Fin
44
45 Fonction distance (P : Tpoint ; Q : Tpoint) : rel
46 Var : dist : rel
47 Dbut
48 Dist<=sqrt[(P.abs-Q.abs) + (P.ord-Q.ord)]
49 Retourner (dist)
50 Fin
51
52 Action ProjectionX (ES : P : Tpoint)
A.BENHARI 110

53 Dbut
54 P.ord<=0
55 Fin
56
57 Action Principale
58 Var : P, Q : Tpoint
59 Dist : rel
60 Dbut
61 SaisieTpoint(P)
62 SaisieTpoint(Q)
63 Dist<=distance(P, Q)
64 Ecrire ( la distance entre ,AfficherTpoint(P), et , AfficherTpoint(Q), est , dist)
65 Fin
66
67
68 Explications 2:
69 Nous ne rentrerons pas ici le tableau comme nous lavons fait prcdemment :
70 Nous utiliserons les entits. Ainsi la dclaration se fera de la manire suivante :
71 Const MAX=100
72 Type : TtabVar=entit (
73 Tab : tab[MAX] dentier
74 Taille : entier
75 )
76
77 Ainsi, dans une fonction, on aura :
78 TtabVar : toto
79 Toto.tab[15]<=1 {pour entrer une valeur de tableau}
80 Toto.taille++ {On augmente la taille du tableau au fur et a mesure
81 Avantage de cette nouvelle manire dentrer un tableau : on peu avoir un tableau de taille variable.
82
83
84 Exercice 32
85 Ecrire un algorithme qui permet de rentrer les donnes dun tableau de type TtabVar et dont on connat la
taille.
86 Ecrire ensuite un algorithme qui permet de rentrer les donnes dun tableau de type TtabVar et ou lon ne
connat pas la taille.
87
88 Action saisieTtabVar (S : tabvar : TtabVar, E : n : entier)
89 Var : i : entier
90 Dbut
91 Pour i de 0 n-1 faire
92 Lire (tabvar.tab[i])
93 Tabvar.taille<=n
94 Fin
95
96 Action saisieTtabVar (S tabvar : TtabVar)
97 Var : rponse : chane de caractre
98 Dbut
99 Tabvar.taille<=0
100 Rpter
101 Ecrire ( voulez-vous entrer un entier ? )
102 Lire (rponse)
103 Si rponse non alors
104 Lire (tabvar.tab[tabvar.taille])
105 Tabvar.taille++
106 Jusqu (rponse= non ou tabvar.taille=MAX)
107 Fin
108
109
110
A.BENHARI 111

111
112 Exercice 33
113 Ecrire un algorithme qui permet de rentrer un tableau de taille variable de Tpoint (voir exercice 30 et 31).
Pour cela, il faudra au pralable crer un nouveau type dentit.
114
115 Const MAX=100
116 Type TtabVarPt=entit (tab : tableau[MAX] de Tpoint, taille : entier)
117
118 Action : SaisieTtabVarTpoint (S : tabvarPt : TtabVarTpoint)
119 Var : rponse : chane de caractre
120 Dbut
121 Tabvar.taille<=0
122 Rpter
123 Ecrire ( voulez-vous entrer un entier ? )
124 Lire (rponse)
125 Si rponse non alors
126 Lire (tabvarpt.tab[tabvarpt.taille].abs)
127 Lire (tabvarpt.tab[tabvarpt.taille].ord)
128 Tabvarpt++
129 Jusqu (rponse= non ou tabvar.taille=MAX)
130
131
132 Exercice 34
133 Ecrire un algorithme qui dtermine le point ( ( !) cest dire son indice)le plus au nord et le point le plus a
louest dans un tableau de Tpoint.
134 Faire ensuite une action principale qui demande la saisie dun tableau de Tpoint lutilisateur (voir
exercice 33) et affiche llment le plus au nord et llment le plus louest.
135
136 Action NordOuest (E : tvp : TtabVarPt, S : nord : entier, S : ouest : entier)
137 Var : i : entier
138 Dbut
139 Nord<=0
140 Ouest<=0
141 Pour i de 0 tpv.taille-1 faire
142 Si tvp.taille[i].abs<tvp.tab[ouest].abs) alors ouest<=i
143 Si tvp.taille[i].ord<tvp.tab[ouest].ord) alors nord<=i
144 Fin
145
146 Action Principale
147 Var toto : TtabVarPt ; n, o : entiers
148 Dbut
149 Saisie TtabVarTpoint (toto)
150 NordOuest (toto, n, o)
151 Ecrire ( llment le plus au nord est , AfficherTpoint(toto.tab[n])
152 {ou AfficherTpoint est la fonction de lexercice
31}
153 Ecrire( llment le plus louest est , AfficherTpoint(toto.tab[o])
154 Fin












A.BENHARI 112

155 Exercice 35
156 Ecrire un algorithme qui dtermine la distance maximale entre deux points dun tableau de Tpoint
157
158 Action DistMax (E : tvp : TtabVarPt)
159 Var : i, j : entiers ; Dmax, dist : reels
160 Dbut
161 Dmax<=0
162 Pour i de 0 tvp.taille-2 faire
163 Pour j de i+1 tvp.taille-1 faire
164 Dist<=distance(tvp.tab[i] ; tvp.tab[j])
165 Si dist>Dmax alors Dmax<=dist
166 Ecrire ( la distance maximale entre deux points du tableau est , Dmax)
167 Fin
A.BENHARI 113

Tableaux tris et dcoupages fonctionnels
Exercice 36
Le but de lexercice est de crer une action de saisie de tableau, qui trie, au fur et mesure des entres, les
valeurs par ordre croissant dans le tableau.
Exemple :
Soit le tableau suivant :
0 1 2 3
2 5 7 9
Comment insrer 6 dans le tableau tri (en supposant quil ny a pas de doublon dans le tableau) ?
- je cherche la bonne position (ici : la case dindice 2)
- dcalage droite si ncessaire :
0 1 2 3 4
2 5 7 7 9
- Insertion de llment
0 1 2 3 4
2 5 6 7 9

126) On a donc ici le dcoupage fonctionnel :
On va donc crer une fonction IndiceEltSup qui cherche la bonne position, une action Insrer qui inclue le
nombre entr dans la bonne case du tableau, et une action DcalageDroite qui dcale comme dans lexemple
toutes les cases dun rang vers la droite si ncessaire.

Const MAX=100
Type TtabVar = entit (tab : tableau[MAX] dentiers, taille : entier)

Fonction IndiceEltSup (tvt : TtabVar, entier, n : entier) : entier
Var : i : entier
Dbut
Tant que (itvt.taille ET tvt.tab[i]<n)
i<=i+1
retourner (i)
Fin

Action DcalageDroite (ES : tvt : TtabVar, E : i : entier)
Var : j : entier
Dbut
Pour j de tvt.taille 1 i par pas de 1 faire
Tvt.tab[j+1]<=tvt.tab[j]
Tvt.taille++
Fin

Action Insrer (ES : tvt : TtabVar, E : i : entier, E : i : entier)
Dbut
DcalageDroite (tvt, i)
Tvt.tab[i]<=i
Fin

Action SaisieTri (S : tvt : TtabVar)
Var : rep : chane, nb : entier, i : entier
Dbut
Tvt.taille<=0
Rpter
Ecrire (Rentrer encore un entier ?)
Lire (rep)
Si rep non alors
Lire (nb)
I<=IndiceEltSup(tvt, nb)
Si non(i<tvt.taille ET tvt.tab[i]=nb)
Insrer (tvt, i, nb)
Jusqu rep= non ou tvt.taille=MAX
Fin
A.BENHARI 114



Exercice 37
127) Faire un algorithme qui fait une recherche dichotomique dans un tableau tri. On pourra utiliser les
fonctions de lexercice prcdent.

Nous allons crer une action qui dfinie la zone de recherche, puis laction RechercheDicho qui oprera la
recherche dichotomique dans lintervalle dfinie par la zone de recherche.

Action ZoneRecherche (E : tvt : TtabVar, E : n : entier, ES : Binf : entier, ES : Bsup : entier)
Var : milieu : entier
Dbut
Milieu <= (Binf + Bsup)/2
Si tvt.tab[milieu]=n alors
Dbut
Binf<=milieu
Bsup<=milieu
Fin
Sinon
Si tvt.tab[milieu]>n alors Bsup<=milieu 1
Sinon Binf<=milieu+1
Fin

Fonction RechercheDicho (E : tvt : TtabVar, E : n : entier)
Var : Binf, Bsup : entiers
Dbut
Binf<=0
Bsup<=tvt.taille 1
Tant que Bsup>Binf faire
ZoneRecherche (tvt, n, Binf, Bsup)
Si Bsup=Binf alors
Retourner (Binf)
Sinon retourner ( -1)


Exercice 38
128) Faire un algorithme qui supprime une valeur dans un tableau tri. On pourra utiliser des fonctions des
deux exercices prcdents.

Le but est dutiliser la recherche dichotomique de lexercice prcdent pour trouver dans le tableau lindice de la
valeur que lon veut supprimer puis faire un dcalage gauche pour remettre en place les valeurs (sans quil y ait
de vide dans une case du tableau)

Action Supprimer (ES : tvt : TtabVar, E : n : entier)
Var : i : entier
Dbut
i<=RechercheDicho(tvt, n)
Si i -1 alors
DecalageGauche (tvt, i)
Fin

Action DecalageGauche (Es : tvt : TtabVar, E : i : entier)
Var : j: entier
Dbut
Pour j de i+1 tvt.taille 1 faire
Tvt.tab[j 1] <= tvt.tab[j]
Tvt.taille <= tvt.taille 1
Fin
A.BENHARI 115

Les Chanes
On va maintenant faire des exercices sur les chanes de caractres.
En pratique on pourra dfinir une chane de caractres de deux manires :

Const MAX entier = 100
Type Tchaine = entit ( tab : tableau[MAX] de caractres
Longueur : entier)

Ou bien :

Const MAX entier = 100
Type Tchaine = tableau [MAX] de caractres
{Avec la sentinelle END}


Exercice 39
Faire un algorithme qui dtermine la longueur dune chane de caractres.
Faire ensuite de deux manires diffrentes, une fonction qui permet de copier la chane dune source dans une
chane destination.

Fonction Longueur (chaine : Tchaine) : entier
Var i : entier
Dbut
i0
Tant que chaine[ i ] != END faire i i+1
Retourner (i)
Fin


Fonction de copie : premire mthode :
Fonction Copier (E : src : Tchaine, S : dest : Tchaine)
Var i, Lsrc : entier
Dbut
LsrcLongueur(src)
Pour i de 0 Lsrc faire dest[ i ]src [ i ]
Fin

Fonction de copie : deuxime mthode : plus optimise :
Fonction CopieOptimise (E : src : Tchaine, S : dest : Tchaine)
Var i : entier
Dbut
i0
tant que src[ i ] != END faire
dest [ i ] src [ i ]
i i+1
dest [ i ] src [ i] {pour copier en fin de fichier la sentinelle}
Fin













A.BENHARI 116

Exercice 40
Faire une fonction de concatnation (ajoute la fin de la premire chane de caractres le contenu de la deuxime
chane de caractres.)
Faire une fonction de Comparaison qui compare deux chanes de caractres suivant lordre lexicographique.
Faire une fonction qui efface une partie de la chane en spcifiant une longueur deffacement et un indice partir
duquel il faut effacer.

Action Concatnation (ES : src1 : Tchaine, E : src2 : Tchaine)
Var i, Lsrc1 : entiers
Dbut
i0
LsrcLongueur (src1)
Tant que src2 [ i ] != END
Src1[ Lsrc1+i] src2[ i ]
ii+1
src1[Lsrc1+i]src2[ i ]
Fin


Pour faire la fonction comparer, il faut dabord crer une fonction qui compare les caractres :
Fonction ComparerChar (char a, char b)
Dbut
Si a<b retourner (-1)
Si a=b retourner (0)
Si a>b retourner (1)
Fin

On peut maintenant faire la fonction de comparaison de chanes de caractres qui utilisera la fonction
ComparerChar :
Fonction Comparer (E : src1 : Tchaine, E : src2 : Tchaine)
Var i, L1, L2, cmp : entiers
Dbut
L1Longueur (src1)
L2Longueur (src2)
I0
Tant que (i<L1 ET i<L2 ET ComparerChar (src1[ i ], src2[ i ])=0) faire ii+1
Si i=L1 ou i=L2 alors
Si i<L1 alors cmp1
Sinon
Si i<L2 alors cmp -1
Sinon cmp0
Sinon cmpComparerChar(src1[ i ], src2 [ i ])
Retourner (cmp)
Fin


Fonction Effacer (ES : src : Tchaine, E : indice : entier, E : lg : entier)
Var i, Lsrc : entiers
Dbut
LsrcLongueur (src)
Pour i de indice+lg Lsrc faire
Src[i-lg]src[ i ]
Fin







A.BENHARI 117

Exercice 41
Ecrire len-tte dune action multi dcalage droite qui dcale droite les lments dune chane partir dun
certain indice et insre des cases vides la place. (des actions de multi dcalage ont dj t vue avec les
tableaux, on ne demande pas den refaire une ici, ce rfrer aux exercices sur les tableaux)
Faire une action dinsertion. On pourra pour cela utiliser au paravent la fonction multi dcalage droite
prcdente.
Faire une action de remplacement dune partie dune chane de caractres par une autre chane de caractres dont
la longueur nest pas forcment la mme. On pourra utiliser des fonctions des exercices 39 et 40.
Faire une fonction Extraire qui prend une partie de chane de caractres partir dun certain indice et la met dans
une chane destination.
Faire une fonction de recherche qui recherche une chane dans une chane de caractre et retourne un indice si
partir de cette case on a la chane cherche. Sinon, elle retourne 1.
Faire une action qui changent toutes les occurrences dune chane dans une chane de caractres par une autre
chane tampon.

Action MultidcalageDroite (ES : src : Tchaine, E : indice : entier, E : lg : entier)

Action Insrer (ES : src : Tchaine, E : indice : entier, E : motif : Tchaine)
Var i, Lsrc, Lmotif : entier
Dbut
LmotifLongueur(motif)
MultidcalageDroite (src, indice, Lmotif)
Pour i de 0 Lmotif-1 faire
src[indice+i]motif[ i ]
Fin

Action Remplacer (ES : src : Tchaine, E indice : entier, E lg : entier, E : motif : Tchaine)
Dbut
Effacer (src, indice, lg)
Insrer (src, indice, motif)
Fin

Fonction Recherche (src : Tchaine, motif : Tchaine, Binf : entier)
Var : i, Lsrc, Lmotif : entiers
Tampon : Tchaine
Dbut
LsrcLongueur (src)
LmotifLongueur(motif)
iBinf
Extraire (src, i, Lmotif, tampon)
Tant que (i<Lsrc Lmotif ET Comparer (tampon, motif)0) faire
ii+1
Extraire (src, i, Lmotif, tampon)
Si non(i=Lsrc Lmotif) alors retourner (i)
Sinon retourner (1)
Fin

Action RemplacarToutesChaines (ES : src : Tchaine, E : ancien : Tchaine, E : nouveau : Tchaine)
Var i , Lancien, Lnouveau, indice :entiers
Dbut
i0
LancienLongueur (ancien)
LnouveauLongueur (nouveau)
Indice Recherche(src, ancien, i)
Tant que indice -1 faire
Remplacer (src, indice, Lancien, nouveau)
iindice+Lnouveau
indiceRecherche(src, ancien, i)
Fin
A.BENHARI 118

Les fichiers
Rappelons tout dabord comment on manipule les fichiers en ASD.
On ne manipule que les identificateurs de fichiers. On ne se soucie donc pas des fichiers sources.

Pour ouvrir un fichier :
OuvrirFichier (IdFic, ModeOuverture)
Avec ModeOuverture = lecture ou criture ou rajout.

Pour fermer un fichier
FermerFichier (IdFic)

Pour lire un fichier
LireFichier (IdFic, lment) cela correspond Lire(n) cin>>n

Pour crire un fichier
EcrireFichier (IdFic, lment) cela correspond Ecrire(n) cout<<n


Exercice 42
Faire lalgorithme dune action qui lit un fichier dentiers et affiche tous les entiers de ce fichiers qui sont pairs.
Ecrire une action qui lit un fichier dentiers et met dans un autre fichier dentiers les valeurs paires.
129) Faire une fonction qui recherche un entier x dans un fichier dentiers et retourne vrai si x est dans le
fichier.

Action EntierPairs (E : Fic : fichier dentiers)
Var n : entier
Dbut
OuvrirFichier (Fic, lecture)
Si EtatFichier (Fic) = succs alors
LireFichier (Fic, n)
Tant que (EtatFichier (Fic) FdF) faire {ou FdF signifie Fin de Fichier}
Si n%2=0 alors Ecrire(n)
LireFichier(n)
FermerFichier (Fic)
Sinon Ecrire ( Erreur, impossible douvrir le fichier en lecture )
Fin

Action EntiersPairsFichier (E : f1 : fichier dentiers, ES : f2 : fichier dentiers)
Var n : entier
Dbut
OuvrirFichier (f1, lecture)
Si EtatFichier (f1) = succs alors
OuvrirFichier (f2, criture)
Si EtatFichier (f2) = succs alors
LireFichier (f1, n)
Tant que EtatFichier(f1)FdF faire
Si n%2=0 alors EcrireFichier(f2, n)
LireFichier (f1, n)
FermerFichier(f2)
Sinon crire ( Erreur en criture )
FermerFichier (f1)
Sinon crire ( Erreur en lecture )
Fin


Fonction Recherche (x : entier, f : fichier dentiers) : boolen
Var bool rep false
Dbut
OuvrirFichier (f, lecture)
Si EtatFichier(f)=succs alors
A.BENHARI 119

LireFichier(f, n)
Tant que (EtatFichier(f) FdF ET nx) faire
LireFichier(f, n)
Si n=x alors rep true
FermerFichier (f)
Sinon Ecrire ( Erreur en lecture )
Fin


Exercice 43
130) Faire une action de fusion de deux fichiers dentiers. Le fichier de sortie doit tre tri.

Action Fusion ( E : f1 : fichier dentiers, E : f2 : fichier dentiers, S : f3 : fichier dentiers)
Var : f3 : fichier dentiers
Dbut
OuvrirFichier (f1, lecture)
Si EtatFichier (f1)=succs alors
OuvrirFichier (f2, lecture)
Si EtatFichier (f2)=succs alors
OuvrirFichier (f3, criture)
Si EtatFichier (f3)=succs alors
LireFichier (f1, n1)
LireFichier (f2, n2)
Tant que (EtatFichier(f1) FdF ET EtatFichier(f2)FdF) faire
Si n1<n2 alors
EcrireFichier (f3, n1)
LireFichier (f1, n1)
Sinon
EcrireFichier (f3, n2)
LireFichier (f2, n2)
Si EtatFichier (f1) FdF alors
Rpter
EcrireFichier (f3, n1)
LireFichier(f1, n1)
Jusqu' EtatFichier(f1)=FdF
Si EtatFichier (f2) FdF alors
Rpter
EcrireFichier (f3, n2)
LireFichier (f2, n2)
Jusqu' EtatFichier (f2) = FdF
FermerFichier (f3)
Sinon crire ( Erreur en criture sur le fichier destination )
FermerFichier (f2)
Sinon crire ( Erreur de lecture sur le fichier f2 )
FermerFichier (f1)
Sinon crire ( Erreur en lecture sur le fichier f1 )
Fin













A.BENHARI 120


Exercice 44
Soit le type suivant :
Type : Tetd = entit ( Nom : chane
Numro : tudiant
Notes : tableau [5] dentiers
Moyenne : entier)
On suppose que la fonction de saisie
Fonction SaisieEtd () : Tetd
131) Permettant de saisir un tableau de Tetd existe. On pourra donc sen servir

Ecrire une fonction qui permet de saisir un groupe dtudiant dans un fichier.
Ecrire une fonction qui permet de calculer la moyenne gnrale dun groupe dtudiant.


Action SaisieGroupe (E : nb : entier, S : Fic : fichier de Tetd)
Var : etd : Tetd i : entier
Dbut
OuvrirFichier (fic, criture)
Si EtatFichier (fic)=succs alors
Pour i de 1 nb faire
EtdSaisieEtd( )
EcrireFichier (fic, etd)
FermerFichier (fic)
Sinon crire ( Erreur )
Fin

Fonction Moyenne (fic : fichier de Tetd ) : rel
Var : Som : rel
Dbut
Som0
nb 0
OuvrirFichier (fic, lecture)
Si EtatFichier (fic)=succs alors
LireFichier (fic, etd)
Tant que EtatFichier (fic)FdF) faire
nbnb+1
SomSom + etd.moyenne
LireFichier(fic, etd)
Retourner (Som/nb)
FermerFichier (fic)
Sinon crire ( Erreur )
Fin

Bibliographie
[1] T. H. Cormen, C. E. Leiserson, and R. L. Rivest . Introduction to Algorithms. The MIT Press, 1990
[2] A. Darte and S. Vaudenay. Algorithmique et optimisation Dunod 2001
[3] D. Froidevaux, M. Gaudel, and D. Soria. Types de donnes et algorithmes . Mcgraw-Hill, 1990
[4] Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest and Clifford Stein.
Introduction to Algorithms, Third Edition. The MIT Press Cambridge, Massachusetts London,
England , 2009

You might also like