Cours Algo

Cours
Cours d’Informatique
d’Informatique
Initiation
Initiation àà l’informatique,
l’informatique,
àà l’algorithmique
l’algorithmique
et
et àà la
la programmation
programmation
11ère
ère année DEUG MIAS-MASS
année DEUG MIAS-MASS
2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 1

- JN Provost - V Pagé
Emploi
Emploi du
du temps
temps
• Affiché au tableau
– Chaque élève aura une séance TD/TP tous les 15 jours. (2
heures/2 heures)
– MIAS: lundi AM ou PM
– MASS: Mercredi 9h-13h
• Ex Lundi prochain: MIAS groupes 1 et 3 (A-CO et
J-PA)
• Mercredi prochain: MASS groupe A (A-K)
• 24 heures de cours
• 12 heures de TD
• 12 heures de TP
Objectif
Objectif
• Familiariser les étudiants avec les techniques et
outils permettant
– de concevoir et de comprendre,
– de réaliser puis traduire
– d’implémenter et enfin d’obtenir un programme
produisant par son exécution sur un ordinateur, le
résultat attendu.
  rigueur de la démarche scientifique
• 24 heures de cours
• 12 heures de TD
• 12 heures de TP
Chapitre
Chapitre 11 ::
Introduction
Introduction àà l’informatique
l’informatique
Chapitre suivant algorithmique

1.1 :: L’informatique
1.1 L’informatique ??
Computer Science
INFORMATIQUE ? en anglais
INFORMATION AUTOMATIQUE
Art d’entraîner automatiquement des actions
Science de l’information
Traitement automatique de l’information

ORDINATEUR
Machine automatique
L’ordinateur
L’ordinateur
• Machine qui permet de traiter de l’information :
– d’acquérir et de conserver de l’information (acquisition,
stockage)
– d’effectuer des traitements (calcul),
– de restituer les informations stockées (restitution)
• Permet de lier «information»  «données» (0 ou 1)
• Différents types d’informations : valeurs numériques,
textes, images, sons, …: tout cela avec des 0 ou 1

Traitement
Traitement de
de l’information
l’information
Schéma de principe du traitement de l’information
Données à l’état brut
ENTREE
Données corrigées
TRAITEMENT Résultats
Par ordinateur
SORTIE

L’ordinateur
L’ordinateur // l’homme
l’homme
• Raison du remplacement :
– Vitesse (pour des opérations « bas niveau »)
– Fiabilité (répétitivité)
– Mémoire
– Coût
• 2 types d’ « informaticiens »
– les utilisateurs des outils informatiques
– les concepteurs de ces outils : votre but
Domaines
Domaines de
de l’informatique
l’informatique
• Domaine du matériel (hardware)
– partie physique de l’ordinateur
– composants constituant un ordinateur (microprocesseur …)
– support du traitement de l’information (disque dur …)
• Domaine du logiciel (software)
– instructions expliquant à l’ordinateur comment traiter un
problème
– Cela nécessite de décrire des : algorithmes et
représentations informatiques de ces instructions
– Pour aboutir à un programme

1.2 :: Matériel
1.2 Matériel
121
121Aperçu
Aperçuhistorique
historique
– Principe de base : John Von Newmann 1946
=véritable naissance de l’informatique
– Sinon les ancêtres et étapes importantes:
• Boulier chinois
• Numération binaire par Francis BACON en 1600
• Machine à calculer de Pascal, 1642 : dépassée par l’apparition de
l’électronique et des semi-conducteurs
• Machine de Falcon, 1728. Première à utiliser un « programme » sur
plaquette de bois perforée
• Mémoire mécanique de Babbage, 1833. Conçoit une mémoire séparée
des organes d’entrée et de sortie
• Algèbre de Boole 1850 (bases de l’automatisme)
• Machine de Hollerith, 1890. Il utilisa le premier la carte perforée, comme
support universel d‘ information , mis en oeuvre dans les premières
générations d‘ ordinateurs.
Les
Lesancêtres
ancêtresdes
desordinateurs
ordinateurs
Machine de Pascal (1645)
Machine de Babbage (1833)

1.2.2
1.2.2 -- Générations
Générationsd’ordinateurs
d’ordinateurs
• Génération 1 (~1945 - 1960)
– machines électroniques composées de circuits à lampes
à vide (et non transistors à semi-conducteurs)
– place importante (équivalent d’une salle)
– performances de l’ordre de 1000 opérations/s
– programmation en langage binaire
– faible portabilité des programmes
– programme et données fournis sous forme de cartes
perforées, résultats sur une imprimante (pas de
stockage)

1.2.2
Générations d’ordinateurs
d’ordinateurs
• Génération 2 (1960 - 1965)
– découverte des transistors qui remplaceront les
circuits à lampes à vide
– Apparition des 1ère mémoires (à tores)
– évite l'échauffement, gain de place, fiabilité
– performances d’environ 100 000 opérations/s
– programmation en langage binaire mais aussi à
l’aide des premiers langages évolués (Fortran,
Cobol, ...)
1.2.2
d’ordinateurs
• Génération 3 (1965 - 1975)
– invention du circuit intégré permettant de placer des
dizaines de transistors sur une puce de silicium
– performances  109 à 1012 opérations/s
– généralisation de la programmation en langage évolué
– Les Systèmes d'Exploitation (OS) Permettent de gérer
plusieurs programmes différents sous le contrôle d'un
programme central

1.2.2
d’ordinateurs
• Génération 4 (1975 - ?)
– exploitation du circuit intégré à grande échelle:
plusieurs dizaines de milliers (millions) de circuits
peuvent être intégrés sur une même puce
– reproduction sur une seule puce d’une véritable micro
machine : le micro processeur. (En 1971 l'Intel 4004 fut
le premier microprocesseur)
– diminution de la place occupé par un ordinateur
– développement de l’ordinateur personnel.
– La programmation s'oriente vers la programmation
OBJETS (orientés autour des données et non plus des
actions)

1.33 -- Structure
1. Structure de
de l’ordinateur
l’ordinateur
Carte vidéo
Disque
Ecran Mémoire
Dur
Centrale
Clavier
Unité de Disquette
Souris traitement
Haut- CDROM
parleurs Unité Centrale
Carte son
Périphériques de communication Unités d’échange
Périphériques de mémorisation Bus
Support de transfert
d'information entre les différents
ensembles d'un ordinateur) .
1.3.1
1. 3.1 -- Périphériques
Périphériques
• 2 types de périphériques
Une pièce de matériel qui peut effectuer une fonction particulière
– périphériques de communication,
– périphériques de mémorisation.
• Périphériques de communication
– Périphériques d’entrées
• clavier
• souris
– Périphériques de sorties
• écran
• imprimantes
Les
Lespériphériques
périphériques
ENTREES
• Clavier
• Souris
MEMOIRES (entrées/sorties)
• Disque dur
• Disquette
• Disque optique (CD)
SORTIES
• Ecran
• Imprimante

• Périphériques de communication
– le modem
• Permet : interconnexion des ordinateurs pour
communiquer, échanger des informations, partager des
applications
• réseau d’ordinateur
• utilisation du réseau téléphonique pour communiquer
 utilisation d’un MODEM
MODEM MODEM
• Convertisseurs A/N ou N/A
• Signal numérique : 0 et 1
• Signal analogique: t et A continu => codage
par modulation
• MODEM = modulation+démodulation

• Périphériques de mémorisation
– permettent de sauvegarder et de restituer des
informations
– quantité d’informations pouvant être
mémorisée se mesure en Octet (8 éléments
binaires)
– périphériques usuels de mémorisation:
• disque dur
• Disquette
• CDROM, DVD
Schéma
Schémad’une
d’uneconfiguration
configurationinformatique
informatique
Unité Centrale (cerveau)
Unité de Traitement
Unité de Commande
et de Contrôle
Unité Arithmétique
et Logique
Mémoire
Périphériques Centrale Périphériques
d’Entrées de Sorties
Périphériques d’Entrées/Sorties
Informations Mémoires Auxiliaires
Commandes

1.3.2
1.3.2 -- La
La mémoire
mémoire centrale
centrale
• Permet de stocker et de restituer des informations
• Correspond à un ensemble fini de cellules
• Une case mémoire (cellule) contient une donnée
ou une instruction
• Chaque cellule est numérotée : adresse
a1 a2 a3 a4 a5

1.3.2
1.3.2 -- La
La mémoire
mémoire centrale
centrale
Contient le programme en cours d’exécution, ainsi que ses données.
Par exemple, lors de la création d’un programme en langage C:
Edition Compilation Exécution
Zone de Editeur Compilateur Code

programme de texte exécutable
Texte du
Variables
Zone de programme Code du
exécutable
données en C programme

La
Lamémoire
mémoireauxiliaire
auxiliaire
La mémoire centrale a une capacité limitée et est volatile
 Nécessité d’enregistrer les informations sur des supports
de mémoire non volatile (en sortie) pour pouvoir les
réutiliser par la suite (en entrée).
FICHIER : élément de mémoire de stockage (mémoire de

masse) contenant de l’information et repérable.
Le codage de l’information définit le TYPE du fichier et

détermine son utilisation comme donnée pour un
programme ou comme programme exécutable.

La
Lamémoire
mémoireauxiliaire
auxiliaire
Les supports magnétiques à ACCES ALEATOIRE (on

choisit la position que l’on veut) permettent une
hiérarchisation des fichiers :
 REPERTOIRE : fichier contenant le nom, l’adresse, … de
plusieurs autres fichiers
 RACINE : fichier répertoire crée automatiquement sur le

support au moment du formatage (disque ou disquette) et
portant le nom du volume (label)
 CHEMIN D’ACCES : liste des répertoires permettant

d ’atteindre un fichier à partir de la racine
La
Ladisquette
disquette

•Les faces
Comme tout disque, une disquette comporte deux faces utilisables pour y enregistrer
l'information.
•Les pistes (tracks)
Les disquettes sont donc structurées en pistes concentriques sur lesquelles l'information sera
écrite et lue. Les pistes qui se font face sur les deux côtés de la disquette et qui portent donc le
même nom constituent un cylindre. Ceux-ci sont numérotés de la même façon que les pistes.
Chaque piste est divisée en plusieurs morceaux: les secteurs.
•Les secteurs (sectors)
De la même façon qu'ne tarte est généralement découpée en morceaux de tailles égales, une
disquette subit une découpe logique. Ainsi chaque piste est découpée en morceaux de tailles
identiques appelés secteurs dont le nombre dépend du type de la disquette.
Capacité = nombre de faces *

nombre de pistes * nombre de secteurs * taille d'un secteur

1.3.3
1.3.3 -- L’unité
L’unité de
de traitement
traitement
Unité Centrale (cerveau)
• Unité de commandes
Unité de Traitement
– unité de contrôle
Unité de Commande
– chef d’orchestre et de Contrôle
– conduit le calcul
Unité Arithmétique
(ordre des instructions) et Logique
voulu par le programmeur
Mémoire
• Unité Arithmétique et logique Centrale
– unité de calcul
– exécute les opérations arithmétiques et logiques (+-*/ et ou
…) d’un programme sous le contrôle de l’unité de commande

L’unité
L’unitécentrale
centrale
CI
CIsur
surlequel
lequelon
ontrouve
trouve
Supports de barrettes
Connecteurs de souris et clavier de mémoires
Connecteurs de contrôleur
de disquettes et disque dur
Emplacements de
cartes d ’extensions
Batterie
Puce du BIOS CPU

