You are on page 1of 120

ABDELKADER BENHARI ABDELKADER BENHARI ABDELKADER BENHARI ABDELKADER BENHARI

L’ALGORITHMIQUE L’ALGORITHMIQUE L’ALGORITHMIQUE L’ALGORITHMIQUE




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 matières
INTRODUCTION A L’ALGORITHMIQUE ........................................................................................................ 4
- Analyse
- Algorithme
- Squelette d’un algorithme
- Elément de base
- Schémas algorithmique
APPLICATION ............................................................................................................................................... 13
DEFINITION DES VARIABLES ....................................................................................................................... 14
- Variable destinée au calcul
- Variable non destinée 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
- Procédure
- Fonction
LES CHAINES DE CARACTERES .................................................................................................................... 22
- Définition
- Concaténation
- Conversions
- Longueur d’une chaîne
- Sous chaîne d’une chaîne
NOTION DE TABLEAU (OU TABLE OU VECTEUR OU MATRICE ARRAY) ............................................. 24
- Définition
- Déclaration du tableau
- Mise à l’état initial
- Recherche de donnée dans un tableau
LES METHODES DE TRI USUELLES .............................................................................................................. 28
- Tri par insertion
- Tri par sélection
- Le tri bulle
- Le tri de shell
- Tri de shell-Metzner
- Tri par vecteur d’indice
- Tri par monotonie
LA RECURSIVITE ........................................................................................................................................... 35
- Définition
- Principe
LES FICHIERS ................................................................................................................................................. 37
- Définition
A.BENHARI 3

- du fichier
- Notion d’enregistrement
- Déclaration des fichiers en algorithme
- Instruction de manipulation des fichiers
- Application sur les fichiers séquentiels
- Les fichiers à accès direct
- Les fichiers texte
ALGORITHMES ET STRUCTURE DE DONNEES ........................................................................................... 44
- Les structures arborescentes
- Graphes
- Problème de la recherche
- Problème du tri
- Quicksort
- Heapsort
ALGORITHMES NUMERIQUES .................................................................................................................... 58
- Généralités
- Systèmes linéaires Ax=b : méthodes 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
- Méthode Jacobi
- Méthode Gauss-Seidel
- Méthode de relaxation
- Méthodes du gradient
PROBLEMES AU MOINDRES CARRES (LINEAIRE) ...................................................................................... 79
- Régression linéaire
- Méthode des équations normales
RESOLUTION DES EQUATIONS NON LINEAIRES ....................................................................................... 81
- Méthode de dichotomie
- Généralités
- Valeurs propres et vecteurs propres
APPROXIMATION POLYNOMIALE & INTEGRATION NUMERIQUE .......................................................... 85
- Approximations polynomiales
ÉQUATIONS DIFFERENTIELLES .................................................................................................................... 89
- Généralités
- Méthode de résolution numérique
- Méthode de Euler
- Méthode du développement de Taylor
- Méthode de Runge - Kutta
EXERCICES CORRIGES .................................................................................................................................. 92
BIBLIOGRAPHIE ......................................................................................................................................... 120

A.BENHARI 4




L’ALGORITHMIQUE L’ALGORITHMIQUE L’ALGORITHMIQUE L’ALGORITHMIQUE


I. INTRODUCTION A L’ALGORITHMIQUE

Qu’est ce qu’un algorithme ?
"Une suite finie de règles à appliquer dans un ordre déterminé à un nombre fini de données
pour arriver, en un nombre fini d'étapes, à un certain résultat, et cela indépendamment des
données".
Encyclopaedia universalis

I.1. Analyse
Définition
La décomposition d’un problème en sous problèmes, ensuite des sous problèmes en sous
problèmes, on arrive ainsi à des problèmes non décomposables, ou à des tâches élémentaires.
Ces tâches élémentaires ordonnées forment la succession des étapes qui permettent à partir
d’une situation initiale d’aboutir à une situation finale qui représente la solution du problème
de départ. Une première solution peut être rédigée dans un langage non formel (en français
par exemple), ensuite traduite dans un langage formel (algorithme), à partir duquel il est
possible d’écrire un programme dans un langage de programmation et de l’exécuter sur une
machine.
Démarche de décomposition
Nous allons détailler un exemple qui montre la démarche de décomposition et comment
arriver à résoudre un problème sans faire autre chose que de l’exprimer par des problèmes
plus petits.
Le problème initial : un individu se trouve devant une voiture et doit la faire démarrer.

Entrer dans la voiture
Démarrer la voiture

Ouvrir la portière
Monter
Fermer la portière

Faire fonctionner la voiture
Démarrer la voiture

Mettre la clé dans le contact
Faire un quart de tour, les voyants doivent s’activer
Continuer à tourner la clé jusqu’à ce que la voiture émette un bruit indiquant
l’état de marche normal
A.BENHARI 5


Appuyer sur la pédale d’embrayage
Enclencher la première vitesse
Désactiver le frein à main
Actionner doucement le démarreur et relâcher progressivement l’embrayage.

La solution finale est exprimée par les tâches se trouvant en bas du schéma. Cette succession
de tâches s’appelle un algorithme mais il est ici exprimé dans un langage non formel.
La situation initiale : individu, et voiture ouverte (non verrouillée).
La situation finale : individu dans la voiture et voiture en état de marche.

L’algorithme a besoin de certains renseignements externes pour pouvoir fonctionner
correctement (voyants, bruit que fait la voiture…etc.)
La solution est donnée dans le cas où il n’y a aucun problème, supposons maintenant que la
voiture ne veut pas démarrer où qu’une fois démarrée, le conducteur cale ! Que faire ? Il est
clair que notre algorithme ne répond plus à la question, et qu’il faut l’améliorer pour qu’il
marche dans toutes les situations possibles.
Nous allons réécrire notre algorithme.
Entrer dans la voiture
Démarrer la voiture

Ouvrir la portière
Monter
Fermer la portière

Faire fonctionner la voiture
Démarrer la voiture

Si le conducteur a la clé alors
Tant que la voiture n’est pas en état de fonctionnement normal il faut
Début
Mettre la clé dans le contact
Faire un quart de tour, les voyants doivent s’activer
Continuer à tourner la clé jusqu’à ce que la voiture émette un
bruit indiquant l’état de marche normal
Si la voiture ne démarre pas alors
Retourner la clé dans le sens contraire
Reprendre à : Mettre clé dans contact
Fin
Appuyer sur la pédale d’embrayage
Enclencher la première vitesse
Désactiver le frein à main
Actionner doucement le démarreur et relâcher progressivement
l’embrayage.
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
Définition
Un algorithme est rédigé dans un pseudo-langage et destiné à une machine abstraite
(virtuelle). Il permet de décrire formellement toutes les étapes nécessaires qui à partir d’une
situation initiale, permettent d’aboutir à une situation finale. Cette dernière constitue la
solution qui résout un problème donné.
Le langage algorithmique est précis, et suit des règles qui seront décrites tout au long de ce
document.
Démarche : Problème, analyse, algorithme
Pour illustrer la démarche qui permet d’écrire un algorithme nous allons traiter des exemples
concrets
1
er
exemple : Somme de deux entiers
Soit le problème formulé dans les termes suivants : écrire un algorithme qui calcule la somme
de deux entiers, et affiche le résultat à l’écran.
Le problème ici est simple, il s’agit de calculer la somme de 2 entiers. Le problème ne précise
pas où trouver les deux entiers, il est alors possible de supposer que les deux entiers seront
donnés par l’utilisateur, ce dernier dialogue avec la machine par l’intermédiaire du clavier.
On dit alors que les deux entiers seront saisis au clavier. L’énoncé ne précise pas non plus que
faire du résultat, on suppose alors que ce dernier sera affiché sur l’écran.

Voici le schéma qui résume notre problème.


Figure Erreur ! Il n'y a pas de texte répondant à ce style dans ce document.-1
Deux données seront à l’entrée d’une boîte qui réalise le calcul et fournit en sortie la somme
de ces deux données.
En algorithmique, il est fréquent de parler d’entrée et de sortie.
o Les données d’un algorithme sont appelées entrées : elles sont à la base du traitement
des algorithmes.
o Les résultats d’un algorithme sont appelés sorties : elles sont le fruit des traitements
faits par les algorithmes et fournissent une réponse au problème posé.
Donnée 2
Résultat
Calcul de Somme
Donnée 1
A.BENHARI 7

La boîte de la figure Figure Erreur ! Il n'y a pas de texte répondant à ce style dans ce document.-1
représente ce que nous allons appeler par la suite un processus de calcul. Ce processus réalise
un traitement simple, qui est le calcul de Donnée 1 + Donnée 2. Une fois le résultat obtenu il
sera affiché sur l’écran.
La totalité du schéma est le processus général et c’est ce qu’il faut concrétiser par un
algorithme.
Pour écrire cet algorithme nous avons besoin de :
1. Accepter Donnée 1 et la stocker,
2. Accepter Donnée 2 et la stocker,
3. Calculer Donnée 1 + Donnée 2,
4. Stocker le résultat,
5. Afficher le résultat sur l’écran.
Nous avons ainsi décomposé le problème comme expliqué dans la section 0, les tâches
numérotées de 1 à 5 sont en fait l’algorithme écrit en langage non formel. Il est possible de
noter ici, que chaque problème possède la solution dans sa décomposition.
Nous allons le traduire dans un langage algorithmique formel, et nous expliquerons les
différents mots-clés utilisés au fur et à mesure.
Algorithme Somme
Variables
Donnée1, Donnée2, Résultat : entier
Début
Ecrire (Donner la donnée numéro 1 )
Lire Donnée1
Ecrire (Donner la donnée numéro 2 )
Lire Donnée2
Résultat = Donnée1+Donnée2
Ecrire (La somme est : Résultat)
Fin

I.3. Squelette d’un algorithme
Algorithme NomDeLAlgorithme
VAR
//Déclaration de variables manipulés par l’algorithme
Donnée1, Donnée2, Résultat : entier
Début
//Corps de l’algorithme constitué par les expressions
Fin
Un algorithme est défini par un entête donnant le nom de l’algorithme, généralement
explicite. L’entête est suivie par une partie déclarative permettant de définir toutes les
données qui seront utilisées par l’algorithme. Par la suite entre deux mots-clé Début et Fin,
nous retrouvons le corps de l’algorithme qui sera constitué par les différentes expressions
permettant de résoudre le problème.
I.4. Eléments de base
Types
Les types permettent de donner un domaine de définition aux objets manipulés par un
algorithme, par exemple des données nécessaires pour un calcul seront définies dans le
domaine des réels ou des entiers, un message affiché sera défini dans le domaine des
caractères alphanumériques…etc.

A.BENHARI 8

Il existe 5 types de base en langage algorithmique de programmation :
Les entiers : définis dans le domaine des entiers naturels et les entiers relatifs.
Les réels
Les caractères : définit tout ce qui est caractère alphanumérique, « a ».. « z », « 1 ».. « 9 »
ainsi que les caractères spéciaux, caractères de ponctuation, etc…
Les chaînes de caractères : un assemblage de caractères forme une chaîne.
Les booléens : un booléen permet de définir une donnée qui ne peut prendre qu’un avaleur
entre deux : vrai ou faux, ou bien 0 ou 1.
Variables
Les variables servent à déclarer des objets nécessaires au bon fonctionnement d’un
algorithme. Les variables doivent être définies avant leur utilisation, en général en dessous de
l’entête de l’algorithme dans une partie qui peut être distinguée par le mot clé VAR. Elles sont
définies grâce à l’un des cinq types de base et peuvent accepter une valeur de début appelée
valeur initiale.
Exemple :

Algorithme Exemple

VAR
Donnée1 : entier
Donnée2 : entier
Car : caractère
Message : Chaîne de caractères
VraiOuFaux : booléen
Début
// Initialisation des différentes variables
Car ‘A’
VraiOuFaux Faux
Donnée1 10
Donnée2 20
.
.
.
Fin

L’initialisation des variables permet de donner à ces dernières une première valeur. Il n’est
pas interdit de changer cette valeur par la suite que ce soit par l’intermédiaire :
o d’une autre affectation,
o d’une expression de calcul,
o d’une lecture au clavier.
Constantes
Les constantes sont des données initialisées qui ne changent jamais de valeur pendant toute la
durée de l’algorithme. Elles peuvent seulement être lues, utilisées pour un traitement,
affichées mais jamais modifiées

Algorithme Circonférence
Constantes
PI = 3,14
VAR
Circonférence : réel
Rayon : réel

A.BENHARI 9

Début
Ecrire (Donner le rayon du cercle)
Lire Rayon
Circonférence PI * (Rayon)²
Ecrire (La circonférence de votre cercle est : Circonférence)
Fin.
Dans cet algorithme PI ne peut qu’être utilisée telle quelle, elle ne peut pas être modifiée
d’une façon quelconque.
Déclaration
La déclaration sert à introduire la donnée (variable ou constante)qui sera utilisée par
l’algorithme. Lors de la déclaration d’une donnée il est nécessaire de lui donner un type, et il
est parfois possible de lui affecter une valeur de départ. Pour les constantes, la valeur de
départ est obligatoire.
Il existe deux manières de déclarer une variable en pseudo-langage.
NomDeLaVariable [: type de la variable]
Ou bien
[Type de la variable] NomDeLaVariable < Valeur de départ>
Remarque : Il est conseillé de garder le même type de déclaration dans le même algorithme.
Exemples :
V1 : entier //Déclaration de V1 de type entier
Entier V2 0 //Déclaration de V2 de type entier avec une valeur initiale égale à 0
Entier V3 //Déclaration de V3 de type entier sans valeur initiale
Il est aussi possible de faire des déclarations « groupées ».
Entier V1, V2, V3 // Déclaration de trois variables de type entier par le biais d’une même
instruction.
Initialisation
L’initialisation d’une variable revient à une affectation d’une première valeur avant toute
autre utilisation de cette variable. Les instructions d’initialisation peuvent figurer n’importe
où dans l’algorithme, et pas nécessairement au début.
Opérateurs
Les opérateurs permettent de modifier des valeurs de données à l’intérieur des expressions.
Nous allons distinguer entre trois types d’opérateurs en algorithmique. Le type d’une donnée
détermine le type des opérateurs qui peuvent lui être appliqués.
Remarque : certains langages de programmation possèdent des opérateurs spéciaux.
Opérateurs arithmétiques
Les opérateurs arithmétiques sont tous utilisés en algorithmique pour écrire des expressions
arithmétiques pouvant être affectées à des variables numériques. Par exemple pour modifier
certaines valeurs il est nécessaire d’utiliser des opérateurs.
Remarque : Il est aussi possible d’utiliser l’opérateur + pour modifier des chaînes de
caractères.
+ : permet les additions
- : permet les soustractions.
* : permet la multiplication
/ : permet la division
% ou modulo : le reste de la division entière
A.BENHARI 10

Opérateurs logiques
Les opérateurs logiques sont utilisés pour affecter ou modifier les valeurs des données de type
booléen. Il en existe trois :
o NON : appelé Non logique, c’est un opérateur unaire,
o OU : opérateur binaire appelé Ou logique,
o ET : opérateur binaire appelé Et logique.
Les trois tableaux ci-dessous résument les tables de vérité des opérateurs logiques :

Et Vrai Faux
Vrai Vrai Faux
Faux Faux Faux

Ou Vrai Faux
Vrai Vrai Vrai
Faux Vrai Faux

Non Vrai Faux
Faux Vrai
Opérateurs relationnels
Les opérateurs relationnels permettent de comparer des expressions entre elles, le résultat sera
une expression logique : vraie ou fausse. Ces opérateurs peuvent comparer entre les types
numériques, les types caractères et les types chaînes de caractères.
<
<=
=
>
>=
<>
Opérateur Type numérique Type alphanumérique Type chaîne
<= 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 étudiées dans les sections
suivantes sous la dénomination de schémas algorithmiques.
Définition
Une variable ou une constante est une expression.
Les expressions peuvent être combinées grâce aux opérateurs 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 procédure.
Les expressions constituent les instructions algorithmiques.

