Initiation Algorithme
Initiation Algorithme
Initiation Algorithme
Par M. Delest
Un algorithme est une procédure de calcul bien définie qui prend en entrée un ensemble
de valeurs et qui délivre en sortie un ensemble de valeurs.
Commentez
Cours pour apprendre les bases de l'algorithmique par M. Delest
I - Introduction..............................................................................................................................................................5
I-A - Notion d'algorithme........................................................................................................................................ 5
I-B - Notion de complexité..................................................................................................................................... 6
I-C - Langage de description d'algorithmes........................................................................................................... 6
II - Codage et structures de contrôle.......................................................................................................................... 6
II-A - Définitions......................................................................................................................................................6
II-B - Types de base.............................................................................................................................................. 7
II-B-1 - Booléens............................................................................................................................................... 7
II-B-2 - Entiers...................................................................................................................................................8
II-B-3 - Réels.....................................................................................................................................................8
II-B-4 - Caractères............................................................................................................................................ 8
II-B-5 - Attention................................................................................................................................................8
II-B-6 - Comparaison.........................................................................................................................................8
II-C - Structures de contrôle...................................................................................................................................8
II-D - Fonctions.......................................................................................................................................................9
II-D-1 - Syntaxe...............................................................................................................................................10
II-D-2 - Utilisation............................................................................................................................................ 10
II-D-3 - Exemple..............................................................................................................................................10
III - Description d'algorithme - Langage EXALGO.................................................................................................... 11
III-A - Généralités................................................................................................................................................. 11
III-B - Type............................................................................................................................................................11
III-C - Variables.....................................................................................................................................................11
III-D - Expressions................................................................................................................................................11
III-E - Instructions simples....................................................................................................................................11
III-F - Structure de contrôle..................................................................................................................................11
III-G - Fonctions....................................................................................................................................................12
III-H - Types..........................................................................................................................................................12
III-H-1 - Type structuré....................................................................................................................................12
III-H-2 - Type pointeur.....................................................................................................................................13
IV - Structures de données....................................................................................................................................... 13
IV-A - Définition.................................................................................................................................................... 13
IV-B - Structure.....................................................................................................................................................14
IV-C - Table d'association à clé unique............................................................................................................... 15
V - Complexité........................................................................................................................................................... 15
V-A - Définitions................................................................................................................................................... 15
V-B - Structures de contrôle................................................................................................................................ 16
V-C - Exemples.................................................................................................................................................... 17
V-C-1 - Somme des N premiers entiers.........................................................................................................17
V-C-2 - Apparition d'une pile dans une suite de n lancers d'une pièce......................................................... 17
V-D - Les courbes « étalon »............................................................................................................................... 19
V-D-1 - n, log(n), nlog(n)................................................................................................................................ 19
V-D-2 - nlog(n), n2, n3................................................................................................................................... 19
V-D-3 - n2, 1.5n ,2n........................................................................................................................................ 20
V-D-4 - 2n, nn n !............................................................................................................................................20
V-E - Formule de Stirling..................................................................................................................................... 21
VI - Tableaux..............................................................................................................................................................21
VI-A - Définition.................................................................................................................................................... 21
VI-B - Primitives....................................................................................................................................................22
VI-B-1 - Initialisation d'un tableau...................................................................................................................22
VI-B-2 - Taille d'un tableau............................................................................................................................. 22
VI-B-3 - Échange d'éléments..........................................................................................................................22
VI-B-4 - Copie de tableau...............................................................................................................................23
VI-C - Quelques exemples d'algorithmes............................................................................................................ 24
VI-C-1 - Somme des éléments d'un tableau d'entiers....................................................................................24
VI-C-2 - Recherche d'un élément................................................................................................................... 24
VI-C-3 - Recherche de l'indice du premier élément minimum........................................................................25
VI-D - Matrices..................................................................................................................................................... 25
VI-D-1 - Déclaration........................................................................................................................................ 25
-2-
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
VI-D-2 - Initialisation........................................................................................................................................25
VI-D-3 - Somme de deux matrices réelles..................................................................................................... 26
VII - Tri non récursif...................................................................................................................................................26
VII-A - Tri sélection...............................................................................................................................................26
VII-B - Tri insertion et tri à bulle.......................................................................................................................... 27
VII-B-1 - Tri insertion.......................................................................................................................................27
VII-B-2 - Tri à bulle......................................................................................................................................... 27
VII-C - Fusion de tableaux triés...........................................................................................................................28
VII-D - Tri par dénombrement.............................................................................................................................. 28
VII-E - Algorithme de fusion de deux tableaux....................................................................................................29
VII-E-1 - Aide.................................................................................................................................................. 29
VII-E-2 - Algorithme de fusion........................................................................................................................ 29
VII-E-3 - Algorithme de fusion pour des morceaux de tableaux.................................................................... 30
VIII - Retour sur les fonctions, récursivité................................................................................................................. 30
VIII-A - Visibilité.................................................................................................................................................... 30
VIII-A-1 - Visibilité d'une variable....................................................................................................................30
VIII-A-2 - Exemple...........................................................................................................................................31
VIII-A-3 - Visibilité d'une fonction....................................................................................................................31
VIII-A-3-a - Exemple.................................................................................................................................. 31
VIII-B - Récursivité............................................................................................................................................... 32
VIII-C - Complexité............................................................................................................................................... 34
VIII-D - Exemples................................................................................................................................................. 35
VIII-D-1 - Recherche d'un élément dans un tableau d'entiers....................................................................... 35
VIII-D-2 - Minimum dans un tableau d'entiers................................................................................................35
IX - Diviser pour régner............................................................................................................................................. 36
IX-A - Dichotomie................................................................................................................................................. 36
IX-B - Exemples................................................................................................................................................... 36
IX-B-1 - Recherche du zéro d'une fonction croissante...................................................................................36
IX-B-2 - Trouver un élément dans un tableau ordonné..................................................................................36
IX-B-3 - Remarque..........................................................................................................................................37
IX-C - Complexité................................................................................................................................................. 38
X - Tris récursifs........................................................................................................................................................ 39
X-A - Tri fusion..................................................................................................................................................... 39
X-B - Tri rapide.....................................................................................................................................................40
XI - Une implémentation des polynômes.................................................................................................................. 41
XI-A - Énoncé....................................................................................................................................................... 41
XI-B - Structure et primitives................................................................................................................................41
XI-B-1 - Structure............................................................................................................................................ 41
XI-B-2 - Addition..............................................................................................................................................41
XI-B-3 - Multiplication......................................................................................................................................42
XI-B-4 - Polynôme opposé............................................................................................................................. 42
XI-B-5 - Multiplication par xn.......................................................................................................................... 42
XI-B-6 - Dérivée.............................................................................................................................................. 43
XI-B-7 - Valeur en un point.............................................................................................................................43
XI-B-8 - Intégrale définie.................................................................................................................................44
XI-C - Amélioration de la complexité................................................................................................................... 44
XI-C-1 - Valeur en un point............................................................................................................................ 44
XI-D - Multiplication.............................................................................................................................................. 44
XII - Listes..................................................................................................................................................................47
XII-A - Définition................................................................................................................................................... 47
XII-B - Liste simplement chainée......................................................................................................................... 47
XII-B-1 - Test de fin de liste........................................................................................................................... 48
XII-B-2 - Chercher un élément dans une liste................................................................................................48
XII-B-3 - Trouver le dernier élément...............................................................................................................49
XII-C - Liste doublement chaînée........................................................................................................................ 49
XII-C-1 - Supprimer un élément..................................................................................................................... 49
XII-D - Quelques algorithmes...............................................................................................................................50
XII-D-1 - Taille................................................................................................................................................. 50
-3-
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
-4-
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
I - Introduction
Définition 1.1. Un algorithme est une procédure de calcul bien définie qui prend en entrée un ensemble de valeurs
et qui délivre en sortie un ensemble de valeurs.
Exemple 1.1
Problème : trier une suite de nombres entiers dans l'ordre croissant.
Entrée : suite de n nombres entiers ( )
Sortie : une permutation de la suite donnée en entrée ( ) telle que . À partir
de la suite (6,9,2,4), un algorithme de tri fournira le résultat (2,4,6,9).
Définition 1.2. Une valeur particulière de l'ensemble des valeurs données en entrée est appelée instance du
problème.
Définition 1.3. Un algorithme est correct, si pour toute instance du problème il se termine et produit une sortie
correcte.
Les algorithmes peuvent être spécifiés en langage humain ou tout langage informatique. Dans ce qui suit, nous
utiliserons un langage proche du langage naturel. Nous donnerons une implémentation en Python (voir cours MISMI
MIS 102).
Définition 1.4. Une heuristique est une procédure de calcul correcte pour certaines instances du problème (c'est-
à-dire se termine ou produit une sortie correcte).
Pour qu'un algorithme puisse être décrit et s'effectue, les données d'entrées doivent être organisées.
Définition 1.5. Une structure de données est un moyen de stocker et d'organiser des données pour faciliter leur
stockage, leur utilisation et leur modification.
• bio-informatique ;
• moteur de recherche sur Internet ;
• commerce électronique ;
• affectation de tâches.
Définition 1.6. L'efficacité d'un algorithme est mesurée par son coût (complexité) en temps et en mémoire.
Un problème NP-complet est un problème pour lequel on ne connaît pas d'algorithme correct efficace, c'est-à-dire
réalisable en temps et en mémoire. Le problème le plus célèbre est le problème du voyageur de commerce.
L'ensemble des problèmes NP-complets ont les propriétés suivantes :
• si on trouve un algorithme efficace pour un problème NP complet alors il existe des algorithmes efficaces pour
tous ;
• personne n'a jamais trouvé un algorithme efficace pour un problème NP-complet ;
-5-
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
• personne n'a jamais prouvé qu'il ne peut pas exister d'algorithme efficace pour un problème NP-complet
particulier.
L'efficacité d'un algorithme est fondamentale pour résoudre effectivement des problèmes.
Exemple1.2.
9
Supposons que l'on dispose de deux ordinateurs. L'ordinateur A est capable d'effectuer 10 instructions par seconde.
7
L'ordinateur B est capable d'effectuer 10 instructions par seconde. Considérons un même problème (de tri par
2
exemple) dont la taille des données d'entrées est n. Pour l'ordinateur A, on utilise un algorithme qui réalise 2n
instructions. Pour l'ordinateur B, on utilise un algorithme qui réalise instructions. Pour traiter une entrée
6
de taille 10 : l'ordinateur A prendra 2000 s et l'ordinateur B prendra 100 s. Ainsi, même si la machine B est médiocre,
elle résoudra le problème 20 fois plus vite que l'ordinateur A.
• en temps, le nombre d'opérations élémentaires effectuées pour traiter une donnée de taille n ;
• en mémoire, l'espace mémoire nécessaire pour traiter une donnée de taille n.
Dans ce cours, nous considérerons que la complexité des instructions élémentaires les plus courantes sur un
ordinateur ont un temps d'exécution que l'on considérera dans ce cours comme constant égal à 1. Les instructions
élémentaires sont : addition, multiplication, modulo et partie entière, affectation, instruction de contrôle. Ce qui
intéresse fondamentalement l'algorithmique, c'est l'ordre de grandeur (au voisinage de l'infini) de la fonction qui
exprime le nombre d'instructions. Les courbes de références sont ici.
Il est nécessaire de disposer d'un langage qui soit non lié à l'implémentation. Ceci permet une description plus précise
des structures de données ainsi qu'une rédaction de l'algorithme plus souple et plus « lisible ». Le langage EXALGO
est un exemple de ce qui peut être utilisé et qui sera utilisé dans ce cours. Il est composé de chaînes de caractères
alphanumériques, de signes opératoires (+, -, *, /, <, <=, >=, >, <>, ==, =, ou, non, et), de mot-clés réservés, et de
signes de ponctuation : ''=, ;, (, ), début, fin, //. Les balises début et fin peuvent être remplacées par { et }.
Python n'utilise pas de marqueurs de fin. Le caractère « : » est le marqueur de début et quand
l'indentation cesse Python considère que c'est un marqueur de fin.
II-A - Définitions
• d'un nom ;
• d'un ensemble de valeurs ;
• d'un ensemble d'opérations définies sur ces valeurs.
-6-
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
On écrit en EXALGO
Type est à prendre pour l'instant dans l'ensemble {entier, car, booléen, réel}.
Définition 2.3. Les Expressions sont constituées à l'aide de variables déjà déclarées, de valeurs, de parenthèses
et d'opérateurs du (des) type(s) de variables concernées.
Définition 2.4. L'affectation est l'instruction qui permet de stocker une valeur dans une variable.
On écrit :
NomDeVariable = ExressionDuTypeDeLaVariable;
II-B-1 - Booléens
Une variable de type booléen prend comme valeur VRAI ou FAUX. Les opérations usuelles sont ET, OU et NON
qui sont données dans les tables qui suivent :
-7-
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
II-B-2 - Entiers
Une variable de type entier peut prendre comme valeur l'ensemble des nombres entiers signés. Les opérations
associées sont les opérations usuelles +,-,*,/.
II-B-3 - Réels
Une variable de type réel peut prendre comme valeur l'ensemble des nombres réels. Les opérations associées sont
les opérations usuelles +,-,*,/.
II-B-4 - Caractères
Une variable de type car peut prendre comme valeur l'ensemble des caractères imprimables. On notera les valeurs
entre guillemets. On considère souvent que les caractères sont ordonnés dans l'ordre alphabétique.
II-B-5 - Attention
Les valeurs :
sont différentes et ne seront pas codées de la même manière dans la mémoire de la machine.
II-B-6 - Comparaison
Les opérateurs <, ≤, ==, !=, >, ≥ permettent de comparer les valeurs de type entier, réel et caractère. Le résultat de
cette comparaison est une valeur booléenne.
• Bloc d'instructions :
début
instruction1
instruction2
..........
fin
• Alternative :
• Alternative simple :
Traduction Python
if ExpressionBooléenne:
BlocInstruction1
else:
BlocInstruction2
si ExpressionBooléenne alors
-8-
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
BlocInstructions1
sinon
BlocInstructions2
finsi;
• Alternative multiple (traduction Python) :
Traduction Python
if cas1:
BlocInstruction1
elif cas2:
BlocInstruction2
elif .....:
.....
......
else:
BlocInstruction
selon que
cas cas1 : BlocInstructions1
cas cas2 : BlocInstructions2
..........
autrement : BlocInstruction
finselonque
• Répétition
L'instruction exit permet d'arrêter la répétition.
Traduction Python
while ExpressionBooléenne:
BlocInstruction
.......
Traduction Python
for VariableIndicatrice in range(ValeurInitiale,ValeurFinale,ValeurPas):
BlocInstruction
.............
pour VariableIndicatrice
allant de ValeurInitiale à ValeurFinale
par pas de ValeurPas faire
BlocInstructions
finpour;
• Le bloc d'instructions est exécuté au moins une fois (ne se traduit pas directement en Python) :
répéter
BlocInstructions
jusqu'à ExpressionBooléenne finrépéter;
II-D - Fonctions
Une fonction est une section d'algorithme qui a un objectif bien défini et un nom. En général, elle communique avec
l'extérieur par le biais de paramètres typés. Elle possède des variables locales qui ne sont pas visibles à l'extérieur
de la fonction. Ces variables peuvent être des fonctions. Une fonction retourne une valeur par l'instruction simple
retourne(Expression). L'expression peut être :
-9-
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
• vide, tout s'est bien passé, mais il n'y a pas de résultat à retourner : retourne() ;
• sans résultat, il est impossible de retourner un résultat suite à un cas de figure de l'instance : retourne(NUL).
II-D-1 - Syntaxe
• Écriture de la fonction :
val ListeVariable:NomDeType
II-D-2 - Utilisation
NomDeFonction(ListeInstanceParamètres)
II-D-3 - Exemple
- 10 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
EXALGO permet de fixer les quelques règles élémentaires permettant d'écrire des algorithmes en s'affranchissant
l'implémentation.
III-A - Généralités
Le langage EXALGO est composé de chaînes de caractères alphanumériques, de signes opératoires, de mot-clés
réservés, et de signes de ponctuation : =, ;,(,), début, fin, //. Les marqueurs de fin, début et fin peuvent être remplacés
par { et } lorsqu'il y a encombrement.
III-B - Type
Définition de type
type NomDeType = TypePrédéfini;
III-C - Variables
III-D - Expressions
Constituées à l'aide de variables déjà déclarées, de parenthèses et d'opérateurs du (des) type(s) des variables
concernées.
• affectation :
NomDeVariable = ExressionDuTypeDeLavariable;
• sortie de calcul : exit, retourne().
• Bloc d'instruction :
Bloc d'instruction
Instruction1
instruction2
.............
• Alternative :
si ExpressionBooléenne alors
BlocInstruction1
sinon
BlocInstruction2
finsi;
- 11 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
• Alternative multiple :
selon que
cas cas1 : BlocInstruction1
cas cas2 : BlocInstruction2
.............
autrement : BlocInstruction
finselonque
• Répétition : exit permet d'arrêter la répétition
pour VariableIndicatrice
allant de ValeurInitiale à ValeurFinale
par pas de ValeurPas faire
BlocInstruction
finpour;
• le bloc d'instruction est exécuté au moins une fois
répéter
BlocInstruction
jusqu'à ExpressionBooléenne finrépéter;
III-G - Fonctions
Une fonction retourne une valeur par l'instruction simple (retourne(Expression)). Une fonction s'utilise dans le calcul
d'une expression ou comme instruction simple.
• Écriture de la fonction :
ref ListeVariable:NomDeType
• par valeur val, on écrit :
val ListeVariable:NomDeType
• Le type du résultat est vide si la fonction ne renvoie pas de résultat.
III-H - Types
Un type structuré est constitué à partir de types de base ou d'autres types déclarés.
- 12 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
Après la déclaration :
var E:NomDeTypeEnregistrement
on accède aux différents champs par le nom de la variable suivi d'un point suivi du nom de champ (E.champ1).
var P:^NomDeType
alors on peut obtenir un objet accessible par allouer(P). Lorsqu'on n'utilise plus l'objet, il faut libérer l'espace qu'il
utilise par desallouer(P).
IV - Structures de données
IV-A - Définition
Définition 3.1. Une séquence sur un ensemble E est une suite d'éléments (e1,e2,…en) d'éléments de E.
Exemple 3.1 (3,5,8,2,12,6) : est une séquence d'éléments de N, ensemble des entiers naturels. ("a","z","T","A","a")
est une séquence sur l'ensemble des caractères imprimables (char).
Il existe plusieurs variantes de séquences suivant les opérations de manipulation autorisées : accès par l'indice de
l'élément ou non, accès à la fin de la séquence ou non…
On utilisera en général des noms particuliers dépendant des caractéristiques de la séquence.
Exemple 3.2 : Un vecteur peut être défini par une séquence dans laquelle l'accès aux éléments se fait par son
indice et la taille de la séquence dépend de l'espace dans lequel on se trouve. On dit aussi qu'on a un accès direct
à l'élément. Dans la plupart des langages de programmation, le vecteur existe sous le nom d'array.
Programme Python
def fac(n):
if (n<=1) :
return 1
else :
- 13 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
Programme Python
return n*fac(n-1)
print(fac(5))
La séquence des valeurs de n au cours des appels récursifs doit être mémorisée. Supposons l'appel fac(4) alors :
IV-B - Structure
Définition 3.2. Une structure sur est une séquence telle que
Les structures sont des cas particuliers de séquences. En algorithmique, chaque ensemble peut être un type de
base ou une structure. Ce mécanisme permet de définir de nouveaux types plus complexes que les types de base.
En EXALGO, on écrit :
nom_du_type = structure
nom_champs_1 :type1;
nom_champs_2 :type2;
…
nom_champs_k :typek;
finstructure
Cela signifie que lorsqu'une variable est déclarée de ce type, elle référence k variables en même temps. Soit V une
variable dont le type est une structure, on désigne un des champs par V. suivi du nom du champ.
Exemple 3.4 : Une date de naissance est un exemple de structure. On peut écrire :
dateDeNaissance = structure
jourDeNaissance: entier;
moisDeNaissance: entier;
annéeDeNaissance: entier;
finstructure
individu = structure
sexe :booléen
date :dateDeNaissance;
finstructure.
Soit la déclaration :
var I :individu
- 14 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
alors I.sexe sera un booléen et I.date.jourDeNaissance sera un entier. Ainsi les instructions suivantes ont un sens :
I.date.jour = 12;
I.sexe = faux;
Définition 3.3 : Soit F un ensemble. Une table d'association à clé unique est une séquence d'éléments de
(N est l'ensemble des entiers naturels), telle que :
Les tables d'association sont un cas particulier de séquences d'éléments structurés. La structure se décrit en
EXALGO :
association = structure
cle :entier;
valeur :type_prédéfini;
finstructure
Exemple 3.5 : Lors de l'activation du compte électronique, l'étudiant de l'Université Bordeaux 1 fournit un numéro
INE qui sera associé à un mot de passe. On a donc quelque part dans le système de gestion des comptes une table
d'association à index unique dont l'élément de séquence est :
Etudiant = structure
INE :entier;
motDePasse :typeMotDePasse;
finstructure
V - Complexité
V-A - Définitions
Définition 4.1. (Notation de Landau). On dit que s'il existe deux nombres réels tels que
.
Exemple 4.1. Si le nombre d'instructions est égal à avec a,b,c des constantes réelles, alors
Les figures permettent de comparer les fonctions usuelles utilisées pour décrire la complexité d'un algorithme en
fonction de la taille n des données d'entrées. Parmi les fonctions usuelles, le log à base 2 de joue un rôle
important. Pour un algorithme A, notons , le coût de l'algorithme A pour une instance D.
- 15 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
• complexité en moyenne :
où
Soit l'ensemble des instances de taille n. Si toutes les instances sont équiprobables, on a :
Parfois, il est nécessaire d'étudier la complexité en mémoire lorsque l'algorithme requiert de la mémoire
supplémentaire (donnée auxiliaire de même taille que l'instance en entrée par exemple).
• opérations élémentaires +, -, *, / ;
• test d'expression booléenne ;
• appel de fonctions.
- 16 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
V-C - Exemples
Source Python
#! /usr/bin/python
def somme(n):
s= 0
for i in [n]:
s = s+i
return s
print suite(4)
On a :
V-C-2 - Apparition d'une pile dans une suite de n lancers d'une pièce
Entrée : un entier n
Sortie : « vrai » si on rencontre une pile, « faux » sinon.
La fonction suivante retourne « vrai » lorsque l'un des lancers est égal à 6 et « faux » sinon.
Source Python
#! /usr/bin/python
- 17 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
Source Python
# Module pour calculer un nombre aléatoire
import whrandom
def rand():
return int(whrandom.random() * 32768.0) % 32768
# Lancer de pile
def resultat_lancer_piece():
return rand()*2/32767
def jeu_de_pile(n):
for i in [n]:
f = resultat_lancer_piece()
if (f == 1):
return 1
return 0
print jeu_de_pile(4)
- 18 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
- 19 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
V-D-4 - 2n, nn n !
- 20 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
VI - Tableaux
VI-A - Définition
Définition 5.1. Un tableau est une table d'association à clé unique telle que :
On écrit en EXALGO :
La taille du tableau est donc max_indice - min_indice + 1. Pour accéder à un élément d'un tableau T d'indice I, on
écrit T[I]. La complexité de l'accès à un élément du tableau est .
- 21 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
Soit min_indice< i<j <max_indice, on notera T[i..j] la séquence des éléments de T (T[i],T[i+1],
…,T[j]).
Beaucoup d'algorithmes peuvent être décrits sans préciser un type particulier. Dans ce cas, on écrira à la place de
type_prédéfini le mot élément et on précisera les valeurs possibles pour élément.
• TC = tableau[1..10] de car; ;
• TE = tableau[1..10] d'entiers;.
L'algorithme qui permet de trier TC et TE est le même. Seul diffère le type de l'élément manipulé. On écrira dans
ce cas un algorithme sur un tableau.
T = tableau[1..10] d'éléments;
VI-B - Primitives
Les paramètres tableaux doivent, sauf raison majeure, être passés en paramètre par référence afin d'éviter la
recopie.
Complexité :
Complexité : .
- 22 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
T[indice1] = T[indice2];
T[indice2] = e;
fin
finfonction
Complexité : .
Complexité :
• minimum :
• maximum :
Source Python
#! /usr/bin/python
# En Python, les tableaux peuvent être construits à partir des listes
# L'index varie de 0 à la taille du tableau -1
class Tableau:
def __init__(self,taille,valinit):
self.tableau = []
for i in range(taille):
self.tableau.append(valinit)
def taille(self):
return(len(self.tableau))
def echange(self,i,j):
tmp=self.tableau[i]
self.tableau[i]=self.tableau[j]
self.tableau[j]=tmp
return()
def copie(self,T1,indiceT_1,indiceT_2,indiceSelf):
if indiceSelf+indiceT_2-indiceT_1 >self.taille():
return(1)
else:
i=indiceT_1
for i in range(indiceT_1,indiceT_2+1):
self.tableau[indiceSelf]=T1.tableau[i]
indiceSelf=indiceSelf+1
return(0)
def ecrire(self):
for i in range(len(self.tableau)):
- 23 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
Source Python
print self.tableau[i],
print
return()
Complexité :
Propriété 5.2. Soit i,j deux entiers, i<=j. Soit T un tableau d'éléments d'indice variant entre i et j. Pour tout élément
e, appartenant au tableau T, on a :
Complexité :
• minimum :
• maximum :
Source Python
from tableaux import Tableau
def chercheRecursif(T,e,min_indice,max_indice):
if T.tableau[min_indice] == e:
return(min_indice)
else :
if min_indice == max_indice :
- 24 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
Source Python
return()
else :
return(chercheRecursif(T, e, min_indice+1, max_indice))
def chercheIteratif(T,e):
for i in range(T.taille()):
if T.tableau[i] == e :
return(i)
return()
On suppose que le tableau contient des éléments comparables (l'ensemble des éléments est muni d'une relation
d'ordre). Choisissons ici, pour simplifier les notations, des entiers.
Propriété 5.3. Soit i,j deux entiers, i<=j. Soit T un tableau d'entiers d'indice variant entre i et j. Soit m l'élément
minimum du tableau, on a :
Complexité :
VI-D - Matrices
VI-D-1 - Déclaration
Une matrice M de dimension est un tableau de dimension n dont chaque élément est un tableau de dimension
m. On peut donc déclarer la matrice sous la forme suivante :
VI-D-2 - Initialisation
Complexité :
- 25 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
Complexité :
On considérera dans tout ce chapitre que l'on manipule des entiers. L'objet du tri est
d'ordonner une séquence de N entiers. On considérera que ces entiers sont rangés dans un
tableau.
Ce tri est basé sur l'algorithme de recherche du minimum On adapte cet algorithme pour pouvoir effectuer la
recherche dans un sous-tableau. On a le déroulement ici.
Propriété 6.1. La complexité de l'algorithme triSelection sur une instance de taille N est
- 26 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
Propriété 6.2. Soit T un tableau d'entiers trié d'indice variant entre i et j. Soit e un entier quelconque, alors on a l'une
des propriétés suivantes :
• e ≤ T[i] ;
• il existe un unique entier k dans [i..j-1] tel que T[k] < e ≤ T[k+1] ;
• e > T[j].
On a le déroulement ici.
Propriété 6.3. La complexité de l'algorithme triInsertion sur une instance de taille N est :
• au minimum en
;
• au maximum et en moyenne en
Idée de la démonstration
La boucle « pour » s'effectue systématiquement et demandera opérations.
La boucle « tant que » effectue au minimum opération (cas où les nombres sont déjà triés) et au maximum
.
La boucle « tant que » effectue en moyenne opérations.
- 27 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
On a le déroulement ici.
Propriété 6.4. La complexité de l'algorithme triBulle sur une instance de taille N est .
Lorsque deux tableaux T1 et T2 sont triés, il est aisé de construire un nouveau tableau contenant la séquence triée
regroupant les séquences correspondantes à T1 et T2.
PREMIERE VERSION
fonction fusion(ref T1 :tableau[1..N1] d'entier;
ref T2 :tableau[1..N2] d'entier
) :tableau[1..N1+N2] d'entier;
var I1,I2,i :entier;
var T :tableau[1..N1+N2] d'entier;
début
I1 = 1;
I2 = 1;
pour i allant de 1 à N1+N2 faire
si T1[I1]≤T2[I2] alors
T[i] = T1[I1];
I1 = I1+1;
sinon
T[i] = T2[I2];
I2 = I2+1;
finsi
finpour
retourner(T)
fin
finfonction
Complexité :
Cette version ne fonctionne pas toujours. Par exemple, si I1 a dépassé N1 et vaut par
exemple N1+1, on comparera T1[N1+1] à T2[I2] ce qui n'a pas de sens. Il faut donc utiliser
un algorithme exact. On a le déroulement ici.
Soit une séquence d'éléments de [0..k], il est alors possible de réaliser l'histogramme des valeurs. Par la suite le tri
des éléments de la séquence se fait en temps linéaire .
- 28 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
max = maximum(T);
pour j allant de 0 à max faire
pour k allant de 1 à H[j] faire
T[i] = j;
i = i+1;
finpour
finpour
fin
finfonction
On a le déroulement ici.
VII-E-1 - Aide
On considère une nouvelle fonction copie qui copie un tableau dans un autre même s'ils n'ont pas la même définition.
L'en-tête de la fonction est :
- 29 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
fintantque
si I1 ≤ N1 alors
copier(T1,T,I1,N1,i)
sinon
copier(T2,T,I2,N2,i)
finsi
retourner(T)
fin
finfonction
VIII-A - Visibilité
Comme vu au chapitre Codage et structures de contrôle, on peut déclarer dans une fonction des variables et des
fonctions locales :
La multi-imbrication possible des fonctions entraîne l'existence de problèmes de visibilité : entre les variables et entre
les fonctions.
• Règle 1 : une variable V (locale ou non) est visible depuis sa déclaration jusqu'au marqueur finFonction de la
fonction F où elle a été déclarée.
- 30 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
• Règle 2 : si une fonction G est locale à F et déclare une variable V déjà déclarée dans F alors la variable
originelle est momentanément cachée.
VIII-A-2 - Exemple
début
x = 1;
y = 2;
z = 3;
R() …
Q(z);
fin
finFonction
On a le déroulement ici.
Une fonction est visible depuis la fin de son entête jusqu'au finFonction de la fonction où elle a été déclarée. Cependant
comme pour les variables, elle peut momentanément être cachée par une autre fonction ayant le même entête
(surcharge).
VIII-A-3-a - Exemple
La fonction P suivante est annotée pour préciser la visibilité des fonctions Q,R,T.
- 31 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
finFonction ;
début
....// on peut utiliser P,Q,R
fin
finFonction
fonction T(...) :...;
début
....// on peut utiliser P,Q,T mais pas R
fin
finFonction ;
début
... //// on peut utiliser P,Q,T mais pas R
fin
finFonction
VIII-B - Récursivité
La récursivité consiste à remplacer une boucle par un appel à la fonction elle-même. Considérons la suite factorielle,
elle est définie par :
;
•
On a le déroulement ici. On peut décrire sur le papier les changements et les appels sous la forme suivante :
- 32 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
Plusieurs appels à la fonction peuvent être exécutés dans son corps. Soit la suite dite de Fibonacci définie par :
;
•
;
•
On a le déroulement ici. On peut décrire sur le papier les changements et les appels sous la forme suivante :
- 33 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
VIII-C - Complexité
;
•
e
Une fonction permettant le calcul de son n terme est :
- 34 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
La complexité en nombre d'opérations de suite et suiteR est en . On aurait donc tendance à préférer suiteR
pour sa lisibilité. Cependant, si on examine la complexité en mémoire, suite est en alors que suiteR est en
.
La programmation non récursive est donc plus efficace. L'utilisation de la récursivité ne doit pas se faire au
détriment de l'efficacité.
VIII-D - Exemples
Chaque fois que l'on désire programmer une fonction récursive, on doit répondre aux questions suivantes :
- 35 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
IX-A - Dichotomie
La dichotomie fait partie des méthodes dites « diviser pour régner ». Elle consiste pour un objet de taille N à exécuter
un algorithme de façon à réduire le problème à un objet de taille N/2. On répète alors l'algorithme de réduction sur
ce dernier objet. Ainsi, il suffit de connaître la résolution pour un problème de taille faible (typiquement N=1 ou N=2)
pour obtenir la totalité de la résolution.Ce type d'algorithme est souvent implémenté de manière récursive. Lorsque
cette technique est utilisable, elle conduit à un algorithme très efficace et très lisible.
Il est parfois nécessaire de traiter les données avant d'appeler la fonction récursive. La fonction récursive est alors
une fonction locale à la fonction d'appel.
IX-B - Exemples
Soit g une fonction croissante sur un intervalle [a,b] et telle que f(a)≤0 et f(b)≥0. L'algorithme ci-dessous permet de
trouver la valeur x de [a,b] telle que f(x)=0 avec une précision e.
Nous avons déjà traité cet algorithme sous une autre forme au chapitre Tableaux.
Propriété 8.1. T un tableau d'entiers triés d'indice variant entre d et f. Posons . Soit e un entier
appartenant à la séquence contenue dans T. On a l'une des propriétés suivantes :
• T[m] = e ;
• e est dans la séquence contenue dans T[d..m-1] ;
• e est dans la séquence contenue dans T[m+1..f].
- 36 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
Idée de la preuve : la complexité de la fonction cherche est donnée par la complexité de chercheRec. Soit le
nombre de tests effectués par cette fonction.
On a :
IX-B-3 - Remarque
a montré qu'en utilisant une méthode « diviser pour régner », la multiplication peut s'effectuer en .
- 37 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
IX-C - Complexité
;
2 Pour résoudre un problème de taille
, l'algorithme consiste à décomposer le problème en sous-problèmes ayant tous la taille n/b (peut-être
approximativement) ;
3 À appliquer l'algorithme à tous les sous-problèmes ;
4 À construire une solution du problème en composant les solutions des sous-problèmes.
La complexité en temps de l'algorithme est donc déterminée par une équation de récurrence de la forme :
qui après résolution permet de montrer que cette méthode conduit à des algorithmes plus efficaces en nombre
d'opérations. Cependant, cela ne doit pas occulter l'aspect mémoire. La complexité en mémoire doit rester d'un ordre
raisonnable. (cf. récursivité).
- 38 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
X - Tris récursifs
On considérera dans tout ce chapitre que l'on manipule des entiers. L'objet du tri est
d'ordonner une séquence de N entiers. On considérera que ces entiers sont rangés dans un
tableau :
Cet algorithme consiste à diviser la séquence d'entiers en deux sous-séquences, à les trier de manière récursive,
puis à fusionner les deux sous-séquences triées. On utilise la fonction fusion vue au chapitre tris non récursifs.
On a le déroulement ici.
Propriété 9.1. La complexité du tri fusion pour une séquence de n éléments est .
idée de la preuve : la complexité de la fonction triFusion est donnée par la complexité de triFusionRec. Soit
le nombre de tests effectués par cette fonction. On a :
On en déduit :
- 39 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
et
Cet algorithme consiste à utiliser une valeur x de la séquence pour diviser la séquence d'entiers en deux sous-
séquences :
On a le déroulement ici.
Propriété 9.2. La complexité du tri rapide pour une séquence de n éléments est :
• au maximum en
;
• en moyenne et au minimum en
- 40 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
XI-A - Énoncé
Décrire une structure permettant de gérer des polynômes définis sur les réels. Écrire un ensemble de primitives
associées permettant les principales opérations.
XI-B-1 - Structure
Un polynôme peut être défini par son degré et un tableau contenant les coefficients. On définit également une primitive
d'initialisation.
XI-B-2 - Addition
- 41 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
retourner(p);
fin;
finfonction;
Complexité :
XI-B-3 - Multiplication
Complexité :
Soit :
Complexité :
- 42 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
var i:entier;
var d:polynome;
début
d.degre = p.degre + n;
si n>0 then
pour i de 0 à n-1 FAIRE
d.coeff[i] = 0;
finpour
pour i de 0 à p.degre faire
d.coeff[i+n] = p.coeff[i];
finpour
sinon
pour i de -n à p.degre faire
d.coeff[i+n] = p.coeff[i];
finpour
finsi
retourner(d)
fin
finfonction
Complexité :
XI-B-6 - Dérivée
Complexité :
Complexité :
- 43 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
Même si en première approche, la complexité ne prend en compte que le nombre d'opérations (+, *), en seconde
analyse, les multiplications sont beaucoup plus coûteuses que les additions. Cela est pris en compte dans les
algorithmes ci-dessous.
L'algorithme énoncé au paragraphe précédent effectue 2n multiplications. Le schéma d'Horner d'un polynôme permet
d'effectuer n multiplications seulement. Le schéma d'Horner repose sur la propriété suivante :
XI-D - Multiplication
Une méthode « diviser pour régner » permet d'améliorer cet algorithme. Elle est basée sur l'égalité suivante :
- 44 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
Cette égalité signifie, entre autres, que si deux polynômes sont de degré 1, il suffit de trois multiplications de réels pour
obtenir leur produit. Les quantités a, b, c, d, y étant quelconque, celles-ci peuvent être elles-mêmes des polynômes.
Soit le polynôme :
avec :
De même, on a :
- 45 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
De plus, on est amené à calculer des produits de polynômes de degré au plus n/2. Il s'agit donc d'une méthode :
« diviser pour régner ». La complexité en nombre de multiplications est alors . Comme on notera ci-
dessous, l'algorithme est plus complexe à écrire, mais il est bien plus efficace aussi.
Un prétraitement permet de considérer des polynômes de même degré. Il faut donc une fonction « chapeau ». On
définit de plus deux autres fonctions utiles pour le calcul :
• etend : si le degré de
, alors
est modifié de manière à ce que les coefficients manquants soient à zéro, et les degrés des deux polynômes
deviennent ainsi égaux ;
• tronque : permet d'initialiser un polynôme avec les premiers termes d'un autre polynôme (calcul de
et
).
- 46 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
c0 = p.coeff[0] * q.coeff[0];
c2 = p.coeff[1] * q.coeff[1];
c1 = (p.coeff[0] + p.coeff[1]) * (q.coeff[0] + q.coeff[1]);
c1 = c1 - c0 - c2;
retourner(polynome([c0,c1,c2]));
autrement
m = partieEntière(p.degre/2);
a = decale(p, -(m+1));
b = tronque(p, m);
c = decale(q, -(m+1));
d = tronque(q, m);
C2 = multirec(a, c);
C0 = multirec(b, d);
C1 = multirec(ajout(a,b), ajout(c,d));
C1 = ajout(C1, ajout(moins(C0), moins(C2)));
C1 = decale(C1, 1+m);
C2 = decale(C2, 2+2*m);
C0 = ajout(C0, ajout(C1,C2));
retourner(C0);
finselonque:
fin
finfonction;
début
si p.degre > q.degre alors
p1 = p;
p2 = etend(q, p.degre);
sinon
p1 = q;
p2 = etend(p, q.degre);
finsi;
retourner(multirec(p1,p2));
fin
finfonction
XII - Listes
XII-A - Définition
Définition 6.1. Une liste est une table d'association à clé unique telle que :
La complexité de l'accès à un élément par son pointeur est . Si p est un pointeur vers un élément alors
contenu(p) est l'élément lui-même. Un pointeur qui n'adresse aucun élément a pour valeur NIL. On écrit en EXALGO
pour déclarer un pointeur :
nom_pointeur=^type_predefini;
type_liste=liste de type_predefini;
La manipulation des éléments de la liste dépend des fonctions définies comme s'exécutant en temps .
Définition 6.2. Une liste est dite simplement chainée si les opérations suivantes s'effectuent en :
- 47 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
• accès :
On écrira en EXALGO listeSC pour préciser qu'il s'agit d'une liste simplement chaînée.
Complexité :
• minimum :
;
• maximum :
- 48 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
Complexité : .
Définition 6.3. Une liste doublement chaînée est une liste pour laquelle les opérations en temps sont celles
des listes simplement chaînées auxquelles on ajoute les fonctions d'accès.
On écrira en EXALGO listeDC pour préciser qu'il s'agit d'une liste doublement chaînée.
Complexité :
• minimum :
;
• maximum :
- 49 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
XII-D-1 - Taille
Complexité : .
Complexité moyenne : .
On considérera dans tout ce chapitre que l'on a des valeurs qui correspondent à un caractère.
Pour certaines structures de données, l'ensemble des langages de programmation proposent une traduction
immédiate. Pour d'autres, il n'existe pas de traduction immédiate. Il faut alors définir explicitement l'algorithme de
chacune des primitives.
- 50 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
Exemple - les listes. On doit définir le stockage de la liste, et en fonction de ce stockage comment s'effectue par
exemple l'adjonction.
L'implémentation doit respecter la complexité des primitives à part celle d'initialisation (celle-ci ne s'exécutera qu'une
fois).
Exemple - les listes. On utilise souvent les fonctions ajouter et supprimer, mais une seule fois creerListe.
Ici nous allons choisir de ranger les éléments dans un tableau « suffisamment grand ». Chaque élément du tableau
est une paire (valeurElement, pointeurSuivant). Un pointeur est la valeur d'un index du tableau ; ainsi l'accès au
suivant est en complexité . La zone de stockage peut donc être décrite par :
elementListe = structure
valeur :car;
suivant :entier;
finstructure;
stockListe = tableau[1..tailleStock] d'elementListe;
La valeur du pointeur (champ suivant) est donc un entier compris entre 0 et tailleStock. La valeur 0 correspondant à
l'absence d'élément suivant. Le premier élément doit être accessible en , il faut donc conserver son index. Si la
liste est vide, par convention, l'index du premier sera 0. On peut donc représenter une liste par la structure suivante :
listeSC_Car = structure
tailleStock :entier;
premier :entier;
vListe :stockListe;
finstructure;
Le tableau de stockage étant grand, mais pas illimité, il faudra prévoir que l'espace de stockage puisse être saturé.
Pour ajouter un élément, il faut pouvoir trouver un élément « libre » dans le tableau. Une première solution consiste
à marquer les éléments libres du tableau (par exemple champ suivant de l'élément a pour valeur -1). Dans ce cas,
- 51 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
il faudra parcourir le tableau (complexité en moyenne). Par suite, la primitive insérerAprès ne sera plus
en complexité puisqu'il faudra d'abord trouver un élément libre. Une solution compatible avec la complexité
des primitives consiste à gérer cet espace de stockage en constituant la liste des cellules libres. On modifie donc
en conséquence la description de listeSC_Car :
listeSC_Car = structure
tailleStock :entier;
premier :entier;
premierLibre :entier;
vListe :stockListe;
finstructure;
Par convention, l'espace de stockage sera saturé lorsque l'index premierLibre vaut 0 (la liste des cellules libres est
vide). On définit donc la fonction de test :
Les opérations sont respectivement de type insererEnTete et supprimerEnTete. Préciser la liste sur laquelle s'effectue
l'opération revient à préciser le pointeur de tête sur lequel on travaille.
- 52 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/
Cours pour apprendre les bases de l'algorithmique par M. Delest
si listeLibreVide(L) ou P == 0 alors
retourner faux;
sinon
nouv = prendreCellule(L,L.premierLibre);
L.vListe[nouv].valeur = x;
L.vListe[nouv].suivant = suivant(L,P);
L.vListe[P].suivant = nouv;
retourner vrai;
finsi
fin
finfonction
XIV - Remerciements
Toute l'équipe de Developpez.com remercie sincèrement M. Delest qui nous a aimablement permis de publier son
tutoriel sur notre site. Nous tenons également à remercier zoom61, Siguillaume et Winjerome pour la gabarisation,
ainsi que Claude Leloup et Malick SECK pour leur relecture orthographique.
- 53 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée
par les droits d'auteur. Copyright ® 2016 M. Delest. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
http://algo.developpez.com/tutoriels/initiation/