Le
Leprocesseur
processeur(CPU)
(CPU)
Séquenceur d ’instructions
Interface du bus d ’instructions
Décodeur d ’instructions
Unité de traitement
Unité arithmétique et logique
Registres:
Mémorise différents
états binaires (environ 10)
résultant des opérations élémentaire
Unité de contrôle Unité de détection d’erreurs Overflow
Retenue
Parité
1.3.4
1.3.4 -- Les
Les bus
bus
Disque
Ecran Mémoire
Dur
Centrale
Clavier
Unité de Disquette
Souris traitement
CDROM
• Permettent
Haut- de faire
Unité
le lien entre les
Centrale
parleurs
différentes unités d’un ordinateur
• représente le chemin utilisé par les
informations pour aller d’une unité à l’autre
1.4
1.4 :: Logiciel
Logiciel
– instructions expliquant à l ’ordinateur comment
traiter un problème
– algorithmes et représentation informatiques de
ces instructions
– programme

1.4.1
1.4.1 -- Algorithmes
Algorithmes et
et programmes
programmes
• Algorithme :
– suite des actions à effectuer pour
• réaliser un traitement donné
• résoudre un problème donné
• Exemples d’algorithme dans la vie courante

– pour tricoter un pull : (maille à l’endroit, …)
– pour faire la cuisine : recette
– pour jouer une sonate : partition
1.4.1
Algorithmes et
et programmes
programmes
Informations
en entrée
Algorithme informatique
=
procédure de calcul
Rigueur scientifique
IMPORTANT ! Informations
en sortie
Sinon, information de sortie
erronée
1.4.1
Algorithmes et
et programmes
programmes
• Programme :
– codage d’un algorithme afin que l’ordinateur
puisse exécuter les actions décrites
– doit être écrit dans un langage compréhensible
par l’ordinateur
 langage de programmation (Assembleur
(micropro), Basic, C, Fortran, Pascal, Cobol …)
• Un programme est donc une suite ordonnée
d’instructions élémentaires codifiées dans
un langage de programmation
1.4.2
1.4.2 -- Langages
Langages de
de programmation
programmation
• L’ordinateur
– construit autour d’un ensemble de circuits électroniques (le
courant passe, le courant ne passe pas)
– traite donc que des signaux assimilables à 0 ou 1
– une opération élémentaire  suite de 0 et de 1 = suite de bits
(BInary digiT) ! Un champ de 8 bits constituant ce qu'on
appelle 1 byte ou 1 octet. Importance des unités en
science. Rappel: k(2^10) M et G .
• Pour que les programmes et les données soient
compréhensibles par l’ordinateur il faut effectuer un
codage binaire
1.4.2
1.4.2 -- Langages
Langages de
de programmation
programmation
• Langage machine
– langage binaire
– ses opérations sont directement compréhensibles par
l’ordinateur
– propre à chaque famille d’ordinateur
– Pour pouvoir manipuler du langage machine, on est obligé de
passer par de l'Assembleur.
• Ecriture des premiers programme en langage

machine

Les
Leslangages
langages
Rédiger un programme consiste à préparer le travail à FAIRE FAIRE à la
machine, sous forme d’une liste d’instructions.
Les instructions que peut exécuter l’unité de traitement sont codées en langage
binaire spécifique à chaque machine (langage machine).
Langage du programmeur  langage machine (code binaire exécutable). La
traduction est effectuée par un compilateur (qui est lui aussi un
programme …).
TYPES DE LANGAGES  STYLE DE PROGRAMMATION
• langages impératifs (Fortran, Pascal, C …) : Il s'agit de faire exécuter une
suite d'ordres par une machine bête mais disciplinée.
• langages Déclaratifs: l'activité de programmation consiste essentiellement
à décrire le rapport qui existe entre les données et les résultats que l'on
veut obtenir, plutôt que la séquence de traitements qui mène des unes aux
autres
– fonctionnels (Lisp, Scheme …)
– logiques (Prolog … )
• langages objets (C++, VisualBasic, Delphi, Java …)

• Habituellement, un programme c'est une suite d'instructions.
L'ordinateur est très bête et il faut tout lui détailler:
– Mettre la main sur la poignée de la porte
Tourner la poignée
Pousser la porte
Mettre le doigt sur l'interrupteur
Appuyer sur l'interrupteur pour allumer l'ampouleLe programme
principal
• Tout se passe très bien. Mais qu'est-ce qui se passe par
exemple si on met une porte automatique ? Le programme sera
incapable de trouver la poignée et d'ouvrir la porte !
• En programmation objet, on associe aux objets des actions
(aussi appellées méthodes). Par exemple, à l'objet porte on
peut associer la méthode ouvrir. De même pour l'ampoule on
pourrait associer une méthode allumer, éteindre, etc.
• Le programme devient plus simple:
– porte.ouvrir
ampoule.allumer
» Le nouveau programme principal
• On a plus besoin de savoir comment la porte s'ouvre. On se contente
de l'ouvrir.
• Pour indiquer qu'on applique la méthode (ouvrir) sur l'objet (porte), on
note souvent objet.méthode (ici : porte.ouvrir).