I.5. Schémas algorithmiques
Schéma algorithmique simple
Affectation
L’affectation est l’expression de base en algorithmique, elle permet d’associer une valeur
quelconque à une variable de l’algorithme. Il est clair que la valeur doit être du même type
que la variable.
L’affectation comprend 2 parties séparées par le symbole d’affectation « » :
o une partie gauche appelée aussi valeur de gauche et constituée par une variable, c'est-
à-dire un objet qui peut prendre une valeur,
o une partie droite ou valeur droite constituée par une « expression » pouvant être
évaluée.

VAR
V1 : entier
V2 : réel

Début
V1 10.5 // Affectation erronée
V1 10 // Affectation correcte, on dit que V1 reçoit la valeur 10
V2 32.5 // Affectation correcte, V2 reçoit 32.5
V2 10 // Affectation correcte, les réels englobent les entiers naturels
V2 25/2 // Affectation correcte, V2 recevra le résultat du calcul de 25 divisé par 2
Fin
Lecture de données
Une autre manière d’accorder des valeurs à des variables est de faire ce qu’on appelle une
lecture de données. La lecture se fait à partir d’un dispositif d’entrée, en l’occurrence un
clavier. On l’appelle aussi saisie ou entrée de données. Ce procédé est utilisé à chaque fois
qu’une valeur est requise par l’algorithme et que cette valeur ne peut être donnée que par
l’utilisateur, c'est-à-dire la personne qui utilise le programme. Bien sûr dans un algorithme il
n’y aura pas de véritable saisie à partir du clavier mais seulement une simulation de la saisie.
L’algorithme simule une demande de donnée à l’utilisateur et l’accepte pour la stocker dans
une variable.
Plus tard, l’algorithme sera traduit par un programme, le programme sera compilé et les
instructions qui seront exécutables par une machine demanderont une saisie réelle de la part
de l’utilisateur. Ce dernier devra taper une donnée du type requis au clavier et valider sa
réponse par un retour chariot.
La syntaxe permettant de lire une donnée est la suivante :
Lire NomDeLaVariable

Ecriture de données
L’écriture de données permet un autre type d’interaction avec l’utilisateur : la sortie de
messages ou de résultats à l’attention de ce dernier. L’écriture se fait sur un dispositif de sortie
tel que l’écran ou l’imprimante par exemple.
A.BENHARI 12

La syntaxe communément adoptée est la suivante :
Ecrire « Message »
Ecrire Valeur
Incrémentation
L’incrémentation est une expression particulière qui permet d’augmenter la valeur d’une
variable d’une certaine quantité à la fois.
V1 V1 + 1
V2 V2 + 2
Décrémentation
La décrémentation permet de réduire la valeur d’une variable.
V1 V1 - 1
V2 V2 - 2
Schéma algorithmique conditionnel
Un schéma algorithmique conditionnel donne à l’algorithme la possibilité d’aller dans un sens
plutôt que dans un autre. Une condition est évaluée, et à partir du résultat de cette évaluation
un choix est fait.
































A.BENHARI 13



II. Application

Ennoncé de EXAM1 : on fait passer un examen à des étudiant et l’on veut déterminer ceux qui
sont admis . Il y a 3 matières : math (coef 3), français (coef 2) et informatique (coef 5).
Les notes peuvent aller de 0 à 20. Il y a admission à la condition d’obtenir la moyenne
c'est-à-dire 10 sur 20.

Réalisation des spécifications :
3 matières :
maths 3
français 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

Réalisation d’un organigramme de programmation ou ordinogramme



Réalisation de l’algorithme
algo exam1 ()
Début
Entrée des notes
Calculé le total
Si total >= 100
Admis
Ajourné
FIN
Non Oui
A.BENHARI 14

/* déterminer admis ajourné*/
/* 0<= notes <= 20 */
const
entier coefmath 3
entier coeffran 2
entier coefinfo 5
var locales
réel fran, math, info, total
début
afficher (« Entrez la note de math = » )
saisir (math)
afficher (« Entrez la note de français = » )
saisir (fran)
afficher (« Entrez la note d’informatique = » )
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. Définition des variables
2 types de variables

a. Variable destiné au calcul
Entier : peut contenir un nombre entier entre -32 768 et 32 767. Représentation binaire pure
en machine
Réel : tous les nombres dont les entiers. Représentation virgule flotante.
0,3458.10
4
(mentis et caractéristique)
Logique ou booléen :
2 valeurs : vrai et faux

var locales
logique homme
début
si homme ou si homme = vrai
alors
afficher (« c’est un homme. »)





b. Variable non destiné au calcul
car : un symbole
chaîne (longueur) : chaîne de charactère
A.BENHARI 15


ex :
chaîne (15) phrase
….
Phrase « il y a des nuages »

IV. Entrée de données dans la machine
saisir (nom_variable)

V. Affichage de résultats
afficher (« libellé1 », var1, « libellé2 », var2, …)

VI. Calculs
Symbole d’affectation
total math*3 …
Règle hiérarchique des opérateurs :
- puissance : **
- multiplication et division : * et /
- addition et soustraction : + et –
Les parenthèse peuvent changer la hiérarchie des opérations. Réalisation des opérations dans
la parenthèse la plus interne.

VII. Conditions
Exécution séquentielle des instructions des programmes

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





A.BENHARI 16

VIII. Les structures répétitives


Pour que le programme ne boucle pas indéfiniment, il faut continuellement inclure à
l’intérieur de la boucle une instruction capable de modifier la valeur de l’expression testé.


Différentes façon de programmer une boucle :
Lors d’un dialogue clavier/écran = question posé à l’opérateur
Autres traitement ? (oui/non)
Réponse de l’opérateur variable = réponse

Analyse du problème : faire n addition de 2 nombre
c a + b


tant que réponse = « oui » si non
faire
calculer 1 addition
autre calcul ? (oui/non)
saisir la réponse
fin tant que

prog
Début


Calculer 1 addition

(c fois)


fin
Saisie de a et b

Addition

Affichage du résultat

question
A.BENHARI 17



Entrez impérativement dans la boucle : réponse « oui »
Entrez conditionnelle dans la boucle suivant opérateur :
Afficher (calcul ? (oui/non))

algo rep1()
var locales
entier a, b, c
chaîne (3) reponse
début
afficher (« Voulez-vous faire un calcul ? (oui/non) »)
saisir (réponse)
c a + b
tant que réponse = « oui »
faire
afficher (« entrez a et b »)
saisir (a, b)
c a + b
afficher (« résultat= », c)
afficher (« autre addition ? (oui/non) »)
saisir (réponse)
fin tant que
fin

A l’aide d’une marque de fin de travail
algo rep2()
var locales
entier a, b, c
début
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 (« résultat= », c)
afficher (« Entrez a ou -1 pour terminer.»)
saisir (a)
fin tant que
fin








A.BENHARI 18

a. A l’aide d’un compteur
Par incrémentation ou décrémentation

i. Par décrémentation
algo rep3()
var locales
entier a, b, c, i
début
afficher (« Entrez le nombre d’addition à faire.»)
saisir (i)
tant que i > 0
faire
afficher (« entrez a et b »)
saisir (a, b)
c a + b
afficher (« résultat= », c)
ii-1
fin tant que
fin

ii. Par incrémentation
algo rep4()
var locales
entier a, b, c, I, cpt
début
afficher (« Nombre d’addition.»)
saisir (i)
cpt0
tant que i > 0
faire
afficher (« entrez a et b »)
saisir (a, b)
c a + b
afficher (« résultat= », c)
cptcpt+1
fin tant que
fin













A.BENHARI 19

IX. Les procédures et les fonctions (sous-
programme)


Raison des sous programmes :
- réutilisabilité
- lisibilité du programme
- facilité de maintenance
- facilité de mise au point



P1 : entrée
P2 : entrée-sortie
P3 : sortie

A.BENHARI 20



Une fonction ne retourne qu’une valeur, ses paramètres doivent être exclusivement d’entrée
(passage par valeur uniquement)

Entrée = passage de paramètre par valeur
Entrée-sortie et sortie : passage par référence

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














A.BENHARI 21

a. Procédure
Est un sous ensemble indépendant où faisant partie d’un programme principale. Elle
communique avec des paramètres entrée-sortie, sorties.
Exemple : soit calcul de la somme de 2 nombres : c a + b


procédure somme (a, b, c)
val entier a
val entier b
ref entier c

début
ca+b
fin

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

début
afficher (« Entrez une valeur pour x »)
saisir (x)
afficher (« Entrez une valeur pour y »)
saisir (y)
somme (x, y, z)
afficher (« Le résultat est », z)
fin

b. Fonction
Une fonction est une sous partie d’un programme qui retourne 1 valeur donc une fonction
possède un type.
Elle ne doit posséder que des entrés.

Doit contenir la commande retourne (constante, variable, expression arithmétique)






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

val entier a
val entier b
var locales
entier c
début
ca+b
retourne (c)
fin

début
retourne (a+b)
fin


programme principal
algo fpp()
var locales
entier a, b
début
afficher (« entrez a et b »)
saisir (a,b)
afficher (« Résultat », fsomme (a,b))
fin

X. Les chaînes de caractères
a. Définition
C’est un ensemble de caractères affichable. On utilise un code ISO (ASCII) codant 0 – 127
caractère texte et 128 – 255 caractères graphiques
- 0 – 31 caractère de contrôle du terminal
- 48 – 57 chiffre
- 65 … A, B
- 97 … a, b

caractère alphabétique numérique spéciaux

Une chaîne de caractère = caractère concaténé

b. Concaténation
Mise bout à bout de caractère pour former une chaîne
Mise bout à bout de plusieurs chaînes

Opérateur de concaténation = +
y = « il fait chaud » // pas de sémantique
z = « xyaZb2 »
a = « il »
b = « fait »
c = « froid »
d = « chaud »
e = « humide »

y = a + b + d


A.BENHARI 23

c. Conversions
i. Conversions d’une chaîne en entier
Fonction chaînant

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 d’un entier en chaîne
Ent chaine (entier) retourne une chaîne

d. Longueur d’une chaîne
Définition de la chaîne
var locales
chaine (12) a

Longueur effective de la chaîne
= Longueur de l’espace utilisé
longueur (chaine) retourne un entier

ex : l longueur (a)

e. Sous chaîne d’une chaîne
z = « Il fait chaud »
temperature milieu (z, 9, 5)
température = « froid »

milieu (chaine, num départ, nombre à partir de départ)



A.BENHARI 24

XI. Notion de tableau (ou table ou vecteur ou
matrice array)
a. Définition

Un tableau est un ensemble de valeurs de même type

Types :
- prédéfinis = entier, réel, logique, caractère, chaîne
- construits = structuré, énuméré

Ex d’un tableau d’entier
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 l’élément 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. Déclaration 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 chaînes de caractères de 22 caractères
chaine (22) t
2
[1 … 50]

i. Tableau à 1 dimension
On peut le considérer comme linéaire
On le remplie avec 1 et 1 seul indice
(vecteur)
Chaque élément est identique

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

On peut considérer qu’il s’agit d’une nature contenant l lignes et c colones

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

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

Du plus haut niveau au plus bas niveau

c. Mise à l’état initial
Mettre les données dans un tableau correspond au chargement des données dans le tableau.
RAZ, RAB, VRAI / FAUX
- Transfert de variables
- Transfert d’autre tableau
- Saisie
- Donnés de fichiers

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

début /* -1 pour fin*/
afficher (« entrez un numéro de ligne »)
saisir (l)
tant que l <> -1
faire
afficher (« entrez un numéro de colone »)
saisir (c)
afficher (« entrez une valeur pour », l, c)
saisir (t
1
[l,c])
afficher (« Entrez un numéro 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 donnée dans un tableau
i. Recherche par le rang

Ex : afficher (t
1
[3])

ii. Recherche séquentielle
1. Sans erreur possible
A.BENHARI 26

C'est-à-dire élément cherché se trouve toujours dans le tableau


2. Avec erreur possible
En italique dans sch précédent.
∈t
1
(0,1)
∉t
1
(0,1)

procédure rechseq (t
1
[], n atrouve)
ref entier t
1
[1..n]
val entier n
val entier atrouver
var locales
entier i
logique trouve
début
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 (« l’élément », atrouve, « se trouve en », i, « positions »)
sinon
afficher (« erreur »)
fin si
fin


iii. Recherche dichotomique
Attention : Cas particulier pour tableau triées

algo
Début
Tableau à trouver

Trouver 1 élément
du tableau (t fois)

∈t
1
(0,1)
∉t
1
(0,1)

fin
Début traitement


Trouvé (0,1)


Trouvé (0,1)

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

Principe
Soit un tableau d’une 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



procédure 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


début
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
procédure
Début


Traiter 1 élément
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 méthodes 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 élément au suivant de la liste si cet élément à une valeur inférieur, il reste en
place sinon il est échangé avec celui qui est de valeur inférieur, il s’agit donc pour chaque
élément du tableau de lui ménager une petite place parmi ceux qui sont déjà trié en décalant
vers le haut ceux qui sont plus grand que trié.


ii. Algorithme
procédure tri insère (tab [], n)
réf TIND tab [1..n] TIND correspond à un type indéterminé
valeur entier n
var locales
entier i,j
TIND temp
logique fin





début
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 sélection
i. Principe
A chaque itération, on choisi le plue petit élément parmi ceux qu’il reste à trier et on le met à
sa place.

ii. Algorithme
procédure trisélection (tab [], n)
ref TIND tab [1..n]
val entier n
var locales
TIND petit
entier i, ipetit, j
début
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 méthode conduit à peu de décalage. Elle est pourtant moins rapide que la précédente.

c. Le tribulle
i. Principe
On parcoure le tableau autant de fois qu’il le faut en comparant les éléments qui se suivent et
en les échangeant s’ils ne sont pas dans le bonne ordre. A chaque passage, on peut enlever 1 à
n puisque l’on trouve le dernier du tableau à trier.

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




début
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
L’un des plus mauvais trie si les données sont très dispersées par contre, il peut très bien
convenir pour remettre en ordre des données peu triés.

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

Pour limiter les déplacements , on choisi de comparer des éléments du tableau dans des
parties de tableau. On choisi au départ des parties d’un pas égale à la moitié de la taille du
tableau, chaque éléments de la première moitié est comparé à un élément de la seconde. S’il
ne sont pas dans le bonne ordre, ils sont échangé puis on diminue le pas en continuant à
comparer des éléments dont la distance est égale au pas. De cette façon, les éléments traités
sont d’abord 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
Méthode plus efficace que la précédente dans les cas d’une grande dispersion.

e. Tri de shell-Metzner
i. Principe
Même 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 réputé plus rapide que tous les précédant

f. Tri par vecteur d’indice
i. Principe
Méthode ne manipulant pas directement les éléments du tableau mais utilisation d’un vecteur
d’indice qui joue le rôle 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

Après 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

Résultat : -30, 1, 2, 25, 45, 50

ii. Algorithme
(Avec tri par sélection)

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 méthode est très intéressante pour manipuler des fichiers de grande taille, on peut donc
les trier sans déplacer l’ordonnée.

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 d’entre 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
début
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
début
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]
début
i31
tant que i3 <> 0
faire
séparation (t1[], t2[], t3[], i1, i2, i3)
si i3 <> 0
alors
fusion (t1[], t2[], t3[], i1, i2, i3)
finsi
fintant
fin

XIII. La récursivité
a. Définition
On appelle fonction récursive une procédure ou une fonction qui s’appelle elle même.

Fonction entier fn(a)
Si condition d’arrêt
-
-
-
retourne (fn(a))
fin

Cette approche permet de simplifier l’écriture de certain programme comme les listes chaînés
et les arbres.
Elle n’est pas souhaitable pour tout les programmes
Elle n’est jamais la meilleur solution du point de vue temps de traitement et de la place
occupé en mémoire.
Dès la construction de l’algorithme, il faut prévoir une action de fin d’appel (pour ne pas voir
le programme bouclé indéfiniment).

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

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



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

algo factorielle ()
var locales
entier n
début
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
début
si n = 0
alors
retoune0
sinon
retourne (somme (n-1) +n)
finsi
fin

A.BENHARI 37


Ex 3 : écrire une procédure récursive qui affiche tous les éléments d’un tableau d’entier dans
l’ordre croissant de leur indice.



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

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

