Cours d’algorithmique Objectif et plan du cours

 Objectif:
1ère année IMSP • Apprendre les concepts de base de l'algorithmique et de la
programmation
2020/2021, Semestre 1
• Etre capable de mettre en oeuvre ces concepts pour analyser des
problèmes simples et écrire les programmes correspondants
«Ce que l’on conçoit bien s’énonce clairement et les
 Plan:
mots pour le dire arrivent aisément» [N. Boileau] • Généralités (matériel d’un ordinateur, systèmes d’exploitation, langages
de programmation, …)

• Algorithmique (affectation, instructions conditionnelles, instructions

itératives, fonctions, procédures, …)

2020/2021 IMSP - Niv1 1 2020/2021 IMSP - Niv1 2

Système Informatique? Matériel: Principaux éléments d’un PC

 Techniques du traitement automatique de l’information au
moyen des ordinateurs  Unité centrale (le boîtier) Processeur ou CPU
Système informatique = ordinateur + périphériques (Central Processing Unit)
• Mémoire centrale
Éléments d’un système informatique

• Unité de calcul

Applications
• Unité de commande
(Word, Excel, Jeux, Maple, etc.)
Langages
(Java,C/C++, Fortran,etc.)
Système d’exploitation  Périphériques
(DOS,Windows, Unix, etc.) • Moniteur (l'écran), clavier, souris
Matériel • Modem, imprimante, scanner, …
(PC, Macintosh, station SUN, etc.)

2020/2021 IMSP - Niv1 3 2020/2021 IMSP - Niv1 4

Qu’est-ce qu’un programme Les catégories d’ordres

d’ordinateur?
 Allumez un ordinateur, vous n’en tirerez rien!!  les ordinateurs, quels qu’ils soient, ne sont
fondamentalement capables de comprendre que
 Pour le faire marcher il faut lui fournir un programme quatre catégories d'ordres (en programmation, on
Ordinateur = matériel + programme(s) n'emploiera pas le terme d'ordre, mais plutôt celui
d'instructions). Ces quatre familles d'instructions
 Un programme est une suite d’instructions d’ordinateur sont :
• l’affectation de variables
 Une instruction est un ordre compris par l’ordinateur et
• la lecture / écriture
qui lui fait exécuté une action, c-a-d une modification de • les tests
son environnement • les boucles

2020/2021 IMSP - Niv1 5 2020/2021 IMSP - Niv1 6

1
 Actions d’un ordinateur : Exemple
Qu’est ce qu’un système d’exploitation?
 Ensemble de programmes qui gèrent le matériel et
 Attendre qu’un nombre soit tapé au clavier contrôlent les applications
 Sortir à l’écran le nombre entré
 Attendre qu’un nombre soit tapé au clavier • Gestion des périphériques (affichage à l'écran, lecture du
clavier, pilotage d’une imprimante, …)
 Sortir à l’écran le nombre entré
 Additionner les deux nombres entrés • Gestion des utilisateurs et de leurs données (comptes,
partage des ressources, gestion des fichiers et répertoires, …)
 Sortir à l’écran le résultat de l’addition
• Interface avec l’utilisateur (textuelle ou graphique):
Interprétation des commandes

Ces lignes forment un programme d’ordinateur • Contrôle des programmes (découpage en taches, partage
du temps processeur, …)

2020/2021 IMSP - Niv1 7 2020/2021 IMSP - Niv1 8

Langages informatiques Langage machine

 Un langage informatique est un outil permettant de  Langage binaire: l’information est exprimée et manipulée sous
forme d’une suite de bits
donner des ordres (instructions) à la machine

• A chaque instruction correspond une action du processeur

 Un bit (binary digit) = 0 ou 1 (2 états électriques)

 Une combinaison de 8 bits= 1 Octet  28  256 possibilités qui permettent

 Intérêt : écrire des programmes (suite consécutive
d’instructions) déstinés à effectuer une tache donnée
• Exemple: un programme de gestion de comptes bancaires
de coder tous les caractères alphabétiques, numériques, et symboles tels que ?,*,&, …
• Le code ASCII (American Standard Code for Information Interchange) donne les
correspondances entre les caractères alphanumériques et leurs
représentation binaire, Ex. A= 01000001, ?=00111111

 Contrainte: être compréhensible par la machine  Les opérations logiques et arithmétiques de base (addition,
multiplication, … ) sont effectuées en binaire

2020/2021 IMSP - Niv1 9 2020/2021 IMSP - Niv1 10

L'assembleur Langages haut niveau

 Problème: le langage machine est difficile à comprendre par l'humain
 Intérêts multiples pour le haut niveau:
 Idée: trouver un langage compréhensible par l'homme qui sera • proche du langage humain «anglais» (compréhensible)
ensuite converti en langage machine • permet une plus grande portabilité (indépendant du matériel)
• Assembleur (1er langage): exprimer les instructions élémentaires • Manipulation de données et d’expressions complexes (réels,
de façon symbolique
objets, a*b/c, …)
ADD A, 4
traducteur  Nécessité d’un traducteur (compilateur/interpréteur),
LOAD B langage machine
MOV A, OUT exécution plus ou moins lente selon le traducteur
…
• +: déjà plus accessible que le langage machine
• -: dépend du type de la machine (n’est pas portable) Code source Compilateur ou
Langage machine
• -: pas assez efficace pour développer des applications complexes en langage évolué interpréteur
 Apparition des langages évolués
2020/2021 IMSP - Niv1 11 2020/2021 IMSP - Niv1 12

2
 Compilateur/interpréteur Langages de programmation:
 Compilateur: traduire le programme entier une fois pour toutes
 Deux types de langages:
Compilateur
exemple.c exemple
exécution
• Langages procéduraux : sont à base de procédures. Une
fichier source fichier exécutable procédure est une portion de programme écrit en langage de haut
• + plus rapide à l’exécution
niveau qui accomplit une tâche spécifique nécessaire au
• + sécurité du code source
programme.
• - il faut recompiler à chaque modification • Langages orientés objets : sont des langages non procéduraux
dans lesquels les éléments du programme sont considérés comme
 Interpréteur: traduire au fur et à mesure les instructions du des objets qui peuvent s'échanger des messages.
programme à chaque exécution

exemple.bas
Interprétation+exécution  Choix d’un langage?
fichier source
• + exécution instantanée appréciable pour les débutants
• - exécution lente par rapport à la compilation
2020/2021 IMSP - Niv1 13 2020/2021 IMSP - Niv1 14

Principaux Langages de
programmation: Etapes de réalisation d’un programme
Blaise PASCAL, Langage compilé et structuré,
Enoncé du problème
mathématicien et inventeur de dérivé d'ALGOL. c'est un
Pascal la première machine à langage de développement Spécification
calculer 1971 standard pour les micro-
Cahier des charges
ordinateurs.
Analyse
C'est une version améliorée Langage de programmation
du langage de programmation structuré et compilé, très Algorithme
C B du Bell Laboratory, créé en largement employé car ses Traduction en langage
1972 programmes peuvent
facilement se transférer d'un Programme source
type d'ordinateur à un autre. Compilation
Maple Nasa 1980 de SUN couvrir tous les domaines
Programme exécutable
D’application formel
Tests et modifications
Java Microsystems 1990 Ce langage connaît un Version finale et résultats
succès qu'aucun autre
langage n'avait encore connu. La réalisation de programmes passe par l’écriture d’algorithmes
 D’où l’intérêt de l’Algorithmique
2020/2021 IMSP - Niv1 15 2020/2021 IMSP - Niv1 16

Pourquoi apprendre l’algorithmique

pour apprendre à programmer ? Représentation d’un algorithme
 Un algorithme est une description complète et détaillée des actions à Historiquement, deux façons pour représenter un algorithme:
effectuer et de leur séquencement pour arriver à un résultat donné
• L’Organigramme: représentation graphique avec des symboles
• Intérêt: séparation analyse/codage (pas de préoccupation de syntaxe) (carrés, losanges, etc.)
l’algorithmique exprime les instructions résolvant un problème donné
indépendamment des particularités de tel ou tel langage.
• offre une vue d’ensemble de l’algorithme
• Qualités: exact (fournit le résultat souhaité), efficace (temps d’exécution, • représentation quasiment abandonnée aujourd’hui
mémoire occupée), clair (compréhensible), général (traite le plus grand
nombre de cas possibles), … • Le pseudo-code: représentation textuelle avec une série de
 Pour prendre une image, si un programme était une dissertation, conventions ressemblant à un langage de programmation (sans
les problèmes de syntaxe)
l’algorithmique serait le plan, une fois mis de côté la rédaction et
l’orthographe. Mieux faire d’abord le plan et rédiger ensuite que
• plus pratique pour écrire un algorithme
l’inverse… • représentation largement utilisée

2020/2021 IMSP - Niv1 17 2020/2021 IMSP - Niv1 18

3
 Exemple de pseudo code

 problème du tri
Algorithmique
• Entrée: une séquence de n
nombres (a1, : : : ,an)
• Sortie: une permutation (a1’;
: : : ;an’) de la séquence
d’entrée: a1’<a2’<….<an’

• Exemple : (31;41;59;26;41;58)
Notions et instructions de base
 (26;31;41;41;58;59)

2020/2021 IMSP - Niv1 19 2020/2021 IMSP - Niv1 20

Les catégories d’ordres Notions Fondamentales (1/2)

 Karim possède 3 seaux : un seau en plastique d’une contenance de 10 litres,

 les ordinateurs, quels qu’ils soient, ne sont
fondamentalement capables de comprendre que
quatre catégories d'ordres (en programmation, on
n'emploiera pas le terme d'ordre, mais plutôt celui
d'instructions). Ces quatre familles d'instructions
sont :
• Les variables et leurs affectation
un seau en bois d’une contenance de 7 litres et un seau en fer d’une
contenance de 9 litres.
• 10h00 : karim vide ses 3 seaux
• 10h05 : karim va rendre visite a Nabil, celui-ci met 6 litres dans le seau en bois de
Karim
• 10h10 : karim transverse le contenu de son seau en bois dans le seau en fer
•
10h15 : karim revient vers nabil remplir à ras bord son seau en plastique
• 10h20 : karim déverse la moitié de son seau en plastique à l’égout

• la lecture / écriture • 10h25 : karim transvase le contenu de son seau en plastique dans celui en bois
• 10h30 : karim transvase 2 litres de son seau en bois dans celui en fer
• les tests • 10h35 : karim informe Asmae du nombre de litres contenu dans ses seaux en

• les boucles plastique, en bois, en fer.

Quelles sont les quantités des trois seaux que Asmae a reçues?

2020/2021 IMSP - Niv1 21 2020/2021 IMSP - Niv1 22

Notions Fondamentales (2/2)

Notion de variable
 Notion d’algorithme : si les huit phrases sont bien exécutée par Karim,  Dans les langages de programmation une variable sert à stocker
alors l’histoire est un algorithme
 Notion d’instruction : chacune de huis phrases est une instruction (un
la valeur d’une donnée
ordre)
 Notion de valeur : { 0, 3, 5, 6, 8, 10 }  Une variable désigne en fait un emplacement mémoire dont
 Notion de mémoire : elle est matérialisée par les seaux qui « mémorisent » le contenu peut changer au cours d’un programme (d’où le nom
les quantités de liquide
variable)
 Notion de variable : une variable est un emplacement mémoire, ici on a
trois variables (le seau en plastique, le seau en bois et le seau en fer)
 Notion d’environnement : c’est l’ensemble des objet, informations,  Règle : Les variables doivent être déclarées avant d’être
personnes qui on une existence hors de l’histoire mais qui interviennent dans utilisées, elle doivent être caractérisées par :
son déroulement.
 Notion des valeurs d’entrée et de sortie : c’est les valeurs que le • un nom (Identificateur)
processeur reçoit de l’environnement et celles qu’il donne à l’environnement
durant l’exucution. Valeurs en entrée :{6, 10} Valeurs en sortie = {0, 3, 8} • un type (entier, réel, caractère, chaîne de caractères, …)

2020/2021 IMSP - Niv1 23 2020/2021 IMSP - Niv1 24

4
 Choix des identificateurs (1) Choix des identificateurs (2)
Le choix des noms de variables est soumis à quelques règles qui Conseil: pour la lisibilité du code choisir des noms significatifs
varient selon le langage, mais en général: qui décrivent les données manipulées

 Un nom doit commencer par une lettre alphabétique exemples: TotalVentes2006, Prix_TTC, Prix_HT
exemple valide: A1 exemple invalide: 1A

 doit être constitué uniquement de lettres, de chiffres et du

Remarque: en pseudo-code algorithmique, on va respecter
soulignement _ (Eviter les caractères de ponctuation et les espaces)
valides: SMI2007, SMI_2007 invalides: SMI 2007, SMI-2007, SMI;2007 les règles citées, même si on est libre dans la
syntaxe
 doit être différent des mots réservés du langage (par exemple en
Java: int, float, else, switch, case, default, for, main, return, …)

 La longueur du nom doit être inférieure à la taille maximale spécifiée

par le langage utilisé
2020/2021 IMSP - Niv1 25 2020/2021 IMSP - Niv1 26

Types des variables Déclaration des variables

Le type d’une variable détermine l’ensemble des valeurs qu’elle peut  Rappel: toute variable utilisée dans un programme doit avoir
prendre, les types offerts par la plus part des langages sont: fait l’objet d’une déclaration préalable
 Type numérique (entier ou réel)  En pseudo-code, on va adopter la forme suivante pour la
• Byte (codé sur 1octet): de 0 à 255 déclaration de variables
• Entier court (codé sur 2 octets) : -32 768 à 32 767
• Entier long (codé sur 4 ou 8 octets)
Variables liste d'identificateurs : type
• Réel simple précision (codé sur 4 octets)  Exemple:
• Réel double précision (codé sur 8 octets) Variables i, j,k : entier
 Type logique ou booléen: deux valeurs VRAI ou FAUX x, y : réel
 Type caractère: lettres majuscules, minuscules, chiffres, symboles, … OK: booléen
exemples: ’A’, ’a’, ’1’, ’?’, … ch1, ch2 : chaîne de caractères
 Type chaîne de caractère: toute suite de caractères,
 Remarque: pour le type numérique on va se limiter aux entiers
exemples: " Nom, Prénom", "code postale: 1000", …
et réels sans considérer les sous types
2020/2021 IMSP - Niv1 27 2020/2021 IMSP - Niv1 28

L’instruction d’affectation Quelques remarques

 l’affectation consiste à attribuer une valeur à une variable
(ça consiste en fait à remplir où à modifier le contenu d'une zone mémoire)  Beaucoup de langages de programmation (C/C++, Java, …) utilisent
le signe égal = pour l’affectation ←. Attention aux confusions:
 En pseudo-code, l'affectation se note avec le signe ←
Var← e : attribue la valeur de e à la variable Var • l'affectation n'est pas commutative : A=B est différente de B=A
• l'affectation est différente d'une équation mathématique :
- e peut être une valeur, une autre variable ou une expression
- Var et e doivent être de même type ou de types compatibles • A=A+1 a un sens en langages de programmation
- l’affectation ne modifie que ce qui est à gauche de la flèche • A+1=2 n'est pas possible en langages de programmation et n'est
pas équivalente à A=1
 Ex valides: i ←1 j ←i k ←i+j
x ←10.3 OK ←FAUX ch1 ←"SMI"  Certains langages donnent des valeurs par défaut aux variables
ch2 ←ch1 x ←4 x ←j déclarées. Pour éviter tout problème il est préférable d'initialiser les
variables déclarées
(voir la déclaration des variables dans le transparent précédent)
 non valides: i ←10.3 OK ←"SMI" j ←x
2020/2021 IMSP - Niv1 29 2020/2021 IMSP - Niv1 30

5
 Exercices simples sur l'affectation (1) Exercices simples sur l'affectation (2)
Donnez les valeurs des variables A, B et C après exécution Donnez les valeurs des variables A et B après exécution des
des instructions suivantes ? instructions suivantes ?

Variables A, B, C: Entier Variables A, B : Entier

Début Début
A←3 A←1
B←7 B←2
A←B A←B
B←A
B ← A+5
Fin
C←A+B
C←B–A Les deux dernières instructions permettent-elles d’échanger les
Fin valeurs de A et B ?

2020/2021 IMSP - Niv1 31 2020/2021 IMSP - Niv1 32

Exercices simples sur l'affectation (3) Expressions et opérateurs

 Une expression peut être une valeur, une variable ou une
Ecrire un algorithme permettant d’échanger les opération constituée de variables reliées par des opérateurs
valeurs de deux variables A et B exemples: 1, b, a*2, a+ 3*b-c, …

 L'évaluation de l'expression fournit une valeur unique qui est le

résultat de l'opération

 Les opérateurs dépendent du type de l'opération, ils peuvent être :

• des opérateurs arithmétiques: +, -, *, /, % (modulo), ^ (puissance)
• des opérateurs logiques: NON, OU, ET
• des opérateurs relationnels: =,  , <, >, <=, >=
• des opérateurs sur les chaînes: & (concaténation)

 Une expression est évaluée de gauche à droite mais en tenant

compte de priorités
2020/2021 IMSP - Niv1 33 2020/2021 IMSP - Niv1 34

Les instructions d'entrées-sorties:

Priorité des opérateurs lecture et écriture (1)

 Pour les opérateurs arithmétiques donnés ci-dessus, l'ordre de  Les instructions de lecture et d'écriture permettent à la machine de
priorité est le suivant (du plus prioritaire au moins prioritaire) : communiquer avec l'utilisateur

 La lecture permet d'entrer des donnés à partir du clavier

• ^ : (élévation à la puissance)
• * , / (multiplication, division) • En pseudo-code, on note: lire (var)
• % (modulo)
la machine met la valeur entrée au clavier
• + , - (addition, soustraction)
dans la zone mémoire nommée var
exemple: 2+3*7 vaut 23
• Remarque: Le programme s'arrête lorsqu'il rencontre une
 En cas de besoin (ou de doute), on utilise les parenthèses pour instruction Lire et ne se poursuit qu'après la frappe d’une valeur
indiquer les opérations à effectuer en priorité au clavier et de la touche Entrée
exemple: (2 + 3) * 7 vaut 35

2020/2021 IMSP - Niv1 35 2020/2021 IMSP - Niv1 36

6
 Les instructions d'entrées-sorties:
lecture et écriture (2) Exemple (lecture et écriture)
Ecrire un algorithme qui demande un nombre entier à l'utilisateur, puis
 L'écriture permet d'afficher des résultats à l'écran (ou de les écrire qui calcule et affiche le double de ce nombre
dans un fichier)

• En pseudo-code, on note: écrire (var)

Algorithme Calcul_double
la machine affiche le contenu de la variables A, B : entier
zone mémoire var Début
écrire("entrer la valeur de A ")
• Conseil: Avant de lire une variable, il est fortement conseillé
d’écrire des messages à l’écran, afin de prévenir l’utilisateur de lire(A)
ce qu’il doit frapper B ← 2*A
écrire("le double de ", A, "est :", B)
Fin
2020/2021 IMSP - Niv1 37 2020/2021 IMSP - Niv1 38

Exercice (lecture et écriture) Exercice (respect des règles)

 Chacun de ces quatre algorithmes contient une erreur. Laquelle?
Ecrire un algorithme qui vous demande de saisir votre nom puis Algorithme1 Algorithme2
votre prénom et qui affiche ensuite votre nom complet Variables Variables
Quantité : entier X, Y, Z : réel
Prix_unit : réel Début
Algorithme AffichageNomComplet Début Lire (X, Y, Z)
Lire (Quantité, Prix_unit) Z :=X-Y
variables Nom, Prenom, Nom_Complet : chaîne de caractères
Prix_total := Quantité * Prix_unit Écrire (Z)
Début Écrire (Prix_total) Fin
écrire("entrez votre nom") Fin
Algorithme3 Algorithme4
lire(Nom)
Variables Variables
écrire("entrez votre prénom") A1, A2: entier X : réel
lire(Prenom) A3 : réel Début
Début Lire (X)
Nom_Complet ← Nom & Prenom Lire (A1, A2) X := X-1
écrire("Votre nom complet est : ", Nom_Complet) A2 := A1 * A3 X :=Pi * X
Écrire (A2) Écrire (X)
Fin
Fin Fin
2020/2021 IMSP - Niv1 39 2020/2021 IMSP - Niv1 40

Méthode de construction d’un Méthode de construction d’un

algorithme simple (1/4) algorithme simple (2/4)
Méthodologie a suivre :
Exemple :
 constantes : Pi = 3.14159

 Variables : Rayon, Surface

Écrire un algorithme qui consiste a calculer l’air S
 Types : Rayon, Surface : réel
d’un cercle selon la formule S = Pi * R2
Rappel : Pi = 3.14159 et R le rayon du cercle  Expressions et affectation : Surface := Pi * (Rayon)2

 Structures conditionnelles et les boucles : ------

 Opérations d’entrée-sortie : Lire (Rayon),

Écrire (Surface)

2020/2021 IMSP - Niv1 41 2020/2021 IMSP - Niv1 42

7
 Méthode de construction d’un Méthode de construction d’un
algorithme simple (3/4) algorithme simple (3/4)
Algorithme Programme Pascal Programme C
Calcul_Aire Program Calcul_Aire; #include <stdio.h>
Constantes CONST #include <math.h>
Pi = 3,14159 Pi = 3.14159 Main ( )
Variables VAR {
Rayon, Surface : réels Rayon, Surface : REAL; Float Pi = 3.14159;
Début BEGIN Float rayon, surface;
lire (Rayon) READLN (Rayon); Scanf (« °/°f », &rayon);
Surface := Pi * (Rayon)2 Surface := Pi * SQR (Rayon) surface = pi*pow (rayon,2);
écrire (Surface) WRITELN (Surface) Printif (« °/°f\n »surface, )
Fin END. Return 0;
}

2020/2021 IMSP - Niv1 43 2020/2021 IMSP - Niv1 44

Besoin a des concepts de

ruptures de séquence
Algorithmique Algorithme
 Rare les algorithme qui peuvent se
Calcul_Aire décrire uniquement par un
Constantes enchaînement séquentiel
d’opération élémentaire
Pi = 3,14159
Variables
Les structures Rayon, Surface : réels
 On a besoin a des concept de rupture
de séquence comme les test et les

Conditionnelles et les Début boucles

lire (Rayon) Ex :
boucles Surface := Pi * (Rayon)2  un algorithme qui résout une
équation de deuxième degré
écrire (Surface)  un algorithme qui calcule une série
Fin numérique

2020/2021 IMSP - Niv1 45 2020/2021 IMSP - Niv1 46

Les structures conditionnelles et les

boucles Tests: instructions conditionnelles (1)
 Les instructions conditionnelles servent à n'exécuter une instruction
 Les tests simples : permet de réaliser un choix parmi deux ou une séquence d'instructions que si une condition est vérifiée
possibilités (Ex :Booléenne : vrais ou faux)
 Les instructions conditionnelles : c’est un concept  On utilisera la forme suivante: Si condition alors
de tests multiples, permet de comparer un objet à une série de instruction ou suite d'instructions1
valeurs, et exécuter si la condition est vérifier (Ex : recherche des
nombres premier dans une ensemble ) Sinon
instruction ou suite d'instructions2
 Les itérations : consiste a exécuté un bloc d’instructions un Finsi
certain nombre de fois (Ex : calcul d’une suite numérique) • la condition ne peut être que vraie ou fausse
• si la condition est vraie, se sont les instructions1 qui seront exécutées
 Les boucles conditionnelles : consiste a exécuté un • si la condition est fausse, se sont les instructions2 qui seront exécutées
bloc d’instructions un certain nombre de fois si la condition est
vérifier (Ex : On veut afficher le 100 premiers nombres :. Tant que i est plus • la condition peut être une condition simple ou une condition composée de
petit que 100, afficher la valeur de i). plusieurs conditions
2020/2021 IMSP - Niv1 47 2020/2021 IMSP - Niv1 48

8
 Tests: instructions conditionnelles (2) Exemple (Si…Alors…Sinon)
 La partie Sinon n'est pas obligatoire, quand elle n'existe pas et que
Algorithme AffichageValeurAbsolue (version1)
la condition est fausse, aucun traitement n'est réalisé
Variable x : réel
• On utilisera dans ce cas la forme simplifiée suivante: Début
Ecrire " Entrez un réel : "
Si condition alors Lire (x)
instruction ou suite d'instructions1 Si x < 0 alors
Finsi Ecrire ("la valeur absolue de ", x, "est:",-x)
Sinon
Ecrire ("la valeur absolue de ", x, "est:",x)
Finsi
Fin

2020/2021 IMSP - Niv1 49 2020/2021 IMSP - Niv1 50

Exemple (Si…Alors) Exercice (tests)

Ecrire un algorithme qui demande un nombre entier à l'utilisateur,
Algorithme AffichageValeurAbsolue (version2)
puis qui teste et affiche s'il est divisible par 3
Variable x,y : réel
Algorithme Divsible_par3
Début
Ecrire " Entrez un réel : " Variable n : entier
Lire (x) Début
Ecrire " Entrez un entier : "
y← x
Lire (n)
Si x < 0 alors
y ← -x Si (n%3=0) alors
Ecrire (n," est divisible par 3")
Finsi
Ecrire ("la valeur absolue de ", x, "est:",y) Sinon
Ecrire (n," n'est pas divisible par 3")
Fin
Finsi
Fin
2020/2021 IMSP - Niv1 51 2020/2021 IMSP - Niv1 52

Conditions composées Tables de vérité

 Une condition composée est une condition formée de plusieurs C1 C2 C1 ET C2 C1 C2 C1 OU C2
conditions simples reliées par des opérateurs logiques:
VRAI VRAI VRAI VRAI VRAI VRAI
ET, OU, OU exclusif (XOR) et NON
VRAI FAUX FAUX VRAI FAUX VRAI
 Exemples : FAUX VRAI FAUX FAUX VRAI VRAI
• x compris entre 2 et 6 : (x > 2) ET (x < 6) FAUX FAUX FAUX FAUX FAUX FAUX

• n divisible par 3 ou par 2 : (n%3=0) OU (n%2=0)

C1 C2 C1 XOR C2 C1 NON C1
• deux valeurs et deux seulement sont identiques parmi a, b et c :
VRAI VRAI FAUX VRAI FAUX
(a=b) XOR (a=c) XOR (b=c)
VRAI FAUX VRAI FAUX VRAI
FAUX VRAI VRAI
 L'évaluation d'une condition composée se fait selon des règles
présentées généralement dans ce qu'on appelle tables de vérité FAUX FAUX FAUX

2020/2021 IMSP - Niv1 53 2020/2021 IMSP - Niv1 54

9
 Tests imbriqués Tests imbriqués: exemple (version 1)
 Les tests peuvent avoir un degré quelconque d'imbrications Variable n : entier
Si condition1 alors Début
Ecrire ("entrez un nombre : ")
Si condition2 alors
Lire (n)
instructionsA Si n < 0 alors
Sinon Ecrire ("Ce nombre est négatif")
instructionsB Sinon
Finsi Si n = 0 alors
Sinon Ecrire ("Ce nombre est nul")
Si condition3 alors Sinon
instructionsC Ecrire ("Ce nombre est positif")
Finsi Finsi
Finsi
Finsi
Fin
2020/2021 IMSP - Niv1 55 2020/2021 IMSP - Niv1 56

Tests imbriqués: exemple (version 2) Tests imbriqués: exercice

Variable n : entier
Début Le prix de photocopies dans une reprographie varie selon le
Ecrire ("entrez un nombre : ") nombre demandé: 0,5 DH la copie pour un nombre de copies
Lire (n) inférieur à 10, 0,4DH pour un nombre compris entre 10 et 20 et
Si n < 0 alors Ecrire ("Ce nombre est négatif") 0,3DH au-delà.
Finsi
Si n = 0 alors Ecrire ("Ce nombre est nul") Ecrivez un algorithme qui demande à l’utilisateur le nombre de
Finsi photocopies effectuées, qui calcule et affiche le prix à payer
Si n > 0 alors Ecrire ("Ce nombre est positif")
Finsi
Fin
Remarque : dans la version 2 on fait trois tests systématiquement alors que
dans la version 1, si le nombre est négatif on ne fait qu'un seul test
Conseil : utiliser les tests imbriqués pour limiter le nombre de tests et placer
d'abord les conditions les plus probables (minimiser la complexité)
2020/2021 IMSP - Niv1 57 2020/2021 IMSP - Niv1 58

Tests imbriqués: corrigé de l'exercice Tests imbriqués: Exercice 2

Variables copies : entier
prix : réel
Début Écrire l’algorithme du traitement qui calcule le discriminant
Ecrire ("Nombre de photocopies : ") DELTA d’trinome du second degré AX2 + BX + C et qui, en
Lire (copies) fonction de son signe, calcule la ou les racines réelles du
Si copies < 10 Alors trinome ou afiche, si besoin est qu’il n’ya pas de racine réelle.
prix ← copies*0.5
Sinon Si copies < 20 Les trois coefficients A, B et C seront saisis au clavier avant
prix ← copies*0.4 traitement.
Sinon
prix ← copies*0.3
Finsi
Finsi
Ecrire (“Le prix à payer est : ”, prix)
Fin

2020/2021 IMSP - Niv1 59 2020/2021 IMSP - Niv1 60

10
Tests imbriqués: corrigé de l'exercice 2
Variables

Début
A, B, C, Delta, X1, X2 : réels Algorithmique
Lire (A, B, C)
Delta ← B2 – 4 AC

Si (Delta < 0) Alors

Ecrire (« le trinome n’a pas de racine réelle »)
Sinon
Si (Delta > 0 Alors
X1 ← (-B + racine(delta)) / 2A
X2 ← (-B - racine(delta)) / 2A

Ecrire (« le trinome possède deux racines réelles : », X1, X2) Les boucles
Sinon

X1 ← (-B ) / 2A
Ecrire (« le trinome possède une racine réelle : », X1)
Finsi
Finsi

Fin
2020/2021 IMSP - Niv1 61 2020/2021 IMSP - Niv1 62

Les types de boucle

Les boucles Tant que
 On distingue 2 types de boucles:
TantQue (condition)
• Les boucles à compteur ou définie
• On sait à l’avance combien de fois la boucle devra tourner et
une variable (le compteur ) compte les répétitions instructions
• Choisir 10 nombres au hasard. On fera dix fois l’opération choisir
un nombre au hasard.
• Ex : la boucle Pour
FinTantQue Vrai
instructions
• Les boucles à événement ou indéfinie
condition

• On ne sait pas à l’avance le nombre de fois que la boucle sera

exécutée. Faux
• Ça peut dépendre du nombre de données à traiter.
• Ça peut dépendre du nombre d’essais que l’usager a effectués.
• Ex : la boucle Tanque et la boucle jusqu’a

2020/2021 IMSP - Niv1 63 2020/2021 IMSP - Niv1 64

Boucle Tant que : exemple

Boucle Tant que : exemple simple
Un algorithme qui détermine le premier nombre entier N tel que la Algorithme Plus-Grand-Element: Retourne la plus
grande valeur d’une liste
somme de 1 à N dépasse strictement 100 Trace de l’algorithme:
Entrée: n entiers S1,…, Sn
Sortie: grand contenant le plus grand élément n=4; S1= -2; S2=6; S3=5; S4=6
Variables som, i : entier
Debut Algo plus-grand (S,n) grand =-2 i=2
i←0 grand := S1;
som← 0 i:=2; grand = 6 i=3
TantQue (som <=100) Tant que i ≤ n Faire
i=4
Début
i ← i+1
Si Si > grand alors // une plus grande valeur a été trouvée i=5
som ← som+i
grand := Si;
FinTantQue i := i+1;
Ecrire (" La valeur cherchée est N= ", i)
Fin
Fin ecrire (grand)
Fin plus-grand;
2020/2021 IMSP - Niv1 65 2020/2021 IMSP - Niv1 66

11

Algorithme d’Euclide
 Trouver le plus grand diviseur commun (pgcd) de deux entiers
Définition: q est un diviseur commun de m et n si q divise à la
fois m et n (le reste de la division entière est 0)
Le pgdc de m et n est le plus grand entier q divisant à la fois m
et n.
Exemple: pgcd(4, 6) = 2; pgcd(3,8) = 1;
pgcd(9, 12) = 3;
Trouver le PGCD de a et b
Exemple: pgcd(30, 105)
 1ère méthode: Trouver tous les diviseurs de a et b, et trouver le
diviseur commun le plus grand
• Diviseurs de 30: 1, 2, 3, 5, 6, 10, 15, 30
• Diviseurs de 105: 1, 3, 5, 7, 15, 21, 35, 105
 pgcd(30, 105) = 15
• 2ème méthode: la méthode d’Euclide
• 105 = 30.3 + 15. Donc pgcd(105, 30) = pgcd(30,15)
• 30 = 15.2 + 0. Donc pgcd(30, 15) = pgcd(15,0)
• pgcd(15,0)=15

Utile pour la simplification de fractions: pgcd(105,30)=pgcd(30,15)=pgcd(15,0)=15

9/12 = 3.3/4.3 = 3/4

2020/2021 IMSP - Niv1 67 2020/2021 IMSP - Niv1 68

Algorithme d’Euclide
Méthode d’Euclide : Algorithme Entrée: a, b deux entiers positifs Trace de l’algorithme pour
a=504 et b=396
Sortie: pgcd(a,b)
504 396 a
Soient r0, r1 deux entiers strictement positifs,
108 1
tels que r0=r1.q+r2 avec 0≤r2<r1 Procédure pgcd(a,b)
Tant que b <> 0 Faire
b 396 108 a
Début
 Si r2 = 0, pgcd (r0, r1) = r1 72 3
diviser a par b: a = b.q+r, 0 ≤ r < b;
 Sinon, rediviser ri par ri+1 tant que ri+1 est a:=b; b a
108 72
différent de 0 b:=r; 36 1
 Si rn est le premier reste nul, alors Fin
72 36 a
pgcd(r0,r1) = pgcd(r1,r2) = … =pgcd(rn-1,rn)= pgcd(rn-1,0) = rn-1 Retourner (a) b 0 2
Fin pgcd
2020/2021 IMSP - Niv1 69 2020/2021 IMSP - Niv1
b 70

Les boucles Pour Les boucles Pour

Pour compteur allant de initiale à finale par pas valeur du pas Remarques :

instructions  Compteur est une variable de type entier (ou caractère). Elle doit
FinPour être déclarée

i ←initiale  Pas est un entier qui peut être positif ou négatif. Pas peut ne pas
être mentionné, car par défaut sa valeur est égal à 1. Dans ce cas, le
nombre d'itérations est égal à finale - initiale+ 1

Vrai
i n'a pas atteint finale instructions i ← i + pas  Initiale et finale peuvent être des valeurs, des variables définies
avant le début de la boucle ou des expressions de même type que
Faux compteur

2020/2021 IMSP - Niv1 71 2020/2021 IMSP - Niv1 72

12
 Déroulement des boucles Pour Boucle Pour : exemple
1) La valeur initiale est affectée à la variable compteur
Algorithme Plus-Grand-Element: Réécriture de l’algorithme précédent
2) On compare la valeur du compteur et la valeur de finale : mais avec une boucle ``Pour’’
Entrée: n entiers S1,…, Sn
a) Si la valeur du compteur est > à la valeur finale dans le cas d'un pas Sortie: grand contenant le plus grand élément
positif (ou si compteur est < à finale pour un pas négatif), on sort de la
boucle et on continue avec l'instruction qui suit FinPour Algo plus-grand (S,n)
b) Si compteur est <= à finale dans le cas d'un pas positif (ou si compteur grand := S1;
est >= à finale pour un pas négatif), instructions seront exécutées Pour i =1 à n Faire
Si Si > grand alors // une plus grande valeur a été trouvée
i. Ensuite, la valeur de compteur est incrémentée de la valeur du pas grand := Si;
si pas est positif (ou décrémenté si pas est négatif)
ecrire (grand)
ii. On recommence l'étape 2 : La comparaison entre compteur et Fin plus-grand;
finale est de nouveau effectuée, et ainsi de suite …