• Bien sûr il faut détailler ce que fait la méthode ouvrir de porte et la méthode
allumer de lumière. On ne va pas détailler dans le programme ce que fait la
méthode ouvrir, mais on va le détailler dans l'objet lui-même.
• C'est normal, puisque la méthode ouvrir ne s'applique qu'à la porte, pas à la
lumière:
– porte.ouvrir:
– Mettre la main sur la poignée
Tourner la poignée
Pousser la porte
• L'objet porte et sa méthode
• On peut changer la porte en mettant une porte automatique. On peut aussi l'ouvrir
(même si la porte elle-même ne s'ouvre pas de la même façon):
• porte.ouvrir: Se placer devant la porte
Attendre que la porte soit complètement ouverte
• L'objet porte automatique et sa méthode
• Mais votre programme pourra l'ouvrir sans rien changer:
– porte.ouvrir
ampoule.allumer
• Le programme principal : il est inchangé malgré le changement de
porte

1.5
1.5 :: Système
Système d’exploitation
d’exploitation
• Tout premier logiciel indispensable au bon
fonctionnement de l’ordinateur
• Chargé de la gestion globale de l’ordinateur
notamment :
– utilisation de la mémoire vive
– utilisation de la mémoire auxiliaire
– dialogue avec l’utilisateur (i.e. les entrée/sorties)

Système
d’exploitation
• Gestion de la mémoire vive
– aller chercher sur la mémoire auxiliaire le code
(exécutable) et les données nécessaires à
l’exécution d’un programme demandé par
l ’utilisateur
• Gestion des entrées/sorties
– interprétation des frappes de touches au clavier
et des mouvements ou cliques de la souris
– visualisation d’informations à l’écran

Système
d’exploitation
utilisateur
Application 1 Application 2
Matériel
RAM, disque dur, disquette, CD-ROM,
clavier, souris, écran, imprimante

Système
d’exploitation
• Les plus courants :
3 types d’ordinateurs:
– système mono utilisateur
- PC=perso (plusieurs
• MS-DOS pour PC marques compatibles)
• Windows 95-98 pour PC - Mac=perso
• MAC-OS pour Macintosh
- Stations de
– système multi utilisateurs travail=professionnel
• OS/2 pour PC (IBM)
! compatibilité
• Windows NT pour PC
• UNIX
– Linux sur PC (gratuit) ; Solaris sur SUN ; AIX sur IBM
Système
d’exploitation
• Permet aussi d’organiser (gérer) les informations
sur la mémoire auxiliaire
– FICHIER (file): ensemble d’information manipulables
par l’ordinateur ; nom unique dans un répertoire ;
taille en octets
– REPERTOIRE : dossier ou directory ; regroupement
de fichiers ; nom unique
– RACINE (root): dossier situé au plus haut niveau
– CHEMIN D’ACCES (path): liste des répertoires
permettant d’atteindre un fichier à partir de la racine

Système
d’exploitation
Disque dur
Users
Appli Données divers
personelles
mias101 mias120 images info
Exercices windows

1.6
1.6 :: Les
Les applications
applications
Une application est un logiciel fournissant à
l ’utilisateur un environnement
(fonctionnalités) lui permettant de créer,
modifier et/ou consulter des documents
contenant des informations.

Applications
Applications et
et documents
documents
 Interface (menus, barres d’outils, …)
 Fonctions de gestion des documents (ouvrir,
enregistrer, …)
 Fonctions d’édition (couper, copier, coller, …)
 Fonctions de recherche et remplacement
 Insertions d’images, objets … (incorporations…)
 Outils de mise en forme (polices de caractères,
styles …)
 ….

Editeur
Editeur de
de texte
texte
Logiciel permettant de créer des documents
contenant du texte au codage ASCII
(C'est une norme de codage de 128 caractères alphanumériques sur
7 bits. Les versions étendues sur 8 bits, 256 caractères sont
adaptées suivant les pays.)
.
Outil du système d’exploitation (fichiers de
configuration, notices, …)
Bloc-Notes

Traitement
Traitement de
de texte
texte
contenant du texte mis en forme : police et
styles de caractères, style et alignement des
paragraphes, organisation du texte (sections,
hiérarchisation, en-tête et pied de page, table
des matières …) etc...
WordPad Word

Traitement
Traitement d’image
d’image
Logiciel permettant de créer des images
définies sous forme de matrice de points
de couleurs (Pixels).
Inconvénient: ligne=escalier
Paint

Dessin
Dessin vectoriel
vectoriel
A la différence d’une image définie point par
point, un élément de dessin vectoriel se définit
par sa forme, sa position et sa taille.
Un dessin se compose de plusieurs formes
(rectangles, cercles, traits, …) et chaque forme
est modifiable.
Pas l’inconvénient du transparent précedent
Dessin

Tableur
Tableur
contenant des feuilles de calcul constituées de
cellules, organisées en ligne x colonne, pouvant
contenir des informations sous différents
formats (texte, nombres, dates …) ou des
formules de calcul.
Contient des outils d’analyse de ces informations
permettant une visualisation sous forme de
courbes ou diagrammes divers.
Excel
Système
Systèmede
deGestion
Gestionde
deBases
Basesde
deDonnées
Données
contenant des tables d’articles
hiérarchisées ou liées par des champs
communs (relations).
Ex: Généalogie. Listes d’étudiants, avec adresse, téléphone, niveau, …
Contient des outils d’analyse des tables

permettant d’en extraire des
informations à l’aide de requêtes.
Ex: Combien d’étudiants de la fac habitent à Sainte Rose et sont en Deug Mass
Access
Applications
Applications multimédia
multimédia
Logiciels permettant de reproduire ou de
créer des sons, des animations, des
vidéo, …

Navigateur
Navigateur
Logciel permettant de visualiser des pages écrites
en langage HTML et disponibles sur le réseau
Internet.
Netscape

Présentations
Présentations
Il existe aussi des logiciels de présentation
permettant d’afficher une suite de pages à
l’écran sous forme de diaporama.
PowerPoint

Chapitre
Chapitre 22 :: Algorithmique
Algorithmique

2.1
2.1 -- Introduction
Introduction
Matériel / Logiciel
– instructions expliquant à l’ordinateur comment
traiter un problème
– algorithmes et représentation informatiques de
ces instructions
– programme

2.1
2.1 -- Introduction
Introduction
• Les programmeurs sont amenés à concevoir
des logiciels de plus en plus complexes
pour répondre aux besoins des utilisateurs
(applications en réseau, base de données
réparties, …)
 maîtriser le développement des logiciels
est très important

2.2
2.2 -- Algorithmes
Algorithmes et
et programmes
programmes
• Notion précise d’algorithme a été
découverte en 825 par le mathématicien
arabe Muhammmad ibn Musa al-Kharezmi
– Moyen d’automatisation et d’économie de la
pensée
• Petit Larousse : suite d’opérations
élémentaires constituant un schéma de
calcul ou de résolution de problème.

2.2
2.2 -- Algorithmes
Algorithmes et
et programmes
programmes
• Pour nous :
– Un algorithme est une séquence précise et non
ambiguë d’une suite d’étapes pouvant être
exécutées de façon automatique par un
ordinateur pour résoudre un problème
– Spécification du schéma de calcul sous forme

d’une suite finie d’opérations élémentaires
obéissant à un enchaînement déterminé.

2.2
2.2 -- Algorithmes
Algorithmes et
et programmes
programmes
Informations
en entrée
Algorithme informatique
=
schéma de calcul
Un algorithme est une suite finie de règles à

appliquer dans un ordre déterminé à un nombre fini
de données, pour arriver en un nombre fini d’étapes, Informations
à un certain résultat, et cela indépendamment des en sortie
données.

2.2
2.2 -- Algorithmes
Algorithmes et
et programmes
programmes
• Programme :
– codage d’un algorithme afin que l’ordinateur
puisse exécuter les actions décrites
– doit être écrit dans un langage compréhensible
par l’ordinateur
 langage de programmation
• Un programme est donc une suite ordonnée
d’instructions élémentaires codifiées dans
un langage de programmation

2.3
2.3 -- Langages
Langages de
de programmation
programmation
• RAPPEL: Langage machine
– langage binaire
– ses opérations sont directement compréhensibles
par l’ordinateur
– propre à chaque famille d’ordinateur
• Ecriture des premiers programme en langage

machine
2.4
2.4 -- Importance
Importance des
des algorithmes
algorithmes
• Pour mener à bien un traitement sur un
ordinateur il faut :
1. Concevoir un algorithme qui décrit comment
le traitement doit être fait
2. Exprimer l’algorithme sous la forme d’un
programme dans un langage de
programmation adéquat
3. Faire en sorte que l’ordinateur exécute le
programme : compilation
Algorithme
programmation
Programme en langage évolué
traduction
Programme en langage machine
Interprétation par l’Unité Centrale de traitement
le traitement souhaité est réalisé

2.4
2.4 -- Importance
Importance des
des algorithmes
algorithmes
• Quels sont les aspects et propriétés des
algorithmes qu’il est nécessaire d’étudier ?
1. La calculabilité des algorithmes (convergence
de l’algorithme et existence de l’algo) la méthode existe t
elle ? (contre exemple: Dieu existe t il ?)
2. La complexité des algorithmes (nombre
d’opérations nécessaires)
3. L’efficacité des algorithmes (vitesse des algo:
raisonnable) TEMPS D'EXÉCUTION - MÉMOIRE
OCCUPÉE
Exemple
Exemple de
de complexité
complexité
• Complexité en n n
i
i 1
• Complexité en 2n² n n
 (i  j )
i 1 j 1
• Ordre de grandeur pour n grand

• N=> si n*10, temps *10
• N²=> si n*10, temps *100

Efficacité
Efficacité
• Simuler une partie d’échec:
• Trop d’états à mettre en mémoire
• On choisit des choses non-optimales mais efficaces
• Voyageur de commerce
• Comment minimiser le trajet du voyageur de
commerce allant de villes en villes
– Enoncé simple, mais solution très difficile si
nombre de villes est grand (n! possibilités)
• N=5 =>120, n=15 => 1300 G

2.5
2.5 –– Affinement
Affinement des
des algorithmes
algorithmes
• Un algorithme doit décrire précisément le
traitement qu’il doit exécuter et s’assurer que tous
les cas de figures possible ont bien été prévus.
• Exemple : algorithme permettant de calculer la
durée d’un voyage à partir du tableau d’affichage
des aéroports
1. Consulter l’heure de départ
2. Consulter l’heure d’arrivé
3. Soustraire l’heure de départ de celle d’arrivée
2.5
Affinement des
des algorithmes
algorithmes
• Problèmes :
– fuseaux horaires différents
– Si un point applique l’heure d’Été et pas l’autre
• Pour éviter de telles erreurs le concepteur
doit suivre une démarche rigoureuse et
méthodique :
– Affinement progressive de l’algorithme
– Démarche descendant, top down
– Technique du « diviser pour mieux régner »

• Examen: le Mardi 16/4/2002
• Tout réviser le cours + 2 TD/TP
• La moitié des points : QCM (notation précisée sur le sujet)
• ¼: analyse et modifier un programme
• ¼: Créer un programme
• Documents autorisés
• Bibliographie:
– Cours d’informatique: langages et programmation.
MASSON. Scholl-Fauvet-Lagnier-Maraninchi
– Initiation à l’informatique et aux structures de données
Volume 1. DUNOD Courtin-Kowarski

2.5
Affinement des
des algorithmes
algorithmes
• Exemple : robot domestique avec un
algorithme de préparation d’une tasse de
café soluble
1. Faire bouillir l’eau

2. Mettre le café
3. Ajouter l’eau dans les tasses

2.5
Affinement des
des algorithmes
algorithmes
• 1. faire bouillir l'eau
peut être affinée en
– 1.1. remplir la bouilloire d'eau

– 1.2. brancher la bouilloire sur le secteur
– 1.3. attendre l'ébullition
– 1.4. débrancher la bouilloire

2.5
Affinement des
des algorithmes
algorithmes
• 2. mettre le café dans la tasse
pourrait être affiné en
– 2.1. ouvrir le pot à café

– 2.2. prendre une cuiller à café
– 2.3. plonger la cuiller dans le pot
– 2.4. verser le contenu de la cuiller dans la tasse
– 2.5. fermer le pot à café
2.5
Affinement des
des algorithmes
algorithmes
• 3. ajouter de l'eau dans la tasse
pourrait être affinée en
3.1. verser de l'eau dans la tasse jusqu'à ce que

celle-ci soit pleine

2.5
Affinement des
des algorithmes
algorithmes
• 1.1. remplir la bouilloire d'eau
• peut nécessiter les affinements suivants:
• 1.1.1. mettre la bouilloire sous le robinet

• 1.1.2. ouvrir le robinet
• 1.1.3. attendre que la bouilloire soit pleine
• 1.1.4. fermer le robinet
2.5
Affinement des
des algorithmes
algorithmes
• Affinement ne se fait pas dans le vide
• Savoir où s’arrêter
• Connaître les capacités du processeur
• Exemple :
– Brancher la bouilloire, activité interprétable
– Remplir la bouilloire, activité non interprétable
 affinement

2.5
Affinement des
des algorithmes
algorithmes
• Processeur informatique : ordinateur,
capacités d’interprétation connues
• Le concepteur d’un algorithme doit donc
affiner ce dernier jusqu’à ce que les étapes
puissent être écrites à l’aide d’un langage
de programmation

2.1
2.1 –– Ecrire
Ecrire un
un algorithme
algorithme
• Calcul de l'intérêt et de la valeur acquise par
une somme placée pendant un an
• L'énoncé du problème indique
– Les données fournies: deux nombres
représentant les valeurs de la somme placée et
du taux d'intérêt
– les résultats désirés: deux nombres représentant
l'intérêt fourni par la somme placée ainsi que la
valeur obtenue après placement d'un an.
2.1
2.1 -- Exemple
Exemple
• Formalisation de l’algorithme:En français
1. prendre connaissance de la somme initiale et du taux d'intérêt
2. multiplier la somme par le taux; diviser ce produit par 100; le
quotient obtenu est l'intérêt de la somme
3. additionner ce montant et la somme initiale; cette somme est
la valeur acquise
4. afficher les valeurs de l'intérêt et de la valeur acquise.
• SI=somme initiale
• T=taux d’intérêt (ex: 3 pour 3%)
• I=intérets=S*T/100
• SF=somme finale=S+I
2.1
2.1 -- Exemple
Exemple
• Formalisation de l’algorithme
– En langage de description : pseudo code, LDA
(Langage de Description Algorithmique)
écrire " Introduisez la somme initiale (en francs): "
Lire SI
écrire " Introduisez le taux d'intérêt (ex: 3 pour 3%): "
lire T
T  SI* T / 100
SF  SI + I
écrire " L'intérêt fourni est de " , I , "francs "
écrire " La somme après un an sera de " , SF , "francs "

Instructions
Instructions
• les instructions de lecture
lire variable
• les instructions d'écriture
ecrire expression
• les instructions d'assignation
variable  expression

2.2
2.2 -- Instructions
Instructions
• Exemple (TP 1)
– Exprimer un nombre de secondes sous
forme d'heures, minutes, secondes.
– La seule donnée est le nombre total de
secondes que nous appellerons nsec ;
les résultats consistent en 3 nombres :
• h, m, s

2.2
2.2 -- Instructions
Instructions
écrire " Introduisez le nombre de secondes"
lire nsec
s  nsec mod 60
m  (nsec \ 60) mod 60
h  nsec \ 3600
écrire nsec, "valent: ", h, "heure(s) ", m, "minute(s) et", s,
"seconde(s)"

2.3
2.3 -- Déclaratives
Déclaratives
• Il est aussi nécessaire de préciser ce que les
variables utilisées contiendront comme type de
données.
• Il peut s'agir de nombres entiers, de nombres réels,
de chaînes de caractères, ...
• Il faut faire précéder la description de l'algorithme
par une partie dite déclarative où l'on regroupe les
caractéristiques des variables manipulées.

3.3
Déclaratives
• La partie déclarative est placée
(généralement) en tête de l'algorithme et
regroupe une ou plusieurs indications de la
forme:
entier variables
ou
décimaux (réel) variables
3.3
Déclaratives
entier nsec, h, m, s
écrire " Introduisez le nombre de secondes"
lire nsec
s  nsec mod 60
m  (nsec \ 60) mod 60
h  nsec \ 3600
écrire nsec, "valent: ", h, "heure(s) ", m, "minute(s) et", s,
"seconde(s)"
3.4
3.4 –– Traduction
Traduction en
en CC
#include <stdio.h> décrit les fonctions de lecture et affichage sur l’ecran
int nsec, h, m, s; déclarations
main(){ marque le début du programme principal
printf("Introduisez le nombre en secondes : ");

scanf("%d", &nsec);
s=nsec % 60;
m=nsec / 60 % 60;
h=nsec / 3600;
printf("%d secondes valent %d heures %d minutes et %d
secondes\n",nsec,h,m,s);
} marque la fin du programme principal

3.4
Traduction en
en CC
• Un identificateur (nom de variable, fonction, …)
en C doit débuter par une lettre suivie par un
nombre quelconque de lettres, chiffres ou de "_"
(caractère souligné).
• Les identificateurs ne peuvent contenir
d'espacement (caractère "blanc") ou de caractères
tels que %, ?, *, ., - ,... mais peuvent être aussi
longs que l'on veut.

3.4
Traduction en
en CC
• Les variables doivent faire l'objet d'une déclaration
de type de la forme:
type liste_des_variables ;
• Des points-virgules sont obligatoires pour séparer
les instructions
• Les instructions de lecture et d'écriture se traduisent
respectivement par SCANF et PRINTF suivis d'une
liste de variables ou d'expressions placées entre
parenthèses et séparées par des virgules.

4.1
4.1 -- Structures
Structures
• Il a été démontré que pour représenter n'importe
quel algorithme, il faut disposer des trois
possibilités suivantes:
– La structure de séquence qui indique que les opérations
doivent être exécutées les unes après les autres
– la structure de répétition qui indique qu'un ensemble
d'instructions doit être exécuté plusieurs fois.
– la structure de choix qui indique quel ensemble
d'instructions doit être exécuté suivant les circonstances

4.2.
4.2. La
La structure
structure alternative
alternative
• Exemple :
– 2 joueurs A et B
– Chacun montre un certain nombre de doigts (de
0 à 5)
– Si la somme des nombres de doigts montrés est
paire, le premier joueur a gagné
– Sinon c'est le second.
– Le problème est de faire prendre la décision par
l'ordinateur.
4.2.
4.2. La
La structure
alternative
• En Français :
– prendre connaissance du nombre de doigts de A
– prendre connaissance du nombre de doigts de B
– calculer la somme de ces deux nombres
– si la somme est paire, A est le gagnant
– si la somme est impaire, B est le gagnant.
• Remarque: Pour déterminer si un nombre est pair ou impair,

il suffit de calculer le reste de la division par 2 (.. modulo 2):
il vaut 0 dans le premier cas et 1 dans le second.

4.2.
4.2. La
La structure
alternative
• En LDA :
entier na,nb,reste
lire na,nb
reste (na + nb) mod 2
si reste = 0 alors écrire "Le joueur A a gagné."
sinon écrire "Le joueur B a gagné."
fsi
écrire « Fin du jeu »

4.2.
4.2. La
La structure
alternative
• La structure alternative se présente en
général sous la forme :
si expression alors
première séquence d'instructions
sinon
deuxième séquence d'instructions
fsi
4.2.
4.2. La
La structure
alternative
• où expression conditionne le choix d'un des
deux ensembles d'instructions. Cette
expression peut être soit vraie soit fausse
• Si l'expression est vraie, la première
séquence d'instruction sera exécutée et la
seconde sera ignorée;
• Si l'expression est fausse, seule la seconde
séquence d'instructions sera effectuée.

4.2.
4.2. La
La structure
alternative
• Le mot sinon indique où se termine la
première séquence d'instructions et où
commence la seconde.
• Le mot fsi (abrégé de "fin de si") indique où
se termine la seconde séquence
d'instructions.

4.2.
4.2. La
La structure
alternative
• Dans certains cas, lorsque l'expression est fausse, aucune
instruction ne doit être exécutée. La condition s'exprime
alors plus simplement sous la forme:
si expression alors
séquence d'instructions
fsi
• Quoi qu’il arrive, les instructions qui suivent fsi seront
exécutées.
• Chacune des séquences d'instructions d'un si ... fsi peut
contenir des si...fsi. On dit alors que les structures sont
imbriquées.
4.2.
4.2. La
La structure
alternative
• Prendre l’habitude de décaler et
d’utiliser les fsi
si expression1 alors
si expression2 alors
instruction1
sinon
instruction2
Différent de …
Remarque
Remarque
• En C, l’expression est un nombre 0 ou 1
• Donc …

Expressions
Expressionslogiques
logiques
p q p et q p ou q
VRAI VRAI VRAI VRAI
VRAI FAUX FAUX VRAI
FAUX VRAI FAUX VRAI
FAUX FAUX FAUX FAUX
Pour avoir vrai:

OU= l’un ou l’autre doit être vrai
ET= l’un et l’autre doivent être vrai
Expressions
Expressionslogiques
logiques
p non p
VRAI FAUX
FAUX VRAI
• Il existe des thèorèmes :

– non (p et q) est équivalent à (non p) ou (non q)
– non (p ou q) est équivalent à (non p) et (non q)
4.3
4.3--Expressions
Expressionslogiques
logiquesetetvariables
variables
booléennes
booléennes
• a  1; b  2; c  3
• (b > 8) ou (c < 1) ? F ou F = F
• (b > 0) ou (c > 1) ? V ou V= V
• (b > 9) ou (c > 1) ? F ou V = V
• (b > a) et (c > b) ? V et V =V
• (b > a) et (c < 0) ? V et F = F
• non (c < a) ? Non(F)=V
• non ((b > a) et (c > b)) ? Non(V et V)=non(V)=F
• ((b > a) et (c > b)) ou (a < 0) ? (V et V)ou(F)=V ou F=V
Variables
Variablesbooléennes
booléennes
• Variable ne pouvant contenir que deux types de
valeur : VRAI ou FAUX
• Peuvent donc stocker le résultat de l’évaluation
d’une expression logique
• Définition algorithmique :
– Booléen variable
• Définition C : il n’existe pas de type booléen
– Utilisation du type entier
Int OK, pair ;
– égal à 0  FAUX ; différent de 0 (ou 1) VRAI
• LDA : Assignation : OK  VRAI
4.4.
4.4. L'alternative
L'alternative en
en CC
si expression alors if (expression) {
séquence d'instructions séquence_d_instructions;
fsi }
si expression alors if (expression)
une instruction une_instruction;
sinon else {
séquence d'instructions séquence_d_instructions;
fsi }

4.4.
4.4. L'alternative
L'alternative en
en CC (optionel)
(optionel)
#include <stdio.h>
int NA, NB, reste;

main () {
printf("Introduisez le nombre de doigts montrés par le joueur A : ");
scanf("%d",&NA);
printf("Introduisez le nombre de doigts montrés par le joueur B : ");
scanf("%d",&NB);
reste = (NA+NB) % 2;
if (reste==0)
printf("Le joueur A a gagné\n");
else
printf("Le joueur B a gagné\n");
printf("Bravo pour le gangnant\n");
}
Expression
Expression logique
logique en
en CC
• < >
• ==
• !=
• >= <=
• &&
• ||

Chapitre
Chapitre 55 :: La
La structure
structure répétitive
répétitive

5.1
5.1 -- Introduction
Introduction
• L’utilisation d’un ordinateur s’impose lorsque des
volumes importants de données sont manipulées
• Exemple 1: Chercher dans une liste de noms et d'adresses,
l'adresse d'une personne à partir de son nom. Le nombre de
fois qu'il faudra comparer le nom donné aux noms de la
liste est dans ce cas inconnu
• Exemple 2 : Calculer la Nème puissance entière d'un
nombre x par multiplications successives du nombre par
lui-même. Ici, le nombre de répétition (N) de l'instruction
de multiplication est connu.

5.3
5.3 -- La
La boucle
boucle "" pour
pour faire"
faire"
• Lorsque le nombre d’itération est connu
• Exemple de la table de multiplication
• En LDA :
pour var_de_crt  prem_val à dern_val faire
fpour

5.3
5.3 -- La
La boucle
boucle "" pour
pour faire"
faire"
• var_de_crt : est la variable de contrôle, qui est
initialisée à prem_val
• La variable de contrôle est incrémenté
automatiquement à chaque itération
• L’itération s’arrête lorsque :
var_de_crt > dern_val
• Si prem_val > dern_val la séquence d’instructions n’est
jamais exécutée
• La variable de contrôle doit être de type énuméré
• La valeur de la variable de contrôle ne doit pas être
directement modifiée dans la séquence d’instructions
5.3
5.3 -- La
La boucle
boucle "" pour
pour faire"
faire"
• Écrire l’algorithme qui affiche la table de
multiplication de 6.
entier n
lire n
Pour i  1 à 10 faire
écrire n, « fois », i, « font », n*i
fpour

5.1
5.1 -- Introduction
Introduction
• Exemple 3: afficher la table de multiplication à l’ancienne :
– 6 fois 1 font 6
– 6 fois 2 font 12
– …
– 6 fois 10 font 60
• Il serait plus judicieux de faire répéter la ligne
d’affichage en faisant varier le multiplicande
– Pour chaque valeur de n variant de 1 à 10 exécuter :
Ecrire « 6 fois », n, « font », 6*n
5.2
5.2 -- La
La boucle
boucle "" tant
tant que
que ""
lire nom_donné
lire nom1
si nom1 = nom_donné alors
écrire adresse1
sinon
lire nom2
si nom2 = nom_donné alors
écrire adresse2
sinon
lire nom3
si nom3 = nom_donné alors ...

5.2
5.2 -- La
La boucle
boucle "" tant
tant que
que ""
• Fait répéter une séquence d’instructions
aussi longtemps qu’une condition est VRAI
• En LDA :
Tant que condition faire
séquence d’instructions
Ftq

5.2
5.2 -- La
La boucle
boucle "" tant
tant que
que ""
• Au moment du premier passage dans la boucle la
condition est évaluée; si elle est vérifiée, la
séquence d’instructions est exécutée
• A la fin de l’exécution de cette séquence
d’instructions, la condition est de nouveau
évaluée et on répète l’exécution de la séquence
d’instructions tant que la condition est vérifiée.
• Dès que la condition devient fausse, l’exécution
du programme se poursuit à partir de la 1ère
instruction qui suit immédiatement le mot-clé ftq.
5.2
5.2 -- La
La boucle
boucle "" tant
tant que
que ""
• Remarques :
– Si au premier passage la condition est évaluée à
FAUX, le corps de la boucle (la séquence
d’instructions) n’est jamais exécuté
– Si la séquence d’instructions ne change pas la
valeur de la condition, la séquence d’instructions
sera exécutée sans que l’on passe jamais à la suite : on
exécute une boucle infinie
– Les variables qui interviennent dans la condition
doivent être initialiser avant d’aborder la boucle
5.2
5.2 -- La
La boucle
boucle "" tant
tant que
que ""
• Remarques :
– Il est préférable d'exprimer l'expression logique sous la
forme NON(condition(s) d'arrêt).
– Il est en effet plus simple de déterminer les raisons
d'arrêter le processus répétitif que celles de continuer.
– La forme de ce type de boucle devient donc :
tant que NON condition(s) d'arrêt faire

ftq

5.2
5.2 -- La
La boucle
boucle "" tant
tant que
que ""
lire nom_donné
i1
lire nomi
tant que NON ((nomi = nom_donné) ou (fin de liste)) faire
i  i+1
lire nomi
ftq
si nomi = nom_donné alors
écrire adressei
sinon
écrire "Le nom demandé ne se trouve pas dans la liste."
fsi
5.2
5.2 -- La
La boucle
boucle "" tant
tant que
que ""
• Écrire l’algorithme qui affiche la table de
multiplication de 6.
entier n
lire n
i1
tantque
tant i  10
queNON faire
(i > 10) faire
écrire n, « fois », i, « font », n*i
i  i+1
ftq

5.2
5.2 -- La
La boucle
boucle "" tant
tant que
que ""
• Considérons aussi l'exemple suivant :
– étant donnés deux nombres entiers m et n positifs ou
nuls, calculer le PGCD.
– L'algorithme d'Euclide permet de résoudre ce
problème :
• en prenant d'abord le reste de la division de m par n,
• puis le reste de la division de n par ce premier reste,
• etc.
• jusqu'à ce qu'on trouve un reste nul.
• Le dernier diviseur utilisé est le PGCD de m et n.

5.2
5.2 -- La
La boucle
boucle "" tant
tant que
que ""
– Pour m=1386 et n=140, on a successivement :
• 1386 = 140 * 9 + 126
• 140 = 126 * 1 + 14
• 126 = 14 * 9 + 0
– et le PGCD de 1386 et 140 est bien 14.
– Dans cet exemple, il faut répéter le calcul du reste de
la division d'un nombre par un autre.
– Appelons a le dividende, b le diviseur et r le reste

5.2
5.2 -- La
La boucle
boucle "" tant
tant que
que ""
entier m,n,a,b,r,PGCD
Début
lire m, n
am
bn
tant que NON(b = 0) faire
r  a mod b
ab
br
ftq
PGCD  a
écrire "Le PGCD de",m,"et",n,"est",PGCD
Fin
5.4
5.4 –– Les
Les boucles
boucles en
en CC
• En C, la boucle tant que se traduit par
WHILE ( <expression logique>)
instruction;
• ou
WHILE ( <expression logique>) {
séquence d’instructions;
}
Algorithme
Algorithme Euclide
Euclide (PGCD)
(PGCD)
• Soit r le reste de la division euclidienne de a par b :
• a = bq + r , r < b.
• Tout diviseur commun de a et b divise aussi
r = a - bq, et réciproquement tout diviseur commun
de b et r divise aussi a = bq + r. Donc le calcul du
PGCD de a et b se ramène à celui du PGCD de b et
r ; et on peut recommencer sans craindre une
boucle sans fin, car les restes successifs sont
strictement décroissants. Le dernier reste non nul
obtenu est le PGCD cherché.

5.4
5.4 –– Les
Les boucles
boucles en
en CC
#include <stdio.h>
int m,n,a,b,r,PGCD;
main(){
printf("Nous allons calculer le PGCD de 2 nombres\n");
printf("Introduisez le premier nombre : "); a=60 b=42
scanf("%d",&m);
printf("Introduisez le second nombre : ");
r=18
scanf("%d",&n); 42+18 18 a=42 b=18
a=m; b=n;
42 18 r=6
while (b!=0) {
r=a % b; 2x18+6 18 a=18 b=6
a=b; b=r; 6 18
} r=0
PGCD=a; 6 6x3
a=6 b=0
printf("Le PGCD de %d et %d est %d\n",m,n,PGCD);
}
5.4
5.4 –– Les
Les boucles
boucles en
en CC
• En C, la boucle pour se traduit par
for (exp_init ; exp_cond ; exp_evol)
<instruction;>
• Ou
for (exp_init ; exp_cond ; exp_evol) {
<séquence d’instructions;>
}

5.4
5.4 –– Les
Les boucles
boucles en
en CC
• exp_init :
– est une instruction d'initialisation ; elle est exécutée avant l’entrée
dans la boucle
• exp_cond :
– est la condition de continuation ; elle est testée à chaque passage, y
compris lors du premier ; l’instruction ou les instructions composant
le corps du for sont répétées tant que le résultat de l’expression
exp_cond est VRAI
• exp_evol :
– Est une instruction de rebouclage ; elle fait avancer la boucle ;
elle est exécutée en fin de boucle avant le nouveau test de
passage.

5.4
5.4 –– Les
Les boucles
boucles en
en CC
#include <stdio.h>
main(){
int i,n;
printf("Quelle table souhaitez-vous afficher ? : ");
scanf("%d",&n);
for (i=1;i<=10;i++)
printf("%d fois %d font %d\n",n,i,n*i);
} ++ : opérateur d’incrémentation
i++ i=i+1
-- : opérateur de décrémentation
2001/2002
i-- i=i-1
DEUG MIAS-MASS 1ère année - Ph. Hunel 132
5.4
5.4 –– Les
Les boucles
boucles en
en CC
#include <stdio.h>
main() {
int i;
for (i=1;i<=5;i++)
printf("%d : Ca monte\n",i);
printf("--------------------------\n");
for (i=5;i>=1;i--)
printf("%d : Ca descend\n",i);
}

1 : ca monte
2 : ca monte
3 : ca monte
4 : ca monte
5 : ca monte
--------------------------
5 : ca descend
4 : ca descend
3 : ca descend
2 : ca descend
1 : ca descend

5.4
5.4 –– Les
Les boucles
boucles en
en CC
• Somme des 10 premiers entiers :
comparaison entre l’utilisation et de la
boucle « tant que » de la boucle « pour »
somme = 0; somme = 0;
i=0; for (i=0;i<10;i++)
while (i<10) { somme = somme + i;
somme = somme + i;
i = i + 1;
}
5.4
5.4 –– Les
Les boucles
boucles en
en CC
• Le langage C propose également une autre forme
de la boucle tant que qui permet d’exécuter au
moins une fois le corps de la boucle :
DO
<instruction;>
WHILE ( <expression logique>);
• ou
DO {
<séquence d’instructions;>
} WHILE ( <expression logique>);
5.4
5.4 –– Les
Les boucles
boucles en
en CC
#include <stdio.h>
main() {
int i, somme, N;
somme=0;
printf("Entrez le nombre d'élément que vous voulez sommer : ");
scanf("%d",&N);
i=1;
while (i<N) {
somme = somme +i;
i=i+1;
}
printf("Somme des %d premiers entiers est :
%d\n",N,somme);
}
5.4
5.4 –– Les
Les boucles
boucles en
en CC
#include <stdio.h>
main() {
int i, somme, N;
somme=0;
printf("Entrez le nombre d'élément que vous voulez sommer : ");
scanf("%d",&N);
i=1;
do {
somme = somme +i;
i=i+1;
} while (i<N);
printf("Somme des %d premiers entiers est : %d\n",N,somme);
}

4.5
4.5 -- Le
Le choix
choix multiple
multiple
• Supposons que l'on veuille demander à
l'utilisateur de choisir dans un menu une des
3 possibilités offertes.
• Le choix présenté ne se limite pas à une
alternative (soit - soit).
• Mais plutôt à une expression du type
« selon que… »

4.5
4.5 -- Le
Le choix
choix multiple
multiple
• En LDA :
entier i
lire i
selon que
i=1 faire bloc1
ou que i=2 faire bloc2
ou que i=3 faire bloc3
autrement écrire "Mauvais choix"
Fselon
• autrement est comme dans l’alternative facultative

4.5
4.5 -- Le
Le choix
choix multiple
multiple
• Peut toujours s’écrire avec des alternatives :
entier i
lire i
Si i=1 alors
bloc1
sinon
si i=2 alors
bloc2
sinon
si i=3 alors
bloc3
sinon
écrire "Mauvais choix"
Fsi
Fsi
Fsi
4.6
4.6 -- Le
Le choix
choix multiple
multiple en
en CC
• La traduction du choix multiple en C est assez
restrictive, puisque la valeur de l’expression
conditionnant le choix doit être entière (char,
short, int).
• L’instruction switch permet de mettre en place
une structure d’exécution qui permet des choix
multiples parmi des cas de même type et faisant
intervenir uniquement des valeurs constantes
entières.
4.6
4.6 -- Le
Le choix
choix multiple
multiple en
en CC
Switch ( <expression entière> ) {
case <constante entière>:ATTENTION : si la dernière
<instruction 1> instruction n’est pas l’instruction
… break les autres « case » ainsi
que le « default » seront exécutés
<instruction N>
…
default :
<instruction 1>
…
<instruction N>
}

4.6
4.6 -- Le
Le choix
choix multiple
multiple en
en CC
#include <stdio.h>
int i; Entrez votre choix : 1
main() { premier choix
printf("Entrez votre choix : ");
scanf("%d",&i);
switch(i) { Entrez votre choix : 2
case 1:printf("premier choix\n"); deuxième choix
break; troisième choix
case 2:printf("deuxième choix\n"); Autre choix que choix 1, 2 ou 3
case 3:printf("troisième choix\n");
default:printf("Autre choix que choix 1, 2 ou 3\n");
}
}

4.6
4.6 -- Le
Le choix
choix multiple
multiple en
en CC
#include <stdio.h>
int i;
main() {
printf("Entrez votre choix : ");
scanf("%d",&i);
switch(i) {
case 1:printf("premier choix\n");
break;
case 2:printf("deuxième choix\n");
break;
case 3:printf("troisième choix\n");
break;
default:printf("Autre choix que choix 1, 2 ou 3\n");
}
}
Transition
Transition
• Les variables utilisées jusqu’à présent sont
parfois inadaptées au traitement à réaliser
– Difficulté d’en utiliser un nombre important
– Particulièrement lorsqu’il s’agit de valeurs de
même type
– Exemples : relevés mensuels, statistiques
journalières

Chapitre
Chapitre 66 :: Les
Les tableaux
tableaux

6.1
6.1 -- Introduction
Introduction
• Imaginons que nous ayons plusieurs traitements à
effectuer sur des consommations mensuelles d’accès à
Internet (en nombre de minutes)
– Pour conserver les valeurs en mémoire, il est possible de
prendre 12 variables numériques, cons_Internet1,
cons_Internet2, …, cons_Internet12.
– Pour calculer la consommation mensuelle moyenne sur
l’année, la formule suivante peut être écrite :
Moyenne  (cons_Internet1 + cons_Internet2 + cons_Internet3 +
cons_Internet4 + cons_Internet5 + cons_Internet6 + cons_Internet7 +
cons_Internet8 + cons_Internet9 + cons_Internet10 + cons_Internet11
+ cons_Internet12) / 12
– Difficile à faire avec 365 consommations journalières…

6.1
6.1 -- Introduction
Introduction
• Imaginons que nous ayons à compter le nombre de fois,
chacune des notes, de 0 à 20, a été attribuée à une
population d’un grand nombre d’étudiants.
– L’algorithme pourrait être le suivant :
Initialiser les 21 variables à 0
Lire n
Tant que n  99 faire
si n=0 alors note0  note0 + 1
…
Ecrire « donnez la note suivante ou 99 pour terminer »
lire n
Ftq

6.1
6.1 -- Introduction
Introduction
• Pour simplifier cet algorithme, il suffirait de
pouvoir désigner directement la note qui
correspond à la valeur de la variable n
• La structure de données tableau regroupe une
famille de variables et permet de résoudre ce
genre de problème

6.2
6.2 –– Tableaux
Tableaux àà un
un indice
indice
• Un tableau (encore appelé table ou variable indicée) est
un ensemble de données, qui sont toutes de même type,
désigné par un identificateur unique (le nom du
tableau), et qui se distinguent les une des autres par
leur numéro d’indice
• Exemple : les températures sous abri à 15h00 des jours
d’une semaine seront les 7 valeurs de la variable
température, qui est un tableau de 7 éléments
(variables) de type réel désigné par :
– Température[1], Température[2], …, Température[7],
6.2
6.2 –– Tableaux
Tableaux àà un
un indice
indice
• Représentation graphique :
température Nom du tableau
1 25
2 30 Cette case du tableau
3 23 représente la variable
Température[3] dont la valeur est 23
4 36
5 33
6 22
7 27
6.2
6.2 –– Tableaux
Tableaux àà un
un indice
indice
• L’utilisation d’un indice variable présente le principal
intérêt des tableaux
• Si la variable k entière a pour valeur 3, alors
– Température[k] = 23
– Température[k+1] = 36
– Température[k-1] = 30
• Mais attention l’écriture de Température[-2] ou
Température[12] n’ont pas de sens car elles font
référence à des éléments inexistants

6.2
6.2 –– Tableaux
Tableaux àà un
un indice
indice
• De même le calcul de la température moyenne de la
semaine se fera de façon très simple :
Entiers somme, k
Réel moyenne
somme  0
Pour k  1 à 7 faire
somme  somme + Température[k]
fpour
moyenne  somme / 7
6.3
6.3 –– Déclaration
Déclaration des
des tableaux
tableaux
• Comme tout objet un tableau doit être déclaré
avant tout utilisation
• 3 éléments fondamentaux définissent un tableau
à un indice :
– Son nom : identificateur respectant les règles
classiques des identificateurs d’un programme
– Le nombre de ses éléments
– Le type de données qu’il contient
Tableau de 7 entiers Température
Tableau de [1..7] d’entiers Température
6.4
6.4 –– Tableaux
Tableaux àà plusieurs
plusieurs indices
indices
1 2 j n
1
2
3
n
6.5
6.5 -- Les
Les tableaux
tableaux en
en CC
• Exemple :
int a[13];
char b[8][5][10];
float d [6][15][9];
• Principe :
<type><identificateur>[taille1][taille2]…[taillek];
• N’importe quelle référence à une case peut être utilisé
comme une simple variable :
int i,j,k;
a[i]
b[i][j][k]
6.5
6.5 -- Les
Les tableaux
tableaux en
en CC
• La taille correspond au nombre de cases du
tableau
• Attention : les indices, permettant de localiser le
contenu d’une case d’un tableau, varient entre
0 et taille-1
• Il est possible d’affecter un tableau à un
ensemble de valeurs dès sa déclaration par :
<type><identificateur>[taille1][taille2]…={val1, val2, …};
• Exemple :
1 2 3
Int matrice[2][3]={1,2,3,4,5,6} 4 5 6

Exemple
Exemple de
de programme
programme CC
#include <stdio.h>
main(){
int i, somme, temperature[7];
float moyenne;
for (i=0;i<7;i++){
printf("Temperature[%d]=",i);
scanf("%d",&temperature[i]);
}
somme=0;
for (i=0;i<7;i++)
somme=somme+temperature[i];
moyenne=somme/7;
printf("la température moyenne de la semaine est %f\n",moyenne);
}

Chapitre
Chapitre 77 :: Les
Les sous-programmes
sous-programmes

7.1
7.1 -- Introduction
Introduction
• Jusqu’ici nous avons étudié les algorithmes selon une
approche simple :
– Un seul algorithme exprime une fonction
– qui à partir de données initiales produit un résultat
• Cas plus général :
– Le calcul d’une fonction est le résultat de plusieurs
algorithmes disjoints
– À chaque algorithme va donc correspondre un programme
– L’exécution restera quand même séquentiel  un seul
programme s’exécute et exécute l’une de ses instructions
Exemple
Exemplesimple
simpled’appels
d’appelsde
desous-programmes
sous-programmes
#include <stdio.h>
main(){
float X, Y;
printf("Entrez la valeur : "); appel du sous-programme d’affichage
scanf(‘’%f’’,&X); appel du sous-programme de lecture
Y = cos(X); appel du sous-programme cos
printf(" %f’’ ,Y); appel du sous-programme d’affichage
}

Fonctionnement
Fonctionnement
• Un programme particulier (cosinus), le
programme principal, lance successivement un
ensemble de sous-programmes, chacun d’eux
pouvant d’ailleurs lancer ses propres sous-
programmes.
• Cela revient à suspendre l’exécution du
programme en cours, autrement dit le processus du
programme principal et à lancer le processus
associé au sous-programme.
Fonctionnement
Fonctionnement
Processus
courant
Suspension du
processus appelant Sous-programme appelé
Nouveau processus courant
Reprise du
processus appelant
Retour vers
l’appelant
Intérêts
Intérêts
• Diviser pour mieux régner
• Méthode modulaire de conception utilisant
le découpage d’un problème en sous-
problèmes distincts
• Permet de réutiliser des programmes (sous-
programmes) déjà développés et surtout
validés

Problématique
Problématiquede
del’usage
l’usagedes
dessous-programmes
sous-programmes
• Quel est le rôle du sous-programme qui est exécuté

le premier ?
• Peut-on définir des variables communes à plusieurs
sous-programmes et comment sont-elles définies
et/ou modifiées ?
• Comment peut-on transmettre des informations
spécifiques à un sous-programme lors de son
lancement ?
• Comment un sous-programme peut renvoyer des
informations au programme appelant ?
7.2
7.2––Environnement
Environnementd’un
d’unsous-programme
sous-programme
• L’environnement d’un sous-programme est

l’ensemble des variables accessibles et des valeurs
disponibles dans ce sous-programme, en
particulier celles issues du programme appelant.
• Trois sortes de variables sont accessibles dans le
sous-programme :
– Les variables dites globales
– Les variables dites locales
– Les paramètres formels
7.2
Environnementd’un
sous-programme
• Les variables dites globales :

– Celles définies dans le programme appelant et
considérées comme disponibles dans le sous-
programme
– Elles peuvent donc être référencées partout
dans le programme appelant et dans le sous-
programme appelé
– Leur portée est globale

7.2
Environnementd’un
sous-programme
• Les variables dites locales

– Celles définie dans le corps du sous-programme,
utiles pour son exécution propre et accessibles
seulement dans ce sous-programme
– Elles sont donc invisibles pour le programme
appelant
– Leur portée est locale

7.2
Environnementd’un
sous-programme
• Les paramètres formels

– Les variables identifiées dans le sous-
programme qui servent à l’échange
d’information entre les programmes appelant et
appelé
– Leur portée est également locale.

7.3
7.3 –– Les
Les procédures
procédures
• Il s’agit de sous-programmes nommés qui
représentent une ou plusieurs actions, et qui
peuvent calculer et retourner une ou
plusieurs valeurs.
• Une procédure « P » doit être définie une
seule fois dans un algorithme « A » et peut
être appelée plusieurs fois par « A » ou par
une autre procédure de « A ».
7.3
7.3 –– Les
Les procédures
procédures
Entrées Procédure Sorties

7.3
7.3 –– Les
Les procédures
procédures
• La définition d’une procédure comprend trois parties:
• Partie 1 : L’entête
Procédure Nom_procédure (Liste de paramètres formels);
• Partie 2 : Déclaration des variables locales
type_variable_i Nom_variable_i
• Partie 3 : Corps de la procédure
Début
Instructions
Fin

7.3
7.3 –– Les
Les procédures
procédures
• Exemple :
– Calcul de la somme de deux matrices carrées A
et B.
– Pour calculer la somme de deux matrices il faut
lire d’abord ces deux matrices.
– Ainsi, au lieu d’écrire deux fois le sous-
programme de lecture d’une matrice, il est
possible d’écrire plutôt une procédure et de
l’utiliser pour saisir A et B.

7.3.1
7.3.1--Paramètres
Paramètresformels
formels&
&
paramètres
paramètreseffectifs
effectifs
• Dans la déclaration de la procédure « Saisir », Les
paramètres « X » et « dim » sont appelés paramètres
formels dans la mesure où ils ne possèdent pas encore de
valeurs.
• Lors de l’utilisation de la procédure dans l’algorithme
principal, « A », « B » et « n » sont des paramètres
effectifs (ou réels).
• Remarque importante: Dans une procédure, le nombre
de paramètres formels est exactement égal au nombre
paramètres effectifs.
• De même à chaque paramètre formel doit correspondre
un paramètre effectif de même type.
7.3.2
7.3.2 -- Passage
Passage des
des paramètres
paramètres
• Lors de la définition d’une procédure il est
possible de choisir entre trois modes de
transmission de paramètres:
– Mode donnée (En C on parle de Passage par
valeur)
– Mode Résultat (En C on parle de Passage par
adresse).
– Mode Donnée/Résultat (En C on parle de
Passage par adresse):
7.3.2.1
7.3.2.1 –– Mode
Mode données
données
• Rappel
– Déclarer une variable de nom X Réserver un
emplacement mémoire pour X
• Lors de l’appel d’une procédure un emplacement
mémoire est réservé pour chaque paramètre
formel.
• De même, un emplacement mémoire est aussi
réservé pour chaque paramètre effectif lors de sa
déclaration.
• Cependant, lors de l’appel de la procédure, les
valeurs des paramètres effectifs sont copiées dans
les paramètres formels.
7.3.2.1
7.3.2.1 –– Mode
Mode données
données
• L’exécution des instructions de la procédure se fait avec
les valeurs des paramètres formels et toute modification
de ces derniers ne peut affecter en aucun cas celles des
paramètres effectifs.
• C’est le cas :
– dans la procédure « Saisir » du paramètre « dim »
– dans la procédure « Afficher » des paramètres « Y » et « dim »
• Dans ce type de passage de paramètres, les valeurs des
paramètres effectifs sont connues avant le début de
l’exécution de la procédure et jouent le rôle uniquement
d’entrées de la procédure.
7.3.2.1
7.3.2.1 –– Mode
Mode données
données
• En C, en principe il n’existe que des fonctions.
Une fonction qui ne retourne aucun résultat
(type void) peut traduire la notion de procédure.
Procédure Afficher(Données Y:Matrice, Données n:entier)
• Se traduit en C par :
void Afficher(Matrice Y, int n);
Il y a eu initialisation des paramètres formels par
des valeurs lors de l’appel de la procédure
7.3.2.1
7.3.2.1 –– Mode
Mode données
données
Procédure carrés(Données X,Y :entiers)
Entiers A,B
Entiers M1,M2
Début
AX Début
B Y Lire M1, M2
A  AA carrés(M1,M2)
B  BB
écrire « M1= »,M1, « M2= »,M2
Fin
Fin

7.3.2.1
7.3.2.1 –– Mode
Mode données
données
Procédure carrés_bis(Données X,Y :entiers)
Début
X  XX Entiers M1,M2
Y  YY Début
écrire « X= »,X, « Y= »,Y
Lire M1, M2
Fin
carrés_bis(M1,M2)
écrire « M1= »,M1, « M2= »,M2
Fin
7.3.2.2
7.3.2.2 –– Mode
Mode résultats
résultats
• Passage par adresse, par variable
• La différence principale entre le passage par valeur et le
passage par adresse c’est que dans ce dernier un seul
emplacement mémoire est réservé pour le paramètre
formel et le paramètre effectif correspondant.
• Dans ce cas chaque paramètre formel de la procédure
utilise directement l’emplacement mémoire du paramètre
effectif correspondant.
• Toute modification du paramètre formel entraîne la même
modification du paramètre effectif correspondant.
7.3.2.2
7.3.2.2 –– Mode
Mode résultats
résultats
• Dans ce mode de passage de paramètres, les valeurs des
paramètres effectifs sont inconnues au début de
l’exécution de la procédure.
• Un paramètre formel utilisant ce type de passage ne peut
être que le résultat de la procédure. D’où le nom du
mode « Résultat ».
• Pour spécifier dans une procédure qu’il s’agit du mode «
Résultat », il suffit d’ajouter dans l’algorithme la
mention « Résultat » avant le paramètre formel
• Dans le programme Pascal il faut faire précéder le
paramètre du mot clé « Var »
7.3.2.2
7.3.2.2 –– Mode
Mode résultats
résultats
Procédure Somme(Données D,F:entier, Résultat R:entier)
• Se traduit en C par :
void Somme(int D, int F, int *R);
• Contrairement au passage par valeur, dans ce cas à
l’appel de la procédure les valeurs des paramètres
effectifs ne sont pas copiées dans les paramètres
formels.
• Ces derniers utilisent directement l’emplacement
mémoire (ou l’adresse) des paramètres effectifs.

Représentation
Représentation mémoire
mémoire
Sens de transmission des données
… A[1] A[2] A[3] ………… X[1] X[2] X[3] …

… 15 8 2 ………… 15 8 2 …
Passage par valeur
… … … … ……… X[1] A[1] X[2] A[2] X[3] A[3] …

… … … … ……… 15 8 2 …
Passage par adresse
7.3.2.3
7.3.2.3 –– Mode
Mode Données/Résultats
Données/Résultats
• Passage par adresse, par référence
• Les paramètres formels jouent simultanément le rôle
de donnée (i.e. d’entrée) et de résultat (sortie) de la
procédure: d’où l’appellation « Donnée/Résultat ».
• A l’appel de la procédure, les valeurs des paramètres
effectifs sont connues au début de l’exécution de la
procédure mais elles seront modifiées à la fin de cette
exécution: d’ou la seconde appellation « Donnée
Modifiée ».
7.3.2.3
7.3.2.3 –– Mode
Données/Résultats
• Ces deux derniers modes (i.e. Résultat et
Donnée Modifiée) se distinguent uniquement
au niveau de l’algorithme.
• En C ces deux derniers modes sont
exactement identiques : il s’agit dans les deux
cas de passage par adresse.

7.3.2.3
7.3.2.3 –– Mode
Données/Résultats
• On obtient donc la même représentation
mémoire que pour le mode « Résultat » :
… … … … ……… X[1] A[1] X[2] A[2] X[3] A[3] …

… … … … ……… 15 8 2 …
Passage par adresse

7.3.2.3
7.3.2.3 –– Mode
Données/Résultats
• Pour spécifier dans une procédure qu’il s’agit du
mode Donnée/Résultat (ou donnée modifiée), il
suffit d’ajouter dans l’algorithme la mention
– « Donnée/Résultat »
– ou « Donnée Modifiée »
devant le paramètre formel
• Dans le programme C le paramètre formel doit être
un pointeur

7.3.2.3
7.3.2.3 –– Mode
Données/Résultats
• Exemple :
– Algorithme d’une procédure permettant de remplacer
par 0 toutes les valeurs inférieures à 10 des matrices.
– La matrice qu’il faut fournir à cette procédure doit être
une donnée ( i.e. qui contient déjà des valeurs).
– Le résultat de cette procédure c’est cette même matrice
modifiée.
– Ainsi, dans ce cas le mode que l’on doit utiliser est
« Donnée/Résultat » (ou Donnée modifiée).

Procédure Remplacer (Donnée Modifiée
M:Matrices;Donnée dim: entier);
entiers i, j
Début
Pour i1 à dim faire
Pour j 1 à dim faire
Si M[i, j]<10 alors
M[i, j]  0
Fsi
Fpour
Fpour
Fin;

7.4
7.4 –– Les
Les fonctions
fonctions
• Une fonction est un sous-programme qui
calcule, à partir de paramètres éventuels,
une valeur d’un certain type utilisable dans
une expression du programme appelant.
• Les langages de programmation proposent
de nombreuses fonctions prédéfinies : partie
entière d’un nombre, racine carrée,
fonctions trigonométriques, etc.
7.4
7.4 –– Les
Les fonctions
fonctions
• Les fonctions sont comparables aux
procédures à deux exceptions près :
– Leur appel ne constitue pas à lui seul une
instruction, mais figure dans une expression ;
– Leur exécution produit un résultat qui prend la
place de la fonction lors de l’évaluation de
l’expression.

7.4
7.4 –– Les
Les fonctions
fonctions
• La définition d’une fonction comprend aussi trois parties:
• Partie 1 : L’entête
Fonction Nom_fonction(Liste de paramètres formels): Type_fonction
• Partie 2 : Déclaration des variables locales
type_variable_i Nom_variable_i
• Partie 3 : Corps de la fonction
Début
Instructions
Retour valeur retournée
Fin

7.4
7.4 –– Les
Les fonctions
fonctions
• Il s’agit donc de sous-programmes nommés et
typés qui calculent et retournent une et une
seule valeur.
• Le type de cette valeur est celui de la fonction.
Entrées Fonction Sortie

7.4.1
7.4.1 -- Passage
Passage des
des paramètres
paramètres
• Lors de la définition d’une fonction il ne doit,
normalement, être utilisé qu’un seul mode de
transmission de paramètres :
– Mode donnée (En C on parle de Passage par
valeur)
• Cependant les langages de programmation
permettent d’utiliser les autres modes.

7.4.2
7.4.2 –– Fonction
Fonction :: exemple
exemple
• Fonction permettant de calculer ex pour x
donnée avec une précision 10-3 et sachant
que :
2 n
x x  x ... x
e 1! 2! n!
1

Constante utilisée
E=0.001
Variables
Réel x
fonction expo(Donnée x: réel): réel
Entier i
réel f, ex
Début
f 1 ex 1 i 1
Tant que f  E faire
ff(x/i)
ex  ex + f
ii+1
ftq
Retour ex;
Fin

Algorithme
Algorithme principal
principal
Début
Écrire « Donner la valeur de x: »
Lire x
Écrire « L’exponentielle de x= », x, « est : », expo(x)
Fin

7.4.3
7.4.3 –– Traduction
Traduction en
en CC
#include <stdio.h>
#define E 0.001
#define E 0.001
float expo(float x) {
int i; float f,ex;
f=1; ex=1; i=1;
while (f>=E) {
f=f*(x/i);
ex=ex+f;
i++;
}
return ex;
}
7.4.3
7.4.3 –– Traduction
Traduction en
en CC
/*Programme principal */
main() {
float x;
printf("Donner la valeur de x : ");
scanf("%f",&x);
printf("L'exponentiel de x=%f est %f\n",x,expo(x));
}

7.5
7.5 –– Fonctions
Fonctions récursives
récursives
• Expression d’algorithme sous forme récursive :
– définition plus concise
– Démonstration par récurrence
• Principe :
– Utiliser pour décrire l’algorithme sur une donnée d,
l’algorithme lui même appliqué à un sous-ensemble de
d ou une donnée d’ plus petite
• Une fonction récursive possède donc la propriété
de s’appeler elle-même dans sa définition
• Permet de coder des fonctions définies à partir de
relations de récurrence
7.5
récursives
• Exemple calcul du factoriel d’un nombre
entier :
– 1ère définition :
• n! = 1 * 2 * 3 * 4 * … * n
• Traduction par une boucle :
Je vous écoute
– 2ème définition :
• n! 1 si n=0
n * (n-1)!

7.5
récursives
fonction factoriel(Donnée n: entier): entier
Entier fac
Début
si n = 0 alors
fac  1
sinon
fac  n * factoriel(n-1)
fsi
Retour fac;
Fin
7.5
récursives
• Dérouler cet algorithme pour :
factoriel(5)
• Factoriel(5) 5 * 24 =
– Factoriel(4) 4 * 6 = 24
• Factoriel(3) 3*2=6
– Factoriel(2) 2*1=2
. Factoriel(1) 1*1=1
- Factoriel(0) 1

Chapitre
Chapitre 88 :: Les
Les algorithmes
algorithmes de
de tri
tri

8.1
8.1 -- Introduction
Introduction
• Un tableau T est dit « trié en ordre croissant »
si tous les éléments consécutifs du tableau
vérifient :
T[i-1]  T[i]
• Il est admis qu’un
– tableau vide est trié
– tableau ne contenant qu’un seul élément est trié

8.1
8.1 -- Introduction
Introduction
• D’où la définition :
– Un tableau vide (n=0) est ordonné (trié),
– Un tableau contenant un seul élément (n=1) est
ordonné,
– Un tableau T[1..n], n>1, est ordonné si
 i  [2..n], T[i-1]  T[i]

8.1
8.1 -- Introduction
Introduction
• Tri d’un tableau
– Soit un vecteur (tableau à une dimension) T[1..n] à
valeurs dans un ensemble E de valeurs muni d’une
relation d’ordre notée <
– Trier le vecteur T consiste à construire un vecteur
T‘[1..n] tel que :
• T‘ soit trié,
• T‘ et T contiennent les mêmes éléments.
– Le plus souvent T et T‘ sont le même vecteur ; T‘
est construit en permutant entre eux les
éléments de T .
8.2
8.2 –– Tri
Tri par
par remplacement
remplacement
• Cette méthode simple et intuitive est
malheureusement très peu performante.
• Elle consiste à construire un tableau Ttrié[1..n] à
partir de T[1..n] tel que :
Ttrié[i-1]  Ttrié[i] ,  i  [2..n]
• Principe :
– Identifier le maximum du tableau
– Rechercher le minimum du tableau T
– Recopier ce minimum dans Ttrié à la position i
– Remplacer le minimum du tableau T par le maximum
– Recommencer pour i+1
8.2
8.2 –– Tri
Tri par
par remplacement
remplacement
Procédure tri_remplacement (D/R T[1..n], R Ttrié[1..n] : tableau de …)
Entier i,j
E max
Début Fonction maximum( D T[1..n] : tableau de …):E
max  maximum(T[1..n])Entier i
i1 E max
tant que i<n faire Début
j  indice_min(T[1.n]) max  T[1]
Ttrié[i]  T[j] Pour i  2 à n faire
T[j]  max si T[i]>max alors
i  i+1 max  T[i]
fsi
ftq
fpour
Ttrié[n]  max
Retour max
Fin
Fin
8.2
8.2 –– Tri
Tri par
par remplacement
remplacement
• Pour chaque élément rangé dans le tableau
Ttrié, il faut parcourir tout le tableau T et
non une partie du tableau T
• Nécessite un 2ème tableau, or si le nombre
d’éléments à trier est important, cet
algorithme requiert donc un espace
mémoire double.

8.3
8.3 -- Tri
Tri par
par insertion
insertion
• Cette méthode de tri insère (au ième passage) le ième
élément T[i] à la bonne place parmi
T[1],T[2]...T[i-1].
• Après l'étape i, tous les éléments entre la première
et la ième position sont triés.
• Il existe plusieurs méthode de tri par insertion
selon le principe qui est utilisé pour rechercher le
rang de l’élément à insérer parmi les éléments du
début de la liste déjà triés

8.3
8.3 -- Tri
Tri par
par insertion
insertion
Rang de T[i]
0 1 k i temp
• Principe de l’algorithme :
– pour i  2 à n faire
déplacer T[i] vers le début du tableau jusqu'à
la position j<=i telle que
T[j] < T[k] pour j<=k<i et (ou bien T[j]>=T[j-1] ou bien j=1).

8.3
8.3 -- Tri
Tri par
par insertion
insertion
4 2 0 5 3 Vecteur de départ
2 4 0 5 3 Les cellules 1 à 2 sont triées

8.3
8.3 -- Tri
Tri par
par insertion
insertion
Procédure tri_insertion (D/R T[1..n], : tableau de …)
Entier i,j
Début
pour i 2 à n faire
j  i-1
tant que j  1 et T[j] > T[j+1] faire
échange(T,,j+1,,j) Exemple visuel
j  j-1
ftq
fpour
Fin
8.4
8.4 –– Tri
Tri par
par sélection
sélection
• Le principe du tri par sélection d'un vecteur
est d'aller chercher le plus petit élément du
vecteur pour le mettre en premier, puis de
repartir du second, d'aller chercher le plus
petit élément pour le mettre en second etc.
• Au ième passage, on sélectionne l’élément
ayant la plus petite valeur parmi les
positions i..n et on l'échange avec T[i].
8.4
8.4 –– Tri
Tri par
par sélection
sélection
0 2 4 5 3 Le plus petit élément est à sa place
0 2 4 5 3 Les 2 plus petits éléments sont à leur place

8.4
8.4 –– Tri
Tri par
par sélection
sélection
Procédure tri_sélection (D/R T[1..n], : tableau de …)
Entier i,j
Début
pour j i+1 à n faire
si T[i] > T[j] alors
échange(T,i,j) Exemple visuel
fsi
fpour
fpour
Fin
8.5
8.5 –– Tri
Tri àà bulles
bulles
• Le principe du tri à bulles (bubble sort) est
de comparer deux à deux les éléments e1 et
e2 consécutifs d'un tableau et d'effecteur une
permutation si e1 > e2 .
• On continue de trier jusqu'à ce qu'il n'y ait
plus de permutation.

8.5
8.5 –– Tri
Tri àà bulles
bulles
4 0 2 3 5 Fin du premier passage
0 2 3 4 5 Fin du deuxième et dernier passage

8.5
8.5 –– Tri
Tri àà bulles
bulles
Procédure tri_bulles (D/R T[1..n], : tableau de …)
Entier i,j
Début
pour i 1 à n-1 faire
pour j n à i+1 faire {décroissant}
si T[j-1] > T[j] alors

échange(T,j-1,j)
fsi
fpour
fpour
Fin
8.5
8.5 –– Tri
Tri àà bulles
bulles
• Évaluation du coût de l’algorithme
– Les comparaisons sont effectuées à l’intérieur de la
boucle la plus interne
– Pour i=1, n-1 comparaisons sont effectuées
– Pour i=2, n-2 comparaisons sont effectuées
– …………
– Pour i=n-1, 1 comparaison est effectuée
– Le nombre total de comparaisons effectuées est donc :
n1
n(n1)

k 1
k 
2
8.5
8.5 –– Tri
Tri àà bulles
bulles
• Optimisation de l’algorithme
– Après avoir traité i-1 éléments (1  i  n)
• Les éléments de 1..i-1 sont triés
• Tous les éléments compris entre 1..i-1 sont inférieurs aux
éléments compris entre i..n
T[1..i-1]  T[i..n]
• Les éléments compris entre i..n ne sont pas traités
– Si les éléments compris entre i..n sont triés à la suite des
permutations effectuées, il est inutile de poursuivre car :
• T[1..i-1] trié ; T[1..i-1]  T[i..n] ; T[i..n] trié  T[1..n] trié
– Exemple de BATEAUX

Procédure tri_bulles2 (D/R T[1..n], : tableau de …)
Entier i,j
Booléen onapermuté
Début
i 1
onapermuté  VRAI
Tant que onapermuté faire
onapermuté  FAUX
pour j n à i+1 faire {décroissant}
si T[j-1] > T[j] alors
échange(T,j-1,j)
onapermuté  VRAI
fsi
fpour
i i+1
ftq
Fin

PRODECURE Tri_bulle (D/R T[1..n], : tableau de …)
Booleen permut
Début
REPETER
permut  FAUX
POUR i  1 à N-1 FAIRE
SI T[i] > T[i+1] ALORS
échange(T,i,i+1)
permut  VRAI
FSi
Exemple visuel
Fpour
Jusqu’à permut = FAUX
FIN

8.6
8.6 –– Tri
Tri indirect
indirect
• Ce tri utilise un tableau auxiliaire qui indique,
pour chaque élément du tableau à trier, le rang que
celui-ci devrait occuper dans le tableau trié.
• Le principe consiste à compter, pour chaque
élément du tableau à trier, le nombre d’éléments
qui lui sont inférieurs ou égaux. Le nombre trouvé
donnera la place (l’indice) de cet élément dans le
tableau trié
• Le tri se fait donc ensuite par l'intermédiaire de
cet index
8.6
8.6 –– Tri
Tri indirect
indirect
Procédure tri_indirect (D/R T[1..n], : tableau de …)
Entier i
Tableau d’entier ind
Début
ind[i]  1
fpour
COMPTAGE DES ELEMENTS
Ttrié[ind[i]]  T[i]
fpour
Fin
8.6
8.6 –– Tri
Tri indirect
indirect
COMPTAGE DES ELEMENTS
pour k 1 à n faire
si T[k] < T[i] alors
ind[i]  ind[i] + 1
fsi
fpour Exemple visuel
fpour

8.6
8.6 –– Tri
Tri indirect
indirect
AMELIORATION DU COMPTAGE DES ELEMENTS
pour k i+1 à n faire
si T[i] < T[k] alors
ind[i]  ind[i] + 1
sinon
ind[k]  ind[k] + 1
fsi
fpour
fpour
Chapitre
Chapitre 99 ::
Les
Les algorithmes
algorithmes de
de recherche
recherche

9.1
9.1 -- Introduction
Introduction
• Le but de des algorithmes de recherche est de trouver
un élément donné parmi une liste d’éléments fourni
par un vecteur.
• 9.2 – Recherche séquentielle dans un tableau non trié
– On sait faire
– Parcourir le tableau jusqu’à ce qu’on trouve l’élément
recherché ou qu’on ait atteint la fin du tableau
– Dans le pire des cas nécessitera n comparaisons (n étant le
nombre d’éléments du tableau)
• Cas où l’élément recherché n’appartient pas au tableau

9.3
9.3 –– Recherche
Recherche séquentielle
séquentielle dans
dans
un
un tableau
tableau trié
trié
• On sait faire
– Parcourir le tableau jusqu’à ce qu’on trouve l’élément
recherché ou un élément supérieur à l’élément
recherché ou encore qu’on ait atteint la fin du tableau
– Dans le pire des cas nécessitera n comparaisons (n étant
le nombre d’éléments du tableau)
• Cas où l’élément recherché est plus grand que le dernier élément
du tableau (i.e élément d’indice n)
– Amélioration possible :
• Regarder si l’élément recherché n’est pas plus grand que le
dernier élément du tableau
• Mais le problème demeure si l’élément recherché est le dernier
élément du tableau

9.4
Recherche dichotomique
dichotomique
dans
dans un
un tableau
tableau trié
trié
• Existe-t-il un algorithme plus efficace (en
nombre de comparaisons) qui permettrait de
rechercher l’existence d’un élément donné
dans un tableau trié?

9.4
dichotomique
dans
dans un
un tableau
tableau trié
trié
• Supposons un tableau T[1..n] trié
 i  [2..n], T[i-1]  T[i]
• Partitionnons le tableau T en 3 sous-tableaux T[1..m-1],
T[m], T[m+1..n]
• En comparant l’élément recherché à T[m], s’il n’y a pas
égalité, il est possible de dire à quel sous-tableau
appartient l’élément recherché :
– À T[1..m-1] si l’élément recherché < T[m],
– À T[m+1..n] si l’élément recherché > T[m],
• On se retrouve alors dans le cas précédent mais avec les
sous-tableaux T[1..m-1] ou T[m+1..n]
9.4
dichotomique
dans
dans un
un tableau
tableau trié
trié
• Donc :
– Soit il a été trouvé un indice m tel que
Élément recherché = T[m]
• et l’algorithme est terminé
– Soit il a été trouvé en un nombre fini d’itération
un sous-tableau vide et dans ce cas
Élément recherché  T[1..n]
• et l’algorithme est terminé

9.4
dichotomique
dans
dans un
un tableau
tableau trié
trié
• Il faut maintenant déterminer les sous-tableaux T1, T2, T3,
…,Tk tel que chaque sous-tableau Ti soit de taille (nombre
d’éléments) strictement inférieure à la taille du sous-
tableau précédent Ti-1.
• Remarque :
– Si pour T1, T2, T3, …,Tk , on choisit T[1..n], T[2..n], T[3..n], …,
T[k..n], on se ramène à la recherche séquentiel précédente.
• Généralement l’indice m est choisit de telle sorte que la
taille de T[1..m-1] et T[m+1..n] soit la même à un élément
près.
fonction dichoto (D T[1..n], : tableau de …; D elem_rech: …): booléen
Entier inf, sup, m
Booléen trouvé
Début
inf  1 sup  n
trouvé  FAUX
Tant que inf  sup et non trouvé faire
m  (inf + sup) div 2
si T[m] = elem_rech alors
trouvé  VRAI
sinon si T[m] < elem_rech alors
inf  m+1
sinon
sup  m-1
fsi fsi
ftq
retour(trouvé)
Fin

9.4
dichotomique
dans
dans un
un tableau
tableau trié
trié
• Coût de l’algorithme :
– La taille des tableaux de la suite T1, T2, T3, …,Tk
est divisé par 2 à chaque itération :
– n, n/2, …, n/2k-1
– On aura donc la partie entière de log2(n) sous-
tableaux non vides

Chapitre
Chapitre 10
10 :: Types
Types évolués
évolués

10.1
10.1 –– Les
Les structures
structures
• Les tableaux sont des paquets de données
de même type.
• Les structures sont des ensembles de
données non homogènes.
• Les données peuvent avoir des types
différents.
• Les structures sont déclarées ou définies
selon le modèle :
10.1
10.1 –– Les
Les structures
structures
• Les structures sont déclarées ou définies
selon le modèle :
struct nom_de_structure_facultatif {
la liste des données contenues dans la
structure
} la liste des variables construites selon
ce modèle.
10.1
10.1 –– Les
Les structures
structures
• Exemple :
Struct etd {
char nom[20];
char prenom[20];
float note_info;
float note_phi;
float moyenne;
} anriolle;

10.1
10.1 –– Les
Les structures
structures
• etd est un nom de modèle de structure
• anriolle est un objet de type struct etd.
• Les différentes parties de la structure anriolle
sont accessibles par :
– anriolle.nom
– anriolle.prenom
– anriolle.note_info
– anriolle.note_phi
– anriolle.moyenne

10.2
10.2 –– Les
Les unions
unions
• Les unions permettent l'utilisation d'un même
espace mémoire par des données de types
différents à des moments différents.
• Syntaxe de la définition d'une union
Union nom_union {
type1 nom_champ1;
type2 nom_champ2;
…
typeN nom_champN;
} variables;

10.2
10.2 –– Les
Les unions
unions
• Exemple :
union zone {
int entier;
float flottant;
} z1;
• Utilisation
– z1.entier = 1;
– z1.flottant = 2.5;

Fin


Cours Algo

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Cours Algo

Загружено:

Авторское право:

Доступные форматы

Cours

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 1

Chapitre suivant algorithmique

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 4

Traitement automatique de l’information

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 6

Données à l’état brut

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 7

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 9

Machine de Pascal (1645)

Machine de Babbage (1833)

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 12

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 14

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 15

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 18

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 20

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 22

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 23

Edition Compilation Exécution

Zone de Editeur Compilateur Code

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 24

FICHIER : élément de mémoire de stockage (mémoire de

Le codage de l’information définit le TYPE du fichier et

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 25

Les supports magnétiques à ACCES ALEATOIRE (on

 RACINE : fichier répertoire crée automatiquement sur le

 CHEMIN D’ACCES : liste des répertoires permettant

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 27

Capacité = nombre de faces *

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 28

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 29

Puce du BIOS CPU

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 30

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 33

• Exemples d’algorithme dans la vie courante

• Ecriture des premiers programme en langage

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 38

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 39

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 40

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 41

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 42

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 43

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 44

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 46

mias101 mias120 images info

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 47

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 48

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 49

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 50

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 51

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 52

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 53

Contient des outils d’analyse des tables

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 56

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 57

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 58

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 59

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 60

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 61

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 62

– Spécification du schéma de calcul sous forme

2001/2002 DEUG MIAS-MASS 1ère année - Ph. Hunel 63

Un algorithme est une suite finie de règles à