XIV. Les fichiers
a. Définition du fichier
On appelle fichier un ensemble de donné stocker sur un support externe (exp : diskette, CD,
DVD, c’est à dire autre que la RAM).
Fichier binaire et texte intéresse l’algo (surtout binaire).

b. Notion d’enregistrement
Média = disque dur, trieur
On appelle enregistrement un ensemble de donnée sur un sujet déterminé. Un enregistrement
est décrit 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 différencier des autres telque les variables.

A chaque fois que l’on veut identifier un fichier on doit définir la structure de ce fichier
Cette structure est généralement déclaré en début de programme et les caractéristiques des
fichiers dans les variables globales.




A.BENHARI 38








Transfert logique


En mémoire centrale, 3 zones de travail ou BUFFERS qui réalise les entrée, sortie et travail.

c. Déclaration des fichiers en algorithme
Pour éviter les problèmes de recopie, nous déclarons les types de fichiers au niveau global
EX : Soit à déclarer 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

Après déclaration des bibliothèque (#iostream.h)

var globale
CLIENT ennrcli /*déclaration d’un buffer*/
FICHIER (client) ficli /*déclaration d’un 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_d’ouverture)

nom_fichier_logique : nom pour le programme.
nom-fichier_physique : nom connu pour le système d’exploitation.
mode_d’ouverture :
- lecture
- écriture
- Mise à Jour (MAJ) {lecture/écriture}
- Extension {après fin de fichier}

Fonction :
- En ouverture : vérifier que le fichier existe, réserver ensuite un buffer.
- Ouverture en écriture : créé le fichier ou l’écraser s’il existe déjà
- En MAJ : modifier directement chaque enregistrement
- En extension : on efface la fin de fichier actuelle pour enregistrer des données à la
suite de celle qui existe déjà.

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



2. Fermeture
fermer (nom de fichier logique)
Libère le buffer créé à l’ouverture 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 donnée du buffer toujours nommé par le présence du nom du buffer avant le
nom de la donnée séparé d’un point.




A.BENHARI 40






e. Application sur les fichiers séquentiels
i. Soit imprimer le contenu d’un 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 ()
début
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 d’entré ne doit pas être créé à partir de l’éditeur de texte mais à l’aide d’un
programme de création.










A.BENHARI 41







iii. Création d’un fichier séquentiel
types
type struct
chaine (25) nom
entier nucli
fstruct CLIENT

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

algo ecriseq ()
début
ouvre (fisor, « Fiphy », ecriture)
afficher (« entrez un nom ou fin »)
saisir (tnom)
tant que tnom <> « fin »
faire
enrcli.nom tnom
afficher (« entrez un numéro »)
saisir (tnucli)
enrcli.nucli tnucli
écrire (fisor, enrcli)
afficher (« entrez un nom ou fin »)
saisir (tnom)
fintant
ferme (fisor)
fin


f. Les fichiers à accès direct
Sachant que les supports externes tel que les disques magnétiques sont adressable, on va les
utiliser pour retrouver directement des données

Remarque : random (ang) = aléatoire ou au hasard

Dans tous les cas il faut créer une correspondance entre une des informations de
l’enregistrement et le rang de stockage de l’enregistrement sur le support externe.

Algorithme de génération automatique d’adresse ou correspondance direct.

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

Exemple = numéro étudiant = rang de stockage sur le disque





i. Lecture à accès 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 ()
début
ouvre (filogcli, « Fiphy », lecture)
afficher (« entrez un numéro 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 (« Numéro du client : » snucli)
afficher (« entrez un numéro de client ou 0 pour fin »)
saisir (rang)
fintant
ferme (filogcli)
fin

ii. Création a accès 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 ()
début
ouvre (filogcli, « Fiphy », ecriture)
afficher (« entrez un numéro 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 numéro de client ou 0 pour fin »)
saisir (rang)
fintant
ferme (filogcli)
fin

g. Les fichiers texte
i. Définition
Fichier dont les composantes sont des caractères
TEXTE fitext

On la particularité d’être divisé en ligne dont la fin est indiquer par un caractère spéciale en
général ce caractère et le caractère CR (caracter return).
Un fichier texte fait les conversions de formats de données. Les transferts se fond par les
noms de variables et non pas par structure complète. Les entrées sorties standards sont
généralement de ce type (saisir, afficher, imprimer).

Remarque : un fichier texte peut être créé à partir de l’éditeur de texte




ii. Déclaration d’un 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 d’ouverture)

2. Transfert de données
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 données
a. Les structures arborescentes
Un arbre est un ensemble d’éléments appelés nœuds ou sommets organisés de manière hiérarchique à partir d’un
nœud distingué appelé racine. On repère les nœuds de l’arbre en leur donnant des noms différents.
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 définit intuitivement les notions de sous-arbre, de sous-arbre gauche, de fils gauche, de lien gauche et
réciproquement à droite. On définit encore les notions de père, de frère, d’ascendant et de descendant. Les
nœuds d’un arbre binaire ont au plus deux fils. Un nœud interne ou double a 2 fils. Un point simple à gauche a
seulement un fils à gauche, et réciproquement à droite. Un nœud externe ou feuille n’a pas de fils. De façon
généralisée, on qualifie de nœud interne, tout nœud qui n’est pas externe. On appelle les branches de l’arbre tout
chemin (suite consécutive de nœuds) 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 réciproquement à droite.

Les caractéristiques d’un arbre sont :
- la taille de l’arbre est le nombre total de nœuds.
- la hauteur ou niveau d’un nœud x est le nombre de lien sur l’unique chemin allant de la racine à x,
notée h(x).
- la hauteur ou profondeur de l’arbre A, ( ) ( ) { } x h A h
x
max = .
- la longueur de cheminement de l’arbre A, ( ) ( ) ( ) ( ) A LCI A LCE x h A LC
x
+ = =

avec LCE
la longueur de cheminement extérieure ( )

feuille x
x h et LCI la longueur de cheminement intérieure
( )

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 nœud
opérations
r
B
1
B
2
A.BENHARI 45

Ø : arbre
< – , – , – > : nœud x arbre x arbre arbre
racine : arbre nœud
gauche : arbre arbre
droit : arbre arbre.

Proposition : Soit un arbre binaire de taille n, de profondeur p et possédant f feuilles. Si on examine les cas
extrêmes, on obtient que ( )
¸ ¸
1 log
2
− ≤ ≤ n p n ; par ailleurs
p
f 2 ≤ d’où ( )
(
f p
2
log ≥ .

Représentation des arbres en machines : On utilise la structure récursive des arbres.
1) Dans cette première représentation, le chaînage est symbolisé par des pointeurs.

type arbre = adresse de nœud ;
type nœud = structure
val : élément ;
g, d : arbre ;
fin ;
1.
2. L’arbre est déterminé par l’adresse de la racine. On gère la mémoire dynamiquement pour les opérations de
suppression / insertion.

2) Dans la représentation contiguë, on simule les chaînages par des indices dans un tableau.

type arbre = tableau de 1 à N de
structure
val : élément ;
g, d : entier ;
fin ;
3.
4. On utilise l’indice 0 pour indiquer qu’il n’y a pas de fils. L’arbre est déterminé par une variable entière
contenant l’indice de la racine. On va gérer les cases libres pour des insertions / suppressions. On chaîne les
cases libres comme une pile, en utilisant le chaînage g et on utilise une variable entière libre pour indiquer
l’indice du « sommet de pile ».
ii. Arbres binaires complets
Un arbre binaire est complet si tous les nœuds qui ne sont pas des feuilles ont 2 fils.

Propositions : Un arbre binaire complet ayant n nœuds internes possède en tout n+1 feuilles. La démonstration
se fait simplement par récurrence. Par ailleurs, on montre qu’il existe une bijection entre l’ensemble des arbres
binaires de tailles n, B
n
, et l’ensemble des arbres binaires complets de taille 2n+1, BC
2n+1
. Principe : on ajoute
des feuilles de sorte que tout nœud de l’arbre 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 hiérarchique
On dit qu’un arbre binaire est parfait si toutes ses feuilles sont situées sur les deux derniers niveau, l’avant
dernier étant complet, et les feuilles du dernier sont le plus à gauche possible. Attention ! un arbre binaire parfait
n’est pas forcément complet, mais il a toujours au plus un nœud simple (le père de la feuille la plus à droite).

On peut représenter un arbre binaire parfait de taille n de manière compacte par un tableau à n cases. Ceci se fait
en numérotant les nœuds de 1 à n en partant de la racine, niveau par niveau de gauche à droite (ordre
hièrarchique). On a les relation générales suivantes :
- le père du nœud d’indice i est à l’indice i / 2 (division entière) ;
- le fils gauche d’un nœud i est, s’il existe, à l’indice 2i ;
- le fils droit d’un nœud i est, s’il existe, à l’indice 2i+1 ;
- les feuilles sont aux indices > n / 2.

A.BENHARI 46

iv. Parcours en profondeur d’un arbre binaire
On considère l’opération de parcours qui consiste à examiner systématiquement dans un certain ordre tous les
nœuds de l’arbres pour effectuer un traitement de données. Le parcours en profondeur à gauche consiste à partir
de la racine et à tourner autour de l’arbre en allant toujours le plus à gauche possible.

Procédure Parcours(A : arbre) ;
début
Si A = Ø
Alors T
0

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

Chaque nœud est visité trois fois. A chaque visite correspond un traitement T
i
et un ordre de parcours. T
1

s’effectue avant la descente gauche et décrit l’ordre préfixe ou pré-ordre. T
2
s’effectue après la remontée gauche
et avant la remontée droite, l’ordre associé est l’ordre infixe ou symétrique. Le traitement T
3
est réalisé après la
remontée droite ; les nœuds sont parcourus dans l’ordre suffixe ou post-fixe. On ajoute un traitement particulier
T
0
pour les nœuds vides.
v. Arbres généraux
Un arbre général, ou simplement arbre, est une structure arborescente où le nombre de fils n’est plus limité à 2.
Un arbre A = < r, A
1
, A
2
, …, A
n
> est la donnée d’une racine r et d’une suite éventuellement vide de sous-arbres
disjoints. Cette suite est une forêt. Un arbre est obtenu en rajoutant un nœud racine à la forêt.

On donne la signature des arbres généraux :

sorte arbre, forêt
utilise nœud
opérations
cons : nœud x forêt arbre
racine : arbre nœud
sous-arbre : arbre forêt
Ø : forêt
ième : forêt x entier arbre
longueur : forêt entier
insérer : forêt x entier x arbre forêt

Il n’y a plus de notion de fils gauche ou de fils droit. On parle du ième fils d’un nœud.

Dans un parcours à gauche, chaque nœud est rencontré une fois de plus que son nombre de fils.

Procédure Parcours(A : arbre) ;
début
Si sous-arbre(A) = Ø
Alors T
0

Sinon
début
i 1 ;
Répéter
T
i
;
Parcours(ième(sous-arbre(A), i)) ;
i++ ;
Jusqu’à ce que i > longueur(sous-arbre(A)) ;
A.BENHARI 47

T
i
;
fin ;
fin ;

L’ordre préfixe sur les nœuds est obtenu en ne faisant qu’intervenir que T
1
. L’ordre suffixe est obtenu en ne
faisant intervenir que T
i
à l’extérieur de la boucle. Il n’y a pas d’ordre infixe.

Représentation des arbres : On représente un arbre général par des listes chaînées dynamiques.

type arbre = adresse de nœud ;
type nœud = structure
val : élément ;
premier_fils, frère : arbre ;
fin ;
Propositions : Le nombre d’arbres généraux de taille n+1 est
n
n
C
n
2
1
1
+
. Par ailleurs, il existe des bijections
entre les forêts de taille n, les arbres généraux de taille n+1, et les arbres binaires de taille n, avec des propriétés
intéressantes sur les parcours.
b. Graphes
i. Définition
Un graphe est un ensemble d’objets modélisés par des sommets, et mis en relation (binaire). Ces relations sont
modélisés par des arcs ou des arêtes. 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 ordonnées [couple] de sommets appelés arcs [arêtes].
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 s’il existe un arc qui mène 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 arête) les joignant. Dans un graphe orienté, le demi-degré extérieur [intérieur] d’un sommet x, que l’on
note ( ) x d
+
[ ( ) x d

], est le nombre d’arcs ayant x comme extrémité initiale (finale). Le degré de x est
( ) ( ) ( ) x d x d x d
− +
+ = . Pour un graphe non orienté, on définit uniquement le degré d’un 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 chaîne. Dans un graphe orienté [non orienté],
un chemin [une chaîne] dont tous les arcs [arêtes] sont distincts et tels que les sommets aux extrémités coïncident
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 chaîne les joignant. Une composante fortement connexe [connexe] est un
sous-graphe fortement connexe [connexe] maximal.
iii. Graphe et Arbre
En théorie 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
l’orientation soit un arbre.
iv. Signature graphe orienté

sorte sommet
utilise booléen, entier

1
lien d’un sommet sur lui-même
A.BENHARI 48

opérations
s : entier sommet
n° : sommet entier
– arc – : sommet x sommet booléen
d
+
: sommet entier
ième_succ : sommet x entier sommet
prem_succ : sommet sommet
succ_suivant : sommet x sommet sommet

Pour les graphes non orientés, on dispose de la même signature en remplaçant – arc – par – arête – et d
+
par d.
v. Représentation des graphes
On aura deux possibilités classiques de gestion de la mémoire : contiguë et chaînée.

Représentation contiguë : Soit n le nombre de sommet d’un graphe ; on définit la matrice d’incidence 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 d’incidence est symétrique.

type graphe = tableau[1 à n, 1 à n] de booléen.

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

Représentation chaînée : Pour chaque sommet s
i
, on forme la liste d’adjacence, qui est la liste chaînée de tous le
successeur de s
i
.

type graphe = tableau[1 à n] d’adresse de cellule;
cellule = structure
numéro : 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 d’un sommet
s’effectue en ( ) ( ) x d O
+
. La consultation complète 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 chaînage peut être simulé dans un tableau. Pour un graphe non orienté, il y a redondance
2

d’information.
vi. Parcours en profondeur d’un graphe orienté
Le parcours en profondeur un parcours récursif, simulable par une pile.
Principe : On utilise une marque (vecteur de n booléens) pour marquer les sommets au fur et à mesure qu’on les
rencontre. A partir d’un x de départ, non marqué, on avance dans le graphe en allant toujours vers un nouveau
successeur non marqué ; les sommets retenus à chaque fois sont marqués. Quand on ne peut plus avancer, on
revient au choix précédent, et on itère la méthode.

Procédure Profondeur(x : sommet) ;
début
i n°(x) ;
marque[i] vrai ;
pour j de 1 à d
+
(x) faire
début
y ième_succ(x, j) ;
k n°(y) ;

2
y est le successeur de x et réciproquement
A.BENHARI 49

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

Programme principal
début
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 orientés, on dispose du même algorithme en remplaçant d
+
(x) par d.

Les sommets ne sont marqués qu’une seule fois et l’algorithme parcourt un fois et une seule les listes
d’adjacence : complexité en ( )

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

On considère les arcs x y tels que Profondeur(x) appelle Profondeur(y). Ces arcs couvrants constituent une
forêt couvrante constituée d’arborescences disjointes et dont les racines sont les sommets de départ. Les graphes
obtenu sans orientation sont des arbres (graphe non orienté, connexe et sans cycle). La forêt couvrante a autant
d’arbres recouvrants qu’il y a de composantes connexes dans le graphe. Ainsi le parcours en profondeur résout
le test de connexité en temps linéaire.
vii. Parcours en largeur
Le parcours par largeur ou par niveau est un parcours itératif qui fonctionne avec une file.
Principe : On part d’un sommet x et on visite tous les successeurs y de x ; on réitère l’algorithme sur les sommets
y dans l’ordre où on les a rencontrés à partir de x. On utilise toujours une marque de sommets. On utilise une file
pour gérer ce parcours par niveaux.

Procédure Largeur(x :sommet)
début
file_vide(file) ;
i n°(x) ;
marque[i] vraie ;
ajouter(file, x) ;
tant que non est_vide(file) faire
début
y premier(file) ;
retirer(file) ;
pour i de 1 à d
+
(y) faire
début
z ième_succ(y,i) ;
j n°(z);
si non marque[j] alors
début
marque[j] vraie;
ajouter(file,z);
fin;

fin ;
fin ;
fin ;

Programme principal
début
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 même complexité que pour le parcours en profondeur. L’algorithme pour un graphe non orienté s’obtient
simplement en remplaçant d
+
par d. On a la même propriété sur la forêt couvrante et les composantes connexes
que pour le parcours en profondeur.
c. Problème de la recherche
i. Introduction
Considérons un ensemble de grande taille ayant des caractéristiques communes. On veut faire de manière
optimisée des opérations de recherche, d’adjonction et de suppression. A chaque élément, on associe une clé
simple (critère unique) : recherche associative. Les bases de données traitent des critères plus généraux et des
clés multiples.
Signature

sorte ensemble
utilise élément, clef
opérations
clé : élément clef
vide : ensemble
ajouter : élément x ensemble ensemble
supprimer : clef x ensemble ensemble
_ ∈ _ : clef x ensemble booléen

Remarques :
- Si plusieurs éléments ont la même clé, la recherche fournit une solution quelconque parmi les
possibilités ; s’il n’y a pas de solutions (échec), on fournit une valeur spéciale.
- La suppression commence par une recherche, en cas d’échec de la recherche, la suppression laisse
l’ensemble inchangé.
- En général, et s’il n’y a pas ambiguïté, on confond l’élément et sa clé.

La complexité fondamentale est celle de la comparaison entre deux clés. Si l’ensemble des clés est muni d’une
relation d’ordre, on peut les trier avec des algorithmes efficaces. On distingue les méthodes de recherche
séquentielle, les méthodes de recherche dichotomique, de hachage, et les méthodes arborescentes.
ii. Arbres binaires de recherche
On représente un ensemble ordonné à n éléments par un arbre binaire à n nœuds (les nœuds sont les éléments), et
c’est la comparaison avec la valeur d’un nœud qui va orienter la suite de la recherche.
Un arbre binaire de recherche est un arbre binaire tel que pour tout nœud x , les nœuds de son sous arbre-gauche
s’ils en existent ont des valeurs inférieures ou égales à celle de x, et les nœuds de son sous arbre-droit des valeurs
strictement supérieures ;


6.









ce que l’on traduit par g(A) ≤ racine(A) < d(A).

On obtient toujours l’ensemble ordonné par un parcours récursif gauche symétrique. Il n’y a pas unicité de la
représentation.
x
≤x

>x

A.BENHARI 51

iii. Recherche d’un élément

rechercher : valeur × arbre booléen

On compare l’élément à la valeur de la racine :

- égalité succès

x = r ➩ rechercher (x , < r , g , d > ) = vraie
7.
- si le sous-arbre sélectionné est vide, l’élément est absent échec

rechercher ( x , ∅ ) = faux

- si la valeur est plus petite, on recommence récurcivement dans le sous-arbre gauche ; et
réciproquement 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 l’arbre ).
iv. Adjonction d’un élément aux feuilles

ajout_feuille : arbre × valeur arbre

L’adjonction aux feuilles d’un élément se réalise en deux étapes :
- étape de recherche pour savoir où insérer le nouvel élément ;
- adjonction elle-même.

On compare la valeur de l’élément à ajouter à celle de la racine pour déterminer si on l’ajoute 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 récursif se fait sur un arbre vide ; on crée un nouveau nœud à cette place pour le nouvel élément
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 l’algorithme d’adjonction aux feuilles (récursif) en LDA :

Fonction adjonction_feuille (A : arbre , e : entier ) : arbre
début
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 itérative de l’algorithme ( voire td…).
12.
13. La complexité d’un adjonction est O ( hauteur de l’arbre ).
A.BENHARI 52


v. Adjonction d’un élément à la racine
Soit A un arbre binaire de recherche, on veut ajouter x à la racine.

On procède en deux étapes :
- on coupe A en deux arbres binaires de recherche G et D contenant respectivement tous les
éléments ≤ x et tous ceux > x.
- construire l’arbre < x , G , D >

voire cours…
vi. Suppression d’un élément

supprimer : arbre × valeur arbre

- recherche de l’élément à supprimer
- suppression qui dépend de la place de l’élément, selon que le nœud est sans fils, avec un seul fils,
ou avec deux fils. La suppression d’un nœud sans fils est immédiate. Pour la suppression un nœud avec un
seul fils, on remplace ce nœud par son fils. Pour un nœud, avec deux fils, on dispose de deux solutions : soit
on remplace le nœud à supprimer par le plus grand élément de son sous-arbre gauche, soit on le remplace
par le plus petit élément de son sous-arbre droit.

On donne l’algorithme de suppression en LDA :
14.
Fonction suppression ( A : arbre , e : entier ) : arbre
début
% recherche de l’élément à 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 l’élément 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 élément de l’arbre A, le plus à droite %
début
si est_vide(d(A))
alors retourner racine(A)
sinon
retourner max(d(A))
fin

Fonction retire_max ( A : arbre ) : arbre
% retourne l’arbre privé de son plus grand élément %
A.BENHARI 53

début
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 l’arbre ).
Conclusion, Tri par arbre binaire de recherche
Toutes les opérations ont une complexité dépendant de la hauteur de l’arbre binaire de recherche. Elle varie
entre O (log n ) pour des arbres équilibrés et O ( n ) pour des arbres dégénérés.

Par conséquent, le tri par arbre binaire de recherche, obtenu par un parcours symétrique de l’arbre, a une
complexité en comparaison dans le pire des cas variant entre O ( n log n ) et O ( n² ).
d. Problème du tri
i. Introduction
Le problème du tri est quasiment le plus important en informatique.

Spécification du tri : La donnée est une liste à n éléments ; à chaque élément est associée une clé dont la valeur
appartient à un ensemble totalement ordonné ; le résultat est une liste dont les éléments sont une permutation de
la liste d’origine, et telle que les valeurs des clés soient croissantes quand on parcourt la liste séquentiellement.

Un tri est stable, s’il conserve l’ordre de départ des éléments dont les clés sont égales.

En fonction de la capacité mémoire, on distingue le tri interne (tout en mémoire centrale) et le tri externe
(mémoire centrale + disque). Pour le tri interne, on a des algorithmes qui travaillent sur place, c’est-à-dire sur la
liste de départ et des algorithmes qui manipulent physiquement une copie. On a des algorithmes différents et plus
compliqués quand ils se font sur place.

On compte le nombre de variables auxiliaires pour évaluer la complexité en mémoire. Le tri interne, sur place,
avec un nombre constant de variables auxiliaires possède une bonne complexité en espace. On compte le nombre
de comparaisons entre clés et de transferts d’éléments pour évaluer la complexité en temps.

On distingue les méthodes simples et les méthodes plus complexes.
ii. Tri par arbre binaire de recherche
C’est une méthode plus complexe, qui consiste à créer l’arbre binaire de recherche, puis à faire un parcours
symétrique, pour obtenir la liste trieé.

voire partie sur les arbres binaires de recherche…
e. Quicksort
i. Principe
On choisit une des clés de la liste (par exemple, celle du premier élément), et on l’utilise comme pivot. On
construit sur place une sous-liste dont les clés sont inférieures ou égales au pivot et une sous-liste dont les clés
sont strictement supérieurs au pivot.





p > pivot ≤ pivot
A.BENHARI 54

Le pivot p a alors sa place définitive. Et on recommence récursivement sur chacune des deux sous-listes. A la
fin, la liste est triée par ordre croissant. Remarquons que le choix du pivot est délicat ; de lui dépend
l’équilibrage des deux sous listes.

On suppose donnée une procédure

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 résultat l’indice
k où le pivot a été placé et le tableau t réagencé.

La procédure générique du quicksort s’écrit :

Procédure Quicksort (e/s t : tableau de 1 à n entiers , e/ i : entier , e/ j : entier)
utilise localement k : entier
début
si i < j
alors début
Placer (t , i , j , k)
Quicksort (t , i , k - 1)
Quicksort (t , k + 1 , j)
fin

fin

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

La procédure Placer : La partition et le placement du pivot ne nécessite qu’un parcours.







On utilise deux compteurs l et k qui partent des extrémités du sous-tableau, et qui vont l’un vers l’autre :
- l part de i+1 et avance tant que l’on rencontre un élément ≤ à a.
- k part de j et recule tant que l’on rencontre un élément > à a.
On échange les deux éléments et on recommence la progression jusqu’à ce que les deux compteurs se croisent :
la place définitive du pivot est en k, et on y place le pivot a par échange avec un élément ≤ à a.

Si on utilise la procédure Placer sur un sous-tableau qui n’est pas à la fin de ( x = t[j+1] existe ), alors
l’élément x est un pivot placé antérieurement. Donc, on a [ ] ] [ , , s t x j i s ≥ ∈ ∀ . Par conséquent, cet élément x
va arrêter la progression du compteur l. Pour utiliser cette propriété (effet de bord) lors de tous les appels, on
rajoute un terme en t[n+1] qui contiendra un élément plus grand que tous les autres.

15. Procédure Placer (e/s t : tableau de 1 à n entiers , e/ i : entier , e/ j : entier , /s k : entier)
16. utilise localement l : entier
17. début
18. l i +1
19. k j
20. % boucle : tant que les compteurs ne se croisent pas %
21. tant que l ≤ k faire
22. début
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 début
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 définitive %
34. échanger t[i] et t[k]
35. fin
ii. Complexité
36. Complexité de Placer : Considérons un sous-vecteur à p éléments, on la pivot aux p - 1 autres éléments. 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 déjà trié est en prenant à chaque fois le 1
er
élément comme
pivot. Le graphe des appels sera dégénéré (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
ième
place de la liste à trier. On suppose que toutes les places sont équiprobables ; on a la probabilité
1/n d’avoir le pivot à la place p et donc d’avoir deux sous-listes de taille p - 1 et n - p. On démontre ( voire
cours + td ) que la complexité en moyenne est en O (2n log n).
iii. Taille de la pile de récursivité
41. Dans la procédure Quicksort, le 2
ème
appel est terminal, ce qui veut dire qu’on peut le supprimer, et donc
éviter des empilements. Comme un seul appel va être conservé, on l’effectuera systématiquement sur la plus
petite des deux sous-listes. La taille de récursion sera en O (log
2
n), car on divisera par 2 la taille de la liste
d’appel.
42.
Procédure Quicksort (e/s t : tableau de 1 à n+1 entiers , e/ i : entier , e/ j : entier)
utilise localement k : entier
début
tant que i < j
alors début
Placer (t , i , j , k)
% on choisit le plus petit %
si (j - k) > (k - i)
alors début
Quicksort (t , i , k - 1)
i k + 1
fin

sinon début
Quicksort (t , k + 1 , j)
j k - 1
fin
43. fin

fin

f. Heapsort
3

C’est un tri par sélection des minimums successifs basé sur une structure de tas. On va obtenir un tri O (n log n)
comparaisons au pire, sans mémoire auxiliaire.

3
Tri par tas

A.BENHARI 56

i. Arbres partiellement ordonnés
Un tri par sélection nécessite de savoir localiser et récupérer efficacement ( en O (1), si possible ) le minimum
parmi les éléments non encore placés.
On considère le cas particulier du type abstrait ensemble où les seules opérations sont :
- l’accès à un élément minimum
- la suppression du minimum
- l’adjonction d’un nouvel élément
On représente cette ensemble par un arbre binaire parfait partiellement ordonné.
44.
Un arbre partiellement ordonné est un arbre étiqueté par les valeurs d’un ensemble muni d’un ordre total, tel
que la valeur associée à tout nœud soit ≤ aux valeurs associées aux fils. La racine contient toujours un élément
minimum, accès en O (1).
45.
1) Adjonction d’un élément x
On ajoute d’abord x comme une feuille en conservant la structure d’arbre binaire parfait. Puis, on reconstruit
l’ordre partiel :

y x
tant que ( y ≠ racine ) et ( y < père(y) ) faire
échanger y et père(y)
46.
2) Suppression du min
Une fois la racine enlevée, on place la dernière feuille à la racine, pour conserver la structure d’arbre binaire
parfait. Puis, on reconstruit l’ordre partiel :

y racine
tant que ( y n’est pas une feuille ) et ( y n’est pas ≤ aux deux fils ) faire
échanger y et son fils de valeur minimum

47.
48. La complexité en nombre de comparaisons de l’adjonction et de la suppression du minimum est au pire en
O (hauteur de l’arbre). Par ailleurs, la hauteur d’un arbre binaire parfait ayant n nœuds est de
¸ ¸
n
2
log .

On utilise la représentation en tableau (ordre hiérarchique) des arbres binaires parfaits. ( voire partie sur les
structures arborescentes) Le tableau forme le tas.

On donne les algorithmes écrits en LDA des procédure d’adjonction et de suppression du minimum :

Procédure ajouter ( e/s t : tableau de 1 à N entiers , e/s n : entier , e/ x : entier )
% ajoute l’élément x à t ayant n éléments au moment de l’appel %
utilise localement i : entier
début
si n < N
alors début
n++
t[n] x
i n
tant que ( i > 1 ) et ( t[i] < t[i div 2] ) faire
début
échanger t[i] et t[i div 2]
i i div 2
fin
fin
sinon écrire débordement du tas
fin

Procédure 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 éléments %
utilise localement i, j : entiers
A.BENHARI 57

début
min t[1]
t[1] t[n]
n--
i 1
% tant que l’on est pas sur une feuille %
tant que ( i ≤ n div 2) faire
début
si ( n = 2i ) ou ( t[2i] < t[2i+1])
alors j 2i
sinon j 2i +1
si ( t[i] > t[j])
alors début
échanger t[i] et t[j]
i j
fin
sinon exit
fin
fin

ii. Tri par tas
Principe :
- Construire un tas contenant les n éléments par adjonction successives ; en O (n log n).
- Tant que le tas n’est pas vide, faire supprimer le minimum du tas avec réorganisation, mettre ce
minimum à sa place définitive ; 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 à récupérer 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 l’ensemble dans l’ordre décroissant.


49.
50.
51.
52.
53. Procédure heapsort (e/s t : tableau de 1 à n entiers)
54. utilise localement p, min : entiers
55. début
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 : l’incrémentation et la décrémentation de p est généré par les procédures en e/s.







tas à traiter minimums bien plaçés min t[n]
A.BENHARI 58

XVI. Algorithmes numériques

a. Généralités
i. Normes et rayon spectral

Définition norme vectorielle :
+
→R R x x
n
, a vérifiant :
- 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.

Définition 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.

Propriétés :
- X A AX . ≤ et B A AB . ≤
- Cas de A symétrique : ( )
i
i
A A λ ρ max
2
= =
- Dans le cas général,
max
2
µ = A , maximum des valeurs singulières
i i
λ µ = avec
i
λ les valeurs
propres (positives) de la matrice symétrique 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 d’une matrice inversible :
Considérons un système linéaire AX=b. L'expérience de Wilson met un évidence une instabilité des calculs dans
certains cas. Si l'on modifie sensiblement les paramètres de la matrice A, ou du second membre b, on peut
trouver des résultats complètement différends !
- ( )
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 symétrique : ( )
min
max
2
λ
λ
= A Cond ; dans la cas général : ( )
min
max
2
µ
µ
= A Cond

Théorèmes sur le conditionnement :

Théorème : ( ) b b X X A B AX ∆ + = ∆ + = et . On a ( )
b
b
A Cond
X
X ∆


.
Théorème : ( )( ) 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 numérique d’une matrice :

Soit A une matrice inversible et A
-1
son inverse théorique.
M est un inverse de A du point de vue numérique 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 résout rarement un système linéaire en calculant
l'inverse b A X
1 −
=
A.BENHARI 60

b. Systèmes linéaires Ax=b : méthodes
directes
i. Formules de Crammer
Cette méthode nécessite le calcul d'un déterminant, dont la complexité est en n!. La compléxité de la formule de
Cramer est en n
2
n!. Par conséquent, cette méthode n'est pas utilisable en informatique.

ii. Méthode 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 problème des coefficients diagonaux nuls : il faut permuter les lignes lorsque apparaît un zéro sur la
diagonale.
Stratégie 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é
numérique, on divise par le terme de la colonne k, qui a la plus grande valeur absolue.
Stratégie du pivot avec seuil :
On effectue une permutation uniquement des ε <
k k
a
,
. Cependant cette méthode peut être mise en défaut. Il
vaut mieux utiliser la méthode du pivot maximum partiel, qui n'est pas vraiment plus coûteuse en calcul.
iii. Calcul de l’inverse
Une idée pour résoudre le sytème Ax=b serait de calculer l’inverse de A. En effet, on a b A x
1 −
= .
Méthode de Shermann – Morison
Soit A une matrice n x n, réelle inversible, dont on connaît l’inverse A
-1
; soit B une perturbation, on cherche à
calculer ( )
1 −
+ B A .
On démontre 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 qu’un 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 stratégie du pivot partiel maximum, au calcul de l’inverse.
On considère une matrice A inversible, de dimension n
On résout n l e Ax
l
≤ ≤ = 1 pour , ce qui revient à écrire I A A =
−1
. . On procède par élimination de Gauss,
ce qui donne une matrice triangulaire supérieure (complexité en n
3
). Ensuite, on réalise n remontées, une par
vecteur
l
e (complexité en n
2
).
A.BENHARI 61

En résumé, on a
l
e Ax = et MA U e M x U
l
= = avec . . une matrice triangulaire supérieure.
On veut traiter tous les seconds membres en une seule passe ; pour cela on considère la matrice n x 2n suivante :
|
|
|
|
|
¹
|

\
|
qui après calculs donne
|
|
|
|
|
¹
|

\
|
.

On donne ici un exemple d’écriture en langage de description algorithmique :

- Procédure pivot ( k , l : entiers ; OK : booléens )
- Début
- Max := ( ) k k A , ;
- l := k ;
- Pour i := k+1 à n faire
- Si max < ( ) k i A ,
- Alors
- Début
- Max := ( ) k i A , ;
- l := i ;
- Fin ;
- OK := Max > ε ;
- Fin ;

- Procédure permuter ( k , l : entiers )
- Début
- Si l k ≠
- Alors
- Pour j := k à 2n faire
- Début
- c := ( ) j k A , ;
- ( ) j k A , : = ( ) j l A , ;
- ( ) j l A , := c ;
- Fin ;
- Fin ;

On donne maintenant le programme principal, réalisant le calcul de l’inverse.

- Début
- Initialiser A et lire ε ;
-
- /* triangularisation */
- Pour k := 1 à n faire
- Début
- Pivot (k , l , OK ) ;
- Si non(OK)
- Alors
- Début
- 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 remontées */
- Pour k := 1 à n faire
- Pour i := n-1 à 1 par pas de -1 faire
- Début
- 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é numérique, 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 inférieure à la précision machine ε, alors on arrête
en disant que la matrice n’est pas inversible à ε près (test d’inversibilité informatique). Cependant, elle peut
très bien être inversible du point de vue mathématique !
c. Factorisation A=LU
Soit A une matrice régulière, de dimension n.
Lien avec la méthode de Gauss
On applique la méthode de Gauss sans pivoter. U est une matrice triangulaire supérieure réelle, telle que
U A J
n k
k
=

= , 1
.
On donne la définition 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 démontre que l’inverse des J
k
existe et que

=

=
n k
k
J L
, 1
1
est une matrice triangulaire inférieure, 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 procède par identification en utilisant les propriétés de L (triangulaire inférieure avec une diagonale de 1) et
de U (triangulaire supérieure). 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
- Début
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 donnée appropriée que la bande, soit un O(W.N), ce qui est intéressant si
W << N.

Propriété fondamentale :
La bande se conserve par factorisation LU. On parle de structure de données statique. En revanche, si on utilise
des techniques de pivotage au cours d’une factorisation LU sur une matrice bande, alors la structure bande n’est
pas conservée.
On utilise la méthode uniquement dans le cas, où à priori on ne pivote pas. La condition suffisante la plus connue
est « A matrice à diagonale strictement dominante », c’est à dire


=
> ∈ ∀
i j
n j
j i i i
a a n i
, 1
, ,
, 1 .
Cas des matrices symétriques définies positives (SDP)
Cf. factorisation Cholesky et Crout.
d. Factorisation PA=LU
P est la matrice des permutations.
L est une matrice triangulaire inférieure dont la diagonale se compose de 1.
U est une matrice triangulaire supérieure.

A.BENHARI 64

Matrice de permutation élémentaire 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.

(à compléter 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 symétriques et positives.
Théorème : Soit A une matrice SDP de dimension n. Il existe une et une seule matrice B triangulaire inférieure,
telle que A=BB
t
.

f. Factorisation A=LDL
t
: Crout
Théorème : Soit A une matrice SDP de dimension n. Il existe une et une seule matrice L triangulaire inférieure et
D diagonale positive, telles que A=LDL
t
.
Remarque : Crout a le même comportement numérique que Cholesky. Cependant, il est plus utilisé car
généralisable au cas complexe.

Soit A une matrice symétrique définie positive (quelconque ?).
L est une matrice triangulaire inférieure 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 divisés par les coefficients b
ii
. D est la
matrice dont les coefficients diagonaux sont les b
ii
²
.

i. Algorithme par ligne pour l’obtention 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 l’algorithme correspondant :

- Pour i de 1 à n faire
- Début
- 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 inférieure de A.

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

On donne l’algorithme modifié :

- Pour i de 1 à n faire
- Début
- Pour j de 1 à i-1 faire
- Début
- 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 l’obtention de la
factorisation
Principe : On construit L et D, en procédant par décomposition successives. On réalise le découpage 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 réitérant 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 inférieure, par construction.

On donne l’algorithme de calcul de L et de D par colonne, qui procède en écrasant la partie triangulaire
inférieure de A, (les 1 de la diagonale de L ne sont pas stockés, car on préfère y stocker D) :

- Début
- Pour k de 1 à n-1 faire
- Pour j de k+1 à n faire
- Début
-
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 donnée d’implémentation serait un vecteur à une dimension stockant consécutivement les colonnes
de la partie triangulaire inférieure 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
Considérons une matrice A symétrique creuse. On utilise une structure de donnée 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 précisément, on considère
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 considérerait pleine.

Définitions :
- Un terme de remplissage apparaît en (i,j) au cours de la factorisation si et seulement si 0
,
=
j i
a et
0
,

j i
l . On reformule le problème 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 . C’est à dire, à la k
éme

itération ( ) 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'intérieur 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) dépend uniquement des coefficients (3,1) et (2,1) qui sont non nuls, par conséquent le
coefficient (3,2) devient logiquement non nul : effet de remplissage. Ensuite, le coefficient (4,2) qui dépend des
coefficients (4,1) et (2,1) devient logiquement non nul. (…) Le coefficient (5,3) dépend des coefficients (5,k) et
(3,k) pour k variant de 1 à 3-1=2, etc.

Remarque : Ainsi, on voit que le phénomène dépend de l’ordre selon lequel on exécute les itérations, c’est à dire
de la numérotation des inconnues du système ! Si l’on permute les indices 5 et 1 dans l’exemple précédent, 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 l’on peut trouver une matrice de permutation P, telle que la
factorisation de la matrice PAP
t
crée le moins de remplissage possible ? Il n’existe pas de méthode exacte en
temps raisonnable et on va utiliser des méthodes approchées (heuristiques).
A.BENHARI 69

iv. Caractérisation du remplissage par les graphes
On utilise un graphe afin de déterminer quels sont les termes logiquement non nuls qui vont apparaître au cours
du calcul.
Le graphe associé à une matrice A symétrique d'ordre n possède n sommets que sont les indices de 1 à n des
coefficients de la matrice. Un coefficient non nul est repéré 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é :





Considérons une permutation donnée telle que ( ) i x
i
= σ et plaçons nous à la k
éme
itération :
-
trouver le monotone adjacent de
k
x qui est l’ensemble de tous les sommets liés à
k
x avec un numéro plus
grand, ( ) ( ) { } possible arête une soit , que et tel ,
k j j k
x x k j x x Madj > =

- rajouter une arête de remplissage pour tout couple de tels sommets non liés entre eux.
- On fait cela dans l’ordre des k croissants de 1 à n-1. A la fin, on obtient le graphe dit d’élimination.

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
Considérons une matrice SDP A de dimension n.

Définition : Pour chaque ligne, on considère 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 stockée par ordre
croissant de colonne (soit 1 + −
i
c i coefficients). Le profil ligne est l’union des P
i
pour i variant de 1 à n. On a
besoin d’un 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.

Propriété fondamentale : Le profil ligne se conserve par factorisation (statique). Le remplissage est inclus dans
le profil ligne. Par conséquent, on va chercher à trouver des numérotations qui tendent à minimiser la taille du
profil ligne.

On adapte l’algorithme 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
Critère approché : On va chercher une numérotation des sommets du graphe
σ
G minimisant le profil A. Pour
cela, on cherche à diminuer la taille m. On utilise un critère local : à i fixé, on va essayer d’obtenir
i
c proche
autant que possible de i, ce qui va induire un tassement vers la diagonale.

A.BENHARI 70

Le problème en terme de numérotation sur
σ
G est le suivant : « numéroter ses voisins avec des numéros les plus
proches possibles de i ».

v. Numérotation en couches :

On partitionne l’ensemble des sommets du graphe par rapport à leur distance à un sommet de départ x. On
numérote continûment selon les couches et le plus grand écart varie comme un O(longueur d’une couche). Le
nombre de sommets étant fixé, on cherche le sommet x de départ de telle manière que le nombre de couche
( ) x h générés à 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, nécessairement ( ) ( ) x h y h ≤
- Si h(x) > h(y) Alors réitérer, Sinon, on est dans le cas où h(x) = h(y), et y est le point de départ.









A partir de l’exemple précédent, on choisit y = 2 et on obtient h(y) = 2. En réitérant de nouveau, on obtiendra
pas mieux. Donc on déduit 2 = x .

On applique le changement de numérotation :
Ancien numéro i 1 2 3 4 5
Nouveau numéro ( ) 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
Théorème : CNS de création d’une arête de remplissage
Soit
σ
G le graphe numéroté associé à la matrice A.
Une arête de remplissage ( )
j i
x x , est créée si et seulement si :
- l’arête est déjà présente dans
σ
G ;
- il existe un chemin allant de
i
x à
j
x tel que les numéros intermédiaires soient plus petits que ceux des
extrémités.
A.BENHARI 71


Idée de numérotation : Pour mettre en défaut ce théorème, on utilise des séparateurs topologiques. Cette
méthode consiste à séparer deux sous-ensembles A et B par un ensemble C, appelé séparateur ; de sorte que tout
chemin allant d’un élément de A vers un élément de B passe au moins par un sommet de C. Si on numérote les
sommets de C avec des numéros plus grands que ceux affectés à A et B, alors il n’y aura pas d’arête de
remplissage créées entre les éléments de A et ceux de B.




On applique ce principe de numérotation récursivement par bloc, jusqu’à tomber sur une grille qui n’est plus
séparable. Ce faisant on limite excellemment le remplissage, mais le profil risque d’être mauvais.

Remarque : Il faut une autre structure de donnée que celle du profil non adapté. Par ailleurs, il y a aussi une
indépendance des calculs exploitable sur une machine à architecture parallèle.

Exemple :
On reprend l’exemple précédent…






On effectue le changement de numérotation :
|
|
|
|
|
|
¹
|

\
|
= →
|
|
|
|
|
|
¹
|

\
|
=
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
l’on peut vérifier que cette dernière matrice ne se remplie pas du tout !
vi. Utilisation de la factorisation pour résoudre Ax=b
Il s’agit de résoudre b Ax = en utilisant la factorisation de Cholesky - CROUT : b X ALDL
t
= . On procède
en trois étapes.
- Descente : Posons x DL y
t
= et résolvons b Ly = , dont la complexité est en
2
2
n
(matrice triangulaire).
On écrit un algorithme utilisant un accès 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 ;
- Résolution du système diagonal : Posons x L z
t
= et résolvons y Dz = (par n divisions).

- Pour i de 1 à n faire
di
y
z
i
i
= ;
- Montée : Résolvons finalement z x L
t
= , dont la complexité est en
2
2
n
.
On écrit un algorithme utilisant un accès par ligne dans L
t
, ce qui revient à un accès 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 symétrie. 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.

Considérons le fait que l’on stocke les données en mémoire de façon mono-dimensionnelle. On va donc être
obligé de choisir une organisation ligne par ligne, ou colonne par colonne des données.
Si l’on choisit une organisation ligne par ligne, on s’aperçoit que l’algorithme de descente est bien adapté à la
structure de données par ligne, tandis que l’algorithme de montée, qui pratique un accès aux données par colonne
ne l’est pas. C’est pourquoi, il faut écrire un algorithme de montée accédant aux données 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. Systèmes linéaires Ax=b : méthodes itératives
a. Principe
i. Méthode itératives 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 récurrence
b NX MX
n n
+ =
+1
ou encore b M NX M X
n n
1 1
1
− −
+
+ = . Si X est solution du problème, il vient
que ( ) ( ) ( )
0
1
X X N M X X
n
n
− × = −

. ( ) N M B
1 −
= est appelée la matrice d'itération.
Ainsi pour que X X
n
→ , il est nécessaire que ( ) 0
1


n
N M .

Remarque : Le cadre normale de convergence des méthodes itératives classiques est : « A matrice symétrique
définie positive ».
ii. Vitesse de convergence :
Théorème : ( ) ( ) 1 ssi 0 < → B B
n
n
ρ .

Vitesse de convergence : Considérons la matrice d'itération B symétrique, alors ( ) B B ρ =
2
et l'on obtient
le résultat suivant : ( )
2
0
2
. x x B x x
k
k
− ≤ − ρ .
En conclusion, le rayon spectral de la matrice d'itération mesure la vitesse de convergence. La convergence est
d'autant plus rapide que le rayon spectral est plus petit. On admettra que ce résultat ce généralise aux matrices
quelconques.

b. Méthode Jacobi
Notation :
|
|
|
¹
|

\
|


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

Soit ( )
n i
i
k k
x x
, 1 =
= le vecteur itéré, on donne l’algorithme 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


Théorème : Soit A une matrice symétrique, à diagonale strictement dominante, c'est à dire


>
j i
j i i i
a a
, ,

alors la méthode est convergente car ( ) ( ) 1
1
< +

F E D ρ .

A priori, cette méthode converge pour une matrice A SDP.

A.BENHARI 74

c. Méthode Gauss-Seidel
Boucle directe
On reprend le schéma de matrice précédent et on pose E D M − = et F N = . La formule de récurrence
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 l’algorithme 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 procède 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
calculés déjà
1
4 4 3 4 4 2 1
.

Boucle rétrograde
Cette fois, on pose F D M − = et E N = .
On propose l’algorithme 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
Théorème : Soit A une matrice symétrique définie positive, alors la méthode est convergente
car ( ) ( ) 1
1
< −

F E D ρ .

Comparaison : Si A est SDP les méthodes 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. Méthode de relaxation
Pour cette méthode, on pose E
w
D
M − = et F D
w
w
A M N + |
¹
|

\
| −
= − =
1
, avec 0 ≠ w . On donne la
matrice d’itération :
(
¸
(

¸

+ |
¹
|

\
| −
|
¹
|

\
|
− =

F D
w
w
E
w
D
L
w
1
1
. Ainsi pour 1 = w , on se ramène à la méthode de
Gauss-Seidel.

Théorème : Soit A une matrice SDP. Il y a convergence si et seulement si ( ) 1 <
w
L ρ . On démontre 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 procède 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 symétrique définie 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 méthode de façon heuristique pour des matrices qui ne sont pas tridiagonale.


Dichotomie : Si l’on cherche
optimal
w par dichotomie, l’expérience montre qu’il faut obligatoirement procédé
par valeurs supérieures (la fonction ( )
w
L w ρ a possède pour
optimal
w w > une pente de 1).
Évaluation du rayon spectral de L :
On écrit les itérés de Gauss-Seidel :
¹
´
¦
+ =
+ =

+
c x L x
c x L x
k k
k k
1 1
1 1
.
.
d’où ( )
1 1 1
.
− +
− = −
k k k k
x x L x x . On utilise la
méthode de la puissance itérée et on déduit : ( )
1
1
1
lim

+
∞ →


=
k k
k k
k
x x
x x
L ρ . En pratique, on fait l’approximation
pour des itérés dont l’écart a diminué de manière significative.

Schéma d’implémentation :
- Soit x
0
donné
- On réalise p itérations avec Gauss-Seidel, on obtient la suite des itérées jusqu’à x
p
à partir de laquelle on
évalue de manière approchée ( )
1
L ρ et
optimal
w .
- Puis on applique la méthode de relaxation avec
optimal
w w = .
- On s’arrête lorsque l’on a atteint la précision désirée.

Remarque : Toute la difficulté réside dans la choix de p. Il faut que le nombre total d’itérations soit n << pour
être compétitif avec Cholesky. Le choix de p se fait au cas par cas.
A.BENHARI 76

e. Méthodes du gradient
4

Principe : méthode de la plus grande descente
Soit A une matrice symétrique définie positive.
Théorème : Soit ( ) X b X AX X J , 2 , − = . Alors X est solution de b AX = , si et seulement si X réalise
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 linéaire b ax = .

Formule de récurrence : Prenons un X
0
quelconque, et supposons que nous ayons obtenu par itération X
k
.
Considérons la courbe de niveau k ( ) ( ) { }
k
X J X J X = que tel , pour calculer X
k+1
, on se déplace 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 récurrence :
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 résume 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 méthode, on va utiliser un ensemble de directions conjugués.
k
g est la meilleure direction locale,
mais pas à long terme, sinon l'algorithme convergerait d'un coup! D'où l'idée, 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 résolvant le système obtenu, par annulation des
dérivées partielles pour la fonction J (qui doit être minimum), on calcule les valeurs des coefficients
1
et
− k k
β α .

On va maintenant résumer la méthode :
- 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 connaît
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é rédigée en privilégiant les notes de cours plutôt que celle de TD, où les
notations et les méthodes diffèrent sur quelques points.

A.BENHARI 77

- On prépare 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 démontre que la correction apportée dans cette méthode est optimale.

Formule par récurrence : On démontre après coup que cette méthode donne la solution de l'équation linéaire au
bout de N itérations ! Par conséquent, on pourrait la considérer comme une méthode directe, mais on préfère la
prendre comme une méthode itérative, et s'arrêter pour N k ≤ quand la précision est satisfaisante.
Préconditionnement :
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 déjà
solution ! Rappelons : ( ) 1 ≥ A Cond . Ici, on voit que la vitesse de convergence va dépendre de la matrice A, et
plus particulièrement de son conditionnement. On va alors introduire la notion de préconditionnement.

Transformation :
On cherche à résoudre un autre système b Y A
~ ~
= ayant même solution, mais pour lequel la matrice A
~
possède
un meilleur conditionnement.
On considère
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'intermédiaire de Y sont dits non transformés. Lorsque Y n'apparaît plus
dans le calcul l'algorithme est dit transformé.

Algorithme du gradient préconditionné transformé :
Prenons un X
0
quelconque, et supposons que nous ayons obtenu par itération X
k
. On pose b AX g
k k
− = et
k k
g C h
1 −
= , ce qui revient à résoudre
k k
g Ch = . Résolution d'un système linéaire ! 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 résultat fondamental suivant
( )
( )
A
k
A
k
X X
A Cond
A Cond
X X −
|
|
¹
|

\
|
+

≤ −
0
1
~
1
~
. Il faut à présent
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 déduire que ( ) ( ) A C Cond A Cond
1
~

= , car ces deux matrices ont les mêmes valeurs
propres.

Choix de C (méthode heuristique) :
- Factorisation incomplète de Cholesky : Lorsque l'on pose
t
BB A = , il peut sur venir un phénomène de
remplissage ! D'où l'idée de réaliser une factorisation incomplète 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 phénomène 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 phénomène de remplissage peut souhaitable. Et si l'on pose Id C = , le conditionnement
n'est pas amélioré par rapport à celui de A.
A.BENHARI 78

On va alors prendre
t
EE C = (factorisation incomplète de Cholesky), ce qui correspond à un compromis
entre le choix d'un bon conditionnement pour à et la disparition du phénomène de remplissage.
- Factorisation incomplète de Crout: On peut tout aussi bien utiliser Crout (qui est la méthode proposée en
TD). Dans ce cas, R LDL A
t
− = et on prend
t
LDL C = .
Voici deux conditions suffisantes chaques à l’existence : 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é préconditionné transformé
- Factorisation incomplète de Cholesky : R EE A
t
+ = ; on pose
t
EE C =
- Au départ : 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 connaît
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 prépare 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 à résoudre car factorisation de Cholesky ou de Crout)
-
k k k k
d h d β + − =
+ + 1 1


Tests d'arrêts pour les méthodes itératives
On se donne une précision 0 > ε . On voudrait que l'algorithme se termine une fois la précision atteinte, c'est à
dire ε ≤ − X X
n
. Cependant, on ne connaît pas X ! On utilise par conséquent le test
suivant ε 2
1
≤ −
+ n n
X X , dont on considère en pratique qu'il est équivalent au premier, même si cela n'est
qu'à demi vrai en théorie (la réciproque est fausse). Il peut y avoir de rare cas où l'algorithme s'arrête, alors que
l'on est loin de la solution !!! Mais faute de mieux…
Finalement, on prend comme test d'arrêt : ε ≤ −
+ n n
X X
1
et /ou ε ≤ = −
n n n
g X AX .

Remarque : La méthode du gradient conjugué préconditionné est plus performant en nombre d’itération que la
méthode de relaxation avec
optimal
w .
A.BENHARI 79

XVIII. Problèmes au moindres carrés (linéaire)
a. Régression linéaire
Etant donné une série 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 général
On étudie un cas plus général ( ) ( )


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. Méthode des équations normales
Théorème
Le vecteur x réalise 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.
Défauts numériques
On appliquera la méthode des équations normales pour un nombre faible d'inconnues 2, 3, 4 ou 5. Un premier
défaut est l'imprécision du calcul engendré par le produit matriciel A A
t
. Par ailleurs, si la matrice A est creuse,
A A
t
peut très bien ne pas l'être…
Méthode de la factorisation QR (rectangulaire)
Définition (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
supérieure.
Théorème : minimiser
2
b Ax − pour N supérieur à 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
Définition des matrices de Householder
Soit u un vecteur unitaire ( ) 1
2
= u de dimension m. On définit la matrice de Householder de dimensio m m×
t
m u
u u Id H . 2 − = .
u
H est symétrique et orthogonale ( ) 1
2
=
u
H . On note également
β
t
m u
v v
Id H
.
− =
en posant u v . 2β = .
Propriété 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 réel.

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 procède colonne par colonne.
On rappelle la géométrie de
|
|
|
|
|
|
|
|
¹
|

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

- Occupons nous de la première 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 première colonne de
1
A est
|
|
|
|
|
¹
|

\
|
0
0
1
M
α
.
A.BENHARI 81

- On s'intéresse 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 première colonne de
2
A reste inchangée par
rapport à
1
A et l'on a fabriqué la deuxième colonne
|
|
|
|
|
|
¹
|

\
|
0
0
2
M
α
x
.
- Il vient K = × × = × = =
2 2 1 1 1 0
A H H A H A A On itère la méthode 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 vérité, on peut habilement intégrer le calcul de b Q
t
à l'algorithme précédent. Cela est simple, il suffit de
rajouter une N+1 colonne à la matrice initiale, ( ) b A A =
0
. Ainsi après N itérations, on obtiendra le résultat
b Q
t
toujours dans la même colonne.
Obtention de la factorisation A = QR par Givens
(…)
XIX. Résolution des équations non linéaires
a. Méthode de dichotomie
Considérons 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 réitère. La précision obtenue au bout de k itérations est
k
a b
2

. La méthode de
la dichotomie est robuste, mais n'est pas généralisable à la dimension n.

b. Généralités
i. Méthode convergente, d'ordre p
Une méthode itérative est convergente : X X
n
→ solution, si
p
n n
X X C X X p C − ≤ − ∃
−1
/ , . On dit
que la méthode est dite d'ordre p.
Théorème 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 théorème, il suffit de vérifier qu'il existe une boule ( ) X X X B −
0
, sur laquelle, on a la
propriété ( ) ( )
1 2 1 2
y y k y y − ≤ −φ φ avec 1 0 < < k . L'inégalité des accroissement finis nous donne
( )
( )
j
i
j i c c x
c
c k


= ′ =
φ
φ
, ,
sup sup .
ii. Méthode d'itérations successives pour résoudre
( ) 0 = X F
Posons ( ) ( ) X F X X − = φ . Si X est point fixe de φ alors X est solution de ( ) 0 = X F . On définit alors la
récurrence suivante : ( )
n n n
X F X X − =
+1
.
Méthode de Newton - tangente
En dimension 1 pour des réels,
( )
( )
n
n
n n
x f
x f
x x

− =
+1
. La méthode de la tangente est d'ordre 2. Inconvénient, si
on part d'une certaine boule , la méthode converge, sinon l'algorithme peut osciller et ne pas converger ! Cette
méthode se généralise à la dimension n. Pour des complexes, on peut employer deux fois cette méthode.
Méthode 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 itération. Si on part d'une
certaine boule au voisinage de la solution, la méthode est convergente d'ordre 2. Si on fait un choix au hasard
pour
0
X , il faut prévoir un test d'arrêt au bout de 100 itérations 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
après la première utilisation… Factorisation PA=LU…
Méthode de Bairstow dans le cas des polynômes
On cherche à résoudre ( ) 0 = x P , avec ( )
0
1
1
a x a x x P
n
n
n
+ + + =


K .
Méthode
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 déterminer les coefficients α et β, on cherche une racine de l'application ( ) ( )
1 0
, , : r r F a β α .

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

Finalement, le polynôme α β + + = x x A
2
1
fournit deux racines de P. On réitère la méthode sur
1
Q tel que
1 1
Q A P = . Cependant, les itérations successives entraînent une perte progressive de la précision.
A.BENHARI 83

Variante
Pour ne pas choisir ( )
0 0
, β α complètement au hasard, une méthode consiste à sélectionner une centaine de
couples et à choisir, pour débuter l'algorithme, celui qui rend le polynôme minimum.
Amélioration de la précision
La racine obtenue étant assez proche de la racine réelle, on effectue la méthode de la tangente pour améliorer la
précision. Tous les 4 ou 5 coups, on améliore la précision avec la précision avec la méthode de la tangente. Cette
dernière méthode ne s'applique qu'aux racines réelles (on applique deux fois la méthode pour les racines
complexes).
Méthode de Bernouilli pour le calcul de la racine dominante si elle est unique
???
c. Valeurs propres et vecteurs propres
Conditionnement
Théorème
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 symétrique, la matrice de passage est orthogonale et son conditionnement égale à 1.
Bissection de Givens - Householder
Méthode
1. Chercher une matrice tridiagonale semblable à A ayant même valeur propre.
2. Chercher ces valeurs propres.
Tridiagonalisation
Cet algorithme utilise des matrices de Householder. On procède bloc par bloc, en dimension décroissante.
- 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
découpe
1
A en bloc selon le schéma :
|
|
¹
|

\
|
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 réel. Voilà ce qui en définitive va rendre la matrice
tridiagonale.
- On applique la même méthode que précédemment avec une dimension en moins…
- On réitère la méthode 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 intègre le calcul de α dans la méthode 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
~ ~

Méthode de recherche des valeurs propres
A partir de la matrice tridiagonale M, on va construire le polynôme caractéristique dont les racines sont
précisément 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 polynômes caractéristiques.
-
1.
i
P est le polynôme caractéristique 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 réelles distinctes qui séparent les i+1 racines de P
i+1
.
Bissection de Givens
Soit µ un réel. Soit ( ) ( ) ( ) ( ) ( ) { } µ µ µ
i
P signe P signe i E K
1
, , + = . On définit ( ) µ , i N le nombre de
changement de signe dans ( ) µ , i E . Alors ( ) µ , i N représente le nombre de racines de P
i
qui sont inférieures et
distinctes de µ.

On ordonne les λ
i
de manière croissante :
n
λ λ < <L
1
. Considérons 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
réitère…
Une variante pour éviter les overflows
(…)
-
Méthode de la puissance itérée
Soit A une matrice quelconque, éventuellement à coefficient complexe.
Théorème
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'hypothèse "
0
q un vecteur non orthogonal au sous-espace propre à gauche
6
associé à λ" n'est
pas nécessaire, car le phénomène d'arrondi permet de s'éloigner du cas orthogonal !
- Si A n'est pas diagonalisable, la méthode fonctionne encore, mais la convergence est plus lente.
- En pratique, on choisit la norme infinie, et ( ) 1 , , 1
0
K = q .
Méthode de la déflation
On suppose maintenant que l'on connaît λ
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 symétrique ?). Le principe est simple, on forme la matrice B tel que
*
1 1 1
u u A B λ − = .
Cette matrice possède les mêmes valeurs propres, les mêmes vecteurs propres, sauf λ
1
et u
1
. Par conséquent, si
l'on applique la méthode de la puissance itérée, on va obtenir λ
2
et u
2
.

En pratique, on ne calcule pas B… La seule différence avec la méthode de la puissance itérée est dans la formule
( )
1 1
u q A x
k k k
α − =
+
. (Phénomène d'arrondi compensatoire inverse…)

Cette méthode permet en réitérant de trouver λ
3
, λ
4
mais pas au delà, car il y a répercussion des erreurs d'arrondi.
Méthode de la puissance itérée inverse
Cette méthode permet de calculer la plus petite valeur propre λ
n
et son vecteur propre u
n
. On prend
1 −
= A B et
on applique la méthode de la puissance itérée à B, ce qui donne
n
u et
n
λ
1
.

Pour trouver la valeur propre la plus proche de µ, on applique la méthode de la puissance itérée à
Id A B . µ − = , ce qui donne
k
u et µ λ −
k
.
XX. Approximation polynomiale & Intégration
numérique
a. Approximations polynomiales
i. Polynômes orthogonaux
Soit ( ) ( ) ( )

=
b
a
dx x W x Q x P Q P, avec ( ) 0 ≥ x W un poids. Considérons
n
P P P , , ,
1 0
L avec P
i
un
polynôme de degrés 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 zéros, [ ] 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 .
Théorèmes
- 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 polynôme P
de degrés inférieur ou égal à n tel que
∞ ∞
− ≤ − f Q f P pour tout polynôme Q de degrés inférieur ou égal
à n.
Théorème
On considère
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 polynôme Q de
degrés n. P est la meilleure approximation uniforme sur [ ] b a, .
Algorithme
Du point de vue informatique, on se donne une tolérance 0 > ε , d'où si ε α ≤ − −

P f , alors pour tout
polynôme Q de degrés 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 démontre que l'algorithme converge.
iii. Approximation par interpolation
Considérons n+1 points
n
x x x < < < L
1 0
. Soit P un polynôme de degrés n tel que ( ) ( )
i i
x f x P = . Un tel
polynôme existe et on démontre qu'il est unique. On définit ( )


=
|
|
¹
|

\
|


=
n
j k
k k j
k
j
x x
x x
x W
0
un polynôme de degrés 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 définit ( ) ( ) ( ) 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 définit le polynôme P de degrés 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 réalise l'interpolation sur N sous-segments de longueur
N
a b −
avec 5 ou 6 points (en pratique).
Intégration numérique
Si
n
P converge uniformément 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 nécessairement a b a
i
i
− =

.
La méthode 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 = .

Théorème : 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 polynôme de degrés 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
méthode est d'ordre 2, et non d'ordre 1 comme on le croit souvent !
Formule des trapèzes
Les polynômes qui interpolent sont de degrès 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 méthode 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 méthode est d'ordre 4.
v. Spline
Théorème
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 polynôme de degrés 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 différentielles
a. Généralités
Problème de Cauchy
Soit [ ]
M M
R R a x x f → × +
0 0
, : , continue, telle que ( ) ( ) y x f y x , , a . Etant donnée 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
, problème de Cauchy
dimension M et d'ordre 1.

Le problème 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 ramène au problème de Cauchy d'ordre 1 en posant
( ) |
|
|
|
|
¹
|

\
|

=
−1 P
y
y
y
z
M
, de dimension PM .
Théorème (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 problème de Cauchy d'ordre 1
possède une solution unique.
b. Méthode de résolution numérique
On se place dans le cadre de ce théorème, 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 générale employée pour la résolution numérique des équations
différentielles 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
méthode. Posons
n
n
ε ε sup = . La méthode est stable si et seulement si ε A y z A
n n
n
≤ − ∃ max / .
Consistance
La méthode 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
méthode 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 méthode 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 méthode est stable et consistante [d'ordre p], alors la méthode est convergente [d'ordre p].
Théorème 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 méthode est stable.
Théorème 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. Méthode 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. Méthode du développement 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 dérivées rend la méthode impraticable !
e. Méthode 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 prédicteur
2 / 1 + n
y , la méthode 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 méthode est
d'ordre 2, et correspond à une amélioration 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 tolérance ε > 0.
- On choisit arbitrairement h et on applique la méthode.
- On recommence avec 2 / h . Si le résultat obtenu pour un pas divisé par 2, est à ε près celui obtenu pour un
pas de h alors le pas est bon, sinon on réitère. 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 d’une action qui échange deux variables A et B

Action : Echange
Var : A, B, C : réels
Début : Ecrire (« Saisissez deux variables »)
Lire (A, B)
C <= A
A <= B
B <= C
Ecrire (« les valeurs de », A, « et de » , B, « ont été changées »)
Fin


Exercice 2 :
Ecrire une fonction qui donne les carré d’un réel

Fonction : carré (x :réel) :réel
Var : x_au_carré
Début
x_au_carré <= x*x
retourner x_au_carré
fin

Remarques :

Dans une fonction, la seule variable qui est définie est celle du résultat, les autres sont définies dans la fonction
mère, et apparaissent ici en temps qu’entrées.
Dans une fonction, ne pas oublier de retourner le résultat.


A.BENHARI 93

Exercice utilisant les structures SI…ALORS…SINON et SELON…QUE

Exercice 3 :
Ecrire une action qui fournit les félicitations ou l’ajournement d’un élève suivant sa note en utilisant Si-alors-
sinon.

Action : Jury
Var : note : réel
Début : lire (note)
Si note <10 alors écrire (« ajourné »)
Sinon écrire (« reçu »)
Fin

Exercice 4 :
Ecrire un programme qui donne la valeur absolue de 2 réels :

Action : Valeur_absolue
Var : a, b : réels
Début : Ecrire (« saisissez 2 réels »)
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 créant une fonction valeur absolue et en faisant appel à cette fonction dans
une action :

Fonction : valAbs (x :réel) :réel
Var : absx : réel
Début : si x <0 alors absx <= -x
Sinon absx <= x
Retourner absx
Fin

Et
Action : Valeur_absolue2
Var : A, B réels
Début : Ecrire (« saisissez 2 réels »)
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 d’un cylindre en faisant appel à une fonction ‘aire d’un cercle’.

Fonction : aire_cercle (rayon :réel) :réel
Var : Aire : réel
Const : PI=3.14
Début : Aire <= PI*rayon*rayon
Retourner (Aire)
Fin

Fonction : volume_cercle (hauteur, rayon :réels) :réel
Var : volume : réel
Début : Volume <=aire_cercle (rayon)*hauteur
Retourner volume
Fin
A.BENHARI 94



Exercice 6 :
Ecrire un algorithme permettant de résoudre une équation du premier degré

Action : premierdegre
Var : a, b, x réels
Début : Ecrire (« saisissez les valeurs a et b de l’équation 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 résoudre une équation du second degré en utilisant des si alors..

Action : seconddegré
Var : a, b, c, delta
Début : Ecrire (« saisissez les valeurs a, b et c de l’équation ax²+bx+c=0 : »)
Lire (a, b, c)
Si a=0 alors écrire (« équation du premier degré »)
Sinon delta<=b²-4*a*c
Début
Si delta>0 alors écrire (« les solutions de l’équation sont », (-b-sqrt(delta))/(2*a), « et », (-
b+sqrt(delta))/(2*a))
Sinon
Début
Si d=0 alors écrire ( -b/(2a))
Sinon écrire (« pas de solutions réelles »)
Fin
Fin
Fin

Ecrire le même algorithme avec des selon-que :

Action : seconddegré
Var : a, b, c, delta
Début : Ecrire (“saisissez les valeurs de a, b et c de l’équation ax²+bx+c)
Lire (a, b, c)
Si a=0 alors écrire (« résoudre permier degré »)
Sinon début
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 réelle »)
Fin selon
Fin











A.BENHARI 95

Exercice 8
Ecrire un algorithme qui donne la durée de vol en heure minute connaissant l’heure de départ et l’heure
d’arrivée.
1) on considère que le départ et l’arrivée ont lieu même jour
2) idem mais sans faire les conversions en minutes
3) on suppose que la durée de vol est inférieure à 24 heures mais que l’arrivée peut avoir lieu le
lendemain.


1)
Action : DuréeVol1
Var : h1, h2, m1, m2, hr, mr : entiers
Début : Ecrire (« entrer horaire de départ et d’arrivée »)
Lire (h1, m1, h2, m2)
mr <= [h2*60+m2] – [h1*60+m1]
hr <= mr/60
mr <= mr%60
Ecrire (« durée de vol : » , hr, mr)
Fin

Remarque : l’opération % (modulo) permet de calculer le reste de la division entière.

2)
Action : DuréeVol2
Var : h1, h2, hr, m1, m2, mr : entiers
Début : Ecrire (« entrer horaire de départ et d’arrivée »)
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 : DuréeVol3
Var : h1, h2, m1, m2, hr, mr : entiers
Début : Ecrire (« entrer horaire de départ et d’arrivée »)
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
Début : 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
Début
Retourner (–max3(-a, -b, -c))
Fin

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

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