2020/2021 IMSP - Niv1 73 2020/2021 IMSP - Niv1 74

Boucle Pour : remarque Lien entre Pour et TantQue

 Il faut éviter de modifier la valeur du compteur (et de finale) à La boucle Pour est un cas particulier de Tant Que (cas où le nombre
l'intérieur de la boucle. En effet, une telle action : d'itérations est connu et fixé) . Tout ce qu'on peut écrire avec Pour peut être
remplacé avec TantQue (la réciproque est fausse)
• perturbe le nombre d'itérations prévu par la boucle Pour
• rend difficile la lecture de l'algorithme Pour compteur allant de initiale à finale par pas valeur du pas
• présente le risque d'aboutir à une boucle infinie instructions
Exepmle : Pour i allant de 1 à 5 FinPour
i  i -1 peut être remplacé par : compteur ← initiale
écrire(" i = ", i)
Finpour
(cas d'un pas positif) TantQue compteur <= finale
instructions
compteur ← compteur+pas
FinTantQue

2020/2021 IMSP - Niv1 75 2020/2021 IMSP - Niv1 76

Lien entre Pour et TantQue: exemple

Solution avec la boucle Pour

Variables x, puiss : réel

Calcul de x à la puissance n n, i : entier
avec la boucle Pour et la Debut
boucle TantQue Ecrire (" Entrez respectivement les valeurs de x et n ")
Lire (x, n)
x : un réel non nul puiss ← 1
n : entier positif ou nul Pour i allant de 1 à n
puiss← puiss*x
FinPour
Ecrire (x, " à la puissance ", n, " est égal à ", puiss)
Fin

2020/2021 IMSP - Niv1 77 2020/2021 IMSP - Niv1 78

13
 Algorithme de la fonction factorielle :
Solution avec la boucle Tant Que Exemple

Variables x, puiss : réel  Écrire deux algorithmes qui calculent

n, i : entier pour un entier positif donné n la valeur
Debut
Ecrire (" Entrez respectivement les valeurs de x et n ") n!, un de ces algorithmes doit utilisé la
Lire (x, n) boucle Pour et l’autre la boucle Tanque
puiss ← 1, i ← 1
TantQue (i<=n)
puiss← puiss*x
i ← i+1 Entrée : n de type naturel
FinTantQue
Ecrire (x, " à la puissance ", n, " est égal à ", puiss)
Sortie : factoriel (n) = 1*2*3*…..*(n-1)*n
Fin

2020/2021 IMSP - Niv1 79 2020/2021 IMSP - Niv1 80

Algorithme de la recherche des

Algorithme de la fonction
nombres premiers : Exemple
factorielle
Algorithme / tantque Algorithme / Pour  Problème: Écrire l’algorithme estPremier,
Calcul factorielle 1 Calcul factorielle 2 qui a partir d’un entier strictement positif
Variables Variables
i, f, n : Naturel i, f, n : Naturel
donné, retourne le résultat booléen VRAI ou
Début Début FAUX selon le nombre est premier ou non.
i←1 f←1
f←1 pour i variant de 2 à n  Procédure : pour déterminer si un entier m
tant que (i < n) f←f*i
i ← i+1 Fin pour est un nombre premier. Il suffit de tester si
f←f*i
Fin de tant que
écrire (f) m est divisible par un entier entre 2 et m/2
• Ex : 1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37,
Fin
écrire (f)
Fin
41, 43, 47. (listes des nombres premier <=50)
2020/2021 IMSP - Niv1 81 2020/2021 IMSP - Niv1 82

La boucle tantque en langage de La boucle Pour en langage de

programmation programmation
Langage Pascal Langage Pascal
While condition Do For variable := valeur initiale To valeur finale Do
Begin init
Begin test
Bloc d’instructions
Bloc d’instructions;
corps_boucle End; test
End;

Langage C et Java Langage C et Java corps_boucle

while (condition) { for (i=valeur initiale; i<= valeur finale; i++) {

incr
Bloc d’instructions; Bloc d’instructions;
} }

2020/2021 IMSP - Niv1 83 2020/2021 IMSP - Niv1 84

14
 Détecter l’erreur dans les deux
essaie tant que et pour Boucles imbriquées
 Les instructions d'une boucle peuvent être des instructions
Algorithme Algorithme itératives. Dans ce cas, on aboutit à des boucles imbriquées
Essai de tant que Essai pour
Variables Variables  Exemple: Exécution
n : entier K, N : entier
Pour i allant de 1 à 5 OX
Début Début
Pour j allant de 1 à i OOX
n ← 15 n ← 200
tant que (n<>0)
écrire("O") OOOX
pour K variant de 1 à n
écrire (n) écrire (K) FinPour OOOOX
n←n-2 K ← n – 100 écrire("X") OOOOOX
Fin de tant que Fin pour FinPour
Fin Fin

2020/2021 IMSP - Niv1 85 2020/2021 IMSP - Niv1 86

La boucle Faire…Tant Que

Les boucles Répéter … jusqu’à …
• Faire Répéter
Instruction(s)
Tant que (condition) Instruction(s) de la
instructions instructions
• do boucle
Jusqu'à condition
Instruction;
while (condition) Faux
condition
condition
Vraie
do Vrai
{ La boucle s’exécute tant que la Fausse  Condition est évaluée après chaque itération
f :=n; condition est vraie. La boucle
n--; cesse lorque la condition est
 les instructions entre Répéter et jusqu’à sont exécutées au moins une fois et
fausse. À utiliser si l’on veut que la leur exécution est répétée jusqu’à ce que condition soit vrai (tant qu'elle est
} while (n>1);
boucle soit exécutée au moins une fausse)
fois
2020/2021 IMSP - Niv1 87 2020/2021 IMSP - Niv1 88

Boucle Répéter jusqu’à : exemple Choix d'un type de boucle

Un algorithme qui détermine le premier nombre entier N tel que la somme de 1  Si on peut déterminer le nombre d'itérations avant l'exécution de la
à N dépasse strictement 100 (version avec répéter jusqu'à) boucle, il est plus naturel d'utiliser la boucle Pour

Variables som, i : entier  S'il n'est pas possible de connaître le nombre d'itérations avant
Debut l'exécution de la boucle, on fera appel à l'une des boucles TantQue
som ← 0 ou répéter jusqu'à
i←0
Répéter  Pour le choix entre TantQue et jusqu'à :
i ← i+1
• Si on doit tester la condition de contrôle avant de commencer les
som ← som+i instructions de la boucle, on utilisera TantQue
Jusqu'à ( som > 100)
Ecrire (" La valeur cherchée est N= ", i) • Si la valeur de la condition de contrôle dépend d'une première
exécution des instructions de la boucle, on utilisera répéter jusqu'à ou
Fin faire tanque
2020/2021 IMSP - Niv1 89 2020/2021 IMSP - Niv1 90

15
 Algorithme de la racine carrée :
Exercice Algorithme de la racine carrée

Algorithme Racine Carrée (RC)

 Problème: Écrire l’algorithme qui calcul la racine carrée Variables
d’un nombre sans avoir recours a la fonction mathématique n, x : réels
Racine Carrée prédéfinie. i, max : entier
Début
 Procédure : si n est le nombre dont on souhaite extraire Lire (n)
la racine carrée. On construit une suite de nombres Xi dont Lire (max)
le premier vaut 1 et dont le terme générale a pour x←1
expression : pour i variant de 1 à max
écrire (n)
Xi = (n/xi-1 + xi-1) / 2
x ← ((n/x) + x) / 2
Rq : Cette suite converge systématiquement vers racarrée (n) Fin de pour
Fin

2020/2021 IMSP - Niv1 91 2020/2021 IMSP - Niv1 92

Fonctions et procédures
Algorithmique  Lorsqu’une séquence d’instructions se répète plusieurs fois, il est
intéressant de faire un sous-programme correspondant à ce bloc
d’instructions et de l’utiliser autant de fois que nécessaire

 Cette séquence d’instructions sera définie dans un sous-programme

qui peut prendre la forme d’une procédure ou d’une fonction

 De plus, un programme est presque toujours décomposable en

Fonctions et procédures modules qui peuvent alors être définis de manière indépendante.
Cela permet de modifier éventuellement un module sans pour autant
changer le corps du programme et de rendre le programme plus
compréhensible (lisibilité)

 Un programme est alors un ensemble de procédures / fonctions

2020/2021 IMSP - Niv1 93 2020/2021 IMSP - Niv1 94

Notion de bloc dans un

programme Fonctions

2020/2021 IMSP - Niv1 95 2020/2021 IMSP - Niv1 96

16
 Exemple de programme /
Forme d’une Fonction fonction
 Une fonction s'écrit en dehors du programme principal sous la forme

Fonction identificateur (paramètres et leurs types) : type_fonction

Instructions constituant le corps de la fonction

retourne …
FinFonction

 type de fonction : le type du résultat renvoyé par la fonction

 Identificateur : le nom que l’on a donné à la fonction
 liste de paramètres : la liste des paramètres formels donnés en entrée
avec leurs types
 corps de la fonction : un bloc d’instructions, pouvant comprendre la
déclaration des « variables locales » a la fonctions
Remarque : le corps de la fonction doit comporter une instruction de la forme :
return(expression); où expression est du type du résultat de la fonction

2020/2021 IMSP - Niv1 97 2020/2021 IMSP - Niv1 98

Exemple de fonction / fonction Fonctions : exemples

 La fonction SommeCarre suivante calcule la somme des carrées de
deux réels x et y :
Fonction SommeCarre (x : réel, y: réel ) : réel
variable z : réel
z ←x^2+y^2 Paramètres
retourne (z) formels
FinFonction

 La fonction Pair suivante détermine si un nombre est pair :

Fonction Pair (n : entier ) : booléen

retourne (n%2=0)
FinFonction
2020/2021 IMSP - Niv1 99 2020/2021 IMSP - Niv1 100

Subdivision d’un problème en un ensemble

de fonctions
Utilisation des fonctions
 L'utilisation d'une fonction se fera par simple écriture de son nom
dans le programme principale. Le résultat étant une valeur, devra  Problème: Trouver le plus petit nombre
être affecté ou être utilisé dans une expression, une écriture, ... premier strictement supérieur à un entier
 Exepmle : Algorithme exepmleAppelFonction positif donné n
variables z : réel, b : booléen
Début
b ←Pair(3) • Utiliser l’algorithme qu’on a déjà fait estPremier
z ←5*SommeCarre(7,2)+1 (le plus petit nombre premier p supérieur à un
écrire("SommeCarre(3,5)= ", SommeCarre(3,5)) entier n) en tant que fonction.
Fin • Fait appel a cette fonction a l’intérieur de
 Lors de l'appel Pair(3) le paramètre formel n est remplacé par le l’algorithme premier-plus-grand
paramètre effectif 3
2020/2021 IMSP - Niv1 101 2020/2021 IMSP - Niv1 102

17
 La fonction de recherche des
Entrée: Un entier positif m Entrée: Un entier positif n
Sortie: Vrai si m est premier, Faux si non. Sortie: Le plus petit nb premier m > n

nombres premiers Fonction est-premier (m) Algorithme premier-plus-grand (n)

Pour i := 2 à ENT(m/2) Faire m := n+1;
Fonction estPremier Si m mod i = 0 alors // i divise m Tant que est-premier(m) est Faux Faire
Fonction est-premier (m : entier) : booléen Retourne (Faux) m := m+1;

Pour i := 2 à ENT(m/2) Faire Retourne (Vrai) Retourne(m)

Fin est-premier Fin est-premier
Si m mod i = 0 alors // i divise m
Retourne (Faux)
Trace de premier-plus-grand pour Trace
Trace
de de
est-premier
est-premier
pour
pour
m=9:
m=11:
m=10:
Retourne (Vrai) n=8:
i=2 11
9 mod
10mod
mod222===110
FinFonction est-premier m=9 i=3 9 mod 3 = 0
i=5 11 mod 5 = 1
m = 10
m = 11
2020/2021 IMSP - Niv1 103 2020/2021 IMSP - Niv1 104

Procèdures Appel d'une procédure

 Dans certains cas, on peut avoir besoin de répéter une tache dans plusieurs  L'appel d'une procédure, se fait dans le programme principale ou dans une
endroits du programme, mais que dans cette tache on ne calcule pas de autre procédure par une instruction indiquant le nom de la procédure :
résultats ou qu'on calcule plusieurs résultats à la fois
Procédure exemple_proc (…)
 Dans ces cas on ne peut pas utiliser une fonction, on utilise une procédure …
FinProcédure
 Une procédure est un sous-programme semblable à une fonction mais qui
ne retourne rien Algorithme exepmleAppelProcédure
 Une procédure s'écrit en dehors du programme principal sous la forme : Début
exemple_proc (…)
Procédure nom_procédure (paramètres et leurs types) …
Fin
Instructions constituant le corps de la procédure
 Remarque : contrairement à l'appel d'une fonction, on ne peut pas affecter la
FinProcédure procédure appelée ou l'utiliser dans une expression. L'appel d'une
 Remarque : une procédure peut ne pas avoir de paramètres procédure est une instruction autonome

2020/2021 IMSP - Niv1 105 2020/2021 IMSP - Niv1 106

Paramètres d'une procédure Transmission des paramètres

 Les paramètres servent à échanger des données entre le programme Il existe deux modes de transmission de paramètres dans les langages de
principale (ou la procédure appelante) et la procédure appelée programmation :

 La transmission par valeur : les valeurs des paramètres effectifs sont

 Comme avec les fonctions :
• Les paramètres placés dans la déclaration d'une procédure sont appelés
paramètres formels. Ces paramètres peuvent prendre toutes les valeurs
possibles mais ils sont abstraits (n'existent pas réellement)
• Les paramètres placés dans l'appel d'une procédure sont appelés paramètres
effectifs. ils contiennent les valeurs pour effectuer le traitement
affectées aux paramètres formels correspondants au moment de l'appel de la
procédure. Dans ce mode le paramètre effectif ne subit aucune modification
 La transmission par adresse (ou par référence) : les adresses des
paramètres effectifs sont transmises à la procédure appelante. Dans ce
mode, le paramètre effectif subit les mêmes modifications que le paramètre
formel lors de l'exécution de la procédure

 Le nombre de paramètres effectifs doit être égal au nombre de paramètres

• Remarque : le paramètre effectif doit être une variable (et non une
valeur) lorsqu'il s'agit d'une transmission par adresse
formels. L'ordre et le type des paramètres doivent correspondre
 En pseudo-code, on va préciser explicitement le mode de transmission dans
la déclaration de la procédure
2020/2021 IMSP - Niv1 107 2020/2021 IMSP - Niv1 108

18
 Transmission des paramètres : exemples Transmission par valeur, par adresse : exemples
Procédure incrementer1 (x : entier par valeur, y : entier par adresse) Procédure qui calcule la somme et le produit de deux entiers :
x ← x+1 Procédure SommeProduit (x,y: entier par valeur, som, prod : entier par adresse)
y ← y+1 som ← x+y
FinProcédure prod ← x*y
Algorithme Test_incrementer1 FinProcédure
variables n, m : entier
Début Procédure qui échange le contenu de deux variabales :
n←3 Procédure Echange (x : réel par adresse, y : réel par adresse)
m←3 variables z : réel
incrementer1(n, m) résultat : z←x
écrire (" n= ", n, " et m= ", m) n=3 et m=4 x←y
Fin y←z
FinProcédure
Remarque : l'instruction x ← x+1 n'a pas de sens avec un passage par valeur
2020/2021 IMSP - Niv1 109 2020/2021 IMSP - Niv1 110

Variables locales et globales (1) Variables locales et globales (2)

 On peut manipuler 2 types de variables dans un module (procédure ou
fonction) : des variables locales et des variables globales. Elles se
distinguent par ce qu'on appelle leur portée (leur "champ de définition", leur
"durée de vie")
 Une variable locale n'est connue qu'à l'intérieur du module ou elle a été
définie. Elle est créée à l'appel du module et détruite à la fin de son exécution
 Une variable globale est connue par l'ensemble des modules et le
programme principale. Elle est définie durant toute l’application et peut être
utilisée et modifiée par les différents modules du programme
 La manière de distinguer la déclaration des variables locales et globales
diffère selon le langage
• En général, les variables déclarées à l'intérieur d'une fonction ou
procédure sont considérées comme variables locales
• En pseudo-code, on va adopter cette règle pour les variables locales et on
déclarera les variables globales dans le programme principale
• Conseil : Il faut utiliser autant que possible des variables locales plutôt que
des variables globales. Ceci permet d'économiser la mémoire et d'assurer
l'indépendance de la procédure ou de la fonction

2020/2021 IMSP - Niv1 111 2020/2021 IMSP - Niv1 112

Récursivité
Algorithmique  Définition :Un algorithme est dit récursif
lorsqu’il est défini en fonction de lui-même.
 Récursivité simple
La fonction puissance x  xn. Cette fonction peut être
définie récursivement :
La Récursivité

2020/2021 IMSP - Niv1 113 2020/2021 IMSP - Niv1 114

19
 Types de Récursivité Itération et Récursivité : Exemple

• Récursivité multiple : Une définition récursive peut contenir  Calcul de factoriel :

Calcul fact,
plus d’un appel récursif. Nous voulons calculer ici les Variables
combinaisons Cnp en se servant de la relation de Pascal N,f : entier
Debut
f 1
tantque (n > 1)
• Récursivité mutuelle : Des définitions sont dites mutuellement Version itérative f  f * (n−1);
récursives si elles dépendent les unes des autres. Ça peut être le fintantque
Ecrire(f)
cas pour la définition de la parité :
End;

2020/2021 IMSP - Niv1 115 2020/2021 IMSP - Niv1 116

Liste des appels de la fonction

Itération et Récursivité : Exemple factoriel (cas du n=4)
Version récursive Version itérative
Fonction fact (n : entier ) : entier
Si (n=0) alors
retourne (1)
Sinon
Version récursive retourne (n*fact(n-1))
Finsi
FinFonction

 Un module (fonction ou procédure) peut s'appeler lui-

même: on dit que c'est un module récursif

 Tout module récursif doit posséder un cas limite (cas

trivial) qui arrête la récursivité

2020/2021 IMSP - Niv1 117 2020/2021 IMSP - Niv1 118

Récursivité : observations Fonctions récursives : exercice

 Une fonction est définie récursivement lorsque la valeur de la  La version itérative qui calcule la somme
fonction en un point x est définie par rapport à sa valeur en un
point strictement « plus petit » des n premier nombres entier :
 De ce fait, le calcul se fait de proche en proche, jusqu’à atteindre
le plus petit élément pour lequel il faut une valeur immédiate (c’est-
à-dire non récursive)

 Le corps d’une fonction récursive doit toujours exprimer un choix,

soit par une expression conditionnelle, soit par une définition par
cas

 Au moins un cas terminal rend une valeur qui n’utilise pas la

fonction définie
 Écrivez une fonction récursive
2020/2021 IMSP - Niv1 119 2020/2021 IMSP - Niv1 120

20
 Fonctions récursives : exercice Fonctions récursives : exercice
 Ecrivez une fonction récursive (puis itérative) qui calcule le terme n
 La version récursive de la suite de Fibonacci définie par : U(0)=U(1)=1
U(n)=U(n-1)+U(n-2)

Fonction Fib (n : entier ) : entier

Variable res : entier
Si (n=1 OU n=0) alors
res ←1
Sinon
res ← Fib(n-1)+Fib(n-2)
Finsi
retourne (res)
FinFonction

2020/2021 IMSP - Niv1 121 2020/2021 IMSP - Niv1 122

Fonctions récursives : exercice (suite)

 Une fonction itérative pour le calcul de la suite de Fibonacci :
Fonction Fib (n : entier ) : entier
Algorithmique
Variables i, AvantDernier, Dernier, Nouveau : entier
Si (n=1 OU n=0) alors retourne (1)
Finsi
AvantDernier ←1, Dernier ←1
Pour i allant de 2 à n
Nouveau← Dernier+ AvantDernier
AvantDernier ←Dernier Les tableaux
Dernier ←Nouveau
FinPour
retourne (Nouveau)
FinFonction
Remarque: la solution récursive est plus facile à écrire
2020/2021 IMSP - Niv1 123 2020/2021 IMSP - Niv1 124

Exemple introductif Tableaux

 Supposons qu'on veut conserver les notes d'une classe de 30 étudiants
pour extraire quelques informations. Par exemple : calcul du nombre
d'étudiants ayant une note supérieure à 10
 Le seul moyen dont nous disposons actuellement consiste à déclarer 30
variables, par exemple N1, …, N30. Après 30 instructions lire, on doit écrire
30 instructions Si pour faire le calcul
nbre ← 0
Si (N1 >10) alors nbre ←nbre+1 FinSi
….
Si (N30>10) alors nbre ←nbre+1 FinSi
c'est lourd à écrire
 Heureusement, les langages de programmation offrent la possibilité de
rassembler toutes ces variables dans une seule structure de donnée
appelée tableau
2020/2021 IMSP - Niv1
 Un tableau est un ensemble d'éléments de même type désignés
par un identificateur unique
 Une variable entière nommée indice permet d'indiquer la position
d'un élément donné au sein du tableau et de déterminer sa valeur
 La déclaration d'un tableau s'effectue en précisant le type de ses
éléments et sa dimension (le nombre de ses éléments)
• En pseudo code :
variable tableau identificateur[dimension] : type
• Exemple :
variable tableau notes[30] : réel
 On peut définir des tableaux de tous types : tableaux d'entiers, de
réels, de caractères, de booléens, de chaînes de caractères, …
125 2020/2021 IMSP - Niv1 126

21
 Tableaux : remarques Tableaux : exemples (1)
 L'accès à un élément du tableau se fait au moyen de l'indice. Par exemple,  Pour le calcul du nombre d'étudiants ayant une note supérieure à
notes[i] donne la valeur de l'élément i du tableau notes 10 avec les tableaux, on peut écrire :
 Selon les langages, le premier indice du tableau est soit 0, soit 1. Le plus
souvent c'est 0 (c'est ce qu'on va adopter en pseudo-code). Dans ce cas, Variables i ,nbre : entier
notes[i] désigne l'élément i+1 du tableau notes tableau notes[30] : réel
Début
 Il est possible de déclarer un tableau sans préciser au départ sa dimension.
nbre ← 0
Cette précision est faite ultérieurement .

Pour i allant de 0 à 29
• Par exemple, quand on déclare un tableau comme paramètre d'une procédure, Si (notes[i] >10) alors
on peut ne préciser sa dimension qu'au moment de l'appel
nbre ←nbre+1
• En tous cas, un tableau est inutilisable tant qu’on n’a pas précisé le nombre de FinSi
ses éléments FinPour
 Un grand avantage des tableaux est qu'on peut traiter les données qui y écrire ("le nombre de notes supérieures à 10 est : ", nbre)
sont stockées de façon simple en utilisant des boucles Fin
2020/2021 IMSP - Niv1 127 2020/2021 IMSP - Niv1 128

Tableaux : saisie et affichage Tableaux : exemples d'appel

 Procédures qui permettent de saisir et d'afficher les éléments d'un tableau :  Algorithme principale où on fait l'appel des procédures SaisieTab et
Procédure SaisieTab(n : entier par valeur, tableau T : réel par référence ) AfficheTab :
variable i: entier
Pour i allant de 0 à n-1 Algorithme Tableaux
écrire ("Saisie de l'élément ", i + 1) variable p : entier
lire (T[i] )
tableau A[10] : réel
FinPour
Début
Fin Procédure
p ← 10
Procédure AfficheTab(n : entier par valeur, tableau T : réel par valeur )
SaisieTab(p, A)
variable i: entier
Pour i allant de 0 à n-1 AfficheTab(p,A)
écrire ("T[",i, "] =", T[i]) Fin
FinPour
Fin Procédure
2020/2021 IMSP - Niv1 129 2020/2021 IMSP - Niv1 130

Tableaux : fonction longueur Tableaux à deux dimensions

La plus part des langages offrent une fonction longueur qui donne la dimension  Les langages de programmation permettent de déclarer des
du tableau. Les procédures Saisie et Affiche peuvent être réécrites comme suit : tableaux dans lesquels les valeurs sont repérées par deux indices.
Procédure SaisieTab( tableau T : réel par référence ) Ceci est utile par exemple pour représenter des matrices
variable i: entier
Pour i allant de 0 à longueur(T)-1  En pseudo code, un tableau à deux dimensions se déclare ainsi :
écrire ("Saisie de l'élément ", i + 1)
lire (T[i] ) variable tableau identificateur[dimension1] [dimension2] : type
FinPour
Fin Procédure • Exemple : une matrice A de 3 lignes et 4 colonnes dont les éléments
Procédure AfficheTab(tableau T : réel par valeur ) sont réels
variable i: entier variable tableau A[3][4] : réel
Pour i allant de 0 à longueur(T)-1
écrire ("T[",i, "] =", T[i])
 A[i][j] permet d'accéder à l’élément de la matrice qui se trouve à
FinPour l’intersection de la ligne i et de la colonne j
Fin Procédure
2020/2021 IMSP - Niv1 131 2020/2021 IMSP - Niv1 132

22
 Exemples : lecture d'une matrice Exemples : affichage d'une matrice
 Procédure qui permet de saisir les éléments d'une matrice :  Procédure qui permet d'afficher les éléments d'une matrice :

Procédure SaisieMatrice(n : entier par valeur, m : entier par valeur , Procédure AfficheMatrice(n : entier par valeur, m : entier par valeur
tableau A : réel par référence ) ,tableau A : réel par
Début valeur )
variables i,j : entier Début
Pour i allant de 0 à n-1 variables i,j : entier
écrire ("saisie de la ligne ", i + 1)
Pour i allant de 0 à n-1
Pour j allant de 0 à m-1
Pour j allant de 0 à m-1
écrire ("Entrez l'élément de la ligne ", i + 1, " et de la colonne ", j+1)
lire (A[i][j])
écrire ("A[",i, "] [",j,"]=", A[i][j])
FinPour FinPour
FinPour FinPour
Fin Procédure Fin Procédure

2020/2021 IMSP - Niv1 133 2020/2021 IMSP - Niv1 134

Exemples : somme de deux matrices Appel des procédures définies sur les matrices
 Procédure qui calcule la somme de deux matrices : Exemple d'algorithme principale où on fait l'appel des procédures définies
précédemment pour la saisie, l'affichage et la somme des matrices :
Procédure SommeMatrices(n, m : entier par valeur,
tableau A, B : réel par valeur , tableau C : réel par référence ) Algorithme Matrices
Début variables tableau M1[3][4],M2 [3][4],M3 [3][4] : réel
variables i,j : entier Début
Pour i allant de 0 à n-1 SaisieMatrice(3, 4, M1)
Pour j allant de 0 à m-1 SaisieMatrice(3, 4, M2)
C[i][j] ← A[i][j]+B[i][j] AfficheMatrice(3,4, M1)
FinPour AfficheMatrice(3,4, M2)
FinPour SommeMatrice(3, 4, M1,M2,M3)
Fin Procédure AfficheMatrice(3,4, M3)
Fin
2020/2021 IMSP - Niv1 135 2020/2021 IMSP - Niv1 136

Tableaux : trouver l’erreur Tableaux : Exemple d’exercice

Algorithme 1 Algorithme 2
Essai de tableau 1 Essai de tableau 2
Écrire l’algorithme du traitement qui permet de
Variables Variables saisir 10 nombres entiers dans un tableau à
i : entier i, x : entiers une dimension, puis qui recherche et affiche la
Tab(10) : tableau d’entiers Tab(10) : tableau d’entiers valeur minimale entrée dans un tableau.
Début Début
tant que (i <= 10) pour i variant de 1 à 10
L’affichage mentionnera également l’indice
lire tab(i) Si Tab(i+1) < Tab(i) alors
auquel se trouve ce minimum.
i ← i+1 permute Tab(i), Tab(i+1)
Fin de tant que Fin de Si
Fin Fin de pour
Fin

2020/2021 IMSP - Niv1 137 2020/2021 IMSP - Niv1 138

23
 Algorithme recherche Mini Tableaux : 2 problèmes classiques
Recherche Mini
Variables
i, Indice_Mini, Mini : entiers
Tab(10) : tableau d’entiers  Recherche d’un élément dans un tableau
Début
pour i variant de 1 à 10
Lire Tab(i)
• Recherche séquentielle
Fin de pour • Recherche dichotomique
Mini Tab(1)
Indice_Mini  1
pour i variant de 2 à 10
Si Tab(i) < Mini alors
 Tri d'un tableau
Mini Tab(i)
Indice_Mini  i • Tri par sélection
Fin de Si
Fin de pour
• Tri rapide
ecrire (Mini, Indice_Mini)
Fin

2020/2021 IMSP - Niv1 139 2020/2021 IMSP - Niv1 140

Recherche séquentielle Recherche séquentielle (version 2)

 Recherche de la valeur x dans un tableau T de N éléments :  Une fonction Recherche qui retourne un booléen pour indiquer si une valeur
x appartient à un tableau T de dimension N.
Variables i: entier, Trouvé : booléen
… x , N et T sont des paramètres de la fonction
i←0 , Trouvé ← Faux
TantQue (i < N) ET (Trouvé=Faux) Fonction Recherche(x : réel, N: entier, tableau T : réel ) : booléen
Si (T[i]=x) alors
Trouvé ← Vrai Variable i: entier
Sinon Pour i allant de 0 à N-1
i←i+1 Si (T[i]=x) alors
FinSi retourne (Vrai)
FinTantQue FinSi
Si Trouvé alors // c'est équivalent à écrire Si Trouvé=Vrai alors FinPour
écrire ("x appartient au tableau") retourne (Faux)
Sinon écrire ("x n'appartient pas au tableau")
FinSi FinFonction
2020/2021 IMSP - Niv1 141 2020/2021 IMSP - Niv1 142

Notion de complexité d'un algorithme Recherche séquentielle : complexité

 Pour évaluer l’efficacité d'un algorithme, on calcule sa complexité
 Mesurer la complexité revient à quantifier le temps d'exécution et l'espace
mémoire nécessaire
 Le temps d'exécution est proportionnel au nombre des opérations
effectuées. Pour mesurer la complexité en temps, on met en évidence
certaines opérations fondamentales, puis on les compte
 Pour évaluer l’efficacité de l'algorithme de recherche séquentielle, on va
calculer sa complexité dans le pire des cas. Pour cela on va compter le
nombre de tests effectués
 Le pire des cas pour cet algorithme correspond au cas où x n'est pas dans
le tableau T
 Si x n’est pas dans le tableau, on effectue 3N tests : on répète N fois les
tests (i < N), (Trouvé=Faux) et (T[i]=x)

 Le nombre d'opérations dépend généralement du nombre de données à  La complexité dans le pire des cas est d'ordre N, (on note O(N))
traiter. Ainsi, la complexité est une fonction de la taille des données. On
s'intéresse souvent à son ordre de grandeur asymptotique  Pour un ordinateur qui effectue 10 6 tests par seconde on a :

N 103 106 109

 En général, on s'intéresse à la complexité dans le pire des cas et à la
complexité moyenne temps 1ms 1s 16mn40s

2020/2021 IMSP - Niv1 143 2020/2021 IMSP - Niv1 144

24
 Recherche dichotomique Recherche dichotomique : algorithme
 Dans le cas où le tableau est ordonné, on peut améliorer l'efficacité inf←0 , sup←N-1, Trouvé ← Faux
de la recherche en utilisant la méthode de recherche dichotomique TantQue (inf <=sup) ET (Trouvé=Faux)
milieu←(inf+sup)div2
Si (x=T[milieu]) alors
 Principe : diviser par 2 le nombre d'éléments dans lesquels on
cherche la valeur x à chaque étape de la recherche. Pour cela on Trouvé ← Vrai
compare x avec T[milieu] : SinonSi (x>T[milieu]) alors
inf←milieu+1
Sinon sup←milieu-1
• Si x < T[milieu], il suffit de chercher x dans la 1ère moitié du tableau
FinSi
entre (T[0] et T[milieu-1])
FinSi
FinTantQue
• Si x > T[milieu], il suffit de chercher x dans la 2ème moitié du tableau
Si Trouvé alors écrire ("x appartient au tableau")
entre (T[milieu+1] et T[N-1])
Sinon écrire ("x n'appartient pas au tableau")
FinSi

2020/2021 IMSP - Niv1 145 2020/2021 IMSP - Niv1 146

Exemple d'exécution Recherche dichotomique : complexité

 Considérons le tableau T : 4 6 10 15 17 18 24 27 30  La complexité dans le pire des cas est d'ordre log 2 N

 Si la valeur cherché est 20 alors les indices inf, sup et milieu vont évoluer  L'écart de performances entre la recherche séquentielle et la recherche
comme suit : dichotomique est considérable pour les grandes valeurs de N

inf 0 5 5 6 • Exemple: au lieu de N=1milion ≈220 opérations à effectuer avec une

sup 8 8 5 5 recherche séquentielle il suffit de 20 opérations avec une recherche
dichotomique
milieu 4 6 5
 Si la valeur cherché est 10 alors les indices inf, sup et milieu vont évoluer
comme suit :
inf 0 0 2
sup 8 3 3
milieu 4 1 2

2020/2021 IMSP - Niv1 147 2020/2021 IMSP - Niv1 148

Tris d’un tableau

Algorithmique

Les méthodes de Tris

La méthode de tri

2020/2021 IMSP - Niv1 149 2020/2021 IMSP - Niv1 150

25
 Les algorithmes de Tri Tri par sélection

 Il existe plusieurs algorithmes connus pour trier

les éléments d’un tableau :
• Tris élémentaires
• Le tri par sélection
• Le tri par insertion
• Le tri à bulles
• Tris avancées
• Tri rapide
• …..

2020/2021 IMSP - Niv1 151 2020/2021 IMSP - Niv1 152

Tri par sélection : méthodologie Tri par sélection : algorithme

 Supposons que le tableau est noté T et sa taille N
 Nous avions une certaine situation sur l’intervalle [ 0 .. i-1 ] : Pour i allant de 0 à N-2 Réservation de la case
• les éléments jusqu’à i-1 sont triés, indice ← i
• ceux qui suivent sont plus grands, mais pas triés. Pour j allant de i + 1 à N-1
Si T[j] <T[indice] alors
 Nous retrouvons la même situation sur l’intervalle [ 0 .. i ] : indice ← j Recherche de l’élément
concerné
• les éléments jusqu’à i sont triés, Finsi
• ceux qui suivent sont plus grands, mais pas triés. FinPour

temp ← T[indice]
 Cette propriété est donc invariante avec i, on l’appelle un invariant. T[indice] ← T[i] Permutation des deux valeurs
T[i] ← temp
FinPour
2020/2021 IMSP - Niv1 153 2020/2021 IMSP - Niv1 154

Tri par sélection : exemple Tri par sélection : exemple

 Principe : à l'étape i, on sélectionne le plus petit élément parmi les
(n - i +1) éléments du tableau les plus à droite. On l'échange ensuite avec
l'élément i du tableau
 Simuler l’algorithme du tri par sélection sur le tableau  Exemple : 9 4 1 7 3
suivant on montrant les étapes d’exécution. • Étape 1: on cherche le plus petit parmi les 5 éléments du tableau. On
l’identifie en troisième position, et on l’échange alors avec l’élément 1 :

9 4 1 7 3 1 4 9 7 3
• Étape 2: on cherche le plus petit élément, mais cette fois à partir du
deuxième élément. On le trouve en dernière position, on l'échange
avec le deuxième:
1 3 9 7 4

• Étape 3:
1 3 4 7 9

2020/2021 IMSP - Niv1 155 2020/2021 IMSP - Niv1 156

26
 Tri par sélection : complexité Tri par insertion

2020/2021 IMSP - Niv1 157 2020/2021 IMSP - Niv1 158

Tri par insertion : algorithme Tri par insertion : exemple

 Simuler l’algorithme du tri par insertion sur le tableau suivant

on montrant les étapes d’exécution.

2 56 4 7 0

2020/2021 IMSP - Niv1 159 2020/2021 IMSP - Niv1 160

Tri par insertion : Exemple Tri à bulles

- Prendre l’élément i
- Insérer i dans l’ordre entre 0 et i
- Continuer à partir de i+1

 2, 56, 4, 7, 0
 2, 56, 4, 7, 0
 2, 56, 4, 7, 0
 2, 4, 56, 7, 0
 2, 4, 7, 56, 0
 0, 2, 4, 7, 56

2020/2021 IMSP - Niv1 161 2020/2021 IMSP - Niv1 162

27
 Tri à bulles : algorithme Tri à bulles : exemple

 Simuler l’algorithme du tri à bulles sur le tableau suivant on

montrant les étapes d’exécution.

4 1 5 3 2

2020/2021 IMSP - Niv1 163 2020/2021 IMSP - Niv1 164

Tri à bulles : exemple

Tri rapide
 Le tri rapide est un tri récursif basé sur l'approche "diviser pour régner"
Un balayage (consiste à décomposer un problème d'une taille donnée à des sous
2 2 2 2 1 problèmes similaires mais de taille inférieure faciles à résoudre)
3 3 3 1 2
Sens de
5 5 1 3 3  Description du tri rapide :
lecture de
tableau 1 1 5 5 5
4 4 4 4 4 • 1) on considère un élément du tableau qu'on appelle pivot

Suite des balayages

2 1 1 1 1
• 2) on partitionne le tableau en 2 sous tableaux : les éléments inférieurs
ou égaux à pivot et les éléments supérieurs à pivot. on peut placer ainsi
3 2 2 2 2 la valeur du pivot à sa place définitive entre les deux sous tableaux
5 3 3 3 3
1 5 4 4 4
4 4 5 5 5 • 3) on répète récursivement ce partitionnement sur chacun des sous
tableaux crées jusqu'à ce qu'ils soient réduits à un à un seul élément
peuvent être éliminés
2020/2021 IMSP - Niv1 165 2020/2021 IMSP - Niv1 166

