Documente Academic
Documente Profesional
Documente Cultură
Edition 2001
1. INTRODUCTION
La programmation (but final) a souvent été une activité menée sans méthodes strictes, à
grand renfort d'astuces et de recettes personnelles. Cette situation est issue des balbutiements
de l'informatique quand les conditions permettaient (ou favorisaient) cet état de choses.
Disciplines d'organisation
Définition stricte des rôles des membres d'une équipe de programmation et hiérarchie
des équipes.
Grand soin apporté à l'écriture et à la mise à jour de la documentation.
Modularisation du produit et définitions précises des interfaces.
Normes de programmation et normes de présentation des programmes respectées par
l'ensemble de l'équipe.
L’algorithmique est une science très ancienne. Son nom vient d’un mathématicien arabe
du IXème siècle EL KHOWRISMI.
Des mathématiciens grecs comme Euclide ou Archimède en ont été les précurseurs (calcul
du PGCD de 2 nombres, calcul du nombre π).
Quelque soit la donnée sur laquelle il travaille, un algorithme doit toujours se terminer
et fournir un résultat.
Certains algorithmes très anciens (Crible d'Erathostène par exemple) ont été décrits en
utilisant un langage peu formalisé (proche du langage naturel).
D'un autre côté, un algorithme n'a d'intérêt que s'il peut être compris et utilisé par un grand
nombre de programmeurs.
Il a donc fallu élaborer un langage de description suffisamment formel, pour permettre des
implantations dans différents langages de programmation peu fastidieuses, et d'un niveau
suffisant pour qu'il soit un outil de communication efficace.
Expression du raisonnement
Bien souvent, quelques lignes écrites en langage courant suffisent pour décrire
succinctement l'essentiel du problème. L'intérêt de cette étape est qu'elle permet de vérifier
rapidement que l'on se trouve sur la bonne voie. De plus, ces quelques lignes seront un
support efficace lors de l'écriture de l'algorithme.
Un algorithme va manipuler des objets au sens informatique. Ces objets pourront être des
données qui seront fournies en entrée, des résultats produits par l'algorithme ou des outils
nécessaires au bon déroulement de l'algorithme.
En informatique, les objets manipulés par un algorithme doivent appartenir à un type connu
au moment de leur utilisation.
Intérêt: documentation
vérifications possibles dans les langages de haut niveau lors de certaines opérations
On distingue généralement:
- les types scalaires qui sont par définition totalement ordonnés
- les types structurés qui regroupent sous un même nom une collection d'objets
élémentaires qui peuvent être de même type (type homogène) ou de type différents
(type hétérogène). Ces types structurés seront vus ultérieurement.
En résumé,
objet ⇒ donnée ou algorithme
algorithme ⇒ procédure ou fonction
donnée ⇒ constante ou variable
constante ou variable ⇒ type scalaire ou type structuré
type structuré ⇒ type homogène ou hétérogène
Type entier:
prend ses valeurs dans un sous-ensemble des entiers relatifs. C'est un ensemble fini dans
lequel chaque élément possède un successeur et un prédécesseur.
Type réel
prend ses valeurs dans un sous-ensemble de réels décimaux signés. Dans la plupart des
langages, cet ensemble n'est pas un ensemble fini. On ne peut trouver de successeur ou de
prédécesseur à un réel donné.
Type caractère
prend ses valeurs dans l'ensemble des caractères de la table ASCII.
Type booléen
type logique qui peut prendre les valeurs VRAI ou FAUX.
Dans ce tableau, les opérateurs sont classés par ordre de priorité décroissante mais
prudence! dans l'utilisation des priorités car il existe souvent des différences d'un langage de
programmation à l'autre.
En absence de parenthésage, l'évaluation se fait de gauche à droite.
3.3.2. Affectation
L'affectation a pour rôle d'attribuer une valeur, résultat d'une évaluation, à un objet. La
valeur doit être compatible avec le type de la valeur à gauche de l'affectation. Le symbole
utilisé pour l'affectation est <-.
Exemple: prix_total <- nb_kg * prix_du_kg
Si nb_kg est de type entier et prix_du_kg est de type réel alors prix_total doit être de type
réel.
Exemple d'algorithme
ALGORITHME EPICIER
VAR
prix_total , prix_du_kg : REEL;
nb_kg : ENTIER;
DEBUT
ECRIRE('Entrez le prix d'un kilogramme de choux : ');
LIRE(prix_du_kg);
ECRIRE('Entrez le nombre de kilogramme de choux : ');
LIRE(nb_kg);
prix_total <- prix_du_kg * nb_kg;
ECRIRE('Le prix total de l''achat est :',prix_total);
FIN
3.3.4. Commentaires
Afin d'améliorer la lisibilité d'un algorithme, on peut utiliser des commentaires. Un
commentaire est une suite de caractères quelconques encadrée par les symboles CO et FCO.
Exemple: CO ceci est un commentaire FCO
T T1
Les structures fondamentales utilisées pour écrire les algorithmes sont au nombre de 3.
e1
s2
e
SI Condition
ALORS T1;
SINON T2; Condition
FSI
T1 T2
Condition désigne une expression booléenne dont la valeur est VRAI ou FAUX.
T1 et T2 désignent une suite d'instructions (pouvant elles mêmes être des structures
alternatives).
La structure alternative est une structure parenthésée, chaque partie étant délimitée par les
symboles SI, ALORS, SINON et FSI.
Le traitement T2 est facultatif.
Exemple :
ALGORITHME MAXIMUM_DE_DEUX_NOMBRES
VAR
A, B : ENTIER; CO les deux nombres à comparer FCO
MAX: ENTIER; CO le plus grand FCO
DEBUT
ECRIRE('Entrez le premier nombre :');
LIRE(A);
ECRIRE('Entrez le deuxième nombre :');
LIRE(B);
SI A >= B
ALORS MAX <- a;
SINON MAX <- b;
FSI
ECRIRE('le maximum de ', A,' et de ',B,' est : ',MAX);
FIN
e
Lorsque la condition a pour valeur
VRAI, on exécute le traitement T1
puis on revient tester la condition. V RA I
Il est donc nécessaire que l'action T1 C o n d itio n
modifie la condition sinon l'itération
ne s'arrêtera pas.
Lorsque la condition a pour valeur FA U X
FAUX, le traitement séquentiel
T1
continue. L'itération est terminée.
Théorème : Tout programme propre peut être ramené à l'un de ces trois types de
structures.
Ex4 : Equation
Ecrire l'algorithme de résolution d'une équation du second degré.
Ex5 : Moyenne
Ecrire un algorithme qui lit une suite de nombres non nuls terminée par le marqueur 0 et
affiche la moyenne des nombres lus.
Ex7 : Suite
Soit S une suite de nombres entiers positifs ordonnés par ordre croissant.
Ecrire un algorithme permettant de déterminer la longueur L de la plus longue sous-suite
extraite de S et ne comportant que des éléments identiques.
Ex8: Série
Ecrire un algorithme qui calcule la somme de la série
1 - 1/3 + 1/5 - 1/7 + ...
avec une précision de l'ordre de Epsilon lu.
Expression
T1 T2 T3 T4
6.2. La répétition
e
On effectue le traitement T
Si la condition est VRAI,
on recommence le traitement T
L'itération se terminera lorsque T
la condition sera FAUX
Condition
VRAI
s FAUX
e
DEBUT
T
T TANT QUE Condition
FAIRE
DEBUT
T
FIN
VRAI Condition FIN
Exercice :
Traduire le schéma suivant:
T1
V RA I
C o n d itio n
T2 FA U X
- Rendre possible la lecture des modules de haut niveau par des non-spécialistes.
Problème
A
AI1 AI2
AE2
AE21 AE22
AE11 AE12 AE13
1111
Une telle situation peut sembler idyllique, mais il y a une contrepartie: l'analyse
descendante ne permettra que rarement de définir des sous-programmes identiques appelés de
points différents.
L'analyse Top-Down doit être le guide général, mais il peut être profitable, dans le cas
de traitements complexes, d'osciller quelque peu entre analyse descendante et montante.
Le détail de ce sous-programme est décrit par ailleurs dans la partie déclaration de sous-
programme.
Jusqu'à présent, un identificateur était associé à une valeur (donnée), il est ici associé à
une suite d'instructions.
Un sous-programme peut comporter des données (types, variables etc...) qui lui sont
propres. On parle alors de variables locales au sous-programme. On peut noter dès à présent
que ces variables existeront uniquement pendant l'exécution du sous-programme.
La procédure sera écrite avec des arguments fictifs appelés paramètres formels
auxquels on fera correspondre lors de l'appel les données réelles appelées paramètres
effectifs ou réels.
Lorsqu'une procédure doit rendre un résultat unique de type simple, il est commode
de définir cette procédure comme une fonction dont l'utilisation est analogue à celui des
fonctions mathématiques usuelles (SIN(x), TANG(x), COS(x) etc...).
VAR
I : ENTIER;
DEBUT
T;
FIN
La récursivité, c'est la possibilité de faire figurer dans la définition d'un objet une
référence à ce même objet. Beaucoup de langages autorisent la récursivité simple et la
récursivité croisée.
D'où l'algorithme
FONCTION FACT(N : ENTIER) : ENTIER
DEBUT
SI N=1
RETOURNER(1);
SINON
RETOURNER(N*FACT(N-1));
FSI
FIN
En langage C,
int fact(int n) /* fonction fact retournant un entier et acceptant un
paramètre de type entier */
{
if (n == 1)
return(1);
else
return(n*fact(n-1));
}
Une structure de données est caractérisée par ses composantes mais aussi par son mode
d'utilisation. On verra par la suite que des structures semblables sont considérées différentes
car leurs modes d'exploitation sont fondamentalement différents (Exemple : les piles et les
listes).
Il est fréquent d'utiliser dans un problème des objets réunis par des caractéristiques
communes.
Par exemple les jours de la semaine, les élèves d'une classe etc...
Il est alors pratique de donner à cet ensemble d'éléments un même nom. Chaque
élément est désigné par ce nom et un indice donnant le rang de cet élément.
Un tel regroupement de données, toutes de même type est un tableau.
Déclaration
VAR
Tab : ENTIER[inf:sup];
Tab est une variable de type tableau d'entiers dont l'indice peut prendre les valeurs comprises
entre inf et sup (inf<sup).
Le nombre d'éléments du tableau est sup-inf+1.
Le type du tableau est un type simple (entier, réel, booléen, caractère ou chaîne).
Pour sélectionner un élément du tableau, il faut préciser son indice de la façon suivante:
Tab[I] où I est une expression de type scalaire à résultat de type scalaire dont la valeur est
dans l'intervalle de définition des bornes du tableau.
L'itération de type boucle POUR est très souvent utilisée pour le parcours d'un tableau.
Le type TABLEAU peut être multidimensionnel. Chaque élément est alors repéré par
plusieurs indices. La déclaration d'un tel tableau est la suivante:
VAR
RUBIK : ENTIER[1:3,1:3,1:3];
Ce tableau peut être considéré comme un tableau de tableau de tableau.
1 1 1
2 2 2
3 3 3 5
On peut constater que chaque case du tableau de gauche sur le schéma ci-dessus contient un
tableau dont chaque élément contient un tableau de 3 entiers.
Un enregistrement (ou record ou structure) est une structure constituée d'un nombre fixe
de composants appelés champs. Les champs peuvent être de différents types et chaque champ
comporte un identificateur de champ permettant de le sélectionner.
Exemple:
TYPE
T_ABONNE = ENREG
NOM : CHAINE;
PRENOM : CHAINE;
AGE : ENTIER;
SALAIRE : REEL;
FIN
Si on déclare une autre variable ABONNE2 du type T_ABONNE, les opérations d'affectation
seront possibles entre ABONNE1 et ABONNE2.
11.1. Généralités
Un pointeur est un objet (au sens informatique) qui permet d’accéder à un autre objet,
l’objet pointé. Un objet pointeur peut changer de valeur en cours d’exécution, il peut donc
pointer sur des objets différents (mais de même type).
VAR
POINTEUR : T_POINTEUR ;
La variable pointée (ici de type CHAINE) n'existe pas lors de l'exécution. Il faudra la
créer en fonction des besoins. La variable pointée est une variable dynamique contrairement
aux variables statiques utilisées jusqu'à présent.
La variable POINTEUR^ pourra être manipulée exactement comme une variable de type
CHAINE. On pourra lui affecter une valeur, tester la valeur etc.
Exemples :
POINTEUR^ <- 'MARIE'
Où DEBUT est un pointeur sur un enregistrement contenant un champ Nom de type CHAINE
et un champ Suivant de type T_POINTEUR.
Pour construire une liste, il suffira donc de raccrocher plusieurs cellules de ce type les unes
derrière les autres.
TYPE
T_POINTEUR = ^CELLULE;
CELLULE = ENREG
NOM : CHAINE;
SUIVANT : T_POINTEUR;
FIN
VAR
DEBUT : T_POINTEUR;
On a alors
- DEBUT pointe sur DEBUT^ qui est la première cellule
- DEBUT^ est un enregistrement qui contient :
- DEBUT^.NOM qui est de type CHAINE
- DEBUT^.SUIVANT qui peut pointer vers une nouvelle cellule
12.3.1. La pile
Une pile est une structure linéaire dont seul le dernier élément peut être ajouté ou
enlevé. Une image en est donnée par une pile d'assiettes.
Dépiler
Empiler
Pour placer une cellule à la fin de la queue, il faut pouvoir accéder facilement au
pointeur suivant de la dernière cellule:
- pour la première cellule, il s'agit de DEBUT^.SUIVANT,
- pour la deuxième, c'est DEBUT^.SUIVANT^.SUIVANT, etc…
FIN
TYPE
P_ARTICLE = ^ARTICLE;
ARTICLE = ENREG
NUMERO : ENTIER;
LIBELLE : CHAINE;
QUANTITE : ENTIER;
PRIX : REEL;
P_SUIVANT : P_ARTICLE;
FIN
P_FACTURE = ^FACTURE;
FACTURE = ENREG
NUMERO_FACT : ENTIER;
DATE : CHAINE;
P_ART : P_ARTICLE;
FACT_SUIVANTE : P_FACTURE;
FIN
P_CLIENT = ^CLIENT;
CLIENT = ENREG
NOM : CHAINE;
P_FACT : P_FACTURE;
CLI_SUIVANT : P_CLIENT;
FIN
DUPONT DURAND
2 Colle 100 15
21 Vis 10 1,25
Un arbre binaire est un arbre dont les éléments pointent au plus vers deux autres
éléments.
Ces arbres binaires peuvent être utilisés pour effectuer des tris ou des recherches
rapides.
La propriété fondamentale est que chaque cellule comporte:
- Une valeur simple ou complexe (type simple ou structuré)
- A gauche un sous-arbre contenant des valeurs plus petites
- A droite un sous-arbre contenant des valeurs plus grandes
TYPE
P_CELLULE = ^CELLULE;
CELLULE = ENREG
VALEUR : CHAINE;
PTG : P_CELLULE;
PTD : P_CELLULE;
FIN
13.2.1. Définition
Un fichier est un ensemble organisé d'informations (articles ou enregistrements) de même
nature susceptibles de faire l'objet de traitements divers.
Soit F un fichier: ce fichier est dit à accès séquentiel si l'on ne peut accéder à un élément
quelconque de rang n qu'après avoir accédé aux n-1 éléments qui le précèdent.
On se déplace dans ce type de fichier en passant d'un élément à son suivant. Il existe deux
éléments particuliers: le premier qui nous permet d'accéder au fichier et le dernier qui nous
signale qu'il n'a pas de suivant.
1 2 3 4
1 2 3 4
C o u lo ir
Le nom du fichier physique correspond au nom du fichier sur le support physique (en général
disque magnétique, bande, etc...). Ce nom peut comprendre le chemin (absolu ou relatif) du
fichier.
L'opération d'assignation est obligatoire, tous les accès au fichier se feront à l'aide du nom de
fichier logique.
Fermeture.
FERMER(nom_de_fichier_logique);
VAR
POINTEUR : T_POINTEUR ; t_pointeur pointeur;
Passage de paramètres
Paramètres non modifiables (par valeur)
PROCEDURE P3(I,J : ENTIER); Procedure P3(i,j : INTEGER)
Appel P3(k,8); Appel p3(k,8);
Paramètres modifiables
PROCEDURE P4(VAR I : ENTIER); Procedure P4(VAR I : INTEGER)
Appel P4(K); Appel p4(k);
K pourra être modifié par la procédure P4
11-Enregistrement
TYPE TYPE
T_ABONNE = ENREG T_abonne = RECORD
NOM : CHAINE; nom : String[15];
PRENOM : CHAINE; prenom : String[10];
AGE : ENTIER; age : INTEGER;
FIN End;
VAR VAR
ABONNE : T_ABONNE; Abonne : T_abonne;
12-Pointeurs
TYPE TYPE
T_POINTEUR = ^CHAINE ; T_pointeur = ^STRING;
VAR VAR
POINTEUR : T_POINTEUR ; Pointeur T_pointeur;
13-Fichiers
VAR VAR
FIC : FICHIER; fic : file of T_abonne;
NOMFIC : CHAINE; NomFic : String[10];
ABONNE : T_ABONNE; Abonne : T_abonne;
ASSIGNER(FIC, NOMFIC); ASSIGN(fic, NomFic);
OUVREECR(FIC); Rewrite(Fic); { en écriture }
OUVRELEC(FIC); Reset(Fic); {lecture ou lecture/écriture }
FERMER(FIC); Close(fic);
LIRE(FIC,ABONNE); Read(Fic, Abonne);
ECRIRE(FIC,ABONNE); Write(Fic, Abonne);
TABLE DES MATIERES
1. INTRODUCTION...............................................................................................................................................1
2. INTRODUCTION A L’ALGORITHMIQUE.................................................................................................2
2.1. QU’EST-CE QU’UN ALGORITHME ?.....................................................................................................................2
2.2. PROPRIÉTÉS D'UN ALGORITHME.........................................................................................................................2
2.3. PLACE DE L'ALGORITHME DANS LA RÉSOLUTION D'UN PROBLÈME INFORMATIQUE..........................................................3
2.4. NOTION DE PSEUDO-LANGAGE...........................................................................................................................3
2.5. ELABORATION D'UN ALGORITHME......................................................................................................................3
3. OBJETS SIMPLES, TYPES ET ACTIONS ELEMENTAIRES..................................................................5
3.1. TYPE D'UN OBJET...........................................................................................................................................5
3.2. LES OBJETS ...................................................................................................................................................6
3.3. ACTIONS ÉLÉMENTAIRES ..................................................................................................................................6
3.3.1. Opérateurs sur les types simples...............................................................................................................7
3.3.2. Affectation.................................................................................................................................................7
3.3.3. Lecture et écriture.....................................................................................................................................8
3.3.4. Commentaires............................................................................................................................................8
4. LES STRUCTURES FONDAMENTALES ....................................................................................................9
4.1. NOTION DE PROGRAMME PROPRE.......................................................................................................................9
4.2. ENCHAÎNEMENT DES ACTIONS...........................................................................................................................9
4.3. STRUCTURE ALTERNATIVE OU CONDITIONNELLE...................................................................................................10
4.4. STRUCTURE ITÉRATIVE..................................................................................................................................11
5. EXERCICES.....................................................................................................................................................12