Exercice 10
Ecrire avec des Si Alors Sinon une action permettant la saisie d’une note n (0≤n≤20) et qui affiche la mention
(n≥16 : TB, n≥14 : B, n≥12 : AB, n≥10 : Passable, n≥10 : Ajourné)

Action : Mention
Var Note : réel
Début : Ecrire (« saisissez une note »)
Lire (Note)
Si Note≥16 alors écrire (« TB »)
Sinon
Si Note≥14 alors écrire (« B »)
Sinon
Si Note≥12 alors écrire (« AB »)
Sinon
Si Note≥10 alors écrire (« Passable »)
Sinon écrire (« ajourné »)
Fin

A.BENHARI 97

Alternative : écrire le même programme avec des Selon Que :

Action : Note
Var : Note : réel
Selon que
Note ≥ 16 écrire (« TB »)
Note ≥ 14 écrire (« B »)
Note ≥ 12 écrire (« AB »)
Note ≥ 10 écrire (« Passable »)
Sinon écrire (« ajourné »)


Exercice 11
Soit l’algorithme suivant :
Action : Permis_voiture
Var : permis, voiture : booléen
Début : 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 (« j’ai une voiture pas chère »)
Sinon
Si voiture alors écrire (« vous êtes hors la loi »)
Sinon écrire (« vive le vélo »)
fin