Tri Rapide Procédure Tri rapide

Procédure TriRapide(tableau T : réel par adresse, p,r: entier par valeur)

variable q: entier
Si p <r alors
Partition(T,p,r,q)
TriRapide(T,p,q-1)
TriRapide(T,q+1,r)
FinSi
Fin Procédure

A chaque étape de récursivité on partitionne un tableau T[p..r] en deux sous

tableaux T[p..q-1] et T[q+1..r] tel que chaque élément de T[p..q-1] soit
inférieur ou égal à chaque élément de A[q+1..r] . L'indice q est calculé
pendant la procédure de partitionnement

2020/2021 IMSP - Niv1 167 2020/2021 IMSP - Niv1 168

28
 Procédure de partition Tri Rapide : Exemple
Procédure Partition(tableau T : réel par adresse, p,r: entier par valeur,
q: entier par adresse )
Variables i, j: entier Partage avec pivot = 3
pivot: réel
2 4 1 7 3 2 3 6
pivot← T[p], i←p+1, j ← r
TantQue (i<=j)
2 2 1 7 3 4 3 6
TantQue (i<=r et T[i] <=pivot) i ← i+1 FinTantQue
TantQue (j>=p et T[j] >pivot ) j ← j-1 FinTantQue
<3 3
Si i <j alors
Echanger(T[i], T[j]), i ← i+1, j ← j-1 2 2 1 3 3 4 7 6
FinSi Suite du tri
TRI TRI
FinTantQue
Echanger(T[j], T[p]) 1 2 2 3 3 4 6 7
q←j
Fin Procédure
2020/2021 IMSP - Niv1 169 2020/2021 IMSP - Niv1 170

Tri rapide : complexité et remarques

 La complexité du tri rapide dans le pire des cas est en O(N²)

 La complexité du tri rapide en moyenne est en O(N log N)

 Le choix du pivot influence largement les performances du tri rapide

 Le pire des cas correspond au cas où le pivot est à chaque choix le plus petit
élément du tableau (tableau déjà trié)

2020/2021 IMSP - Niv1 171

29