Ce cours concerne les arbres, structure de données organisant les données de manière hiérarchique dans de nœuds reliés entre eux par une relation parent-enfant. Le cours présente les arbres généraux et ensuite les arbres binaires, où chaque nœud possède 0 ou 2 enfants. Enfin, le cours termine en présentant des algorithmes de recherche et en particulier l'arbre binaire de recherche.
Ce premier cours présente les notions d'objet et de classe, et le lien entre elles. Il présente aussi le premier concept clé de la programmation orientée objet, à savoir l'encapsulation des données. Les exemples sont fournis dans plusieurs langages (Python, C#, Java, C++ et PHP).
Objectif général : Acquérir les connaissances nécessaires à la programmation avec le langage Python
Objectifs opérationnels :
- Mémoriser des données primitives
- Traiter des données
- Communiquer avec l’extérieur
- Contrôler le flux d’exécution des instructions
- Mémoriser des données composites
- Découper et réutiliser du code
Ce cours présente la programmation fonctionnelle et montre comment il est possible de programmer avec ce paradigme en utilisant Python. La première partie présente la notion d'objet de type fonction, les fonctions lambda, le type callable et les closures. La deuxième partie présente les décorateur et montre comment ajouter du comportement à une fonction à l'aide d'un décorateur. La troisième partie présente les itérateurs et les générateurs qui, grâce à l'instruction yield, génère les données à la demande.
Ce premier cours présente les notions d'objet et de classe, et le lien entre elles. Il présente aussi le premier concept clé de la programmation orientée objet, à savoir l'encapsulation des données. Les exemples sont fournis dans plusieurs langages (Python, C#, Java, C++ et PHP).
Objectif général : Acquérir les connaissances nécessaires à la programmation avec le langage Python
Objectifs opérationnels :
- Mémoriser des données primitives
- Traiter des données
- Communiquer avec l’extérieur
- Contrôler le flux d’exécution des instructions
- Mémoriser des données composites
- Découper et réutiliser du code
Ce cours présente la programmation fonctionnelle et montre comment il est possible de programmer avec ce paradigme en utilisant Python. La première partie présente la notion d'objet de type fonction, les fonctions lambda, le type callable et les closures. La deuxième partie présente les décorateur et montre comment ajouter du comportement à une fonction à l'aide d'un décorateur. La troisième partie présente les itérateurs et les générateurs qui, grâce à l'instruction yield, génère les données à la demande.
Dans ce cours, on découvre comment lire et écrire des fichiers à l'aide de Python. Il est possible de créer des fichiers texte ou des fichiers binaires. Pour manipuler un fichier, il faut d'abord l'ouvrir, puis on peut faire les opérations et enfin on doit le refermer.
Ce cours présente la notion d'héritage entre classes qui permet de construire une relation de type "is-a". On crée une sous-classe à partir d'une super-classe, pour en hériter une partie de ses membres. On peut ensuite y ajouter des membres spécifiques. Ce cours présente également la redéfinition de méthodes, et comment utiliser les modificateurs de visibilité des membres.
Ce cours présente comment définir de nouveaux objets en définissant des classes. Un objet est une instance d'une classe qui définit les variables d'instances (attributs) et méthodes (fonctionnalités) que les objets créés à partir de la classe auront.
Dans ce cours, on découvre comment construire une interface graphique en Python en utilisant la librairie Tk. Après avoir vu les différents composants de base, ce cours présente la programmation évènementielle qui permet d'écrire du code qui réagit à des évènements comme le clic sur un bouton, par exemple.
Ce cours introduit à la notion de type abstrait de données (TAD). On commence par y découvrir les principes de complexité temporelle et spatiale permettant d'analyser les performances d'une structure de données et d'algorithmes. Ensuite, le cours présente plusieurs TAD : la pile, la file, le deque et le vecteur. Enfin, il présente comment implémenter des TAD avec des structures chainées.
Ce cours présente les relations de composition et d'agrégation qu'il est possible d'établir entre plusieurs classes et objets. La seconde partie présente la notion d'immuabilité d'objets et montre comment faire des copies d'objets.
Ce cours introduit aux trois langages de programmation du Web que sont l'HTML, le CSS et le Javascript. L'HTML est un langage de balisage qui permet de décrire un document et sa structure. Le CSS est un langage qui permet de définir des règles de style à appliquer à un document. Enfin, Javascript est un langage permettant d'ajouter un aspect dynamique à une page web.
Ce cours présente la notion de système d'exploitation et en particulier les Linux embarqués qui sont spécialement conçus pour des systèmes embarqués de haut niveau avec des processeurs à usage général (GPP) comme unité de calcul principale. Il explique ensuite comment Linux embarqué démarre, quelles sont les différentes phases et modalités de stockage du système d'exploitation. Enfin, il présente la BeagleBone Black, ses caractéristiques et comment la programmer. Le cours conclut en expliquant la notion de driver de périphérique et comment ils sont conçus sous Linux à l'aide de fichiers.
Ce cours présente la notion de qualité de code et comment il est possible de l'évaluer grâce à des métriques mesurables. Après avoir présenté plusieurs métriques standards, il se concentrer sur des aspects de qualité de code spécifique à l'orienté objet et présente les cinq concepts de l'orienté objet. La deuxième partie du cours présente plusieurs bonnes pratiques à avoir en programmation orientée objet, sur base d'exemples concrets.
Introduction à la partie technique de la formation Digitalent mise en place par l'équipe ECAM. Cette formation couvre l'impression 3D, la programmation et l'électronique embarquée.
Ce cours est le premier en lien avec l'algorithmique présente les algorithmes et fonctions récursives ainsi que le type abstrait de données arbre. La première partie revient sur les notions de problème, algorithhme et spécification. La deuxième partie présente la récursion et de nombreux exemples. Enfin, la troisième partie présente le type abstrait de données arbre qui permet d'organiser des données de manière hiérarchique. Le cours se termine avec une introduction aux notions de backtracking et lookahead.
Ce cours concerne le polymorphisme, c'est-à-dire la capacité pour une variable de prendre plusieurs types de donnée durant le temps de sa vie. Le cours présente aussi la notion de classe abstraite et d'interface qui est une classe abstraite pure.
Cette présentation concerne la mesure des distances entre la Terre et les étoiles. Elle présente notamment la technique du l'écho radar et celle de la parallaxe.
Git est un logiciel de gestion de versions décentralisé qui vous permettra de gérer la vie d'un code informatique. Il permet une stratégie de backup, de gérer des versions et de stocker tout l'historique des modifications apportées à un projet informatique.
Cette présentation concerne le développement piloté par les tests (TDD, Test-Driven Development). Cette méthodologie se base sur des tests unitaires qui testent de manière indépendante des unités de code (module, procédure/fonction, classe...). En particulier, cette présentation utilise la librairie CUnit utilisée pour le langage C.
Ce cours présente comment réaliser des interfaces graphiques avec Python en utilisant la librairie Kivy. La première partie rappelle les principes de la programmation évènementielle puis présente la séparation interface/comportement à l'aide de fichiers KV et Python. La deuxième partie présente comment réaliser des dessins avec les composants Canvas. On y voit comment dessiner des formes, appliquer des transformations et on termine avec un exemple de composants déplaçables.
Ce cours aborde la gestion d'erreurs en programmation, c'est-à-dire comment gérer les situations où une erreur se produit. Après avoir présenté le principe des spécifications et de la programmation défensive avec l'instruction assert, ce cours présente l'instruction try/except qui permet de capturer des erreurs. Enfin, le cours termine en présentant comment définir ses propres erreurs et les générer avec l'instruction raise.
Ce deuxième cours concerne les tuples, séquences non modifiables d'éléments. On peut les étendre en tuples nommés en ajoutant un nom à chacune des entrées du tuple, appelées alors champs. Enfin, on peut aller plus loin et définir des objets en associant des fonctions à des données. Cette seconde partie introduit à la programmation orientée objet.
Ce cours présente ce qu'est l'internet des objets (IoT), un réseau parallèle au web connectant entre eux des dispositifs physiques. Les différences majeures entre l'IoT et le web sont mises en avant, ainsi que les grands défis auxquels le monde de l'IoT est confronté. Le cours présente ensuite brièvement comment on peut gérer un système embarqué à distance, notamment pour la maintenance, le monitoring, le disaster recovery, notamment à l'aide d'un watchdog. Enfin, pour conclure, plusieurs architectures réseaux possibles sont présentées, pour inter-connecter des systèmes embarqués et les relier au web.
Ce cours présente la notion de système embarqué temps-réel et comment il est possible de gérer cela au niveau software avec un Linux embarqué. Plusieurs solutions sont présentées : OS temps-réel, linux préemptif et support hardware. Enfin, le cours présente le PRU-ICSS, dont est dotée la BeagleBone Black, une unité de calcul spécialisée pour les applications temps réel. Le cours présente comment programmer le PRU et notamment comment compiler un code à sa destination à l'aide d'un langage d'assemblage.
Ce cours présente les principaux moyens de communications que l'on peut déployer au sein d'un système embarqué. Après un rappel sur les différents types de communication (série/parallèle, synchrone/asynchrone, half-duplex/full-duplex), le cours présente le port série ainsi que l'implémentation UART. Vient ensuite le bus USB et les deux modes en hôte ou périphérique. Après cela, le cours présente les protocoles I2C et puis SPI. Enfin, il termine avec le simple bus 1-Wire. Tous ces différents moyens de communication sont disponibles sur la BeagleBone Black et le cours illustre comment les manipuler à l'aide du Linux embarqué.
Ce premier cours introduit la notion de système embarqué en commençant par en donner une définition. Il les caractérise ensuite sur base de plusieurs critères : type d'application, de fonction visé, taille, fiabilité, efficacité. Il présente ensuite plusieurs aspects hardware (unité de calcul, architecture matérielle, composants clés) et software (niveau de programmation, processus de développement). Enfin, il conclut en discutant sur ce qu'est un ingénieur en systèmes embarqués.
Présentation du projet de transmission numérique dans lequel les étudiants sont amenés, en équipes mixtes électroniciens - informaticiens, à développer une application qui, sur base de données collectées par des senseurs, propose une analyse de ces dernières pour fournir un service.
Cette conférence présente le framework Johnny-Five qui permet de programmer des cartes embarquées à l'aide d'un module Node.js. Après un tour rapide du JavaScript et de son fonctionnement, en particulier la programmation fonctionnelle et l'exécution pilotée par les évènements, la présentation décrit Node.js et aborde rapidement son fonctionnement. La troisième partie présente Johnny-Five et plusieurs exemples simples de contrôle d'une LED et de l'utilisation des entrées/sorties numériques et analogiques.
Cette conférence présente LaTeX, un outil permettant de réaliser des documents de haute qualité typographique et professionnelle. Après avoir présenté quelques règles de typographie de la langue française, la présentation fait découvrir les bases de LaTeX et montre comment réaliser son premier document. Elle présente ensuite plusieurs constructions de base comme les listes, l'inclusion d'images et de tableaux, les mathématiques, les listings de code source. Enfin, elle termine avec des constructions plus avancées, comme la notion de figure et références croisées.
Cette présentation montre plusieurs outils gratuits qui peuvent être utilisés pour gérer plusieurs aspects de la gestion de projets, en particulier informatique, de manière collaborative. On y voit comment versioner son code avec Git, déployer son code avec Heroku, tester son code avec Travis, gérer et planifier son temps et ses tâches avec Trello, FreedCamp et Tom'splanner, comment communiquer avec Slack et comment rédiger sa documentation avec Read the Docs.
Ce second cours d'algorithmique présente des techniques utilisées en intelligence artificielle pour trouver une solution à un problème de recherche. La première partie définit un problème de recherche : état, action, arbre d'exécution, espace d'états, cout, objectif et formalisation. La deuxième partie présente plusieurs algorithmes de recherche : non informé (BFS, UCS, DFS, DLS, ID-DFS, BS), informé (BFS, A*) et avec adversaire (Minimax, Alpha-Beta Pruning). Enfin, la troisième partie présente deux librairies Python qui implémentent des algorithmes de recherche.
Ce cours introduit à l'intelligence artificielle. La première partie du cours présente et définit ce qu'est l'intelligence et décrit les notions d'agent rationnel et d'environnement et leurs propriétés. Ces deux concepts permettent d'offrir un cadre de réflexion sur l'intelligence. La fin de la première partie présente les neufs formes d'intelligence selon Howard Gardner. La seconde partie du cours présente et définit l'intelligence artificielle, initiée par Marvin Minsky et John McCarthy au MIT. Elle présente également le test de Turing, test permettant de déterminer si une machine peut penser. Cette partie se termine en présentant les six grands domaines de l'intelligence artificielle.
Ce cours présente les techniques que l'on peut utiliser pour effectuer des calculs parallèles avec une machine. La première partie introduit à la notion de parallélisme et de processus. Elle présente ensuite comment lancer et manipuler des processus avec les modules subprocess et multiprocessing. On y voit également comment communiquer entre processus avec des Queue et des Pipe. La deuxième partie présente les threads et leur utilisation avec le module threading. On y voit également comment créer un pool de workers/executors pour exécuter des jobs. Enfin, la dernière partie présente le framework dispy qui permet de facilement faire du calcul distribué et exploiter le parallélisme de données.
Ce cours concerne la manipulation des chaines de caractères et les expressions régulières. La première partie présente la classe str Python ainsi que les opérations qu'il est possible de faire sur des objets str. La seconde partie concerne les expressions regulières qui permettent de valider des chaines de caractères ou d'en extraire des sous-chaines qui satisfont un motif donné. On y voit finalement comment utiliser le module re Python.
Ce deuxième cours aborde la programmation réseau, c'est-à-dire le développement d'applications avec plusieurs composants qui communiquent entre eux via la réseau. Après une rapide présentation des protocoles UDP et TCP, le cours aborde la notion de socket et présente le module Python de même nom. Le cours présente deux applications concrètes : une application de chat (basé sur UDP) et une application echo (basé sur TCP). Le cours se termine par la découverte de la notion de protocole de communication et de la définition du format des messages échangés.
Ce premier cours introduit à plusieurs aspects liés au développement informatique. Le cours présente comment versioner son code avec le système Git et comment le déployer avec Heroku. Il présente ensuite comment débugguer avec le module pdb et comment profiler son code avec les modules timeit et profile. Enfin, le cours termine en présentant le concept de tests unitaires que l'on peut construire avec les modules doctest et unittest.
Ce cours présente le notion de qualité de code et quels sont les critères et pratiques à adopter pour produire du code de qualité. Il présente les erreurs de programmation les plus fréquentes auprès des apprentis programmeurs. La deuxième partie du cours présente la notion de convention de codage et en particulier le PEP 0008 qui décrit des conventions à adopter lorsqu'on programme en Python.
Ce cours présente ce qu'est Internet et son fonctionnement. En partant de l'ordinateur personnel ou smartphone connectés en un réseau local, le cours remonte petit à petit vers le fournisseur d'accès et l'Internet complet. Le cours présente ensuite plusieurs protocoles qui assurent le bon fonctionnement d'Internet et des services qu'il permet d'offrir. Enfin, la dernière partie concerne l'internet des objets.
Ce cours présente le langage UML qui permet notamment de modéliser des logiciels programmés en orienté objet. Ce cours présente les diagrammes de classes qui permettent de décrire la structure d'un logiciel et les diagrammes d'activité qui permettent de décrire les aspects dynamiques de l'exécution.
OCTO TALKS : 4 Tech Trends du Software Engineering.pdfOCTO Technology
En cette année 2024 qui s’annonce sous le signe de la complexité, avec :
- L’explosion de la Gen AI
-Un contexte socio-économique sous tensions
- De forts enjeux sur le Sustainable et la régulation IT
- Une archipélisation des lieux de travail post-Covid
Découvrez les Tech trends incontournables pour délivrer vos produits stratégiques.
Le Comptoir OCTO - Équipes infra et prod, ne ratez pas l'embarquement pour l'...OCTO Technology
par Claude Camus (Coach agile d'organisation @OCTO Technology) et Gilles Masy (Organizational Coach @OCTO Technology)
Les équipes infrastructure, sécurité, production, ou cloud, doivent consacrer du temps à la modernisation de leurs outils (automatisation, cloud, etc) et de leurs pratiques (DevOps, SRE, etc). Dans le même temps, elles doivent répondre à une avalanche croissante de demandes, tout en maintenant un niveau de qualité de service optimal.
Habitué des environnements développeurs, les transformations agiles négligent les particularités des équipes OPS. Lors de ce comptoir, nous vous partagerons notre proposition de valeur de l'agilité@OPS, qui embarquera vos équipes OPS en Classe Business (Agility), et leur fera dire : "nous ne reviendrons pas en arrière".
Ouvrez la porte ou prenez un mur (Agile Tour Genève 2024)Laurent Speyser
(Conférence dessinée)
Vous êtes certainement à l’origine, ou impliqué, dans un changement au sein de votre organisation. Et peut être que cela ne se passe pas aussi bien qu’attendu…
Depuis plusieurs années, je fais régulièrement le constat de l’échec de l’adoption de l’Agilité, et plus globalement de grands changements, dans les organisations. Je vais tenter de vous expliquer pourquoi ils suscitent peu d'adhésion, peu d’engagement, et ils ne tiennent pas dans le temps.
Heureusement, il existe un autre chemin. Pour l'emprunter il s'agira de cultiver l'invitation, l'intelligence collective , la mécanique des jeux, les rites de passages, .... afin que l'agilité prenne racine.
Vous repartirez de cette conférence en ayant pris du recul sur le changement tel qu‘il est généralement opéré aujourd’hui, et en ayant découvert (ou redécouvert) le seul guide valable à suivre, à mon sens, pour un changement authentique, durable, et respectueux des individus! Et en bonus, 2 ou 3 trucs pratiques!
L'IA connaît une croissance rapide et son intégration dans le domaine éducatif soulève de nombreuses questions. Aujourd'hui, nous explorerons comment les étudiants utilisent l'IA, les perceptions des enseignants à ce sujet, et les mesures possibles pour encadrer ces usages.
Constat Actuel
L'IA est de plus en plus présente dans notre quotidien, y compris dans l'éducation. Certaines universités, comme Science Po en janvier 2023, ont interdit l'utilisation de l'IA, tandis que d'autres, comme l'Université de Prague, la considèrent comme du plagiat. Cette diversité de positions souligne la nécessité urgente d'une réponse institutionnelle pour encadrer ces usages et prévenir les risques de triche et de plagiat.
Enquête Nationale
Pour mieux comprendre ces dynamiques, une enquête nationale intitulée "L'IA dans l'enseignement" a été réalisée. Les auteurs de cette enquête sont Le Sphynx (sondage) et Compilatio (fraude académique). Elle a été diffusée dans les universités de Lyon et d'Aix-Marseille entre le 21 juin et le 15 août 2023, touchant 1242 enseignants et 4443 étudiants. Les questionnaires, conçus pour étudier les usages de l'IA et les représentations de ces usages, abordaient des thèmes comme les craintes, les opportunités et l'acceptabilité.
Résultats de l'Enquête
Les résultats montrent que 55 % des étudiants utilisent l'IA de manière occasionnelle ou fréquente, contre 34 % des enseignants. Cependant, 88 % des enseignants pensent que leurs étudiants utilisent l'IA, ce qui pourrait indiquer une surestimation des usages. Les usages identifiés incluent la recherche d'informations et la rédaction de textes, bien que ces réponses ne puissent pas être cumulées dans les choix proposés.
Analyse Critique
Une analyse plus approfondie révèle que les enseignants peinent à percevoir les bénéfices de l'IA pour l'apprentissage, contrairement aux étudiants. La question de savoir si l'IA améliore les notes sans développer les compétences reste débattue. Est-ce un dopage académique ou une opportunité pour un apprentissage plus efficace ?
Acceptabilité et Éthique
L'enquête révèle que beaucoup d'étudiants jugent acceptable d'utiliser l'IA pour rédiger leurs devoirs, et même un quart des enseignants partagent cet avis. Cela pose des questions éthiques cruciales : copier-coller est-il tricher ? Utiliser l'IA sous supervision ou pour des traductions est-il acceptable ? La réponse n'est pas simple et nécessite un débat ouvert.
Propositions et Solutions
Pour encadrer ces usages, plusieurs solutions sont proposées. Plutôt que d'interdire l'IA, il est suggéré de fixer des règles pour une utilisation responsable. Des innovations pédagogiques peuvent également être explorées, comme la création de situations de concurrence professionnelle ou l'utilisation de détecteurs d'IA.
Conclusion
En conclusion, bien que l'étude présente des limites, elle souligne un besoin urgent de régulation. Une charte institutionnelle pourrait fournir un cadre pour une utilisation éthique.
Le Comptoir OCTO - Qu’apporte l’analyse de cycle de vie lors d’un audit d’éco...OCTO Technology
Par Nicolas Bordier (Consultant numérique responsable @OCTO Technology) et Alaric Rougnon-Glasson (Sustainable Tech Consultant @OCTO Technology)
Sur un exemple très concret d’audit d’éco-conception de l’outil de bilan carbone C’Bilan développé par ICDC (Caisse des dépôts et consignations) nous allons expliquer en quoi l’ACV (analyse de cycle de vie) a été déterminante pour identifier les pistes d’actions pour réduire jusqu'à 82% de l’empreinte environnementale du service.
Vidéo Youtube : https://www.youtube.com/watch?v=7R8oL2P_DkU
Compte-rendu :
PRESENTATION DE L'ACTIVE DIRECTORY SOUS WINDOWS SERVEUR.pptx
Arbre et algorithme de recherche
1. PO3T Programmation orientée objet
Séance 7
Arbre et algorithme
de recherche
Sébastien Combéfis, Quentin Lurkin lundi 9 novembre 2015
2. Ce(tte) œuvre est mise à disposition selon les termes de la Licence Creative Commons
Attribution – Pas d’Utilisation Commerciale – Pas de Modification 4.0 International.
3. Rappels
Structure de données et complexités
Type abstrait de données (TAD)
Complexité temporelle des méthodes
Complexité spatiale de la structure de données
TAD pour représenter des séquences d’éléments
Pile, file, deque et vecteur
Implémentation par structure chainée
Classe interne pour cacher l’implémentation
3
4. Objectifs
Arbre
Le TAD Tree
Implémentation par tableau ou structure chainée
Le TAD BinaryTree
Algorithme de recherche
Recherche séquentielle et dichotomique
Le TAD BinarySearchTree
4
6. TAD Arbre (1)
Un arbre stocke des éléments de manière hiérarchique (tree)
Tout élément possède un parent et zéro, un ou plusieurs enfants
La racine de l’arbre n’a pas de parent
Un arbre possède une unique racine
Bière
Trappiste
Rochefort 8
Trappe
Quadruple
Abbaye
Leffe Rituel
Autre
Maes Raedler CaraPils
6
7. Propriétés des arbres (1)
Ensemble de nœuds liés par une relation parent-enfant
Un arbre non vide possède une racine (qui n’a pas de parent)
Les nœuds v ont un parent unique w (v est enfant de w)
Chaque nœud de l’arbre stocke un élément
Deux nœuds avec le même parent sont frère/sœur (siblings)
Un nœud externe (feuille) n’a pas d’enfants (leaf)
Un nœud interne a un ou plusieurs enfants
7
8. Propriétés des arbres (2)
Le nœud u est un ancêtre du nœud v
si u = v
ou si u est un ancêtre du parent de v
Nœud v descendant de u si u ancêtre de v
Sous-arbre enraciné en un nœud v
Arbre avec v en racine et tous ses descendants comme nœuds
8
9. Propriétés des arbres (3)
Bière
Trappiste
Rochefort 8
Trappe
Quadruple
Abbaye
Leffe Rituel
Autre
Maes Raedler CaraPils
Racine
frère/sœur
parent/enfant
ancêtre/descendant
Nœud interne
Nœud externe
Trappiste parent de Rochefort 8 et Rochefort 8 enfant de Trappiste
Bière ancêtre de CaraPils et CaraPils descendant de Bière
9
10. TAD Arbre (2)
Méthodes spécifiques au TAD arbre
root() renvoie la racine de l’arbre (erreur si vide)
parent(v) renvoie le parent de v (erreur si racine)
children(v) renvoie un itérateur des enfants de v
Méthodes d’interrogation de l’arbre
isInternal(v) teste si v est un nœud interne
isExternal(v) teste si v est un nœud externe
isRoot(v) teste si v est la racine
10
11. TAD Arbre (3)
Méthodes de mise à jour
Décrites plus loin...
Méthodes additionnelles
size() renvoie la taille de l’arbre
isEmpty() teste si l’arbre est vide
elements() renvoie un itérateur des éléments de l’arbre
positions() renvoie un itérateur des nœuds de l’arbre
replace(v, e) remplace l’élément du nœud v par e et renvoie
l’élément qui s’y trouvait avant
11
12. Interface Tree (1)
1 public interface Tree <E>
2 {
3 public Position <E> root () throws EmptyTreeException ;
4
5 public Position <E> parent (Position <E> v)
6 throws InvalidPositionException , BoundaryViolationException ;
7
8 public Iterator <Position <E>> children (Position <E> v)
9 throws InvalidPositionException ;
10
11 public boolean isInternal (Position <E> v) throws InvalidPositionException ;
12
13 public boolean isExternal (Position <E> v) throws InvalidPositionException ;
14
15 public boolean isRoot (Position <E> v) throws InvalidPositionException ;
16
17 public int size ();
18
19 public boolean isEmpty ();
20
21 public Iterator <E> elements ();
22
23 public Iterator <Position <E>> positions ();
24
25 public E replace (Position <E> v, E e) throws InvalidPositionException ;
26 }
12
13. Interface Tree (2)
EmptyTreeException lorsque opération sur arbre vide
Ne devrait jamais arriver puisqu’on connait la taille de l’arbre
InvalidPositionException pour position pas dans l’arbre
Ne devrait jamais arriver car on reçoit les positions de l’arbre
BoundaryViolationException si opération sur la racine
Ne devrait jamais arriver puisqu’on sait tester la racine
13
14. Profondeur
La profondeur de v est son nombre d’ancêtres (v exclu)
Mesure de la distance par rapport à la racine
La racine est à une profondeur de zéro
1 public static <E> int depth (Tree <E> T, Position <E> v)
2 {
3 if (T.isRoot (v))
4 {
5 return 0;
6 }
7 return 1 + depth (T, T.parent (v));
8 }
14
15. Hauteur
La hauteur se définit aussi récursivement
Un nœud externe a une hauteur de zéro
La hauteur de v vaut 1 plus la hauteur maximale de ses enfants
La hauteur d’un arbre non vide est celle de sa racine
1 public static <E> int height (Tree <E> T, Position <E> v)
2 {
3 if (T.isExternal (v))
4 {
5 return 0;
6 }
7
8 int h = 0;
9 for (Position <E> child : T.children (v))
10 {
11 h = Math.max (h, height (T, child))
12 }
13 return 1 + h;
14 }
15
16. Parcours d’un arbre
Un parcours d’arbre traverse tous ses nœuds
Traversée systématique, visite de tous les nœuds
Deux principaux types de parcours
Préfixe : racine puis chaque sous-arbre
Postfixe : chaque sous-arbre puis racine
A
B C D
G H
E
I
F
16
17. Parcours préfixe
A B C D G H E I F
1 public static <E> void preorder (Tree <E> T, Position <E> v)
2 {
3 // Opération avec le noeud v ...
4 System.out.println (v.element ());
5
6 for (Position <E> child : T.children (v))
7 {
8 preorder (T, child);
9 }
10 }
A
1
B
2
C
3
D
4
G
5
H
6
E 7
I 8
F
9
17
18. Structure d’un document
Parcours préfixe utilisé pour parcourir un document
Si on représente la structure en chapitres/sections/...
Rapport
Intro Chap 1 Chap 2
Sec 1.1 Sec 1.2
Chap 3
Sec 3.1
Conclu
18
19. Parcours postfixe
B C G H D I E F A
1 public static <E> void postorder (Tree <E> T, Position <E> v)
2 {
3 for (Position <E> child : T.children (v))
4 {
5 postorder (T, child);
6 }
7
8 // Opération avec le noeud v ...
9 System.out.println (v.element ());
10 }
A
9
B
1
C
2
D
5
G
3
H
4
E 7
I 6
F
8
19
20. Système de fichiers
Parcours postfixe utilisé pour calculer la taille d’un répertoire
Il faut sommer la taille du contenu du répertoire
/home/combefis/ecam/2015/coo
planning.pdf
12 Ko
students.xlsx
42 Ko
slides
cours1.pdf
1.17 Mo
cours2.pdf
2.24 Mo
examens
jan2015.pdf
122 Ko
secret.txt
18 Ko
20
21. Interface Position
Nœuds de l’arbre représentés par l’interface Position
element() renvoie l’élément stocké dans le nœud
La position stocke l’élément et d’autres informations
Informations sur la structure de l’arbre et les liens entre nœuds
1 public interface Position <E>
2 {
3 public E element ();
4 }
21
22. Classe LinkedTree (1)
1 public class LinkedTree <E> implements Tree <E>
2 {
3 private Position <E> root;
4 private int size;
5
6 public LinkedTree ()
7 {
8 root = null;
9 size = 0;
10 }
11
12 private static class TreeNode <E> implements Position <E>
13 {
14 private E element;
15 private TreeNode <E> parent;
16 private List <TreeNode <E>> children;
17
18 public TreeNode (E element , TreeNode <E> parent)
19 {
20 this.element = element;
21 this.parent = parent;
22 this.children = new LinkedList <TreeNode <E>>();
23 }
24
25 public E element ()
26 {
27 return element;
28 }
29 }
22
23. Classe LinkedTree (2)
1 public Position <E> root () throws EmptyTreeException
2 {
3 if (root == null)
4 {
5 throw new EmptyTreeException ();
6 }
7 return root;
8 }
9
10 public int size ()
11 {
12 return size;
13 }
14
15 public boolean isEmpty ()
16 {
17 return size == 0;
18 }
23
24. Classe LinkedTree (3)
1 private TreeNode <E> checkPosition (Position <E> v) throws
InvalidPositionException
2 {
3 if (! (v instanceof TreeNode))
4 {
5 throw new InvalidPositionException ();
6 }
7 return (TreeNode <E>) v;
8 }
9
10 public Position <E> parent (Position <E> v) throws InvalidPositionException ,
BoundaryViolationException
11 {
12 if (isRoot (v))
13 {
14 throw new BoundaryViolationException ();
15 }
16 return (( TreeNode <E>) v).parent;
17 }
18
19 public Iterator <Position <E>> children (Position <E> v) throws
InvalidPositionException
20 {
21 TreeNode <E> tn = checkPosition (v);
22 List <Position <E>> children = new LinkedList <Position <E>>();
23 for (TreeNode <E> p : tn.children)
24 {
25 children.add (p);
26 }
27 return children.iterator (); 24
25. Classe LinkedTree (4)
1 public boolean isInternal (Position <E> v) throws InvalidPositionException
2 {
3 return ! isExternal (v);
4 }
5
6 public boolean isExternal (Position <E> v) throws InvalidPositionException
7 {
8 TreeNode <E> tn = checkPosition (v);
9 return tn.children.isEmpty ();
10 }
11
12 public boolean isRoot (Position <E> v) throws InvalidPositionException
13 {
14 checkPosition (v);
15 return v == root;
16 }
17
18 public E replace (Position <E> v, E e) throws InvalidPositionException
19 {
20 TreeNode <E> tn = checkPosition (v);
21 E old = tn.element;
22 tn.element = e;
23 return old;
24 }
25
26 // ... et elements () et positions () non implémentés .
27 }
25
27. Arbre ordonné et binaire
Un arbre ordonné définit un ordre pour les enfants des nœuds
On peut définir le premier enfant, le deuxième...
Un arbre binaire est un arbre ordonné tel que
Chaque nœud possède au maximum deux enfants
Chaque nœud est soit un fils gauche, soit un fils droit
Le fils gauche précède le fils droit dans l’ordre des enfants
Sous-arbres gauche et droit pour chaque nœud
27
28. Propriétés des arbres binaires
Un arbre binaire peut être propre (ou impropre)
Chaque nœud possède zéro ou deux enfants
Une arête d’un arbre est une paire (u, v) avec u parent de v
Un arbre possède au maximum 2h+1 − 1 nœuds
A
B
D E
C
28
29. TAD Arbre Binaire (1)
Les nœuds d’arbre binaire ont max deux enfants (binary tree)
Un nœud est le fils gauche ou le fils droit
Méthodes spécifiques au TAD arbre binaire
left(v) renvoie le fils gauche de v (erreur si absent)
right(v) renvoie le fils droit de v (erreur si absent)
hasLeft(v) teste si v a un fils gauche
hasRight(v) teste si v a un fils droit
29
30. TAD Arbre Binaire (2)
Méthodes de mise à jour
addRoot(e) crée et renvoie un nœud stockant e et en fait la
racine de l’arbre (erreur si arbre non vide)
insertLeft(v, e) crée et renvoie un nœud stockant e et en fait
le fils gauche de v (erreur si déjà fils gauche)
insertRight(v, e) crée et renvoie un nœud stockant e et en
fait le fils droit de v (erreur si déjà fils droit)
remove(v) supprime le nœud v et le remplace par son fils (erreur
si deux fils)
attach(v, T1, T2) attache T1 et T2 comme sous-arbres gauche
et droit du nœud v (erreur si v interne)
30
31. Interface BinaryTree
L’interface BinaryTree étend l’interface Tree
La méthode children renvoie les fils dans le bon ordre
1 public interface BinaryTree <E> extends Tree <E>
2 {
3 public Position <E> left (Position <E> v)
4 throws InvalidPositionException , BoundaryViolationException ;
5
6 public Position <E> right (Position <E> v)
7 throws InvalidPositionException , BoundaryViolationException ;
8
9 public boolean hasLeft (Position <E> v) throws InvalidPositionException ;
10
11 public boolean hasRight (Position <E> v) throws InvalidPositionException ;
12 }
31
32. Arbre de décision
Un arbre de décision représente un processus de décision
Les nœuds internes contiennent une question
Les nœuds externes contiennent une décision
Les arêtes sont étiquetées avec Oui/Non
Y a-t-il du soleil ?
On est en décembre ?
On fait une raclette !
Oui
On fait un BBQ !
Non
Oui
On dort !
Non
32
33. Expression arithmétique
Une expression arithmétique permet de l’évaluer
Les nœuds internes contiennent une opération
Les nœuds externes contiennent un nombre
(3 ∗ (1 + 8)) − ((5 + 7)/3) −
∗
3 +
1 8
/
+
5 7
3
33
35. Classe ArrayBinaryTree (1)
Numérotation des nœuds d’un arbre avec une fonction p(v)
p(v) = 1 si v est la racine
p(v) = 2p(u) si v est le fils gauche de u
p(v) = 2p(u) + 1 si v est le fils droit de u
12
5
3 7
6 8
17
14
13 16
19
12 5 17 3 7 14 19 6 8 13 16
35
36. Complexité de ArrayBinaryTree
Complexité temporelle des opérations
Méthode Complexité
size, isEmpty O(1)
elements, positions O(n)
replace O(1)
root, parent, children, left, right O(1)
hasLeft, hasRight, isInternal, isExternal, isRoot O(1)
Complexité spatiale en O(2h+1 − 1)
En notant bien qu’il y a une capacité maximale fixée
36
37. Classe LinkedBinaryTree
Utilisation d’une classe BTNode spécifique à l’arbre binaire
Stockage du parent, du fils gauche et du fils droit
1 private static class BTNode <E> implements Position <E>
2 {
3 private E element;
4 private Position <E> parent , left , right;
5
6 public BTNode (E element , BTNode <E> parent , BTNode <E> left , BTNode <E>
right)
7 {
8 this.element = element;
9 this.parent = parent;
10 this.left = left;
11 this.right = right;
12 }
13
14 public E element ()
15 {
16 return element;
17 }
18 }
37
38. Complexité de LinkedBinaryTree
Complexité temporelle des opérations
Méthode Complexité
size, isEmpty O(1)
elements, positions O(n)
replace O(1)
root, parent, children, left, right O(1)
hasLeft, hasRight, isInternal, isExternal, isRoot O(1)
insertLeft, insertRight, attach, remove O(1)
Complexité spatiale en O(n)
Il y a exactement un nœud par élément de l’arbre
38
39. Définition récursive
Définition récursive d’un arbre binaire
Arbre vide
Un nœud avec un élément et sous-arbres binaires gauche et droit
1 public class RecursiveBT <E>
2 {
3 private final E element;
4 private final RecursiveBT <E> left , right;
5
6 public RecursiveBT (E element , RecursiveBT <E> left , RecursiveBT <E> right)
7 {
8 this.element = element;
9 this.left = left;
10 this.right = right;
11 }
12 }
39
41. Recherche linéaire
Parcours de la structure de donnée, élément par élément
Jusqu’à trouver l’élément ou avoir parcouru toute la structure
Complexité temporelle en O(n)
Dans le pire des cas, tous les élément sont parcourus
1 public static boolean find (int [] data , int elem)
2 {
3 for (int i = 0; i < data.length; i++)
4 {
5 if (data[i] == elem)
6 {
7 return true;
8 }
9 }
10 return false;
11 }
41
42. Recherche dichotomique
Recherche plus efficace si les données sont triées
Il faut évidemment avant tout trier les données
Complexité temporelle en O(log n)
On réduit l’espace de recherche de moitié à chaque itération
Recherche de 44
4 6 9 11 12 17 21 23 40 41 44 49 51 59 92 99
start endmid
42
43. Recherche dichotomique
Recherche plus efficace si les données sont triées
Il faut évidemment avant tout trier les données
Complexité temporelle en O(log n)
On réduit l’espace de recherche de moitié à chaque itération
Recherche de 44
4 6 9 11 12 17 21 23 40 41 44 49 51 59 92 99
start endmid
42
44. Recherche dichotomique
Recherche plus efficace si les données sont triées
Il faut évidemment avant tout trier les données
Complexité temporelle en O(log n)
On réduit l’espace de recherche de moitié à chaque itération
Recherche de 44
4 6 9 11 12 17 21 23 40 41 44 49 51 59 92 99
start endmid
42
45. Recherche dichotomique
Recherche plus efficace si les données sont triées
Il faut évidemment avant tout trier les données
Complexité temporelle en O(log n)
On réduit l’espace de recherche de moitié à chaque itération
Recherche de 44
4 6 9 11 12 17 21 23 40 41 44 49 51 59 92 99
start endmid
42
46. Arbre Binaire de Recherche
Un arbre binaire de recherche est un arbre binaire propre
chaque nœud interne stocke un élément e
les éléments du sous-arbre gauche sont <= e
les éléments du sous-arbre droit sont >= e
tous les nœuds externes ne stockent aucun élément
Un parcours infixe permet un parcours par ordre croissant
Complexité temporelle de la recherche en O(h)
43