1) Ecrire l’arbre des conditionnelles
2) Corriger les tests pour que tous les cas soient couvert de manière cohérente
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 vélo Conduisez moi à la gare Voiture pas chère
Conduisez moi à la gare Voiture pas chère Hors la loi Vive le vélo

En clair, selon l’algorithme proposé : si l’on a le permis et la voiture on peut amener quelqu’un à la gare ; si l’on
a que le permis on dit vive le vélo, si l’on n’a que la voiture on conduit aussi à la gare, enfin si l’on a ni permis ni
voiture alors on achète une voiture pas chère. Le cas hors la loi n’est pas évoqué et les correspondance sont
inexactes. Il faut évidemment avoir :
- permis et voiture : conduire à la gare
- permis : j’ai une voiture pas chère
- voiture : vous êtes hors la loi
- ni voiture, ni permis : vive le vélo

Correction de l’algorithme proposé :
Action : Permis_voiture
Var : permis, voiture : booléen
Début : 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 (« j’ai une voiture pas chère »)
Sinon
Si voiture alors écrire (« vous êtes hors la loi »)
Sinon écrire (« vive le vélo »)
A.BENHARI 98



On peut effectivement écrire cet algorithme avec des selon-que :
Action : permis_voiture
Var : permis voiture : réel
Début : 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 (« j’ai une voiture pas chère »)
Non permis et voiture : (« vous êtes hors la loi »)
Non permis et non voiture : (« vive le vélo »)
Fin


