Structure de données et algorithmes Introduction

Faculté Polytechnique

FPMS-INFO

Computer Science Department

FPMS-INFO

University of Mons

Structure de données et algorithmes

Introduction

Prof. Saïd Mahmoudi

Université de Mons FPMS-INFO | Faculté Polytechnique de Mons | UMONS

Sommaire

1. Introduction

2. Algorithmes

3. Codage de l’information

4. Structure de données

5. Architecture des ordinateurs

6. Systèmes d’exploitation

7. Mémoires

2

Université de Mons FPMS-INFO | Faculté Polytechnique de Mons | UMONS 3

Informatique

• Ordinateur : une machine de traitement de l’information.

• Il est capable d’acquérir de l’information, de la stocker, de la transformer en effectuant des traitements quelconques, puis de la restituer sous une autre forme.

• Nous appelons information tout ensemble de données. On distingue généralement différents types d’informations : textes, nombres, sons, images, 3D, vidéos, etc., mais aussi les instructions composant un programme.


Informatique : science du traitement automatique et rationnel de l’information en tant que support des connaissances et des communications.

Science : ensemble cohérent de connaissances relatives à certaines catégories de faits, d'objets ou de phénomènes obéissant à des lois et vérifiées par les méthodes expérimentales.

Automatique : système qui opère, fonctionne sans intervention humaine, par des moyens mécaniques, électriques, électroniques.

donc à l'aide d'une machine.

Rationnel : qui est déduit par le raisonnement et n'a rien d'empirique.donc à l'aide d'un humain.

Informatique : définition

INFORmation autoMATIQUE


• Le traitement peut être réalisé en privilégiant la puissance de la machine et en négligeant l'humain.

• Ce n'est pas la voie choisie dans cet enseignement universitaire. Nous privilégierons toujours le raisonnement humain afin que le traitement automatique soit simplifié.

• La puissance de la machine est en constant développement mais elle est toujours limitée.

• Le raisonnement humain comble considérablement ces limites.


6


Ce que n’est pas l’informatique !!

• les informaticiens ne savent pas nécessairement réparer un ordinateur enpanne, diagnostiquer un problème électronique,

• les informaticiens ne connaissent pas nécessairement toutes les nouvellesversions des programmes, ils ne savent pas toujours utiliser toutes leursfonctions, ils ne passent pas (toujours) leurs journées à tester des jeux ou àchercher des bugs.

• Rien à voir avec « bidouiller » son PC, maîtriser PhotoShop, tenir un blog ou connaître les ruses d'un jeu,

• l’informatique peut s’étudier avec un papier et un crayon, même en absenced’ordinateur.

7

Disciplines de l’Informatique• Informatique théorique (algorithmique, calculabilité,

complexité, graphes, langages formels, etc.)

• Programmation, génie logiciel

• Réseaux, logiciels de télécommunications, sécurité des échanges d’information

