Structure de données et algorithmes Introduction · 2019-05-09 · anglais) ou unité de taitement...

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. Architecture des ordinateurs

4. Codage de l’information

5. Structure de données

6. Architecture des ordinateurs

7. Systèmes d’exploitation

8. 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.


4

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


5

• 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 ...)

• 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 ...

• Systèmes d’information, ingénierie des connaissances ...• 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 …

• 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

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


11


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 1 + D État 2

État 2 Vide G État 3

État 2 + 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.


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)


18

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 Kottke pré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

26

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 ou d’un ensemble de problèmes de même type contenant des opérations bien définies 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, Java, C++, . . .). Ce type de langage est appelé langage de programmation.


29

Jeu de l'urne

• 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


30

• 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


31

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


32

• 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


33

• 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


34

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


35

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


36

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


37

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).


38

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 ! …


39

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


40

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


41

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


42

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


43

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’urne


44

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


45

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


46

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 par secondes,

• 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


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.

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


53

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

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

début (corps de la boucle) fin

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

début (corps de la boucle) fin

Sélection (if (…) {…} else {…})Si (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, vous finirez par tomber sur un cas où cela ne se passe pas bien. Pouvez-vous identifier quel est le problème ?

Test :


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

Exercice : Le robot doit avancer jusqu’au mur devant lui ets’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

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

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 est n'importe où sur le terrain, orienté vers le nord. Aller jusqu'au coin

nord-est.

Le robot



nord-est.

Procédures

• L’algorithme devient répétitifcar il contient du code dupliqué



nord-est.

Procédures

Même code

• L’algorithme devient répétitifcar il contient du code dupliqué


• 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 une portiond’algorithme auquel on a donné un nom et qui peut être « utilisé » (appelé) dansd’autres algorithmes.

• Lorsque le robot rencontre un nom de procédure, il exécute toutes les instructionsde cette procédure puis revient continuer le premier 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 (en tout casmoins clairement que si on trouvaitexplicitement l’ordre « demi-tour »).

Le robot

Procédure


Le robot

• Le Robot est sur le bord sud,orienté ers le nord. Faire letour du terrain dans le sensdes aiguilles d'une montre etrevenir à sa case de départ.


Le robot



Le robot

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

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


Le robot




Le robot

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

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

• 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 est n’importe ou orienté vers lenord. Aller jusqu'au coin nord-est et retour.


76

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 : ?


77

• 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.


78


79

Tant que (drapeau non trié) fairedébut

parcourir drapeau;

permuter deux cellules si nécessaire;

fin



80

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 ?



81

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



82

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


83

• 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



84

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


85

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


86

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


87

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


88

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


89

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


90

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


91

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


92

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 du 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 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

Le principe du tri par insertion est de 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 de carte triée, 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 de carte triée.

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


void tri_insertion(double* t, int n){int i, j;double elementInsere;

for (i = 1; i < n; i++) {/* Stockage de la valeur en i */elementInsere = t[i];/* Décale les éléments situés avant t[i] vers la droitejusqu'à trouver la position d'insertion */for (j = i; j > 0 && t[j - 1] > elementInsere; j--)

{t[j] = t[j - 1];

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

}

Tri insertion


102

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é


103

• 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 ?



104

• 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-ladans 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.


105

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


106

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


107

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


108


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,


109

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 :


110

• 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


111

( 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



112

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



113

• 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é


114

• 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



115

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


116

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



117

• 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)



118

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


119

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.


120

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 :


121

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.



122

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




123

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)



124


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.

• La valeur obtenue dans la procédure ne doit pas "retourner" dans le programme appelant et la valeur interm du programme appelant peut rester inchangée.

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


126

• 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)



127

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




128

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


129

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(){



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


}

Résultat : ?



void main(){



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


}

Résultat : 30


134

• 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


135

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



136

factorielle (3)

if 3 == 1

{ ...

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



137

factorielle (3)



138

factorielle (3)

if 3 == 1

{ ...




139

factorielle (3)

if 3 == 1

{ ...


if 2 == 1

{ ...




140

factorielle (3)

if 3 == 1

{ ...


if 2 == 1

{ ...


if 1 == 1

{ return (1); }

else ...



141

1

factorielle (3)

if 3 == 1

{ ...


if 2 == 1

{ ...


if 1 == 1

{ return (1); }

else ...



142

2

1

factorielle (3)

if 3 == 1

{ ...


if 2 == 1

{ ...


if 1 == 1

{ return (1); }

else ...



143

6

2

1

factorielle (3)

if 3 == 1

{ ...


if 2 == 1

{ ...


if 1 == 1

{ return (1); }

else ...



144

• 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



145

• Inverser les lettres d’un mot

• ôter la première lettre;

inverser le reste du mot;

ajouter la lettre ôtée;


• Exemple 02 :


146

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 :


147

inverser "star";


148

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 {... };


149









ajouter "a"; }; ra


150









ajouter "a"; }; ra

ajouter "t"; }; rat


151









ajouter "a"; }; ra

ajouter "t"; }; rat

ajouter "s"; }; rats


152

• La tour de Hanoï

– Un anneau à la fois

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

Tour de Hanoï


153

• La tour de Hanoï

– Un anneau à la fois

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

Tour de Hanoï


154

0

1

2

3

4

5

6

7


155

Tour de Hanoï


156

Tour de Hanoï


Tour de Hanoï


161

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ï


162

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 sur 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ï


163

• 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ï


164

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

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

• Comment l'organiser au mieux pour les traitements?

Représentation de l’information


165

• 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


167

• Dans le système binaire, pour exprimer n’importe quelle valeur on utilise uniquement 2 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)2Le bits du poids forts Le bits du poids faible


168

Comptage en 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


169

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

170

Conversion d’une base X à la base 10

• Cette conversion est assez simple puisque il suffit de faire le développement en polynôme de ce nombre dans la base 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 :


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


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


175

Représentation décimale en 5 symboles (rang 0 à 4)

4 3 2 1 0

Poids des différents rangs = 10 exposant (rang)

signe 1000 100 10 1

Nombre décimal Valeur Max Min Nombre de valeurs

- 2 0 1 6 -2016 9999 -9999 19999

= 2*(10 exposant 4)-1

car + 0 = - 0

Représentation binaire en 8 bits (rangs 0 à 7)

7 6 5 4 3 2 1 0

Poids des différents rangs = 2 exposant (rang)

128 64 32 16 8 4 2 1

Nombre binaire Valeur Max Min Nombre de valeurs

0 0 1 0 1 0 0 0 40 255 0 256

= 2 exposant 8

Poids pour la représentation des entiers positifs et négatifs

signe 64 32 16 8 4 2 1

Entier en binaire

1 1 1 1 1 1 1 1 -127 127 -127 255

Poids pour la représentation en complément à 2

-128 64 32 16 8 4 2 1

Entier en binaire

0 1 1 0 0 0 0 0 96 127 -128 256


Codification des booléens:Vrai : 1Faux : 0 un seul bit suffit.

Selon l'information que l'on souhaite manipuler, il est donc essentielde choisir son type (typedef), ce qui induit :

• le code de représentation binaire approprié pour conserver cette information en mémoire d'ordinateur,

• l'interprétation de ce code pour établir la correspondance entre notre langage et la représentation informatique,

• les opérations autorisées sur l'information.• on n'additionne pas des booléens,• on ne met pas un réel dans un entier,• …



Les nouveaux multiples

1 kilo 2^{10}= 1 024 unités

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

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

Types de données de base :

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

• Une information d'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 ;



Toutes les données sont du même type (TQ)Tableau (vecteur)

TQ nom_tableau [dim]; /* dim est un entier *//* TQ est un type */

Tableau multidimensionnelTQ nom_tableau [dim1] [dim2] [dimN];

/*dim1, dim2, …, dimN sont des entiers, TQ est un type quelconque*/

Exemple :

int Tab [100];

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


180

Le type n'a pas d'existence physique. C'est la définition d'un ensemble de propriétés (code de représentation, interprétation de ce code, opérations autorisées).

char Vec [7]; (baptisé par typedef char Vec [7] Vecteur)

int Mat [5] [7]; (baptisé par typedef int Mat [5] [7] Matrice)

0 1 2 3 4 5 6

0

1

2

3

4

0 1 2 3 4 5 6


181

Opération nouvelle : déclaration de variable

• Toute entité manipulée par un programme doit être mémorisée.• La déclaration réalise cela.• La place nécessaire à cette mémorisation est définie par le type associé

à cette entité.

int ZAC;bool permutation;Vecteur semaine;Matrice fevrier2016, mars2016;



182

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

typedef TQ Tab [dim] T ;Dans un tableau, toutes les composantes doivent être du même type TQ et sont identifiées par leurs indices prenant leurs valeurs de 0 à (dim – 1).

Généralisons en autorisant des types différents:typedef struct TS { TQ1 comp1 ;

TQ2 comp2 ;

...

TQN compN;

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



183

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


184

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

} Calendrier ;



185

Calendrier mars, avril;

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



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


194

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)



195

En fait, 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");



196

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.



198

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


200

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



212


213


214


215


216


217


218


219

Somme des angles d'un polygone régulier à N côtés :

180° ( N – 2)

D'où un angle et sa moitié

D'où sinus et cosinus de cet angle

D'où aire d'un petit triangle

D'où aire totale


220

Nb côtés S. angles Angle 1/2 angle Aire 1/2 tri. Aire Précision

3 180 60,000 30,000 0,217 1,29904 58,650333%

4 360 90,000 45,000 0,250 2,00000 36,338023%

5 540 108,000 54,000 0,238 2,37764 24,317327%

6 720 120,000 60,000 0,217 2,59808 17,300666%

7 900 128,571 64,286 0,195 2,73641 12,897358%

9 1260 140,000 70,000 0,161 2,89254 7,927457%

12 1800 150,000 75,000 0,125 3,00000 4,507034%

24 3960 165,000 82,500 0,065 3,10583 1,138407%

30 5040 168,000 84,000 0,052 3,11868 0,729480%

36 6120 170,000 85,000 0,043 3,12567 0,506923%

60 10440 174,000 87,000 0,026 3,13585 0,182670%

1000 179640 179,640 89,820 0,002 3,1415720 0,000658%

10000 1799640 179,964 89,982 0,000 3,1415924 0,000007%

100000 17999640 179,996 89,998 0,000 3,1415926515 0,000000%

1000000 179999640 180,000 90,000 0,000 3,141592653618 0,000000%

PI 3,141592653590


221

Somme des angles d'un polygone régulier à N côtés :

180° ( N – 2)

D'où un angle et sa moitié

D'où cosinus de cet angle

D'où côté d'un petit triangle

D'où circonférence totale


222

Nb côtés S. angles Angle 1/2 angle Côté Circonférence Précision

3 180 60,000 30,000 1,732 5,19615 17,300666%

4 360 90,000 45,000 1,414 5,65685 9,968368%

5 540 108,000 54,000 1,176 5,87785 6,451072%

6 720 120,000 60,000 1,000 6,00000 4,507034%

7 900 128,571 64,286 0,868 6,07437 3,323361%

9 1260 140,000 70,000 0,684 6,15636 2,018446%

12 1800 150,000 75,000 0,518 6,21166 1,138407%

24 3960 165,000 82,500 0,261 6,26526 0,285334%

30 5040 168,000 84,000 0,209 6,27171 0,182670%

36 6120 170,000 85,000 0,174 6,27521 0,126876%

60 10440 174,000 87,000 0,105 6,28031 0,045686%

1000 179640 179,640 89,820 0,006 6,28317 0,000164%

10000 1799640 179,964 89,982 0,001 6,28318520 0,000002%

100000 17999640 179,996 89,998 0,000 6,28318530618 0,000000%

1000000 179999640 180,000 90,000 0,000 6,28318530727 0,000000%

Circonférence 6,28318530718


223

Nb côtés Circonférence Précision Aire Précision

3 5,19615 17,300666% 1,29904 58,650333%

4 5,65685 9,968368% 2,00000 36,338023%

5 5,87785 6,451072% 2,37764 24,317327%

6 6,00000 4,507034% 2,59808 17,300666%

7 6,07437 3,323361% 2,73641 12,897358%

9 6,15636 2,018446% 2,89254 7,927457%

12 6,21166 1,138407% 3,00000 4,507034%

24 6,26526 0,285334% 3,10583 1,138407%

30 6,27171 0,182670% 3,11868 0,729480%

36 6,27521 0,126876% 3,12567 0,506923%

60 6,28031 0,045686% 3,13585 0,182670%

1000 6,28317 0,000164% 3,1415720 0,000658%

10000 6,28318520 0,000002% 3,1415924 0,000007%

100000 6,28318530618 0,000000% 3,1415926515 0,000000%

1000000 6,28318530727 0,000000% 3,14159265362 0,000000%

6,28318530718 3,14159265359


PI = 3.141592653589793238512808959406186204433


Tri fusion


228

STRUCTURES DE DONNÉES DYNAMIQUES

1. Structures de données

• Allocation statique • Allocation dynamique• Arbres binaires


237

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).


238


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)


239

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.


240

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



241


• 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.


242

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)



243

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



244

• 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 !


245

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).



246


• 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).