Exercice 12
Ecrire un programme calculatrice permettant la saisie de deux entiers et une opération –booléen- ( +, - , / , x ) et
affichant le résultat. Donner avant cela les spécifications, la solution en langage naturel, les structures de
données.

Spécifications :
Données : 2 opérandes et un opérateur
Résultat : résultat de l’opération choisie

Solution en langage naturel : Saisie des données, envisager tous les cas : +, - , x, /. Attention à la division par
zéro qui est impossible

Structure de données : 2 opérandes : des entiers
Un opérateur booléen : +, -, * , /

Algorithme :

Action : calcul
Var : a, b : réel op : booléen
Début Ecrire (« saisissez le premier entier »)
Lire (a)
Ecrire (« saisissez l’opérateur »)
Lire (op)
Ecrire (« saisissez la deuxième 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 répétitives TANT QUE et REPETER…JUSQU'A et
POUR
Exercice 13
Ecrire le programme qui affiche la somme d’une suite d’entiers saisie par l’utilisateur se terminant par zéro.
Exemple : l’utilisateur entre 1, puis 5, puis 2, puis 0 : affiche : 8
1) donner les spécifications
2) donner la solution en langage naturel
3) indiquer les structures de données
4) faites l’algorithme

Spécifications :
- données : suite de nombre entiers se terminant par zéro
- résultat : la somme de ces entiers