• Logiciels de base (systèmes d'exploitation, bases de données, compilateurs ...)

• Systèmes embarqués, robotique

• Images, son, multimédia, interfaces, homme/machine, infographie ...

• Calcul scientifique, optimisation, intelligence artificielle, bio-informatique, traitement des langues ...

graphe de relations sous Facebook

Robot explorateur NASA

8

Quelques domaine d’application de l’Informatique

• Informatique de gestion• Comptabilité, facturation, paye, gestion des stocks et

du système de production, gestion des relationsclients, banques et bourse, aide à la décision ...

• Informatique industrielle et technologique• Conception et fabrication assistées, modélisation et

simulation de systèmes complexes, informatiqueembarquée, télécommunications et réseaux ...

• Internet• e-commerce, recherche d'informations, sécurité ...

• Et aussi disciplines scientifiques, médicales, scienceshumaines et sociales, arts ...

une salle de marchés

simulation des écoulements d'air

cartographie deconnexions du cerveau (INRIA)

9

Les métiers de l’Informatique• Métiers de l'exploitation

• Technicien de maintenance, technicien support (Hot Liner),administrateur de système d'information, de système, de réseau, etc.

• Métiers de la conception et du développement• Analyste-programmeur, concepteur de logiciel, architecte de systèmes

d'information, web designer, ergonome ...

• Métiers de la recherche• En informatique « pure » ou appliquée à d'autres domaines

• Métiers du conseil et de l'expertise• Mise en œuvre de systèmes d'information, protocoles de sécurité,

impact sur l'organisation de l'entreprise ...

• Métiers du marketing• Ingénieur technico-commercial, chef de produit.

10

Les métiers de l’Informatique

Ingénieur IA


Histoire de l’Informatique

1936 : Alan Turing publie l’article fondateur de l’informatique, et présente la « Machine de Turing », un modèle abstrait pour définir la notion d’algorithme.

Alan Turing



1936 : Alan Turing publie l’article fondateur de l’informatique, et présente la « Machine de Turing », un modèle abstrait pour définir la notion d’algorithme.

Alan Turing



État de la machine Contenu de la cellule

Écrit sur le ruban

Déplacement État suivant

État 0 Vide D État 0

État 0 + D État 0

État 1 + D État 1

La machine de Turing

Unité de commande Programme

+ + + +

Ruban = entrée

sortie et mémoire


Histoire de l’Informatique+ + + + + + +

3 4

État Contenu de la cellule

Écrit sur le ruban

Déplacement État machine suivant


État 0 + D État 1

État 1 + D État 1

État 1 Vide + D État 2

État 2 + D État 2

État 2 Vide G État 3

État 3 + Effacement D Stop

Stop Arrêt du travail

+ + + + + + +

7


Histoire de l’Informatique+ + + + + + +

3 4

État Contenu de la cellule

Écrit sur le ruban

Déplacement État machine suivant


État 0 + D État 1

État 1 + D État 1

État 1 Vide + D État 2

État 2 + D État 2

État 2 Vide G État 3

État 3 + Effacement D Stop

Stop Arrêt du travail

+ + + + + + +

7


Histoire de l’Informatique1946 : l’ENIAC, commandé par l’armée américaine est le 1er ordinateur électronique baséentièrement sur la machine de Turing. Il réalisait 100 000 additions ou 357 multiplications par seconde !

• l’ENIAC n’est pas tout à fait une machine universelle de Turing, au sens où l’algorithme(instructions) n’est pas directement traduisible dans le langage de la machine.

• L’ENIAC ne peut « lire » le code d’instructions d’une autre machine et l’exécuter à saplace.

• Il faut avoir recours à des programmeuses qui change à la main le câblage et lacircuiterie de la machine, et par conséquent l’algorithme des instructions de calcul.


Histoire de l’Informatique1946 : l’ENIAC, commandé par l’armée américaine est le 1er ordinateur électronique baséentièrement sur la machine de Turing. Il réalisait 100 000 additions ou 357 multiplications par seconde !


L’architecture de von Neumann décompose l’ordinateur en quatre parties distinctes :

1. Le processeur est composé d’une unité arithmétique et logique (UAL ou ALU en anglais) ou unité de traitement : son rôle est d’effectuer les opérations de base et d’une unité de contrôle, chargée du séquençage des opérations ;

2. La mémoire qui contient à la fois les données et le programme exécuté par l’unité de contrôle.

3. Les dispositifs d’entrée-sortie, qui permettent de communiquer avec le monde extérieur. Les différents composants sont reliés par des bus

Histoire de l’InformatiqueL’ARCHITECTURE DE VON NEUMANN

John Von Neumann 1950 • Idée: fonctionnalité traitée comme les données• Suivre une recette (programme) • Appliquer chaque étape au ingrédients (données)


L’ARCHITECTURE DE VON NEUMANN


conception de l’EDVAC

http://fr.wikipedia.org/wiki/Electronic_Discrete_Variable_Automatic_Computer


Histoire de l’Informatique2ème génération : les semi-conducteurs (1958-1964)• L'utilisation des transistors à la place des tubes permit de réduire très fortement

l’espace, la fiabilité et la consommation énergétique.• Les premiers ordinateurs entièrement transistorisés apparurent vers 1959

4ème génération : intégration poussée et micro-informatique (1970-...)

• Cette génération concerne l'ère modernede l'informatique.

• Le Cray 1, imaginé par Seymour Cray, futl'un des ordinateurs les plus puissants de lafin des années 70

3ème génération : les circuits imprimés (1964-1970)


• La fin des années 70, et les années 80 ont vu l’essor remarquable de l'informatique "personnelle".

Steve Wozniak, Steve Job, Dan Kottkeprésentent l’Apple I (1976)

• l'apparition des microprocesseurs en 1971, puis des micro-ordinateurs en 1973 a permis le développement de l'informatique personnelle ou micro-informatique



L’Informatique moderne• Sortie en 1981 de l’IBM PC. Apparition des interfaces graphiques et de la souris (1984,

Macintosh d'Apple, X Window au MIT pour Unix) : l'ordinateur tel que vous le connaissez est né !

• Commercialisation de Windows (1985, pas vraiment graphique)

• Création de Linux (Linus Torvalds, 1991), système d'exploitation libre

• Création du Web (Tim Berners-Lee, 1991) et premier navigateur (Mosaic, 1993); création de Yahoo (1994), naissance du W3C (1994)

Deep Blue d'IBM, 1990super-ordinateurmassivement parallèle

Tim Berners Lee


• De fait, les innovations en matière de technologies électroniques n'ont cessé de se succéder : En 2010, Intel produit le Intel Core i7 (Gulftown ) avec 1 170 000 000 transistors, une finesse de gravure 0,032 mm, (1 cheveu : 100 mm) et une puissance de 147 600 MIPS.

Ipad 2

L’Informatique moderne• Création de Google (1998)

• Années 2000 : web 2.0, premiers systèmes collaboratifs, de partage et d'échanges (wiki, forums, peer to peer ...), « cloud computing »

• IBM vient d'annoncer un nouveau procédé de gravure qui va permettre de concevoir une puce de la taille d'un ongle... capable de contenir 30 milliards de transistors !

• Ces puces ne sont pas attendues avant 2020.


• La loi de Moore

https://www.journaldunet.com/solutions/dsi/1173117-la-loi-de-moore-est-officiellement-enterree/

https://www.youtube.com/watch?v=03v8Xc1RmAg




• La loi de Moore






https://www.youtube.com/watch?v=_d6KuiuteIA

28

Informatique : actuellement

https://www.youtube.com/watch?v=_d6KuiuteIA


Informatique


Algorithmes

Algorithme :

• L’algorithme est une suite de raisonnements ou d’opération qui fournit la solution d’un problème

• Procédure de résolution d’un problème portant sur des informations, s’exprimant dans une séquence définie sans ambigüité, destinée à être traduite dans un langage de programmation.

• Un programme n’est rien d’autre que la représentation d’un algorithme dans un langage plus technique compris par un ordinateur (par exemple : Assembleur, Cobol, Python, Ruby, Java, C++, . . .). Ce type de langage est appelé langage de programmation.


Programmes


Exécution d’un programme


• Programme qui transforme du code source en du code exécutable par une machine

• La compilation à lieu avant l’exécution

33

Compilateur


• Programme qui prends un programme en entrée et l’exécute directement

34

Interpréteur


Interpréteur Compilateur

Convertit le programme en prenant une seule ligne à la fois.

Analyse l’ensemble du programme et le traduit dans son ensemble en code machine.

L’analyse du code source prend moins de temps, mais le temps d’exécution global est plus lent.

L’analyse du code source prend beaucoup de temps, mais le temps d’exécution global est comparativement plus rapide.

Aucun code d’objet intermédiaire n’est généré, la mémoire est donc efficace.

Génère du code d’objet intermédiaire qui nécessite en outre une liaison, nécessite donc davantage de mémoire.

Continue de traduire le programme jusqu’à ce que la première erreur soit rencontrée. Par conséquent, le débogage est facile.

Il génère le message d’erreur uniquement après avoir analysé l’ensemble du programme. Par conséquent, le débogage est relativement difficile.

Exemple d’interpréteur: Python, Ruby. Exemple de compilateur: C, C++.

Comparaison


IEEE : top 10 des meilleurs langages de programmation de l’année 2019

LANGAGES


LANGAGES

HTML


HTMLDéfinition :• HTML « HyperText Mark-Up Language » est un langage à base

de balises qui va vous permettre de structurer une page Web.• Les balises permettent notamment de créer des liens entre

pages, insérer des images, etc.

Exemple :

<html>

<head><title> le titre de la page </title>

</head>

<body></body>

</html>


HTML : applications


• Il y a 12 boules noires et 15 boules vertes (NN + NV > 0)

• Quelle sera la couleur de la dernière boule ?

• Tirage et remise des boules

Jeu de l’urne


• Le problème ?

Avoir une seule boule dans l'urne

• Quelle est la solution ?

Enlever toutes les boules (sauf une)

Comment enlever des boules ?

Par le mécanisme de tirage qui est donné.

Sauf une

Est-ce réalisable ?

Jeu de l’urne


Restera-t-il une seule boule à la fin ?

Oui car, après chaque tirage et remise, le nombre de boules diminue de un.

Jeu de l’urne


• Comment mettre en œuvre la solution ?

• A l'aide d'un algorithme, un ensemble de règles opératoires dont l'application permet de résoudre un problème énoncé au moyen d'un nombre fini d'opérations.

1. Tirer deux boules de l'urne2. Si ce sont deux vertes, remettre une noire3. Si ce sont deux noires, remettre une noire4. Si ce sont une verte et une noire, remettre une verte5. S'il reste plus d'une boule, recommencer ce qui précède6. Tirer la boule et annoncer sa couleur

✓ Un algorithme est un énoncé, dans un langage défini, d’une suite d’opérations permettant de résoudre par calcul un problème.

Jeu de l’urne


• Comment mettre en œuvre la solution ?

• A l'aide d'un algorithme, un ensemble de règles opératoires dont l'application permet de résoudre un problème énoncé au moyen d'un nombre fini d'opérations.

1. Tirer deux boules de l'urne2. Si ce sont deux vertes, remettre une noire3. Si ce sont deux noires, remettre une noire4. Si ce sont une verte et une noire, remettre une verte5. S'il reste plus d'une boule, recommencer ce qui précède !!6. Tirer la boule et annoncer sa couleur

✓ Un algorithme est un énoncé, dans un langage défini, d’une suite d’opérations permettant de résoudre par calcul un problème.

Jeu de l’urne


• Recommencer ce qui précèdeimprécis ! Tout ou une partie ?

Répéter

Tirer deux boules de l'urneSi ce sont deux vertes, remettre une noireSi ce sont deux noires, remettre une noireSi ce sont une verte et une noire, remettre une verte

Jusqu'à ce qu'il reste une seule boule dans l'urne

Tirer la boule et annoncer sa couleur

Jeu de l’urne


Opération nouvelle : boucle post-testée do {…} while (…)

• Problème : il est nécessaire de prouver que la condition sera satisfaite à un moment donné.

• Cette condition est appelée le gardien de la boucle.

Répéter

(corps de la boucle)

Jusqu'à ce que (une condition est satisfaite)

Jeu de l’urneItération


Problème : que se passe-t-il s'il n'y a pas au moins deux boules dans l'urne ?

Erreur !

• Tirer deux boules de l'urne est impossible.

• Il est donc nécessaire de vérifier au préalable si les conditions d'activation de la boucle sont satisfaites.

• Notion nouvelle : préconditions de la boucle

Jeu de l’urne


Tant qu'il reste plus d'une boule faire

débutTirer deux boules de l'urneSi ce sont deux vertes, remettre une noireSi ce sont deux noires, remettre une noireSi ce sont une verte et une noire, remettre une verte

fin


Jeu de l’urne


Tant que (une condition est satisfaite) faire

début


fin

Opération nouvelle : boucle pré-testéewhile (…)

{…}

Cette boucle est donc plus générale que la précédente.

Problème : il est nécessaire de prouver que la condition sera satisfaite à un moment donné (boucle infinie).


Soient NT : nombre total de boulesNV : nombre de boules vertesNN : nombre de boules noires

NT = NV + NN

Tant qu'il reste plus d'une boule faire …

Jeu de l’urne

A chaque fois, compter le nombre de boules ? Trop de calcul !

o A chaque itération, le nombre de boules diminue de un. o Or on connaît le nombre de boules initiales.

On pourrait écrire Tant que (NT > 1) faire …

mais il y a mieux ! …


Pour i variant de NT à 2 faire

débutTirer deux boules de l'urneSi ce sont deux vertes, remettre une noireSi ce sont deux noires, remettre une noireSi ce sont une verte et une noire, remettre une verte

fin


Jeu de l’urne


Pour (compteur) variant de (débcompt) jusque (fincompt) faire

début


fin

Opération nouvelle : boucle définie(for (i = dc ; i<= fc; i ++) {…})

• Cette boucle est excellente lorsque l'on connaît le nombre d'itérations nécessaires.

• Pas de problème de gardien pour autant que l'on ne modifie pas le compteur dans le corps de la boucle.

• Le compteur est géré automatiquement par l'instruction de boucle définie.

Jeu de l’urne


compteur = 0 ; Tant que ( compteur < N )

débutcorps de la boucle ;compteur = compteur + 1;

fin

• Remarque: la boucle « Tant que » est la plus générale.• Elle peut remplacer la boucle « Pour … faire » avec les instructions suivantes :

Elle peut remplacer la boucle « Pour … faire » puisque le gardien (la condition) est vérifié avant d'effectuer la boucle.

Jeu de l’urne


Pour i variant de NT à 2 fairedébut

Tirer deux boules de l'urne(supposons qu'il existe une procédure pour accomplir cela)

Si ce sont deux vertes, remettre une noire…

Si ce sont deux vertes : comment accomplir ce test ?

Nous sommes capables de faire cela simultanément,la machine qui nous intéresse n'en est pas capable.

Elle doit simplifier, affiner le problème et traiter une boule à la fois.

Jeu de l’urne


Si la première boule est verte

alorsSi la deuxième boule est verte

alors remettre une noiresinon (c'est donc une noire) remettre une verte

sinon (c'est donc une noire)Si la deuxième boule est noire

alors remettre une noiresinon (c'est donc une verte) remettre une verte

Jeu de l’urneTests


Opération nouvelle : sélection if (…) {…} else {…}

Si (une condition est satisfaite)alors

(opération(s) à accomplir)sinon

(opération(s) à accomplir)

Remarques:• sinon est optionnel• il est possible d'imbriquer des sélections• notez l'indentation des "alors" et "sinon" indispensables pour la lisibilité

Condition

Jeu de l’urne


Pour i variant de NT à 2 fairedébut

Tirer deux boules de l'urneSi la première boule est verte

alorsSi la deuxième boule est verte

alors remettre une noiresinon remettre une verte

sinon (c'est donc une noire)Si la deuxième boule est noire

alors remettre une noiresinon (c'est donc une verte) remettre une verte

finTirer la boule et annoncer sa couleur

Jeu de l’urne


Pour i variant de NT à 2 fairedébutTirer deux boules de l'urneSi la première boule est vertealorsSi la deuxième boule est vertealors remettre une noiresinon remettre une vertesinon (c'est donc une noire)Si la deuxième boule est noirealors remettre une noiresinon (c'est donc une verte) remettre une vertefinTirer la boule et annoncer sa couleur

Jeu de l’urne


Jeu de l’urne

• Complexité (recherche dans un tableau)

• Un algorithme de recherche de complexité exponentielle, • exécuté sur une machine pouvant effectuer un milliard de comparaisons (/s)• prendrait plus de dix mille milliards d’années pour trouver une valeur dans

un tableau de 100 éléments


Pour i variant de NT à 2 faire…

Donc, il est nécessaire de répéter (NT – 1) fois le corps de la boucle.

Nous avons un algorithme de complexité O(N) avec N qui est la taille des données.

Nous avons un algorithme itératif pour solutionner notre problème.

Est-ce le meilleur ?

Critère : temps opératoire donc nombre d'opérations à accomplir.

Jeu de l’urne

Peut-on trouver mieux ?


• Le mécanisme de tirage – remise est itératif.

• Y a-t-il une propriété dans ce mécanisme qui reste vraie à chaque tirage –remise et que nous pourrions utiliser pour trouver une meilleure solution ?

NV = NV – 2 ; NN = NN + 1

NV = NV ; NN = NN – 1

NV = NV ; NN = NN – 1

Jeu de l’urne


• Le mécanisme de tirage – remise est itératif.

• Y a-t-il une propriété dans ce mécanisme qui reste vraie à chaque tirage –remise et que nous pourrions utiliser pour trouver une meilleure solution ?

NV = NV – 2 ; NN = NN + 1

NV = NV ; NN = NN – 1

NV = NV ; NN = NN – 1

Jeu de l’urne

Paritéinchangée


Il y a 12 boules noires et 15 boules vertes.La dernière sera verte.

• La parité des boules vertes reste inchangée.

• Si le nombre initial de boules vertes est impair, la dernière boule sera verte,

• Sinon elle sera noire.

• S'il y a 12.345.679 boules noires et 20.150.202 boules vertes, la dernièreboule sera noire.

Jeu de l’urne


L'algorithme trouvé se transforme en un algorithme trivial

Si NV est pairalors la dernière boule est noiresinon elle est verte

Complexité de l'algorithme : indépendante de N.

Le traitement automatique fournit une solution en O(N),le traitement rationnel fournit une solution indépendante de N : O(1).

Jeu de l’urne

Conclusion: pour construire un bon algorithme, il faut raisonner !


Informatique : science du traitement automatique et rationnel de l’information en tant que support des connaissances et des communications.

Algorithme : ensemble de règles opératoires dont l'application permet de résoudre un problème énoncé au moyen d'un nombre fini d'opérations.

Contrainte pour l'énoncé des règles opératoires : la machine utilisée ne peut accomplir qu'une tâche à la fois de manière séquentielle.

Algorithmes


Boucle post-testée (do {…} while (…)) FAIRE …… TANQUE Répéter (corps de la boucle) jusqu'à ce que (une condition est satisfaite)

Boucle pré-testée (while (…) {…}) TANQUE ….. FAIRETant que (une condition est satisfaite) faire

début (corps de la boucle) fin

Boucle définie (for (i = dc ; i<= fc; i ++) {…}) Pour i variant de dc à fc ….. FAIREPour (compteur) variant de (débcompt) jusque (fincompt) faire

début (corps de la boucle) fin

Sélection (if (…) {…} else {…}) SI …. ALORS ….. SINON …. FSISi (une condition est satisfaite)

alors (opération(s) à accomplir)sinon (opération(s) à accomplir)

Algorithmes


• Un Robot se déplace dans un domainerectangulaire de dimensions finies, divisé encases. Cet espace sera délimité par unefrontière.

• Les cases pourront être vides ou contenir untrésor.

• Le Robot sait réaliser quelques actionsélémentaires et faire quelques observationssur son environnement.

Le robot

Le Robot ne comprend que deux instructions de base:• Avancer : Le Robot avance dans sa direction d'une case. S'il se trouvait devant un

mur, le programme s'arrête et vous invective.• Pivoter à droite : Le Robot tourne d'un quart de tour vers la droite (ou, dans le

sens des aiguilles d'une montre).

http://jrobot.gforge.inria.fr/


Le Robot peut faire quelques tests sur son environnement afin de prendre desdécisions :

• Devant Mur : La case devant lui est-elle un mur ? La réponse est oui s'il setrouve devant un mur, non dans tous les autres cas.

• Devant Marque : La case devant lui est-elle marquée ? La réponse sera non s'ilse trouve devant une case non marquée ou devant un mur, oui dans le cascontraire.

• Sur Marque : Le Robot se trouve-t-il sur une case marquée ?• Devant Trésor : La case devant lui contient-elle un trésor ? La réponse

sera non s'il se trouve devant une case vide ou devant un mur, oui dans le cascontraire.

• Sur Trésor : Le Robot est-il sur le trésor ?

Le robot


Le robotInstructions de base :

Le robot est capable de gérer deux structures de contrôle :

• si ... alors ... sinon ...

• la boucle tant que ... faire ...

Les autres actions

• Marquer : Dépose une marque sur la case où se trouve le Robot. Si la case était déjà marquée, un message d'avertissement est affiché.

• Effacer marque : Enlève la marque sur la case où se trouve le Robot. Si la case n'était pas marquée, un message d'avertissement est affiché.


Le robot

Exercice : avancer de deux casesConditions initiales : • La position et la direction du robot sont aléatoires• La position du trésor n’est pas importante

But : Le robot doit avancer de deux cases dans la direction vers laquelle il regarde.

• Si vous avez trouvé la solution ci-dessus, exécutez-la de nombreuses fois,

Test :

• Pouvez-vous identifier quel est le problème ?

• vous finirez par tomber sur un cas où cela ne se passe pas bien.


But : Le robot doit avancer de deux cases tout droit (dans la direction vers laquelle il regarde).

Si un mur l’en empêche, il devra s’arrêter juste devant le mur.

Le robot




Le robot

Exercice : Le robot doit avancer jusqu’au mur devant lui et s’y arrêter.

Conditions initiales : • La position et la direction du robot sont aléatoires• La position du trésor n’est pas importante


Le robot

o On peut demander à l’ordinateur de répéter des instructions. o On lui fournit également une condition qui lui permet de savoir s’il doit continuer

ou non cette tâche répétitive.






Le robot






• Le Robot est n'importe où sur le terrain, orienté vers le nord.Aller jusqu'au coin nord-est.

Le robot


Procédures



Procédures

Même code

• L’algorithme devient répétitif caril contient du code dupliqué



Procédure : Jusque Mur

Procédures

• On peut créer une procédure pour rendre le code plus lisible.


• On peut créer une procédure pour rendre le code plus lisible.

Procédure : Jusque Mur

Procédures


• Une procédure (on dira aussi module, fonction ou méthode) : est uneportion d’algorithme auquel on a donné un nom et qui peut être « utilisé »(appelé) dans d’autres algorithmes.

• Lorsque le robot rencontre une procédure, il exécute toutes les instructionsde cette procédure puis revient continuer l’algorithme là où il a étéinterrompu.

Procédures


But : Le robot doit avancer jusqu’au mur devant lui, faire demi-tour et revenir à sa position de départ.

Conditions initiales• La position et la direction du robot sont

aléatoires• La position du trésor n’est pas importante

Le robot


Procédures :

• Dans ce genre de problèmes on estsouvent amené à demander au robot defaire demi-tour.

• À la lecture de l’algorithme, il n’apparaitpas clairement qu’on demande au robotd’effectuer un demi-tour.

Le robot

Procédure

Demi-tour


Le robot

• Le Robot est sur le bord sud, orienté vers le nord. Faire le tour du terraindans le sens des aiguilles d'une montre et revenir à sa case de départ.


Le robot

• Le Robot est sur le bord sud,orienté vers le nord. Faire le tourdu terrain dans le sens des aiguillesd'une montre et revenir à sa casede départ.


Le robot

• Le Robot est sur le bord sud,orienté vers le nord. Faire le tourdu terrain dans le sens des aiguillesd'une montre et revenir à sa casede départ.


Le robot

1. Le Robot se trouve sur le bord Ouest, orientévers le nord. Le trésor se trouve sur le bordouest. Dirigez le robot vers le trésor.

2. Le Robot se trouve sur le bord Ouest. Le trésorest soit sur le bord Ouest soit sur le bord Nord.Dirigez le robot vers le trésor


Le robot


Solution incomplète : le robotpeut arriver jusque mur sanstrouver le trésor car il l’alaissé derrière lui.


Le robot


Solution complète


Le robot

• Le Robot se trouve dans le coin sud-ouest, orienté vers le nord. Le trésor setrouve sur un bord du terrain. Aller jusqu'au trésor.


Le robot

• Le Robot se trouve dans lecoin sud-ouest, orienté versle nord. Le trésor se trouvesur un bord du terrain. Allerjusqu'au trésor.

Solution 01


Le robot

• Le Robot se trouve dans lecoin sud-ouest, orienté versle nord. Le trésor se trouvesur un bord du terrain. Allerjusqu'au trésor.

Solution 02


Le robot

• Le Robot se trouve n'importe où dans le terrain. Placez le dans un coin.

• Le Robot se trouve dans le coin sud-ouest. On ne connaît pas son orientation.Orientez le vers le nord.


Le robot

• Le Robot se trouve dans le coin sud-ouest. On ne connaît pas sonorientation. Orientez le vers lenord.


• Le robot est n’importe ou orienté vers le nord. Aller jusqu'au coinnord-est et retour.

Le robot


Le drapeau tricolore (Dijkstra)

• On dispose de N cellules colorées (B, W, R), indexées de 0 à N-1.

• Il convient de les regrouper par couleur en utilisant le même support de stockage.

• Problème : trier les cellules par ordre "croissant".• Contrainte : même support de stockage

• Solution : ?


• Mémoriser le résultat de la comparaison dans la même structure de stockage, soit :

• Si R (rouge) et (W ou B) alors permuterSinon passer à la cellule suivante

• Si W (blanc) et B (bleu) alors permuterSinon passer à la cellule suivante

• Si B (bleu) alors passer à la cellule suivante


• Regarder successivement, à partir des 2 premières, les cellules et les comparer 2 à 2.

• Répéter ces opérations jusqu'à ce que toutes les cellules soient triées.



Tant que (drapeau non trié) fairedébut

parcourir drapeau;

permuter deux cellules si nécessaire;

fin



Tant que (drapeau non trié) fairedébut

parcourir drapeau;

permuter deux cellules si nécessaire;

fin

Tant que (drapeau non trié) faire

début

commencer au début du drapeau;

Pour i variant de 0 à N – 2 faire

si cellule [i] ">" cellule [i+1]

alors permuter cellules;

/*la cellule la plus "grande" est à la fin*/

fin

Problème : drapeau non trié ? Comment le savoir ?



répéterpermutation = FALSE;commencer au début du drapeau;



alors

début

permuter cellules;

permutation = TRUE;

fin

jusqu'à ce que (not permutation)

Trié ? Lorsqu'il n'y a plus de permutation lors d'un parcours


Ou : jusqu'à ce que (permutation == FALSE)


répéterpermutation = FALSE;commencer au début du drapeau;



alors

début

permuter cellules;

permutation = TRUE;

fin

jusqu'à ce que (not permutation)

Trié ? Lorsqu'il n'y a plus de permutation lors d'un parcours


C’est le principe du tri à bulles


• Complexité de l'algorithme (tri à bulles – bubble sort)

• répétercommencer au début du drapeau;

…

• jusqu'à ce que …

• Boucle à répéter (N – 1) fois (dans la plus mauvaise situation)

• Pour i variant de 0 à N – 2 faire …

• Boucle à accomplir (N – 1) fois

• Complexité : O(N²) Proportionnel à N² permutations



Tri à bulle


4 3 2 1

3 4 2 1

3 2 4 1

3 2 1 4

2 3 1 4

2 1 3 4

2 1 3 4

1 2 3 4

1 2 3 4

1 2 3 4

1 2 3 4

Tri à bulle


4 3 2 1

3 4 2 1

3 2 4 1

3 2 1 4

2 3 1 4

2 1 3 4

2 1 3 4

1 2 3 4

1 2 3 4

1 2 3 4

1 2 3 4

Tri à bulle


4 3 2 1

3 4 2 1

3 2 4 1

3 2 1 4

2 3 1 4

2 1 3 4

2 1 3 4

1 2 3 4

1 2 3 4

1 2 3 4

1 2 3 4

Tri à bulle


4 3 2 1

3 4 2 1

3 2 4 1

3 2 1 4

2 3 1 4

2 1 3 4

2 1 3 4

1 2 3 4

1 2 3 4

1 2 3 4

1 2 3 4

Tri à bulle


4 3 2 1

3 4 2 1

3 2 4 1

3 2 1 4

2 3 1 4

2 1 3 4

2 1 3 4

1 2 3 4

1 2 3 4

1 2 3 4

1 2 3 4

Tri à bulle


4 3 2 1

3 4 2 1

3 2 4 1

3 2 1 4

2 3 1 4

2 1 3 4

2 1 3 4

1 2 3 4

1 2 3 4

1 2 3 4

1 2 3 4

Tri à bulle


4 3 2 1

3 4 2 1

3 2 4 1

3 2 1 4

2 3 1 4

2 1 3 4

2 1 3 4

1 2 3 4

1 2 3 4

1 2 3 4

1 2 3 4

Tri à bulle


4 3 2 1

3 4 2 1

3 2 4 1

3 2 1 4

2 3 1 4

2 1 3 4

2 1 3 4

1 2 3 4

1 2 3 4

1 2 3 4

O (N²)

1 2 3 4

Tri à bulle


4 3 2 1

3 4 2 1

3 2 4 1

3 2 1 4

2 3 1 4

2 1 3 4

2 1 3 4

1 2 3 4

1 2 3 4

1 2 3 4

O (N²)

1 2 3 4

O (N)

Tri à bulle


Algorithme du tri à bulle












Tri par sélection

• L'idée du tri par sélection consiste à chaque étape à rechercher le plus petit

élément non encore trié et à le placer à la suite des éléments déjà triés.


void PRINT_MIN(int tab[], int const taille){int i, min;

min = ?;

for (i = 0; i < taille ; ++i){

if (tab[i] < tab[min]){

min = i;}

}cout << " le Minimum est : " << tab[min] <<endl;

}

Recherche du Minimum


void PRINT_MIN(int tab[], int const taille){int i, min;

min = 0;

for (i = 1; i < taille ; ++i){

if (tab[i] < tab[min]){

min = i;}

}cout << " le Minimum est : " << tab[min] <<endl;

}

Recherche du Minimum


void triSelection(int tab[], int const taille){int i, min, j;

for (i = 0; i < taille - 1; ++i){

min = i;for (j = i + 1; j < taille; ++j){

if (tab[j] < tab[min]){

min = j;}

}if (min != i){

std::swap(tab[i], tab[min]); }

}}

Tri par sélection


void triSelection(int tab[], int const taille){int i, min, j;

for (i = 0; i < taille - 1; ++i){

min = i;for (j = i + 1; j < taille; ++j){

if (tab[j] < tab[min]){

min = j;}

}if (min != i){

échanger(tab[i], tab[min]); }

}}

Tri par sélection


Tri insertion

Principe : trier les éléments du tableau comme avec des cartes

• On prend nos cartes mélangées dans notre main.

• On crée deux ensembles de carte, l’un correspond à l’ensemble des cartes triées, l’autre contient l’ensemble des cartes restantes (non triées).

• On prend au fur et à mesure, une carte dans l’ensemble non trié et on l’insère à sa bonne place dans l’ensemble des cartes triées.

• On répète cette opération tant qu’il y a des cartes dans l’ensemble non trié.


void tri_insertion(int tab[], int n){int i, j;double elementInsere;

for (i = 1; i < n; i++) {/* Stockage de la valeur en i */elementInsere = tab[i];

/* Décale les éléments situés avant tab[i] vers la droitejusqu'à trouver la position d'insertion */

for (j = i; j > 0 && tab[j - 1] > elementInsere; j--){

tab[j] = tab[j - 1];}

/* Insertion de la valeur stockée à la place vacante */tab[j] = elementInsere;}

}

Tri insertion


L'algorithme de tri en tas (Heap sort) a une complexité en

O (N log N).

C'est le mieux que l'on puisse obtenir.

• Lorsque l'on recherche le meilleur algorithme, on vise d'abord un algorithme en O(N) puisqu'il faut au moins regarder une fois toutes les données.

• Cependant, comme dans le jeu de l'urne, si les données ont des propriétés intéressantes, on peut viser une complexité moindre.

Complexité


• La solution est obtenue avec trois zones (B, W, R).

Zone B commençant en 0 Zone W commençant en 10 Zone R commençant en 20

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

• Quelle propriété utiliser ?



• La solution est obtenue avec trois zones (B, W, R).

• Au début, ces trois zones n'existent pas. Il n'existe qu'une zone de cellules non classées

• A chaque itération, regardons la première cellule de la zone à classer et plaçons-la dans la zone de sa couleur.

Zone B commençant en 0 Zone W commençant en 10 Zone R commençant en 20

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

Zone à classer (AC) commençant en 0

• Quelle propriété utiliser ?


• Si nous agissons de la sorte, à chaque itération, la zone à classer se réduit de uneunité et les zones classées grandissent avec les cellules de couleur appropriée.


Soient ZW = 0 (début de la zone des blanches)

ZR = 0 (début de la zone des rouges)

ZAC = 0 (début de la zone à classer)

• Après quelques itérations, on a :

Si c'est une blanchealors

débutPermuter cellule [ZAC] et cellule [ZR]ZAC = ZAC + 1ZR = ZR + 1

fin

ZW = 4 ZR = 7 ZAC = 10

0 1 2 3 4 5 6 7 8 9 10 11

ZW = ZR = ZAC = 0




fin


Soient ZW = 0 (début de la zone des blanches)

ZR = 0 (début de la zone des rouges)

ZAC = 0 (début de la zone à classer)

• Après quelques itérations, on a :



fin

ZW = ZR = ZAC = 0


ZW = 4 ZR = 8 ZAC = 11

0 1 2 3 4 5 6 7 8 9 10 11



fin


ZW = 4 ZR = 8 ZAC = 11

0 1 2 3 4 5 6 7 8 9 10 11

On obtient :


Si c'est une rougealors

ZAC = ZAC + 1



ZW = 4 ZR = 8 ZAC = 13

0 1 2 3 4 5 6 7 8 9 10 11 12 13

Si c'est une rougealors

ZAC = ZAC + 1

2 itérations plus loin,


Si c'est une bleuealors

débutPermuter cellule [ZAC] et cellule [ZR]Permuter cellule [ZR] et cellule [ZW] ZAC = ZAC + 1ZR = ZR + 1ZW = ZW + 1

fin

ZW = 4 ZR = 8 ZAC = 13

0 1 2 3 4 5 6 7 8 9 10 11 12 13

Le drapeau tricolore (Dijkstra)On obtient :


• 2 itérations plus loin,



fin


ZW = 5 ZR = 9 ZAC = 14

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14



fin


( Pour ZAC variant de 0 à N-1 faire )début

Si c'est une rougealors ZAC = ZAC + 1;sinon Si c'est une blanche

alors débutPermuter cellule [ZAC] et cellule [ZR]ZAC = ZAC + 1ZR = ZR + 1

fin;sinon /*c'est donc une bleue*/


fin;fin



répéterSi c'est une rougealors ZAC = ZAC + 1;sinon Si c'est une blanche

alors débutPermuter cellule [ZAC] et cellule [ZR]ZAC = ZAC + 1ZR = ZR + 1

fin;sinon /*c'est donc une bleue*/


fin;jusqu'à ce que ZAC = N



• Complexité de l'algorithme

Combien de permutations ?

Rouge: 0 permutation * NR (nombre de cellules rouges)

White : 1 permutation * NW (nombre de cellules blanches)

Bleue : 2 permutations * NB (nombre de cellules bleues)

Total : NW + 2 * NB

Si NR == NW == NB == N/3, alors N permutations.

Complexité : O(N) au lieu de O(N²) pour le tri à bulles.

Peut-on améliorer ?

Complexité


• Les bleues sont très pénalisantes. Pourquoi ?

ZW = 4 ZR = 8 ZAC = 13

0 1 2 3 4 5 6 7 8 9 10 11 12 13

Nous devons amener des cellules dans des zones à partir de la zone à classer. Comment réduire la "distance à parcourir" ?

En plaçant la zone à classer au centre des autres zones,

ZW = 4 ZAC = 8 ZR = 25

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29



ZW = 4 ZAC = 8 ZR = 25

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

Si c'est une bleue, une permutation :

ZW = 5 ZAC = 9 ZR = 25

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

Si c'est une blanche, pas de permutation :

ZW = 5 ZAC = 10 ZR = 25

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

Si c'est une rouge, une permutation :

ZW = 5 ZAC = 10 ZR = 24

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29


141

Soient ZW = 0 (début de la zone des blanches)ZR = N (début de la zone des rouges)ZAC = 0 (début de la zone à classer)

répéterSi c'est une rougealors début

Permuter cellule [ZAC] et cellule [ZR - 1]ZR = ZR - 1

fin;sinon Si c'est une blanche

alors ZAC = ZAC + 1sinon /*c'est donc une bleue*/

débutPermuter cellule [ZAC] et cellule [ZW]ZAC = ZAC + 1ZW = ZW + 1

fin;jusqu'à ce que ZAC = ZR



• Complexité de l'algorithme

Rouge : 1 permutation * NR (nombre de cellules rouges)White : 0 permutation * NW (nombre de cellules blanches)Bleue : 1 permutation * NB (nombre de cellules bleues)Total : NR + NBSi NR == NW == NB == N/3, alors 2*N / 3 permutations.En moyenne, le second algorithme est meilleur que le premier.

Le premier algorithme est-il parfois meilleur ?Peut-on avoir :

NW + 2NB < NR + NB, soitNW + NB < NR, soitNW + NB + NR (== N) < 2NR ?

Oui, si plus de la moitié des cellules sont rouges (en effet, dans le premier algorithme, il n'y a pas de permutation pour les rouges)



Permuter cellule [ZAC] et cellule [ZR - 1]

interm = cellule [ZAC];cellule [ZAC] = cellule [ZR - 1];cellule [ZR - 1] = interm;

Permuter cellule [ZAC] et cellule [ZW]

interm = cellule [ZAC];cellule [ZAC] = cellule [ZW];cellule [ZW] = interm;

Séquentialité des opérations

Procédures et fonctions


Plutôt que permuter deux éléments d'un tableau, permutons deux éléments quelconques que nous appelons

elemdepart et elemarrivee


• A quelques lignes d'intervalle, nous réécrivons alors le même ensemble d'instructions. Donc on peut utiliser des procédures

eleminter = cellule [inddepart];cellule [inddepart] = cellule [indarrivee];cellule [indarrivee] = eleminter;

• Soyons encore plus général.


eleminter = elemdepart;elemdepart = elemarrivee;elemarrivee = eleminter;

• Cet ensemble d'instructions réalise une permutation quels que soient le type des éléments à permuter

• et peut être utilisé pour autant que l'on donne des valeurs et un endroit de mémorisation à ces éléments.


• Nous obtenons alors :


Procédure permutation (eleminter, elemdepart, elemarrivee)

débuteleminter = elemdepart;elemdepart = elemarrivee;elemarrivee = eleminter

fin

• La procédure décrite peut être "appelée" par un programme

• Ce programme pourra l'exécuter s'il fournit les paramètres définisdans l'en-tête de la procédure.



répéterSi c'est une rouge

alors débutpermutation (interm, cellule [ZAC], cellule [ZR - 1])ZR = ZR – 1

fin;sinon

Si c'est une blanchealors ZAC = ZAC + 1sinon /*c'est donc une bleue*/

débutpermutation (interm, cellule [ZAC], cellule [ZW])

ZAC = ZAC + 1ZW = ZW + 1




Définition de la procédure

Procedure permutation (eleminter, elemdepart, elemarrivee)début


fin

Appel de la procédure

permutation (interm, cellule [ZAC], cellule [ZR - 1]);Le programme appelant met :interm dans elemintercellule [ZAC] dans elemdepartcellule [ZR - 1] dans elemarrivee

(pour autant que les types correspondants soient identiques)




3. Les résultats doivent alors être renvoyés vers le programme appelant.

• Quels résultats ?• Uniquement les résultats utiles !

• Dans notre exemple, eleminter n'est pas utile.

1. Le programme appelant envoie des données dans la procédure.

2. La procédure réalise le traitement sur les données reçues.


• Procedure permutation (eleminter, &elemdepart, &elemarrivee)

&elemdepart : signifie que la valeur obtenue pour elemdepart à la fin de la procédure doit être retournée dans la zone de mémorisation d'où provenait elemdepart, soit cellule [ZAC]


• On écrira alors


• La variable eleminter n'est utile que dans la procédure.• Définissons-la uniquement dans celle-ci. C'est une variable locale.

Procedure permutation (type &elemdepart, type &elemarrivee)début

type eleminter;


fin

• Il reste à préciser la mémorisation des données, donc leurs types, pour que la définition de la procédure soit complète.

• On écrira alors :

Procedure permutation (type eleminter, type &elemdepart, type &elemarrivee)



répéterSi c'est une rouge

alors débutpermutation (cellule [ZAC], cellule [ZR - 1])ZR = ZR – 1

fin;sinon

Si c'est une blanchealors ZAC = ZAC + 1sinon /*c'est donc une bleue*/

débutpermutation (cellule [ZAC], cellule [ZW])ZAC = ZAC + 1ZW = ZW + 1




void nommodule (paramètres formels avec leurs types)

/*Spécification du traitement que le module décrit*/

{

... corps du module …

};

On appelle un module par son nom:

nommodule (paramètres actuels);


• Opération nouvelle : Procédure avec paramètres


type nommodule (paramètres formels avec leurs types)

/*Spécification du traitement que le module décrit*/

{

... corps du module …

return (valeur);

};


• Opération nouvelle : Fonction

On appelle un module par son nom:

resultat = nommodule (paramètres actuels);

/*resultat contient alors valeur*/


Passage de paramètres : exemple

void main(){

int resultat = 0;int param1 = 10;int param2 = 20;

calcul(param1, param2, resultat);cout <<"Résultat :« << resultat << endl;}

void calcul(int param1, int param2, int resultat){

resultat = param1 + param2;

}

Résultat : ?



void main(){



void calcul(int param1, int param2, int resultat){


}

Résultat : 0



void main(){

int var = 0;int p1 = 10;int p2 = 20;

calcul(p1, p2, var);cout <<"Résultat :« << var << endl;}

void calcul(int param1, int param2, int &resultat){


}

Résultat : ?



void main(){



void calcul(int param1, int param2, int &resultat){


}

Résultat : 30


Fonctions : exemple


Fonctions : exemple

void main(){

}


• Une procédure peut être "appelée" par un programme

• qui en obtiendra l'exécution s'il fournit des valeurs et des endroits de mémorisation des paramètres définis dans l'en-tête de la procédure.

Quel programme ?

Peu importe ! Y compris toute autre procédure, y compris la procédure elle-même.

On parle alors de procédure récursive.

Fonctions Récursives


int factorielle (int N)

/*Calcule la factorielle N pour tout entier N > 0*/

{

if N == 1

{ return (1); }

else { return (N * factorielle (N-1) ); };

};

factorielle (N) = N * factorielle (N-1)

Vrai pour tout N > 1 et factorielle (1) = 1



factorielle (3)



factorielle (3)

if 3 == 1

{ ...

else { return ( 3 * factorielle (2) ); };



factorielle (3)

if 3 == 1

{ ...


if 2 == 1

{ ...




factorielle (3)

if 3 == 1

{ ...


if 2 == 1

{ ...


if 1 == 1

{ return (1); }

else ...



1

factorielle (3)

if 3 == 1

{ ...


if 2 == 1

{ ...


if 1 == 1

{ return (1); }

else ...



2

1

factorielle (3)

if 3 == 1

{ ...


if 2 == 1

{ ...


if 1 == 1

{ return (1); }

else ...



6

1

factorielle (3)

if 3 == 1

{ ...


if 2 == 1

{ ...


if 1 == 1

{ return (1); }

else ...


2


• Un algorithme qui s’appelle lui-même est un algorithme récursif

• Conditions pour un algorithme récursif

– S’appeler soi-même

– Les paramètres actuels doivent se simplifier à chaque appel

– Une sortie de secours pour laquelle il n’y a plus d’appel récursif



• Inverser les lettres d’un mot

• ôter la première lettre;

inverser le reste du mot;

ajouter la lettre ôtée;


• Exemple 02 :


void inverser (séquence)

/*inverse la séquence donnée de lettres*/

{

if ( séquence ne contient qu'une lettre )

{ l'écrire; }

else

{ ôter la première lettre de la séquence;

inverser (reste de la séquence);

ajouter la lettre ôtée;

};

};


• Exemple 02 :


inverser "star";


inverser "star";if "star" contient une lettre

{ ... }else {ôter "s";

inverser "tar";if "tar" contient une lettre

{ ... }else {ôter "t";

inverser "ar";if "ar" contient une lettre

{ ... }else {ôter "a";

inverser "r";if "r" contient une lettre

{ l'écrire;} relse {... };










ajouter "a"; }; ra










ajouter "t"; }; rat

ajouter "a"; }; ra










ajouter "s"; }; rats

ajouter "t"; }; rat

ajouter "a"; }; ra




• La tour de Hanoï

– Un anneau à la fois

– Un anneau ne peut être sur un plus petit que lui

Tour de Hanoï


• La tour de Hanoï

– Un anneau à la fois

– Un anneau ne peut être sur un plus petit que lui

Tour de Hanoï


0

1

2

3

4

5

6

7


Tour de Hanoï


Tour de Hanoï


Tour de Hanoï

N-1


Tour de Hanoï

1


Tour de Hanoï

N-1


Tour de Hanoï


Principe de résolution

• transférer les 63 disques supérieurs de A à C

• déplacer le disque inférieur de A à B

• transférer les 63 disques de C à B

pour 63, 62, 61, ..., 1. D’où la formulation générale :

• transférer N-1 disques du départ sur l'intermédiaire

• déplacer 1 disque du départ sur l'arrivée

• transférer N-1 disques de l'intermédiaire sur l'arrivée

Tour de Hanoï


• Complexité de l’algorithme

– Lorsque N == 64, 2 appels avec N == 63, 4 appels avec N == 62, ...,

264 - 1 exécutions de l'algorithme.

– Il y a donc 264 - 1 déplacements à effectuer

– Si les prêtres déplacent un disque par seconde sans jamais faire une erreur, le temps nécessaire au transfert total devra être de l'ordre de

600 000 000 000 d'années !

– On peut prouver qu'il n'existe aucun algorithme plus rapide.

Tour de Hanoï





Tour de Hanoï





Tour de Hanoï






Tour de Hanoï







600 000 000 000 d'années !

Tour de Hanoï







600 000 000 000 d'années !


Tour de Hanoï


void deplacertour (int N, depart, arrivee, intermediaire)

/* déplace une tour de N disques du départ à l'arrivée en utilisant sicela est nécessaire l'intermédiaire */

{

if ( N == 1 )

{ déplacer un disque du départ vers l'arrivée; }

else {

deplacertour (N-1, depart, intermediaire, arrivee);

déplacer 1 disque du départ sur l'arrivée;

deplacertour (N-1, intermediaire, arrivee, depart);

};

};

Tour de Hanoï







600 000 000 000 d'années !


Tour de Hanoï


Représentation de l’information


• Outils de l'algorithmique

o Boucles

o Sélection

o Séquence

• Méthodes algorithmiques

o Itération

o Modularité (Procédure et fonction)

o Récursivité

• Données de base

o Codage

o Mémorisation

o Opérations autorisées

• Accessibilité des données

o Structuration

o Sauvegarde



• Comment représenter l'information dans la machine?

• Types de base

• Types structurées

• Comment l'organiser au mieux pour les traitements?




Système binaire

201

• Le système binaire exprime n’importe quelle valeur en utilisant uniquement deux symboles : {0 , 1}

10

3210123

2

10

0123

2

)625,14(2*12*02*12*02*12*12*1(1110,101)

)14(2*02*12*12*1(1110)

=++++++=

=+++=

−−−

• Un nombre dans la base 2 peut être écrit aussi sous la forme polynomial :

( 1101)2La base

Un bit

( 1 1 0 1)2

Le bits du poids forts Le bits du poids faible


= 13

202

Codage Binaire

• Sur un seul bit : 0 , 1

Décimal Binaire

0

1

2

3

00

01

10

11

• Sur 3 Bits

Décimal Binaire

0

1

2

3

4

5

6

7

000

001

010

011

100

101

110

111

• Sur 2 bits :

4 combinaisons = 22

8 combinaisons = 23

Valeurs : de 0 .. 23-1 c.a.d de 0 à 7• Sur 8 Bits : 28 combinaisons Valeurs : de 0 .. 28-1 c.a.d de 0 à 255


Conversion de la base 10 à la base 2

35 2

171 2

81

2

40 2

20 2

0 1 2

1 0

Exemple 1 : (35)10=(?)2

Le principe consiste à faire des divisions successives du nombre sur 2 , et prendre le reste des divisions dans l’ordre inverse.

Après division : on obtient : (35)10=(100011)2


Conversion de la base 10 à la base 2

0,71875 x 2 = 1 , 4375

0, 4375 x 2 = 0 , 875

0, 875 x 2 = 1 , 75

0, 75 x 2 = 1 , 50

0, 50 x 2 = 1 , 00

( 0, 1 0 1 1 1) 2

205

Conversion d’une base X à la base 10

• Conversion est assez simple

• Il suffit de faire le développement en polynôme du nombre dans labase X , et de faire la somme par la suite.

10

101

5

10

3210123

2

10

012012

16

10

0123

2

)4,23(4,03205*25*35*4)2,43(

)625,13(2*12*02*12*12*02*12*1(1101,101)

)423(716025616*716*1016*116*716*16*1(1A7)

)13(2*12*02*12*1(1101)

=++=++=

=++++++=

=++=++=++=

=+++=

−

−−−

A

Exemple :


Représentation des entiers signés

• Bit de signe

Représentation signe-magnitude:

• Le bit de poids fort indique le signe (0 si positif et 1 si négatif) et les bits restants la valeur du nombre.

• Avec n bits on peut représenter des entiers entre: -(2n-1-1) et +(2n-1-1)

Exemple avec n=4

• Deux représentations sont possibles pour zéro


Valeurs négatives : le complément à 2

= Complément à 1 + 1

= inversion des bits + 1

Exemple :

▪(-1)10 = 1 + compl(1)

▪= 1 + compl(000000012)

▪= 1 + 111111102

▪= 111111112 = (-1)2


Exemple

|N| = 0 0 1 0 1 1 0 0

1 1 0 1 0 0 1 1

+ 1

Cà2(N) = 1 1 0 1 0 1 0 0

CA2(-44) =


Exemple


Le complément à 2 su 3 bits

0 1 1

0 1 0

0 0 1

0 0 0

1 1 1

1 1 0

1 0 1

1 0 0

= + 3

= + 2

= + 1

= 0

= - 1

= - 2

= - 3

= - 4

Bit de signe

• Sur 3 bits : 23 combinaisons (positives et négatives)

Valeurs : de -22 à 22-1


Le complément à 2 sur 8 bits

Type char


• Les réels sont codés en binaire par la représentation dite en virgule flottante

• En simple précision : codage sur 4 octets , formé de gauche à droite de :

• Signe: 1 bit• Exposant: 8 bits• Mantisse: 23 bits

Représentation en virgule flottante


• La norme IEEE 754 sur 32 bits

1,mantisse * 2 exposant

12,5 = +1,1001*23 Forme normalisée

0 100 0001 0 100 1000 0000 0000 0000 0000

12,5 =(41480000)IEEE 754

Codage de 3 par excès de 127

3+127 = 128+2

= 27+21

=(10000010)2

Codage en binaire

12,5 = 8 + 4 + 0,5

12,5 = 23 + 22 + 2-1

12,5 = (1100,1)2

4 81 04 0 0 0

-127 0 128

0 127 255

Représentation en virgule flottante


Types de données de base :

- int (entier)- float (réel)- double (réel) - char (caractère)- bool (booléen)

• Une variable appartenant à un de ces types peut valoir une des valeurs énumérées dans le type.

• Toute variable (une information utilisée dans une application) devra être définie par son type:

int ZAC ;bool permutation ;


217

Nom du type Ensemble de valeurs Nombre d’octets

char [-128 à 127] , [-27 .. 27-1] 1

unsigned char [0 à 255] , [0 .. 28-1] 1

short int [-32768.. 32767] , [-215 .. 215-1] 2

int [-2147483648.. 2147483647] , [-2 31 .. 231-1] 4

float Réel double simple précision[-3,4 10-38 .. 3,4 10-38]

4

double Réel double double précision[-1,7 10-308 .. 1,7 10-308]

8

boolean True ou False 1

Codage binaire : types de bases


Les nouveaux multiples : unités de stockage

1 kilo 2^{10} octets = 1 024 octets. 1unité = 1 octet

1 méga 2^{20}= 1024 * 1024 = 1 048 576 unités

1 giga 2^{30}= 1024 * 1024 * 1024 = 1 073 741 824 unités

1 tera 2^{40}= 1024 * 1024 * 1024 * 1024 = 1 099 511 627 776 unités

1 peta 2^{50}= 1024 * etc… = 1 125 899 906 842 624 unités

1 exa 2^{60}= 1024* etc...= 1 152 921 504 606 846 976 unités

1 zetta 2^{70}= 1024* etc...= 1 180 591 620 717 411 303 424 unités

1 yotta 2^{80}= 1024* etc...= 1 208 925 819 614 629 174 706 176 unités


• Combien de bits vaut 1 téraoctet (en puissances de 2).

• Transformer en binaire en codage simple, les valeurs suivantes : 40 et 10,25

• Transformez en décimal : la valeur binaire 1001,11

• Quelle est la représentation de la valeur –27 en binaire sur 8 bits en complément à 2

• Quelle est la représentation sur 32 bit en virgule flottante de : −17.25

• Quelle est la valeur décimal du nombre binaire suivant qui représente un réel en virgule flottante :

1 10000000 01001000000000000000000

• Quelle est la différence entre un entier long et un entier court

• Sur combien de bits sont codés les réels en double précision et par quelle méthode ?

219

Exercices


Tableau (vecteur)TQ nom_tableau [dim]; /* dim est un entier */

/* TQ est un type */Tableau multidimensionnel

TQ nom_tableau [dim1] [dim2] ….[dimN]; /*dim1, …, dimN des entiers, TQ est un type quelconque*/

Exemple :

const int Nmax = 100;int Tab [100], MyTab[Nmax];

Tab définit une zone de mémorisation de 100 composantes

identifiées par leurs indices variant de 0 à 99, pouvant accueillir des entiers.

Types de données structurés

• Les tableaux regroupent des données homogènes, • Toutes les données sont du même type (TQ)

Tableaux :


Exemple :typedef unsigned int U__INT;


• Le mot clé typedef permet de renommer ou de définir un type

Définir un nouveau type

char Vec[7]; // définition d’une variable Vec

typedef char Vecteur[7]; // définition d’un nouveau type Vecteur

Vecteur Vec;

0 1 2 3 4 5 6

int Ma_Matrice1[5][7];

typedef int Matrice[5][7];Matrice Ma_Matrice2;

0

1

2

3

4

0 1 2 3 4 5 6


Généralisations du type tableau par autorisation de types différents :

struct TS { TQ1 comp1 ;

TQ2 comp2 ;

...

TQN compN;

};struct TS T1, T2; // déclaration de variables

Dans une structure, les composantes peuvent être de types différents (TQ1, TQ2, …, TQN) et sont identifiées par leurs noms explicites (comp1, …, compN)

Types de données structurésStructures :

Définition du type "structure"


Généralisations du type tableau par autorisation de types différents :

struct TS { TQ1 comp1 ;

TQ2 comp2 ;

...

TQN compN;

};struct TS T1, T2; // déclaration de variables

typedef struct TS { TQ1 comp1 ;

TQ2 comp2 ;

...

TQN compN;

} NewType ;

NewType T1, T2; // déclaration de variables

Types de données structurésStructures :

Définition du type "structure"


typedef struct{string nom;string prenom e;int age;} Personne;


typedef struct TS {TQ1 comp1 ;

TQ2 comp2 ;

...

TQN compN;

} NewType ;

NewType T1, T2;

T1. comp1 = val1; T2. comp1 = val2

Personne P1, P2[10];

P1. nom = "Dupont"

P1. prenom = "Duront"

P1. age= 30;

P2[0]. nom = "Dupont"

P2[0]. prenom = "Duront"

P2[0]. age= 30;


semaine

L M M J V S D

fevrier2016

1 2 3 4 5 6 7

8 9 10 11 12 13 14

15 16 17 18 19 20 21

22 23 24 25 26 27 28

29

M M J V S D L

mars2016

1 2 3 4 5 6 7

8 9 10 11 12 13 14

15 16 17 18 19 20 21

22 23 24 25 26 27 28

29 30 31

Calendrier

Types de données structurésExemple :

Jours de la semaine:

Numéros du mois

Jours du mois

typedef struct Cal {Vecteur jour ;Matrice date ;int mois ;

} Calendrier ;

typedef struct Cal {char jour [7] ;int date[5][7];int mois ;

} Calendrier ;


semaine

L M M J V S D

fevrier2016

1 2 3 4 5 6 7

8 9 10 11 12 13 14

15 16 17 18 19 20 21

22 23 24 25 26 27 28

29

M M J V S D L

mars2016

1 2 3 4 5 6 7

8 9 10 11 12 13 14

15 16 17 18 19 20 21

22 23 24 25 26 27 28

29 30 31

Calendrier



Numéros du mois

Jours du mois


} Calendrier ;

typedef int Matrice[5][7];typedef char Vecteur[7];


semaine

L M M J V S D

fevrier2016

1 2 3 4 5 6 7

8 9 10 11 12 13 14

15 16 17 18 19 20 21

22 23 24 25 26 27 28

29

M M J V S D L

mars2016

1 2 3 4 5 6 7

8 9 10 11 12 13 14

15 16 17 18 19 20 21

22 23 24 25 26 27 28

29 30 31

Calendrier



Numéros du mois

Jours du mois


} Calendrier ;

typedef int Matrice[5][7];typedef char Vecteur[7];


mars

M M J V S D L 1 2 3 4 5 6 7 3

8 9 10 11 12 13 14

15 16 17 18 19 20 21

22 23 24 25 26 27 28

29 30 31

avril

V S D L M M J 1 2 3 4 5 6 7 4

8 9 10 11 12 13 14

15 16 17 18 19 20 21

22 23 24 25 26 27 28

29 30


Calendrier mars, avril ;typedef int Matrice[5][7];typedef char Vecteur[7];

typedef struct Cal{Vecteur jour;Matrice date;int mois;} Calendrier;

avril.mois = 4;

avril.jour[0] = ‘V’;

avril.date[0][0] = 1;

Calendrier An_2016 [12];An_2016[3] = avril;


Opération nouvelle : définition du type "suite"

Un fichier est un ensemble structuré d'informations stockées sur un support externe (disque dur, disque USB, CD-ROM, DVD, carte mémoire, etc.).

C'est une suite d'informations qui ne sont pas forcément du même type (char,int, struct, ...)

Dans les fichiers séquentiels, les enregistrements sont mémorisésconsécutivement dans l'ordre de leur entrée et peuvent seulement être lusdans cet ordre.

Si on a besoin d'un enregistrement précis dans un fichier séquentiel, il fautlire tous les enregistrements qui le précèdent en se déplaçant à partir dupremier.

Représentation de l’information : fichiers


Il existe deux types de fichiers :

Les fichiers textes : sont les fichiers dont le contenu représente uniquementune suite de caractères imprimables, d'espaces et de retours à la ligne(.txt,...). Ils peuvent être lus directement par un éditeur de texte.

Les fichiers binaires : sont les fichiers qui ne sont pas assimilables à desfichiers textes (.exe, .mp3, .png, ...). Ils ne peuvent pas être lus directementpar un éditeur de texte.



• L'accès à un fichier d'un support de stockage de masse (disque dur,disque optique,...) est coûteux : temps des transferts, mécaniquedétériorable,...

• Donc, il faut réduire le nombre d'accès ⇒ Utilisation d'une zonemémoire appelée



• L'accès à un fichier d'un support de stockage de masse (disque dur,disque optique,...) est coûteux : temps des transferts, mécaniquedétériorable,...

• Donc, il faut réduire le nombre d'accès ⇒ Utilisation d'une zonemémoire appelée : zone tampon (buffer)


• Ainsi, une instruction d'écriture (resp. lecture) dans le programme nese traduira pas immédiatement par une écriture (resp. lecture) sur ledisque mais par une écriture (resp. lecture) dans le buffer,

• avec écriture (resp. lecture) sur disque quand le buffer est plein (resp.vide).


Fichiers


Fichiers


Fichiers


Fichiers


Opérateurs :

Rewrite (sauve) définit sauve comme étant la suite vide, donc la suite de longueur 0. (On souhaite écrire dans le fichier à partir du début. On réécrira donc sur les données existantes si le fichier n'est pas vide)

Write (sauve, x) ajoute un élément de valeur x à la suite sauve. ( x est du type T0 et on écrit sa valeur dans le fichier)

Reset (sauve) positionne au début de la suite. (On souhaite lire le fichier à partir du début)

Read (sauve, x) affecte l'élément courant de la suite à la variable x et avance la position suivante de la suite. (x est du type T0 et on lit sa valeur dans le fichier)



En réalité, sauve est une variable dont la zone de stockage est en mémoire alors que l'on souhaite enregistrer ou lire sur un fichier c'est-à-dire une zone sur le disque dur.

Il convient de mettre en correspondance ces deux zones, d'assigner la variable logique du programme au fichier physique du disque dur:

Assign (variable logique, fichier physique);

Assign (sauve, "donnees.dat");



La zone de stockage en mémoire, appelée tampon ou buffer, doit être initialisée pour pouvoir accéder au fichier. C'est accompli avec une opération Open de la variable.

Open (sauve); (Reset ou Rewrite)

Chaque fois que le tampon est plein, un transfert automatique est réalisé vers le fichier.

Si en fin d'écriture, la tampon n'est pas plein, le transfert automatique n'est pas réalisé. Il faut l'imposer avec une opération Close de la variable.

Close (sauve);



• La classe ofstream permet d'écrire des données sur les fichiers,

• La classe ifstream permet de lire des données dans un fichier.

• Il est toujours important d'utiliser la fonction close() des objetsofstream ou ifstream qui sont créés, notamment pour libérer lesressources systèmes liées à ces objets et en particulier pour vider lamémoire tampon associée au flux sur le fichier.



ofstream sauve ("donnees.dat"); /* pour écrire*/ (≡ Assign)

sauve.open (); (≡ Rewrite)sauve << x; /*cout est toujours ouvert pour l'écran*/ (≡ Write)

sauve.close (); (≡ Close)

ifstream sauve ("donnees.dat"); /* pour lire*/ */ (≡ Assign)

sauve.open (); (≡ Reset)sauve >> x; /*cin est toujours ouvert pour le clavier*/ (≡ Read)

sauve.close (); (≡ Close)



• Modes d'ouverture

Pour pouvoir écrire à la fin d'un fichier, il faut le spécifier lors del'ouverture en ajoutant un deuxième paramètre à la création du flux :

ofstream monFlux (nomFichier.c_str(), ios::app);

app est un raccourci pour append, le verbe anglais qui signifie « ajouter à la fin »

Fichiers


Caractère par caractère, en utilisant get().

Lire ligne par ligne : récupérer une ligne entière et la stocker dans une chaîne de caractères.

Trois manières différentes de lire un fichier :

Lire mot par mot : >>

Fichiers


Recherche linéaire :

i = 0 ;

Tant que ( (i < N) ET ( a [i] ≠ x ) )

{ i = i + l ; };

Recherche d’un élément dans un vecteur

Attention à l'ordre de l'expression booléenne !


i = 0 ;

Tant que (( a [i] ≠ x ) ET (i < N) )

{ i = i + l ; };

Possible débordement de i (i peut être égale à N)



i = 0 ;

Tant que ( (i < N) ET ( a [i] ≠ x ) )

{ i = i + l ; };

• Remarque : avec la boucle « Pour … faire », on fait moins de tests, mais on va jusqu'au bout du tableau

• Complexité maximale: O (N)

• Complexité moyenne: O (N/2)

Recherche d’un élément dans un vecteur

Attention à l'ordre de l'expression booléenne !


Recherche dichotomique

(dans le cas où les éléments du tableau sont ordonnés)


• On prend un élément du vecteur au hasard et on le compare aunombre cherché.

1. S'il est plus petit, le nombre cherché est dans la partie gauche;

2. S'il est plus grand, il est dans la partie droite.


G = 0 ;

D = N-1 ;

trouve = FALSE ;

Tant que ( (G < D) ET ( NON trouve) )

début

m = toute valeur entre G et D ;

if ( a [m] = = x )

{ trouve = TRUE; }

else {

if ( a [m] < x )

{G = m + 1; }

else { D = m; };

}

fin

Recherche dichotomiqueRecherche de x ?


• Eliminer, à coup sûr, le maximum d'éléments à chaque étape

• Choisir l'élément au milieu du tableau restant à considérer

• Amélioration? On teste si a[m] == x ? à chaque étape alors que la condition n’est vérifiée au maximum qu'une fois

Choix de m ?



G = 0 ;

D = N-1 ;

trouve = FALSE ;

Tant que (G < D)

début

m = (G + D) div 2 ;

if ( a [m] < x )

{ G = m + 1; }

else { D = m; };

fin

if ( a [D] = = x )

{ trouve = TRUE; }



G devient-il égal à D ?

Oui car à chaque étape

• G croît pour être égal à m + 1 c'est-à-dire (le milieu de l'intervalle entre G et D) + 1 ou

• D décroît pour être égal à m c'est-à-dire le milieu de l'intervalle entre G et D (par division entière)

• L'algorithme se termine-t-il ?

Complexité: O (log2N) (<< N lorsque N est grand)



21

G D

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14

3 6 9 11 15 21 24 28 30 34 39 41 43 53 58

7

G D

0 1 2 3 4 5 6 7

3 6 9 11 15 21 24 28

3

G D

4 5 6 7

15 21 24 28

5

G D

4 5

15 21

4

GD

5

21


Valeur recherchée : 21


21

G D

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14

3 6 9 11 15 21 24 28 30 34 39 41 43 53 58

7

G D

0 1 2 3 4 5 6 7

3 6 9 11 15 21 24 28

3

G D

3 4 5 6 7

11 15 21 24 28

5

G D

3 4 5

11 15 21

4

G D

4 5

15 21

4

G D

4 5

15 21

Si G = mRecherche dichotomique

G ne se déplacera pas vers D


Si D = m -1

21

G D

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14

3 6 9 11 15 21 24 28 30 34 39 41 43 53 58

7

G D

0 1 2 3 4 5 6

3 6 9 11 15 21 24

3

G D

4 5 6

15 21 24

5

GD

4

15



N log2N N log2N N² Temps (µsec)

1 0,00 0,00 1 1 1 1 1

10 3,32 33,22 100 10 3,32 33,22 100

100 6,64 664,39 10000 100 6,64 664,39 10000

1000 9,97 9965,78 1000000 1000 9,97 9965,78 1 "

10000 13,29 132877,12 100000000 10000 13,29 132877,12 1 ' 40 "

100000 16,61 1660964,05 1,0E+10 100000 16,61 1,661 " 2 h 46 ' 40 "

1000000 19,93 19931568,57 1,0E+12 1 " 19,93 19,932 " 11 j 13 h 46 ' 40 "

50172



STRUCTURES DE DONNÉES DYNAMIQUES

1. Structures de données

• Allocation statique • Allocation dynamique• Arbres binaires










Types de mémoire

• les plus rapides : les registres qui forment des mémoires de quelques octets au plus en relation directe avec le processeur

• très rapides : les mémoires cache ou antémémoires du processeur(temps d'accès voisins de la nanoseconde)

• rapide : la mémoire centrale (temps d'accès décuplés)

• lentes : les disques magnétiques (temps d'accès voisins de la milliseconde) appelés aussi disques durs

• très lentes : les mémoires d'archivage (CD, bandes magnétiques) combinant stockage au moindre coût et sauvegarde permettant la remise d'un fichier dans son état antérieur (back-up).



Allocation de mémoire

• La mémoire dans un ordinateur est une succession d’octets (soit 8 bits), organisés les uns à la suite des autres et directement accessibles par une adresse.

• Les entités utilisées (variables, constantes, (sous-)programmes) par le programme source sont représentées en mémoire (RAM de l'ordinateur)


Allocation de mémoire

• La mémoire principale se divise en deux parties :

1. L’une est associée au système d’exploitation, toujours résidente en mémoire

2. L’autre destinée aux processus en cours d’exécution


Un processus, est un programme en cours d’exécution par un ordinateur.


Plusieurs emplacements dans la mémoire vive (segments)

• statique ou text : emplacement pour les programmes, sous-programmes

• Bss, data : emplacement pour les variables globales et les constantes

• tas ou heap : emplacement ou sont stockés des espaces mémoires alloués dynamiquement. La taille du tas varie en fonction de l'exécution du programme

• pile ou stack : emplacement ou sont stockées les variables locales et lesparamètres formels (paramètres d’appel ) des fonctions. La taille de la pile varie en fonction de l‘exécution du programme




• La pile (stack) est un espace mémoire réservé au stockage des variables désallouées automatiquement.

• La mémoire allouée dans le tas doit être désallouée explicitement.


Allocation statique

• Allocation de mémoire effectuée lors de l'exécution mais prévue lors de la compilation

• À chaque type de données correspond une taille mémoire et une façon de représenter l'information

• À chaque variable ou paramètre formel déclarés correspond un espace mémoire dont la taille est fonction du type

• Le compilateur ajoute donc automatiquement du code pour réserver de l'espace mémoire avant utilisation (au niveau de la déclaration) et pour libérer si besoin est (dans la pile)



Allocation dynamique

• Allocation de mémoire effectuée lors de l'exécution mais non prévue lors de la compilation

• Allocation qui se fait uniquement dans le tas

• Cette allocation est à la charge du programmeur,• Il lui faut donc :

• une procédure permettant de réserver une zone mémoire (allouer())

• une procédure permettant de libérer une zone mémoire (liberer())

• une variable (et donc un type) permettant de référencer cette zone mémoire allouée



• Les structures de données de base sont statiques.

• Des structures de données dynamiques sont indispensables pour de nombreuses applications (lorsque l'on ne connaît pas à l'avance le nombre d'éléments dans la structure).

• Utilisons une structure récursive dont la définition du type utilise le type que l'on est en train de définir.


typedef int Tableau [100]; // création d’un nouveau type Tableau;Tableau MyTab; MyTab[0] = 5;

100 doit être spécifié au début du programme d’où la dimension statique !


type T = pointer to T0

T0 * T, exemple : int * T;

• Les valeurs du type T sont des pointeurs vers des données du type T0.

• En effet, les valeurs de type T sont des adresses mémoire où l'on peut trouver T0.

• Comme les valeurs sont variables, pour une même variable de ce type, on peut accéder à plusieurs endroits mémoire différents en cours d'exécution.

• On prend possession de l'adresse mémoire de type T0 souhaitée par le mécanisme d'allocation dynamique (new).




• On introduit la procédure new.

• Etant donnée une variable pointeur p de type T,l'instruction new (p) alloue effectivement une variable detype de données T0 et affecte le pointeur désignant cettevariable à p.

• On peut faire référence à la valeur pointeur elle-même parp (c'est-à-dire comme valeur de la variable pointeur p).Par contre, la variable à laquelle p fait référence estdésignée par (*p).



typedef struct Record Noeud;

struct Record{int cle;struct Record *suivant;...};

• (* définitions des types *)

typedef struct Record *Ptr;Ou typedef Noeud *Ptr;

• (* déclarations des variables *)

Ptr p, q;

• (* instructions *)

p = new Noeud;oup = new struct Record;


p est du type pointer vers T ( T*)

*p est du type T





Listes linéaires

p = new struct Record;

struct Record{int cle;struct Record *suivant;

};

typedef struct Record Noeud;

typedef Noeud *Ptr;

Ptr p, q;


p

p = new Record;

q ->suivant = p ;

p ->suivant = q ;

Listes linéairesInsertion en fin de liste

q

q = new Record;

P ->suivant = q ;


p

q

p = new Record;q = new Record;q ->suivant = p ; p = q ;

Listes linéairesInsertion en début de liste


Création d'une liste de n éléments

p = NULL ; {liste vide au début}

while (n > 0) {

q = new Record;

q->suivant = p ;

p = q ;

q->cle = n ;

n = n-1 ;

}

p

q

Listes linéaires

NULL


Listes linéaires

NULL


Exemple en C++


• Insertion dans une liste après p

q->suivant = p->suivant ;

p->suivant = q ;

Listes linéaires


Recherche d'un élément dans une liste

while ((p != NULL) & (p->cle != x)) p = p->suivant ;

Attention : l'ordre des conditions est essentiel !

Listes linéaires


Listes linéaires


Listes linéaires


290

Listes linéaires

Université de Mons FPMS-INFO | Faculté Polytechnique de Mons | UMONS291

Listes linéaires


Listes linéaires


293

Listes linéaires


294

Listes linéaires


295

Listes linéaires


296

Listes linéairesmain ()


297

( Implémentation d'une liste par tableau )

Procédure INSERER complexité: O (N)

Procédure SUPPRIMERcomplexité: O (N)

Listes linéaires


298

• Une pile (stack en anglais) est une liste dans laquelle l'insertion ou la suppression d'un élément s'effectue toujours à partir de la même extrémité de la liste, extrémité appelée le sommet de la pile.

• L'action consistant à ajouter un nouvel élément au sommet de la pile s'appelle empiler; celle consistant à retirer l'élément situé au sommet de la pile s'appelle dépiler.

• Une pile permet de modéliser un système régi par la discipline "dernier arrivé - premier sorti"; on dit souvent qu'il s'agit d'un traitement LIFO (last in, first out).

• La hauteur de la pile est son nombre d'éléments.

Piles


299

Opérations sur les piles

EMPILER (x, p)

DEPILER (p)

SOMMET (p)

VIDE (p)

RAZ (p)

…

Piles


300

Implémentation par tableau (p est un tableau, sommet est un entier)

PILEVIDE (p) sommet := LongMax + 1;SOMMET (p) p[sommet];EMPILER (x, p) sommet := sommet - 1; p[sommet] := x;DEPILER (p) sommet := sommet + 1;EST-PILEVIDE (p) sommet = LongMax + 1 ?

Piles


301

Implémentation par une liste chaînée

PILEVIDE (p: pile); crée une pile vide p.SOMMET (p: pile); renvoie l'élément au sommet

de la pile p (non vide).Idem premier d'une liste

EMPILER (x: element, p: pile); insère x au sommet de la pile p.Idem insérer (entête) d'une liste

DEPILER (p: pile); supprime l'élément au sommet de la pile p ( (non vide).Idem supprimer (entête) d'une liste

EST-PILEVIDE (p: pile): booléen; teste si la pile p est vide.

Piles


302

• Une file est une liste dans laquelle toutes les insertions de nouveaux éléments s'effectuent d'un même côté de la liste appelé fin et toutes les suppressions d'éléments s'effectuent toujours à partir de l'autre extrémité, appelée début.

• L'action consistant à ajouter un nouvel élément à la fin de la file s'appelle enfiler; celle consistant à retirer l'élément situé au début de la file s'appelle défiler.

• Une file permet de modéliser un système régi par la discipline "premier arrivé - premier sorti" (FIFO : first in, first out).

Files


303

Opérations sur une file

FILEVIDE (f: file); crée une file vide f.

TETE (f: file); renvoie l'élément en tête de la file f (non vide).

EMFILER (x: element, f: file); insère x à la fin de la file f.

DEFILER (f: file); supprime l'élément en tête de la file f (non vide).

EST-FILEVIDE (f: file): booléen; teste si la file f est vide.

Files


304

Implémentation par un tableau

• Si la file est représentée par un tableau f, on doit gérer deux indices tête et queue indiquant les cases de f entre lesquelles se trouvent toutes les données;

• la donnée devant sortir en premier figure dans la case d‘indice tête, tandis que la première case libre, c'est-à-dire la case dans laquelle on placera la prochaine donnée enfilée, est d‘indice queue + 1.

• Possibilité de gestion cyclique pour éviter le débordement (dans ce cas, queue devient plus petit que tête).

Files


305

Implémentation par une liste chaînée

Files


306

Une file circulaire est repérée par un pointeur sur sa dernière place (si la file est vide, le pointeur vaut null). La tête de la file est donc l’élément suivant, et peut être facilement supprimée; de même, l’insertion en fin de file se fait facilement.

Files


307

ARBRES

• Un arbre est une structure composée d'éléments appelés nœuds;

• Il est constitué d'un nœud particulier appelé racine et d'une suite ordonnée éventuellement vide A1, A2, …, Ap d'arbres appelés sous-arbres de la racine.

• Un arbre contient donc au moins un nœud : sa racine.

• Définition récursive !


308

Parcours d'arbre (procédures récursives)

Parcours préfixe de NLister NParcours préfixe des fils de N (de gauche à droite)

Parcours infixe de NParcours infixe du fils gauche de NLister NParcours infixe des autres fils de N

Parcours postfixe de NParcours postfixe des fils de N (de gauche à droite)Lister N

ARBRES


309

Parcours préfixe* + a b + a c (notation polonaise)

Parcours infixea + b * a + c (notation standard)

Parcours postfixea b + a c + * (notation polonaise inverse)

Parcours d’un arbre


310

Arbres binaires

• Un arbre binaire est soit vide, soit constitué d'un nœud particulier appelé racine et de deux sous-arbres binaires disjoints appelés sous-arbre gauche et sous-arbre droit.


311

• Un arbre binaire est dit complet si tout nœud interne a exactement deux fils.

• Un arbre binaire est dit parfait si, en appelant h la hauteur de l'arbre, les niveaux de profondeur 0, 1, …, h - 1 sont complètement remplis alors que le niveau de profondeur h est rempli en partant de la gauche; la structure d'un arbre binaire parfait est complètement déterminée par son nombre de nœuds.

Arbres binaires


312

• Un arbre binaire est dit équilibré si, pour tout nœud de l'arbre, les sous-arbres gauche et droit ont des hauteurs qui diffèrent au plus de 1.

• Un arbre binaire parfait est équilibré. On peut démontrer que la hauteur h d'un arbre binaire équilibré ayant n nœuds vérifie : log2(n + 1) ≤ h ≤ 1,44 log2(n + 2).

• On notera donc que la profondeur moyenne des nœuds d'un arbre binaire équilibré est en O (log2n).


313

Arbres tournois

• Un tas est un arbre tournoi parfait.

• Un arbre tournoi est un arbre binaire dont les sommets sont munis d’une clé, et tel que pour tout sommet autre que la racine, la clé du sommet est plus grande (petite) que celle de son père. En d’autres termes, les clés sur un chemin (dé)croissent de la racine vers une feuille.

Arbre tournoi Tas


314

Implémentation d'un arbre général par tableau


315

Implémentation d'un arbre général par pointeurs


316

Implémentation d'un tas par tableau

Tableau a avec n = 9

1 3 2 6 9 5 4 8 7

Indices du tableau

1 2 3 4 5 6 7 8 9

EST-ARBREVIDE n = 0 ? ARBREVIDE n = 0RACINE 1 DERNIERE-FEUILLE nPERE (p) p div 2FILS-GAUCHE (p) 2p FILS-DROIT (p) 2p + 1EST-FEUILLE p > n div 2 (n div 2 : l’indice du père de la dernière feuille)

CREER-FEUILLE (x, a) n = n + 1; a[n] = xSUPPRIMER-FEUILLE n = n – 1CONTENU (p) a[p]


Insertion dans un tas


318

Rangement du plus grand


Complexité


Ajout d’un nœud dans un tas


Construction d’un tas

Illustration de ConstruireTas(scan [Cormen et al., 1994])


Tri tas

Illustration de TrisTas

(scan [Cormen et al.,

1994])


323

TRI TAS


324


325


326

Complexité: O (n log2 n) !


Fin de la matière à prendre en compte pour l’examen


328

Un ordinateur actuel comporte trois composants essentiels:

l'unité centrale de traitement (UCT), qui fait les opérations de base;

la mémoire qui contient :• l'algorithme spécifiant les opérations à exécuter;• l'information, ou les données, à partir desquelles les

opérations agissent;

les dispositifs d'entrée et de sortie (dispositifs E/S) grâce auxquelsl'algorithme et les données entrent en mémoire et l'ordinateurcommunique les résultats.

Architecture de l'ordinateur


329

Collecteur

Emetteur

Collecteur Base Emetteur

Silicium

n

np

Isolant en bioxyde de

silicium

Conducteur en aluminium

Base

Transistor


330

Porte AND

Entrées

Sortie

Portes OR et NOT de manière similaire.

Toutes les opérations logiques sont donc réalisables.


331

Additionneur

0+0=0, retenue 00+1=1, retenue 01+0=1, retenue 01+1=0, retenue 1

La retenue n'est nécessaire que lorsque les deux chiffres sont 1. La porte AND réalise cela.

La somme de deux chiffres est égale à 1 si et seulement si un chiffre est 1 et l'autre 0. C'est obtenu par (premier chiffre AND NOT second chiffre) OR (second chiffre AND NOT premier chiffre).


332

• En combinant des additionneurs, on réalise la somme des nombres binaires.

• On peut alors effectuer les opérations de soustraction, de multiplication et de division de manière similaire.

• A l'aide de transistors, combinés en portes, assemblées en composants, il est donc possible de réaliser toutes les opérations logiques et arithmétiques sur les nombres binaires.

Additionneur


333

Mémoires

Un transistor laisse passer un courant ou non.

Une bascule est un ensemble de transistors qui conserve un courant ou non tant qu'on ne change pas son état.C'est donc un composant qui conserve (mémorise) une information élémentaire (un bit) tant qu'une tension électrique alimente l'équipement.

Un ensemble (par exemple 64) de bascules constitue une cellule mémoire qui permet de mémoriser un mot d'information tant que l'ordinateur est sous tension. Chaque cellule mémoire est repérée et répertoriée par un numéro, son adresse.


334

Bus des données

• Il permet de transmettre les informations dans les deux sens entre la mémoire et l'additionneur.

• Un bus de données est à la base un assemblage de fils qui connectent les différents composants entre eux. Le nombre de fils correspond généralement à la taille du mot du processeur.

• Puisqu'un bus de données ne peut transférer qu'un mot de données à la fois, il faut nécessairement déterminer quels sont les composants autorisés à utiliser les bus à tout moment. Cela peut être effectué en connectant chaque composant au bus par l'intermédiaire d'une porte ET dont l'autre entrée est un signal de contrôle qui ne libère le mot de données que si le bus est libre.


335

L'horloge et l'unité de commande

• Les signaux de contrôle émanent du composant "unité de commande" qui a pour fonction de réaliser le transfert de composant à composant des données qui conviennent au moment voulu, et de s'assurer que les opérations correctes sur les données sont effectuées. (accès au bus, changement de l'état d'une bascule, …)

• L'horloge, élément de l'unité de commande, produit des signaux à intervalles réguliers. Ces signaux sont utilisés par l'unité de commande pour s'assurer que tous les composants de l'ordinateur fonctionnent en synchronisation les uns avec les autres, et que chaque composant dispose d'un temps suffisant pour mener son opération à terme.

• La fréquence de l'horloge est donc une bonne mesure de la rapidité de calcul d'un processeur.


336

Système d’exploitation


337

Exécution des algorithmes par un ordinateur

• Pas de méthode simple pour entrer un programme dans la mémoire de l'ordinateur.

• Entrées/sorties (E/S) difficiles à utiliser car fonctions des périphériques.

• Pas de méthode simple pour qu'un programme ou ses données dépasse la capacité de la mémoire.

• Une tâche seule occupe généralement très peu le processeur.

• L'ordinateur est programmé en langage machine, inapproprié pour les tâches de programmation.


338

Logiciels de base ou programmes système

Le système d’exploitation qui a trois fonctions :• gère les caractéristiques matérielles des composants de l’ordinateur,

• aide à la manipulation des programmes et des données,

• permet le partage de l'ordinateur entre plusieurs utilisateurs, de manière simultanée.

Les traducteurs de langage traduisent des programmes écrits en langages évolués (Pascal, C, C++, ...) dans le langage machine de l'ordinateur concerné.

Les éditeurs permettent de modifier des programmes, des fichiers de données, ...

Les chargeurs s’occupent de l’installation des programmes dans la mémoire centrale.


339

Traducteurs de langages

Traduit en langage machine des programmes écrits en langage évolué. Le résultat est traité par un interpréteur microprogrammé qui génère les signaux de commande pour l'exécution.

Deux sortes d'entités à traduire:

▪ Les instructions en langage évolué qui en nécessiteront beaucoup en langage machine.

▪ Les structures de données qui doivent être représentées sous forme de bits, de nombres et d'adresses.


340

Interpréteur

Fonctionnement

• lire une instruction du programme évolué;• l'exécuter;• passer à l'instruction suivante; etc.

Avantages • la traduction n’est pas conservée en mémoire• la détection d’erreur est facilitée

Désavantages• traductions multiples• lenteur d’exécution du programme


341

Compilateur

Fonctionnementlire et traduire tout le programme évoluéle mémoriserl'exécuter

Avantages• La traduction est enregistrée (programme objet)• rapidité d’exécution du programme

Désavantages• besoin de mémoire pour la mémorisation• détection d’erreurs plus difficile


342

Système d’exploitation

Le système d exploitation a trois fonctions :

1. gère les caractéristiques matérielles des composants de l’ordinateur grâce à des programmes dédicacés,

2. aide à la manipulation des programmes et des données par des programmes de commande,

3. permet le partage de l'ordinateur entre plusieurs utilisateurs, de manière simultanée, grâce à la multiprogrammation.


343


344

• Pour la multiprogrammation, il faut

• La distribution qui fait passer le processeur d’une tâche à l'autre

• La gestion des interruptions pour interrompre une tâche en cours

• L’affectation des ressources aux tâches selon les besoins

• La protection des ressources contre les accès non autorisés

• La planification des tâches selon les priorités


345

Distributeur

Les tâches (processus) sont dans l’un des trois états suivants:

• En cours d'exécution: le processus est exécuté par l’UCT.

• Prêt: le processus est exécutable et attend que l’UCT lui soit affectée.

• Bloqué: le processus attend quelque chose (un résultat, la fin d'un transfert E/S, ...)


346


347

• Pour partager le processeur entre tous les processus, on alloue un quantum de temps à chacun (50 ms) à tour de rôle et selon les priorités. Remarque: en 50 ms, un processus peut accomplir de très nombreuses instructions.

• Lorsque le quantum est écoulé, le processus en cours est stoppé, sauvegardé en mémoire et attend que ce soit de nouveau son tour.

• Ce système est appelé time sharing (temps partagé)

Distributeur


348

Le distributeur est normalement appelé dans les circonstances suivantes :

• un processus en cours d'exécution demande un transfert E/S ou une ressource; il devient bloqué;

• le quantum d'un processus en cours d'exécution expire, indiquant que l'UCT doit être affectée à un autre processus;

• l'exécution d'un processus se termine.

En réalité, à chacun de ces évènements, un signal d'interruption est envoyé au processeur qui met en œuvre le gestionnaire d'interruption. Celui-ci analyse l'interruption, fait ce qui doit être fait et appelle le distributeur.

Distributeur


349

Gestion de la mémoire

Trois aspects fondamentaux:

1. Affectation: pour qu'un processus soit exécuté il doit lui être affecté une mémoire suffisante pour stocker son programme et ses données.

2. Protection: il est important qu'aucun processus ne puisse avoir accès à une partie quelconque de mémoire qui ne lui soit pas affectée.

3. Utilisation: l'affecter au mieux avec des processus prêts à être exécutés.


350

• Le système d'exploitation doit être libre d'affecter à un processus n'importe quelle partie de la mémoire actuellement disponible.

• Mais comment un compilateur peut-il générer des adresses exactes alors qu'il ignore quelle zone mémoire le programme objet occupera pendant l'exécution?

• Pour cela, distinguer adresses du programme générées par un traducteur de langage et adresses mémoire des cellules dans lesquelles le programme objet doit par la suite résider.

• Le traducteur de langage suppose que la totalité de la mémoire est disponible, et génère des adresses de programme partant de zéro: ces adresses doivent alors être transformées en adresses mémoire correspondantes pour la zone de mémoire affectée au programme objet par le système d'exploitation.



351

Les registres de base et de limite

• Le registre de base contient l'adresse de la première cellule mémoire affectée au processus.

• Le registre de limite ou registre de longueur, fixée par le système d'exploitation et correspondant au nombre de cellules mémoire affectées au processus en cours d'exécution.



352


353

La pagination

• Technique de gestion de la mémoire qui permet à un processus d'être exécuté quand seul un segment du programme et des données réside en mémoire centrale.

• Le programme et les données de chaque processus sont divisés en un certain nombre de pages de taille identique, et la mémoire est elle-même divisée en un nombre de structures de page d'égale grandeur.

• Chaque structure de page peut contenir une page d'un processus.

• Les structures de page sont affectées par le système d'exploitation, de sorte qu'à tout moment chaque processus ait quelques pages occupant les structures de page de la mémoire, pendant que le reste est conservé en mémoire auxiliaire.


354

L'UCT transforme une adresse programme en une adresse mémoire

• en calculant, à partir de l'adresse programme, quelle page et quelle cellule dans la page sont désignées; et

• en utilisant les informations gardées par le système d'exploitation pour déterminer quelle structure la page occupe actuellement.

La pagination


355

La pagination


356

• La pagination donne l'illusion d'une mémoire virtuelle plus grande que la mémoire disponible.

• La protection de la mémoire contre des accès non autorisés est garantie par l'utilisation d'une table de pages séparée pour chaque processus.

• Le système d'exploitation doit choisir les pages à enlever pour placer les pages dont les processus ont besoin.

La pagination

Documents

Structure de données et algorithmes Introduction