247


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;


248

p est du type pointer vers T ( T*)

*p est du type T



249



250

Listes linéaires

p = new struct Record;

struct Record{int cle;struct Record *suivant;

};

typedef struct Record Noeud;

typedef Noeud *Ptr;

Ptr p, q;


251

p

q

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

Listes linéaires


252

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

p = new Record;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


253

Listes linéaires

NULL


254

Exemple en C++


255

• Insertion dans une liste après p

q->suivant = p->suivant ;

p->suivant = q ;

Listes linéaires


256

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


257

Listes linéaires


258

Listes linéaires


259

Listes linéaires


260

Listes linéaires


261

Listes linéaires


262

Listes linéaires


263

Listes linéaires


264

Listes linéaires


265

Listes linéairesmain ()


266

( Implémentation d'une liste par tableau )

Procédure INSERER complexité: O (N)

Procédure SUPPRIMERcomplexité: O (N)

Listes linéaires


267

• 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


268

Opérations sur les piles

EMPILER (x, p)

DEPILER (p)

SOMMET (p)

VIDE (p)

RAZ (p)

…

Piles


269

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


270

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


271

• 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


272

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


273

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


274

Implémentation par une liste chaînée

Files


275

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


276

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 !


277

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


278

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


279

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.


280

• 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


281

• 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).


282

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


283

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


284

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


285

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 2CREER-FEUILLE (x, a) n = n + 1; a[n] = xSUPPRIMER-FEUILLE n = n – 1CONTENU (p) a[p]


286

Insertion dans un tas


287

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])


292

TRI TAS


293


294


295

Complexité: O (n log2 n) !


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


297

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


298

Collecteur

Emetteur

Collecteur Base Emetteur

Silicium

n

np

Isolant en bioxyde de

silicium

Conducteur en aluminium

Base

Transistor


299

Porte AND

Entrées

Sortie

Portes OR et NOT de manière similaire.

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


300

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).


301

• 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


302

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.


303

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.


304

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.


305

Système d’exploitation


306

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.


307

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.


308

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.


309

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


310

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


311

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.


312


313

• 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


314

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, ...)


315


316

• 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


317

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


318

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.


319

• 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.



320

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.



321


322

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.


323

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


324

La pagination


325

• 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

Structure de données et algorithmes Introduction · 2019-05-09 · anglais) ou unité de taitement...

Documents

Transcript of Structure de données et algorithmes Introduction · 2019-05-09 · anglais) ou unité de taitement...