Solution en langage naturel : tant que l’entier saisi n’est pas zéro, l’ajouter à la somme partielle et saisir l’entier
suivant.

Structure de données :
- entier : entier courant (saisi)
- entier : somme partielle

Algorithme :
Action : Somme Suite
Var : a, s : entiers
Début s<=0 Attention : dans une structure tant que ne pas oublier d’initialiser!!!
Lire (a)
Tant que a≠0 faire
Début
s<=s+a
Lire (a)
Fin
Ecrire (s)
Fin


Exercice 14
Ecrire un algorithme qui affiche la moyenne d’une suite d’entiers se terminant par zéro (le zéro n’entrant pas en
compte dans la moyenne : il est juste la pour indiquer la fin de saisie)
1) donner les spécifications
2) donner la solution en langage naturel
3) indiquer les structures de données
4) faites l’algorithme

Spécification :
- données : suite d’entier se terminant par zéro
- résultat : la moyenne de ces entiers (zéro exclu)

Solution en langage naturel :
Tant que l’entier saisi différent de 0 alors ajouter l’entier aux entiers précédents et faire la moyenne (c’est à dire
diviser par le nombre d’entiers

Structures de données :
- entier : entier saisi
- entier : résultat moyenne

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

Lire (n)
Tant que n≠0 faire
Début
Moy <= moy*s+n)/(s+1)
s<=s+1
lire (n)
fin
Ecrire (moy)
Fin


Exercice 15
Ecrire un algorithme permettant la saisie d’une suite d’entiers se terminant par zéro et vérifier si cette suite
contient deux entiers consécutifs égaux en utilisant les structures tant que.
1) donner les spécifications
2) donner la solution en langage naturel
3) indiquer les structures de données
4) faites l’algorithme

Spécifications :
- données : suite d’entier se terminant par zéro
- résultat : vrai si deux entiers consécutifs, faux sinon.

Solution en langage naturel : comparer l’entier courant et le précédent. Et tant que ils sont différents, on continu
la lecture et tant que l’entier courant est différent de zéro.

Structures de données :
- entier : nombre courant
- entier : nombre précédent

Algorithme :
Action : Entiers consécutifs
Var : nc, np : entier
{on désignera par nc le nombre courant et np le nombre précédent}
Début Lire (nc)
np<=nc-1
{pour être sur que le nombre courant ne sera pas le même que le nombre précédent dès le départ on affecte la
valeur nc-1 au nombre précédent. On aurait tout aussi bien pu lui donner la valeur zéro)
Tant que nc≠0 et np ≠nc faire
Début
np<=nc
lire (nc)
fin
Si nc≠0 alors écrire (« oui »)
Sinon écrire (« non »)
Fin

Refaire le même algorithme en utilisant une structure répéter jusqu'à
Action : Entiers consécutifs
Var : nc, np : entiers
Début
Lire (nc)
Si nc ≠ 0 alors Répéter
Début
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 d’une suite se terminant par zéro
1) donner les spécifications
2) donner la solution en langage naturel
3) indiquer les structures de données
4) faites l’algorithme

Spécifications :
- données : une suite d’entiers se terminant par zéro
- résultat : un entier : le maximum de cette suite

Solution en langage naturel : comparer l’entier courant avec le maximum et tant que nc<max on continue, sinon
on affiche la résultat et on continue, et tant que nc ≠0

Structures de données
- n : entier courant (saisi)
- max : entier max de la suite

Algorithme :
Action : max suite
Var : n, max : entiers
Début Lire (n)
Max<=n
Tant que n≠ 0 faire
Début
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 qu’il
souhaite. A chaque échec, le programme lui indique si l’entier cherché est plus grand ou plus petit que sa
proposition.
Un score indiquant le nombre de coups joués est mis à jour et affiché lorsque l’entier est trouvé.
1) donner les spécifications
2) donner la solution en langage naturel
3) indiquer les structures de données
4) faites l’algorithme

Spécifications :
- données : nombre entier
- résultat : nombre de tentatives

Solution en langage naturel : saisir un nombre entier par le premier joueur. Tant que le joueur 2 n≠saisie, dire si
n est > ou < à nombre cherché, incrémenter de 1 et continuer. Quand le résultat est trouvé, afficher le nombre de
tentatives.

Structures de données :
- a : nombre saisi par l’utilisateur 1
- n : nombre saisi par l’utilisateur 2
- t : tentatives

Algorithme :
Action : devinette
A.BENHARI 102

Var : a, n, t : entiers
Début : Lire (a)
Lire (n)
t=0
Tant que a≠n faire
Début
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 l’astuce suivante : soustraite
le plus petit des deux entiers du plus grand jusqu'à ce qu’ils soient égaux
Ecrire le même programme en utilisant l’algorithme d’Euclide : d’une part en utilisant uniquement les structures
TANT QUE, d’autre part en utilisant uniquement les structures REPETER JUSQU'A.

Action : PGCD
Var : a, b entiers
Lire (a, b)
Début
a = ValAbs (a)
b = ValAbs (b)
Répéter
Selon que
a>b a<=a-b
a<b b<=b-a
jusqu’a a=b
écrire (a)
Fin

Même programme avec Euclide et des TANT QUE :
Action : PGCD
Var : a, b, r entiers
Lire (a, b)
r<=a%b
tant que r≠0 faire
début
a<=b
b<=r
r<=a%b
fin
écrire (b)
fin

Même programme avec Euclide et des REPETER JUSQU'A :
Action : PGCD
Var : a, b, r entiers
Lire (a, b)
Répéter 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 d’une suite de nombre entrée par
l’utilisateur. Faire la même chose en comptant par pas de –1.

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

Même programme par pas de –1 :
Action : somme_entier
Var : k, nb, n, somme : entiers
Début :
Somme<=0
Ecrire (« combien voulez-vous entrer de nombres ? »
Lire (nb)
Pour k de nb à 1 par pas de –1 faire
Début
Lire (n)
Somme<=somme + n
Fin
Ecrire (somme)
Fin


Exercice 20
Traduire le POUR de l’algorithme suivant en REPETER JUSQU'A :
Action : bidon
Var : k, nb : entiers
Début
Lire (nb)
Pour k de 1 à nb faire
Ecrire (k)
Fin

Action : Bidon
Var : k, nb : entier
Début
Lire (nb)
K<=1
Si nb>0 alors
Répéter é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
Début
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
Début
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 d’un tableau croissant : si T[k]<T[k+1] on enregistre, si T[k]>T[k+1] on
redemande la saisie d’un nombre plus grand

Const : MAX=100
Ttype : Ttab=tableau [max]d’entier

Action : saisie_tableau_croissant
Var : tab : Ttab, i : entier
Début
Lire (Tab[0])
Pour i de 1 à MAX-1 faire
Répéter lire (tab[i])
jusqu'à tab[i] ≥ tab[i-1]
Fin


Exercice 24
Ecrire une fonction retournant le maximum d’un tableau de taille n.
Faire le même algorithme mais qui ne retourne que l’indice de la case du tableau contenant le maximum du
tableau.

Fonction : maximum (tab : Tableau d’entier n :entier) : entier
Var : max, i : entiers
Début
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 d’entier n :entier) : entier
Var : indice, i, max : entiers
Début
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 généraux sur les actions paramétrées

5) Exercice 25
6) Ecrire une fonction Afficher qui affiche a l’écran le contenu d’un tableau. Ecrire aussi l’action
principale qui permettra de comprendre comment fonctionne cette fonction afficher.
7)
8)
9) {Ne pas oublier d’indiquer les paramètres du tableau !}
10) Const : MAX : entier=100
11) Type : Ttab : Tableau [MAX] d’entier
12)
13) Fonction Afficher (tab : tableau d’entiers, n entiers)
14) Var : i entier
15) Début :
16) Pour i de 0 à n-1
17) Ecrire (tab[i], « »)
18) Fin
19)
20) Action principale
21) Var t1 t2 : Ttab
22) Début
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) Résultat à l’écran :
33) 1 3
34) 4 5 7
35)
36)
37) Exercice 26
38) Ecrire une fonction qui permet la saisie d’un tableau. Faite aussi l’action principale qui permettra
d’accéder a cette fonction saisie mais aussi d’afficher dans un second temps le résultat
39)
40) Fonction : saisie (Stab : tableau d’entiers, N :entier)
41) Var : i entier
42) Début :
43) Pour i de 0 à n-1 faire
44) Lire (tab[i])
45) Fin
46)
47) Action principale
48) Var : tabl : Ttab
49) Début
50) Saisie (toto, 10)
51) Afficher (toto, 10)
52) Fin
53)
54) Ou afficher est la fonction de l’exercice 1.
55)
56)
57)
58)
59)
A.BENHARI 107

60) Exercice 27
61) Ecrire une fonction qui calcule le nombre d’inversion d’un tableau de taille n (c’est à dire i<j et
tab[i]>tab[j] pour tout i et j.)
62)
63) Fonction inversion (tab : tableau d’entiers, N entier)
64) Var : j, C, i entiers
65) Début
66) C<=0
67) Pour i de 0 à n-2 faire
68) Début
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 éléments de la suite définie par u
0
=1 et u
n+1
=somme de k=0
jusqu'à n de (u
k
*u
n-k
)
78) Aide : stocker les éléments dans un tableau toto avec toto[0]=1. Puis on utilise une boucle imbriquée
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) Début :
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 d’entiers, E : n : entier)
99) Var : i :entier
100) Début
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 d’entier, E : n :entier)
107) Var : temp
108) Début
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 d’entiers, E : n : entier)
A.BENHARI 108

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

Entités : types structurés
1 Explications 1 :
2 Les types structurés sont :
- les tableaux (voir les exercices précédents)
- les entités (ou l’on regroupe plusieurs types sous un même objet)
3
4 Exemple :
5 Etudiant (nom, groupe, note)
6 Type : Etd : entité (
7 Nom : chaîne de caractère ;
8 Groupe : caractère ;
9 Note : entier ;
10 ) ;
11
12 Pour faire appel à ce type d’entité on fera dans la fonction :
13 Var : Tetd toto ;
14 Toto.nom=alex
15 Toto.groupe=A
16 Toto.note=15
17 Ecrire (« l’étudiant », toto.nom, « du groupe », toto.groupe, « a eu », toto.note)
18
19
20 Exercice 30
21 Proposer une entité de données 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-têtes des fonctions/actions suivantes :
- saisie d’un point
- affichage d’un point
- calcul de la distance entre deux points
- projection d’un point sur l’axe 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 résultats.
33
34 Action SaisieTpoint (S : P : Tpoint) {Tpoint a été défini à l’exercice 30}
35 Début
36 Lire (P.abs)
37 Lire (P.ord)
38 Fin
39
40 Action AfficherTpoint (E : P : Tpoint)
41 Début
42 Ecrire (« ( », P.abs, « ; », P.ord, « ) »)
43 Fin
44
45 Fonction distance (P : Tpoint ; Q : Tpoint) : réel
46 Var : dist : réel
47 Début
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 Début
54 P.ord<=0
55 Fin
56
57 Action Principale
58 Var : P, Q : Tpoint
59 Dist : réel
60 Début
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 l’avons fait précédemment :
70 Nous utiliserons les entités. Ainsi la déclaration se fera de la manière suivante :
71 Const MAX=100
72 Type : TtabVar=entité (
73 Tab : tab[MAX] d’entier
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 manière d’entrer un tableau : on peu avoir un tableau de taille variable.
82
83
84 Exercice 32
85 Ecrire un algorithme qui permet de rentrer les données d’un tableau de type TtabVar et dont on connaît la
taille.
86 Ecrire ensuite un algorithme qui permet de rentrer les données d’un tableau de type TtabVar et ou l’on ne
connaît pas la taille.
87
88 Action saisieTtabVar (S : tabvar : TtabVar, E : n : entier)
89 Var : i : entier
90 Début
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 : réponse : chaîne de caractère
98 Début
99 Tabvar.taille<=0
100 Répéter
101 Ecrire (« voulez-vous entrer un entier ? »)
102 Lire (réponse)
103 Si réponse≠ « non » alors
104 Lire (tabvar.tab[tabvar.taille])
105 Tabvar.taille++
106 Jusqu’à (réponse= « 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 préalable créer un nouveau type d’entité.
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 : réponse : chaîne de caractère
120 Début
121 Tabvar.taille<=0
122 Répéter
123 Ecrire (« voulez-vous entrer un entier ? »)
124 Lire (réponse)
125 Si réponse≠ « non » alors
126 Lire (tabvarpt.tab[tabvarpt.taille].abs)
127 Lire (tabvarpt.tab[tabvarpt.taille].ord)
128 Tabvarpt++
129 Jusqu’à (réponse= « non » ou tabvar.taille=MAX)
130
131
132 Exercice 34
133 Ecrire un algorithme qui détermine le point ( ( !) c’est à dire son indice)le plus au nord et le point le plus a
l’ouest dans un tableau de Tpoint.
134 Faire ensuite une action principale qui demande la saisie d’un tableau de Tpoint à l’utilisateur (voir
exercice 33) et affiche l’élément le plus au nord et l’élément le plus à l’ouest.
135
136 Action NordOuest (E : tvp : TtabVarPt, S : nord : entier, S : ouest : entier)
137 Var : i : entier
138 Début
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 Début
149 Saisie TtabVarTpoint (toto)
150 NordOuest (toto, n, o)
151 Ecrire (« l’élément le plus au nord est », AfficherTpoint(toto.tab[n])
152 {ou AfficherTpoint est la fonction de l’exercice
31}
153 Ecrire(« l’élément le plus à l’ouest est », AfficherTpoint(toto.tab[o])
154 Fin












A.BENHARI 112

155 Exercice 35
156 Ecrire un algorithme qui détermine la distance maximale entre deux points d’un tableau de Tpoint
157
158 Action DistMax (E : tvp : TtabVarPt)
159 Var : i, j : entiers ; Dmax, dist : reels
160 Début
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 triés et découpages fonctionnels
Exercice 36
Le but de l’exercice est de créer une action de saisie de tableau, qui trie, au fur et à mesure des entrées, les
valeurs par ordre croissant dans le tableau.
Exemple :
Soit le tableau suivant :
0 1 2 3
2 5 7 9
Comment insérer 6 dans le tableau trié (en supposant qu’il n’y a pas de doublon dans le tableau) ?
- je cherche la bonne position (ici : la case d’indice 2)
- décalage à droite si nécessaire :
0 1 2 3 4
2 5 7 7 9
- Insertion de l’élément
0 1 2 3 4
2 5 6 7 9

126) On a donc ici le découpage fonctionnel :
On va donc créer une fonction IndiceEltSup qui cherche la bonne position, une action Insérer qui inclue le
nombre entré dans la bonne case du tableau, et une action DécalageDroite qui décale comme dans l’exemple
toutes les cases d’un rang vers la droite si nécessaire.

Const MAX=100
Type TtabVar = entité (tab : tableau[MAX] d’entiers, taille : entier)

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

Action DécalageDroite (ES : tvt : TtabVar, E : i : entier)
Var : j : entier
Début
Pour j de tvt.taille – 1 à i par pas de –1 faire
Tvt.tab[j+1]<=tvt.tab[j]
Tvt.taille++
Fin

Action Insérer (ES : tvt : TtabVar, E : i : entier, E : i : entier)
Début
DécalageDroite (tvt, i)
Tvt.tab[i]<=i
Fin

Action SaisieTrié (S : tvt : TtabVar)
Var : rep : chaîne, nb : entier, i : entier
Début
Tvt.taille<=0
Répéter
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)
Insérer (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 l’exercice précédent.

Nous allons créer une action qui définie la zone de recherche, puis l’action RechercheDicho qui opérera la
recherche dichotomique dans l’intervalle définie par la zone de recherche.

Action ZoneRecherche (E : tvt : TtabVar, E : n : entier, ES : Binf : entier, ES : Bsup : entier)
Var : milieu : entier
Début
Milieu <= (Binf + Bsup)/2
Si tvt.tab[milieu]=n alors
Début
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
Début
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 précédents.

Le but est d’utiliser la recherche dichotomique de l’exercice précédent pour trouver dans le tableau l’indice de la
valeur que l’on veut supprimer puis faire un décalage à gauche pour remettre en place les valeurs (sans qu’il y ait
de vide dans une case du tableau)

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

Action DecalageGauche (Es : tvt : TtabVar, E : i : entier)
Var : j: entier
Début
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 Chaînes
On va maintenant faire des exercices sur les chaînes de caractères.
En pratique on pourra définir une chaîne de caractères de deux manières :

Const MAX entier = 100
Type Tchaine = entité ( tab : tableau[MAX] de caractères
Longueur : entier)

Ou bien :

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


Exercice 39
Faire un algorithme qui détermine la longueur d’une chaîne de caractères.
Faire ensuite de deux manières différentes, une fonction qui permet de copier la chaîne d’une source dans une
chaîne destination.

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


Fonction de copie : première méthode :
Fonction Copier (E : src : Tchaine, S : dest : Tchaine)
Var i, Lsrc : entier
Début
LsrcLongueur(src)
Pour i de 0 à Lsrc faire dest[ i ]src [ i ]
Fin

Fonction de copie : deuxième méthode : plus optimisée :
Fonction CopieOptimisée (E : src : Tchaine, S : dest : Tchaine)
Var i : entier
Début
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 concaténation (ajoute à la fin de la première chaîne de caractères le contenu de la deuxième
chaîne de caractères.)
Faire une fonction de Comparaison qui compare deux chaînes de caractères suivant l’ordre lexicographique.
Faire une fonction qui efface une partie de la chaîne en spécifiant une longueur d’effacement et un indice à partir
duquel il faut effacer.

Action Concaténation (ES : src1 : Tchaine, E : src2 : Tchaine)
Var i, Lsrc1 : entiers
Début
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 d’abord créer une fonction qui compare les caractères :
Fonction ComparerChar (char a, char b)
Début
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 chaînes de caractères qui utilisera la fonction
ComparerChar :
Fonction Comparer (E : src1 : Tchaine, E : src2 : Tchaine)
Var i, L1, L2, cmp : entiers
Début
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
Début
LsrcLongueur (src)
Pour i de indice+lg à Lsrc faire
Src[i-lg]src[ i ]
Fin







A.BENHARI 117

Exercice 41
Ecrire l’en-tête d’une action multi décalage à droite qui décale à droite les éléments d’une chaîne à partir d’un
certain indice et insère des cases vides à la place. (des actions de multi décalage ont déjà été vue avec les
tableaux, on ne demande pas d’en refaire une ici, ce référer aux exercices sur les tableaux)
Faire une action d’insertion. On pourra pour cela utiliser au paravent la fonction multi décalage à droite
précédente.
Faire une action de remplacement d’une partie d’une chaîne de caractères par une autre chaîne de caractères dont
la longueur n’est pas forcément la même. On pourra utiliser des fonctions des exercices 39 et 40.
Faire une fonction Extraire qui prend une partie de chaîne de caractères à partir d’un certain indice et la met dans
une chaîne destination.
Faire une fonction de recherche qui recherche une chaîne dans une chaîne de caractère et retourne un indice si à
partir de cette case on a la chaîne cherchée. Sinon, elle retourne –1.
Faire une action qui changent toutes les occurrences d’une chaîne dans une chaîne de caractères par une autre
chaîne tampon.

Action MultidécalageDroite (ES : src : Tchaine, E : indice : entier, E : lg : entier)

Action Insérer (ES : src : Tchaine, E : indice : entier, E : motif : Tchaine)
Var i, Lsrc, Lmotif : entier
Début
LmotifLongueur(motif)
MultidécalageDroite (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)
Début
Effacer (src, indice, lg)
Insérer (src, indice, motif)
Fin

Fonction Recherche (src : Tchaine, motif : Tchaine, Binf : entier)
Var : i, Lsrc, Lmotif : entiers
Tampon : Tchaine
Début
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
Début
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 d’abord 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, élément) cela correspond à Lire(n) cin>>n

Pour écrire un fichier
EcrireFichier (IdFic, élément) cela correspond à Ecrire(n) cout<<n


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

Action EntierPairs (E : Fic : fichier d’entiers)
Var n : entier
Début
OuvrirFichier (Fic, lecture)
Si EtatFichier (Fic) = succès 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 d’ouvrir le fichier en lecture »)
Fin

Action EntiersPairsFichier (E : f1 : fichier d’entiers, ES : f2 : fichier d’entiers)
Var n : entier
Début
OuvrirFichier (f1, lecture)
Si EtatFichier (f1) = succès alors
OuvrirFichier (f2, écriture)
Si EtatFichier (f2) = succès 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 d’entiers) : booléen
Var bool rep false
Début
OuvrirFichier (f, lecture)
Si EtatFichier(f)=succès alors
A.BENHARI 119

LireFichier(f, n)
Tant que (EtatFichier(f) ≠ FdF ET n≠x) 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 d’entiers. Le fichier de sortie doit être trié.

Action Fusion ( E : f1 : fichier d’entiers, E : f2 : fichier d’entiers, S : f3 : fichier d’entiers)
Var : f3 : fichier d’entiers
Début
OuvrirFichier (f1, lecture)
Si EtatFichier (f1)=succès alors
OuvrirFichier (f2, lecture)
Si EtatFichier (f2)=succès alors
OuvrirFichier (f3, écriture)
Si EtatFichier (f3)=succès 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
Répéter
EcrireFichier (f3, n1)
LireFichier(f1, n1)
Jusqu'à EtatFichier(f1)=FdF
Si EtatFichier (f2) ≠ FdF alors
Répéter
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 : chaîne
Numéro : étudiant
Notes : tableau [5] d’entiers
Moyenne : entier)
On suppose que la fonction de saisie
Fonction SaisieEtd () : Tetd
131) Permettant de saisir un tableau de Tetd existe. On pourra donc s’en servir

Ecrire une fonction qui permet de saisir un groupe d’étudiant dans un fichier.
Ecrire une fonction qui permet de calculer la moyenne générale d’un groupe d’étudiant.


Action SaisieGroupe (E : nb : entier, S : Fic : fichier de Tetd)
Var : etd : Tetd i : entier
Début
OuvrirFichier (fic, écriture)
Si EtatFichier (fic)=succès alors
Pour i de 1 à nb faire
EtdSaisieEtd( )
EcrireFichier (fic, etd)
FermerFichier (fic)
Sinon écrire (« Erreur »)
Fin

Fonction Moyenne (fic : fichier de Tetd ) : réel
Var : Som : réel
Début
Som0
nb 0
OuvrirFichier (fic, lecture)
Si EtatFichier (fic)=succès 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 données 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