Simulation Graphique Des Traitements Sur Les Arbres Binaires

Ministère de l’enseignement supérieur et Recherche scientifique
Université de la Manouba
Ecole Nationale des Sciences Informatique
Simulation Graphique des traitements sur les

Arbres Binaires
Rapport de stage de programmation élaboré par :

EDDAHECH Soumaya
KHAYAT Arwa
Année Universitaire : 2010 - 2011

Remerciement
En préambule à ce rapport, nous souhaitions adresser nos remerciements les plus

sincères aux personnes qui nous ont apportées leur aide et qui ont contribué à l'élaboration de
projet.
Nous tenons à remercier dans un premier temps, toute l’équipe pédagogique

de l’Ecole Nationale des Sciences Informatiques, pour nous avoir donné l’occasion
d’effectuer ce stage d’été dans les meilleures conditions possibles.
Nous remercions également Mademoiselle Ben Ali et Madame Souileh pour l’aide et
les conseils concernant les missions évoquées dans ce rapport, qu’ils nous ont apportés lors
des différents suivis. Nous espérons que ce travail soit au niveau de leurs attentes et de la
confiance qu’ils ont bien voulu nous donner.
Nous n'oublions pas nos parents pour leur contribution, leur soutien et leur patience.
Enfin, nous adressons nos plus sincères remerciements à tous nos proches et amis, qui nos ont
toujours soutenues et encouragées au cours de la réalisation de ce projet.
Merci à tous et à toutes.
Table des figures
Figure1.1 Le parcours en largeur ……………….......................................................................8

Figure1.2 Le parcours préfixe ………………………………….……….………………..…....8
Figure1.3Le parcours infixe …………………………………….………………………….….8
Figure1.4 Le parcours post fixe …………………………………...…………...…….……..…8
Figure1.5 Les fonctionnalités offertes par l’application……………….………………….….11
Figure2.1 Le splashscreen de l’application………………………...…….…………………..14
Figure2.2 La fenêtre principale …………...…………………………….…………………....15
Figure2.3 La fenêtre de dialogue de l’opération de création……...…………….…….…..….17
Figure2.4 La fenêtre de dialogue de l’opération de recherche d’un élément dans l’arbre…....18
Figure2.5 La fenêtre de dialogue de l’opération de calcul de la taille.……………….……....20
Figure2.6 La fenêtre de dialogue de l’opération de calcul de nombre de feuilles……..……..21
Figure2.7 La fenêtre de dialogue de l’opération de transformation..………..……..…....……22
Figure2.8 La fenêtre de dialogue de l’opération d’ajout………….. ………………...……….23
Figure2.9 La fenêtre de dialogue de l’opération de suppression..…………………..….….....24
Figure3.1 Modularité de l’application……………………..……………… ..…….…..…......27
Figure3.2 Format d’un fichier représentant un arbre binaire……………… ..…….…..…......34
Table des matières
Introduction .................................................................................... 5
Chapitre1: Présentation du projet ............................................. 6
1.2 Motivation du travail ..........................................................................................................................6
1.1 Intégration du TIC dans l’enseignement ..............................................................................................6
1.3 Les arbres binaires ..............................................................................................................................7
1.4 Travail demandé ............................................................................................................................... 10
2.1 Fonctionnalités à implémenter .......................................................................................................... 10
2.2 Critères d’évaluation ......................................................................................................................... 11
2. Langage de programmation ....................................................................................... 12
3.1 Solutions envisageables .................................................................................................................... 12
2.2 Solution retenue ............................................................................................................................... 12
2.3 Conclusion ........................................................................................................................................ 13
Chapitre2 :Conception de l’interface ....................................... 14
1. Le splashscreen .................................................................................................................................... 14
2. La fenêtre principale ............................................................................................................................ 15
3. les fenêtres de dialogues ...................................................................................................................... 16
3.1 Création d’un arbre binaire ............................................................................................................... 17
3.2 Recherche d'un élément dans un arbre binaire .................................................................................. 18
3.3 Calcul de la taille .............................................................................................................................. 20
3.4 Calcul du nombre de feuille .............................................................................................................. 21
3.5 Création d'un arbre binaire de recherche .......................................................................................... 22
3.6 Adjonction d'un élément .................................................................................................................. 23
3.7 Suppression d'un élément .................................................................................................................. 24
4. Conclusion ................................................................................................................... 25
Chapitre3: Implémentation des fonctionnalités…… ............. 26
1. Modularité ............................................................................................................................................ 26
2. Présentation des principales classes ...................................................................................................... 27
2.1 Module affichage ............................................................................................................................... 27
2.2 Module traitement .............................................................................................................................. 28
2.3 Module de gestion de fichiers ........................................................................................................... 33
3. Améliorations possibles ........................................................................................................................ 35
3.1 Utiliser les onglets ............................................................................................................................ 35
3.2 Pouvoir imprimer les arbres ............................................................................................................ 35
3.3 Intégration d’autres fonctionnalités ................................................................................................. 35
3.4 Discussion en ligne........................................................................................................................... 36
4. Conclusion ............................................................................................................................................ 36
Conclusion…. ................................................................................. 37
Annexe…. ........................................................................................ 38
Introduction
L’évolution des technologies de la communication d’une part et l’analyse des besoins

en matière de formation après les reformes des enseignements supérieurs d’autre part amènent
la communauté universitaire à s’intéresser à l’intégration des technologies de l’information et
de la communication dans l’enseignement.
Mais l’utilisation des nouvelles technologies n’est pas en elle-même un objectif,

néanmoins c’est un support sur lequel on peut se baser afin de proposer une nouvelle
approche méthodologique dans l’enseignement. En algorithmique, l’exploitation de tel
technologie a pour objectif fondamental de résoudre un problème majeur rencontrant les
étudiants qui est la compréhension.
C’est dans ce contexte que se situe ce travail qui consiste à la réalisation d’une
application pédagogique à l’usage des enseignants et leurs étudiants. Celle-ci doit être un
support de cours d’algorithmique sur les arbres ainsi qu’une base de travail individuel pour
chaque étudiant. Cette application s’appuie particulièrement sur la visualisation
d’algorithmes. Elle doit faciliter la compréhension de ces algorithmes en déroulant ceux-ci
tout en montrant les modifications subies par l’arbre.
Ce rapport s’articule ainsi en trois parties. Le premier chapitre est consacré à la

présentation du projet, l’analyse et à la spécification des besoins, il contient une explication
détaillée des exigences auxquelles notre application doit répondre. Le chapitre suivant
développe la conception de l’application et décrit l’environnement de développement et les
différentes techniques utilisées lors du développement de l’application.
Département Informatique 5 EDDAHECH.S & KHAYAT.A /2010

Projet d’été Présentation du projet
Chapitre I
Présentation du projet
Dans le cadre de notre formation d’ingénieurs informaticiens à l’Ecole Nationale des

Sciences de l’Informatique, nous avons eu l’occasion d’effectuer notre projet d’été qui
consiste à la réalisation d’une application pédagogique facilitant la manipulation d’arbres
binaires.
Dans ce chapitre, nous présentons le cadre général de notre projet. En effet, nous
commençons par découvrir le sujet du projet. Ensuite nous présentons les diverses
fonctionnalités à implémenter.
I. Motivation du travail
La compréhension des algorithmes constitue un problème qui se pose à chacun de l’étudiant

en informatique, à l’enseignant d’algorithmes, et encore au concepteur d’algorithme.
Ce problème est complexe car il demande d’établir une relation entre un objet statique
algorithme et un objet dynamique qui est son exécution.
Afin d’assurer la compréhension de ce dernier, la meilleure solution était de le visualiser et
de le voir s’exécuter suivant la citation de Donald Ervin Knuth : « An algorithm must be seen
to be believed. » et en exploitant l’intégration des technologies de l’information et de la
communication dans l’enseignement.
1. Intégration de TIC dans l'enseignement
Les TIC1s sont à l’origine de grandes innovations dans tous les secteurs d’activité à travers le
monde entier. Cette révolution inclue aussi le domaine éducatif qui s’est évolué grâce à elle.
La question qui se pose maintenant est : Comment peut-on profiter des facilités apportées par
les TICs et améliorer la qualité de l’enseignement et de l’apprentissage?
Les TICs s’imposent de plus en plus comme support incontournable dans l’apprentissage des
différents savoirs et comme moyen d’exécution pratique en même temps ce qui justifie la
1
Les technologies de l’information et de la communication

citation de Debray : «Si les technologies ne permettent pas d’accomplir le processus de

transmission de connaissances dans son intégralité, elles en facilitent certains mécanismes».
En effet, l’étudiant apprend à être autonome et à s’ouvrir sur différents ressources
pédagogiques. En plus, ils lui offrent une illustration pratique de toutes connaissances
théorique : en algorithmique par exemple, la visualisation des algorithmes est l’une des
meilleures méthodes facilitant leurs compréhension.
Les arbres binaires constituent l’une des plus importantes structures de données d’une part et
l’une des plus difficiles à apprendre et à enseigner de l’autre ce qui amènent beaucoup
d’informaticien à penser à résoudre ce problème en réalisant des applications pédagogiques
traitant cette structure.
2. Les arbres binaires

Dans cette section on va s’intéresser à présenter les arbres binaire en tant structures de donné
se caractérisant par un ensemble d’opérations élémentaires facilitant leurs manipulation en
vue de présenter par la suite leurs utilités.
2.1. Définition et Opérations élémentaires
2.1.1 Définition
Un arbre binaire est une structure de données qui peut se représenter sous la forme d'une
hiérarchie dont chaque élément est appelé nœud, le nœud initial étant appelé racine. Dans un
arbre binaire, chaque élément possède au plus deux éléments fils au niveau inférieur,
habituellement appelés gauche et droit.
2.1.2 Opérations élémentaires

Les arbres binaires représentent une structure de données très utilisée. En effet, ce type de structure
si elle est bien utilisée donne de très bonnes performances. Afin de bien manipuler la structure
arborescente on doit d’abord la maitriser.
Création d’un arbre binaire
On peut distinguer deux types de création d’un arbre : création d'un arbre vide, et création d'un
arbre à partir d'un élément et de deux sous arbres.
Calcul de la taille
Pour compter la taille d'un arbre, on calcule, pour chaque nœud qui existe, une somme égale à un
à laquelle on additionne la somme des nœuds du fils gauche et la somme des nœuds du fils droit.
Calcul de nombre de feuilles

Le calcul du nombre de feuille repose sur la définition récursive suivante:

- un arbre vide n'a pas de feuille.
- un arbre non vide a son nombre de feuille défini de la façon suivante :
- si le nœud est une feuille alors on renvoie 1
- si c'est un nœud interne alors le nombre de feuille est la somme du nombre de
feuille de chacun de ses fils.
Parcours en largeur et parcours en profondeur
Parcours en largeur
Le parcours en largeur n'est pas souvent utilisé dans la manipulation des arbres en effet le temps requis
pour faire ce parcours n'est plus linéaire. Ce type de parcours est défini ainsi :
On visite les nœuds par niveau
Figure1.1. Le parcours en largeur
Parcours en profondeur
Nous distinguons 3 sous types de parcours en profondeur (infixe, post fixe, préfixe).
Figure1.2. Le parcours préfixé Figure1.3. Le parcours infixé Figure1.4. Le parcours post fixe
on traite le contenu du nœud dès on traite le contenu du nœud après on traite le contenu du nœud après
qu'on est dessus, ensuite on avoir parcouru et affiché le contenu avoir parcouru et affiché ses deux
parcourt son fils gauche puis son de son fils gauche; une fois que fils.
fils droit. c'est fait, on parcourt et on affiche
son fils droit.
Recherche d’élément
La recherche se fait en effectuant l’un types de parcours précédant et en comparant chaque fois la
valeur du nœud à celle de la valeur recherchée.
Création d’un arbre binaire de recherche

Cette création se fait par insertions successives des nœuds dans un ordre croissant des clés dans le
sous arbre gauche et décroissant dans le sous arbre droite, pour obtenir à la fin un ABR2 dont la
manipulation est beaucoup plus simple.
Adjonction d’élément aux feuilles dans un ABR
L'insertion d'un nœud commence par une recherche : on cherche la clé du nœud à insérer ;
lorsqu'on arrive à une feuille, on ajoute le nœud comme fils de la feuille en comparant sa clé à
celle de la feuille : si elle est inférieure, le nouveau nœud sera à gauche ; sinon il sera à droite.
Suppression d’élément d’un ABR
Suppression d'une feuille : Il suffit de l'enlever de l'arbre
Suppression d'un nœud avec un enfant : Il faut l'enlever de l'arbre en remplaçant par son fils.
Suppression d'un nœud avec deux enfants : On remplace le nœud par son successeur le plus
proche ou son plus proche prédécesseur. Puis on applique à nouveau la procédure de suppression
à N, qui est maintenant une feuille ou un nœud avec un seul fils.
De la diversité des opérations effectuées sur les arbres binaires on peut déduire l’importance
de la structure arborescente.
2.2. Utilités des structures arborescentes

Les arbres binaires représentent la forme la plus basique des structures hiérarchiques, en effet
ces derniers existent partout dans la nature (exploration de l’espace) par exemple : les nids
de fourmis, les éclairs et les neurones sont tous sous formes d’arbres.
L’utilisation des arbres en tant que structure abstraite est illustré par :
Dans les organisations, décomposition en parties, plans de recherche, …

Présentation (interfaces) des données.
Organisation des fichiers d’un système d’exploitation, structure des documents :
Un document est un arbre dont les nœuds sont de 3 catégories: élément, attributs,
textes
2
Arbre Binaire de Recherche

Donc pour manipuler un document il suffit de bien savoir manipuler les arbres.
Structure efficace en mémoire : arbres de recherche (search trees).
Représentation des expressions arithmétiques et dérivation.
Ensuite, si on mesure le temps et l’espace nécessaire à un algorithme pour résoudre un

problème traitant des arbres binaires, on trouvera que la complexité de ce dernier est au pire
des cas logarithmique.
Nous pouvons donc conclure de ce qui précède que les arbres binaires permettent de
structurer les données d’une manière facilitant leurs manipulations et implémentation
algorithmique.
Mais malgré leur importance, les étudiants n’aiment pas les manipuler puisque ils les trouvent
difficiles à bien saisir, ceci est due peut être à le fait qu’ils sont habitués à travailler avec des
structures séquentielles non arborescentes.
Essayant de franchir cet handicape, nous avons choisi de réaliser ce projet afin de pouvoir
faciliter la tâche de compréhension des algorithmes manipulant un exemple des structures
arborescentes (les arbres binaires) et peut être participer au développement de EAD3.
II. Travail demandé

Notre approche met l'accent sur l'activité du sujet afin d’atteindre les objectifs pédagogiques
escomptés. Par conséquent, plusieurs fonctionnalités sont prévus pour aider l’apprenant à
s’auto former en lui permettant de développer ses compétences en manipulation des arbres
binaires.
1. Fonctionnalités à implémenter
Après une prise en main des outils à mettre en œuvre et une phase de prise de connaissances
sur les besoins de l'étudiant, nous avons décidé d’implémenter les fonctionnalités suivantes
dans notre application.
Simulation des traitements sur les arbres
Explication graphique
Gestion de fichier
Ressources pédagogiques
Manuel d'utilisation
3
Enseignement A Distance

• Simulation des traitements sur les arbres

Notre projet permet d’implémenter divers algorithmes traitant la structure arborescente
comme la création, calcul de nombre de feuilles, recherche, création d’ABR et l’adjonction et
la suppression d’un élément.
• Explication graphique
Pour satisfaire à l’objectif de notre application, la solution qui nous garantit une meilleure
compréhension était l’explication graphique de déroulement des algorithmes.
• Gestion de fichier
Pour donner une touche de professionnalisme à cette application, nous avons décidé d’offrir à
l’utilisateur la possibilité d’enregistrer son travail et réutiliser un arbre qu’il a sauvegardé.
• Ressources pédagogiques
Le projet qu’vient de réaliser n’est qu’une application pédagogique d’où la nécessité d’ajouter
des ressources pédagogiques: des cours et des exercices proposés à l’ENSI sur les structures
arborescentes.
• Manuel d'utilisation
Pour faciliter son utilisation, l’application contient un manuel décrivant d’une manière
détaillée toutes les options qu’elle offre.
Ouvrir un
Aller au cours
nouveau fichier
/ exercice
Apprenant Manuel Quitter

Ouvrir un fichier d’utilisation Créer un ABR
existant Suppression
Créer Ajout d’elt Enregistrer
un AB Nbr de feuille Des
Quitter Taille/ Rechercher Fichiers
Figure1.5. Les fonctionnalités offertes par le projet
2. Critères d’évaluation
Cette application sera utilisée par chacun de l’étudiant et du professeur, d’où elle doit être
simple en manipulation, riche en connaissances et bien représentée pour faciliter
l’apprentissage d’une part et encourager l’étudiant à l’utiliser d’autre part.
Ensuite, cette dernière doit jouer en quelque sorte le rôle du professeur, en cas de son
utilisation dans l’EAD, d’où l’interface graphique doit être présentée dans un cadre
pédagogique et elle doit aussi être interactive et conviviale.

III. Langage de programmation
Pour fixer les logiciels nécessaires pour l'implémentation nous avons été invités à choisir le
langage de programmation qui peut servir le mieux pour le développement de notre
application.
1. Solutions envisageables
Plusieurs solutions technologiques peuvent être adoptées. Dans le cas de développement

d’une application visualisant des algorithmes, il s’agit de lister les solutions à la fois
portables, simples à mettre en œuvre et convenable a ce type d’application: il est par exemple
difficile d’implémenter une interface graphique utilisant un langage disposant des recouses
graphique limités.
Les solutions de langage de programmation sont alors les suivantes :
Application
Solution Avantages Inconvénients
exécutable
- Interface spécifique à
- Rapidité
chaque plate-forme
Langage C C - Simplicité de
- Portage difficile entre
codage
systèmes
Langage C ++ C++ - Rapidité - Idem «100 % C»
- Rapidité - manque de
Langage Python Python
-Simplicité de codage bibliothèques spécifiques
- Affranchissement
- Dégradation de la
des plates-formes
Langage Java Java vitesse d’exécution (Java
- Simplicité de
semi-compilé)
codage
Table1.1.Tableau comparatif des solutions technologiques envisageables
2. Solution retenue
Comme nous l’avons vu précédemment, plusieurs langages de programmation peuvent être

utilisés pour le développement d'une interface graphique comme C, C++, Python, VB etc...
Pour notre application nous avons décidé d'utiliser le langage de programmation java pour
plusieurs raisons citons:

• Portabilité excellente: A la différence des langages comme le C ou le C++, Java ne fournit

pas un code directement exécutable par la machine mais un « byte-code » (code
intermédiaire) qui sera exécuté par une machine virtuelle. Cette dernière est une application
portée sur la majorité des plates-formes existantes (Windows, UNIX, Solaris) qui interprète le
byte-code. C’est grâce à cette propriété qu’un programme Java s’exécute de la même manière
quelle que soit la plate-forme.
• Langage puissant.
• Langage orienté objet: Java est complètement orienté objet, elle permet d'avoir une
application bien structurée, modulable, maintenable beaucoup plus facilement et efficace.
• JDK très riche: Contrairement à la plupart des autres langages (sauf la plateforme .Net), Java
met à la disposition du développeur une API très riche lui permettant de faire de très
nombreuses choses.
• Nombreuses librairies tierces.
• IDE de très bonne qualité et libres : Eclipse et Netbeans par exemple.
• Langage extrêmement bien documenté.
Donc notre application sera développée en JAVA, cette dernière intègre deux bibliothèques
servant au développement des interfaces graphiques: AWT et SWING. Pour assurer une
indépendance vis à vis de système d'exploitation hôte nous utiliserons les composants SWING
pour la construction de l'interface graphique
IV. Conclusion
Nous avons présenté dans ce chapitre la cadre générale ou se situe notre application en
précisant les objectifs de cette dernière. Ainsi nous avons essayé d’expliquer d’une manière
brève les diverses fonctionnalités offertes par notre interface graphique qui sera le sujet du
chapitre suivant.

Projet d’été Implémentation de fonctionnalités
Chapitre II
Conception de l'interface
L'interface est un élément primordiale puisqu'elle permet à l'utilisateur d'agir sur le

programme, nous sommes donc appelé à faire notre possible pour la rendre le plus intuitive et
agréable possible. Nous présentons ici une phase conceptuelle traitant l'aspect graphique de
notre application et ses fonctionnalités.
Notre interface sera composée principalement de 3 objets:
un splashscreen
une fenêtre principale
ensemble de fenêtre de dialogue
I. Le splashscreen
Pour donner une touche professionnelle à notre application, on a décidé de réaliser un

splashscreen qui a pour rôle d'annoncer le chargement de l'application, cacher à l’utilisateur le
temps de chargement ainsi lui fournissant quelques informations comme le nom du logiciel, la
version et son logo sans oublier bien sûr dans notre cas le cadre de réalisation de l'application.
L'idée d'avoir un splashscreen nous a poussé à réfléchir sur le thème à adopter pour notre
interface, nous avons décidé d'implémenter un thème qui dévoile l'aspect pédagogique de
notre application nous avons choisi donc un thème scolaire de façon à approcher l'application
de l'étudiant et l'enseignant en s'inspirant de leur milieu universitaire et par conséquence
garantir une continuité entre la réalité et l’environnement numérique.
Figure 2.1. Le splashscreen de l'application

On a nommé notre application SimBTree (SIMilator Binary Tree), ce nom représente bien le
sujet de notre projet. Le logo est constitué d'une structure abstraite symbolisant un arbre suivi
par le nom de l'application,
Le choix de la couleur verte est bien étudiée, en effet ce couleur est dans l'esprit de notre
programme puisqu'il fait référence à la nature spécialement les arbres de même ce couleur
symbolise un environnement paisible qui favorise la stabilité et la concentration ce qui
coïncide avec l'objectif pédagogique de notre projet.
II. La fenêtre principale
Comme elle appelée cette fenêtre présente l'application proprement dite.
Afin de l'organiser selon nos souhaits nous l'avons découpée en diffèrent parties explicités par
la figure ci-dessous:
Barre d’outils
Zone de dessin
Zone d’explication
Figure 2.2. La fénetre principal

Barre de menu: Cette partie concerne des fonctionnalités permettant la gestion et

l'utilisation de l'application.
Afin d'organiser les menus de façon intuitive, nous avons conservé le menu « Fichier » et
« Aide »communs à tous les programmes. Nous avons ajouté d'autres menus spécifiques aux
fonctionnalités de notre programme. Nous donnons ci-dessous l'organisation de notre menu:
Fichier Traitement Ressources Aide

• Nouveau • Créer • Cours • Manuel
• Ouvrir • Rechercher • Exercices d'utilisation
• Enregistrer • Calculer taille • A propos
• Quitter • Calculer nombre de SimBTree
feuilles
• Transformer en
arbre binaire de
recherche
• Ajouter un élément
aux feuilles
• Supprimer un
élément.
Table 2.1. Contenu de la barre de menu
Barre d'outils: elle intègre des boutons permettant un accès rapide aux fonctionnalités
principales de l'application qui sont les fonctionnalités relatives à la manipulation des
arbres binaires ainsi l'accès à des ressources pédagogiques qui nous parons
indispensables pour assurer une certaine compréhensibilité des traitements à simuler.
Zone de dessin: c'est la zone ou sera représenté l'arbre binaire à manipuler ainsi que
les explications accompagnés. Cette Zone de dessin sera affichée à partir de la barre de
menu Fichier/Nouveau. Nous avons essayé ici de respecter notre orientation à avoir
une interface graphique très proche à l'environnement universitaire d'où la zone de
dessin prend la forme d'un tableau vide ainsi l'interface propose un bouton pour
changer le curseur par un bâton.
Il faut noter que le tableau vide correspond à un arbre vide.
Zone des explications: cette zone est réservé pour fournir à l'utilisateur des
explications lui permettant de comprendre la démarche adopté et par la suite
l'algorithme implémenté dernière le traitement en cours.

III. Les fenêtres de dialogue

Ces fenêtres sont activées en fonction de traitement demandé, elles permettent à l'utilisateur
de faire entrer une information, de faire certains choix ou encore afficher des résultats.
Le fonctionnement de ces fenêtres sera explicité par des diagrammes de séquences
génériques.
1. Création d'un arbre binaire
Figure 2.3. Fenêtre de dialogue de l'opération de création
Cette fenêtre est conçus afin de permettre à l'utilisateur d'entrer les données à stoker dans les
nœuds de l'arbre ainsi choisir le positionnement de chacun de ces derniers par rapport à son
nœud père. Son fonctionnement est explicité par le diagramme de séquences ci-dessous.
Création d’un arbre binaire

Ce diagramme montre la création d’un arbre binaire en procédant par adjonction, en effet,
l’utilisateur peut insérer des nœuds comme il le souhaite mais c’est l’application qui se charge
de créer l’arbre et de l'afficher.
Initialement on commence par un arbre vide à laquelle on ajoute en premier lieu un nœud
racine puis on termine par le reste des nœuds et c'est l'utilisateur qui contrôle la position du
nœud à insérer soit fils gauche soit fils droite du nœud parents sélectionnée.
Cette fenêtre de dialogue permet grâce à sa composition et l'état de ses boutons de guider
l'utilisateur de façon implicite à bien choisir la prochaine tache à effectuer de manière à
satisfaire ses besoins et de lui imposer le respect de certains règles ce qui nous paraît
intéressant de point de vue pédagogique: A l'ouverture de la fenêtre seule le bouton racine et
Terminer sont actifs: l'utilisateur est appelé à choisir entre créer un arbre non vide en passant
obligatoirement par la création d'un nœud racine ou choisir de conserver l'arbre vide en
appuyant sur Terminer.
Les boutons Ajouter fils gauche et Ajouter fils droite change leur état d'activation en fonction
du nœud sélectionné si un nœud possède un fils gauche et un autre droite les deux boutons
sont désactives, ce ci informe l'utilisateur qu'un arbre binaire ne peut avoir au maximum que
deux fils.
2. Recherche d'un élément dans l'arbre binaire
Figure 2.4. Fenêtre de dialogue de l’opération de recherche d'un élément dans l'arbre

Cette fenêtre permet à l'utilisateur de saisir la valeur du nœud à rechercher et de choisir le

type parcours à adopter son fonctionnement est décrit par le diagramme suivant:
Recherche d’un élément dans l’arbre binaire
Ce diagramme de séquence montre le déroulement de l'opération de recherche, après la saisie

de donnée à rechercher et le choix de type de parcours l'appui sur le bouton valider permet de
dérouler l'algorithme de recherche et afficher le résultat, on distingue deux cas:
• l'élément recherché existe d'où les nœuds le contenant seront graphiquement

sélectionnés et un message indiquant une recherche fructueuse sera affiché dans la
fenêtre de dialogue.
• l'élément recherché est inexistant un message indiquant que l'élément est inexistant
sera affiché.
Pour mieux appréhender l'utilisateur, cette fenêtre de recherche offre ce dernier la possibilité
de faire une exécution pas à pas via les deux boutons Suivant et Précédant qui seront activés
suite à l'action sur le bouton Valider et ils permettent de suivre graphiquement le parcours de
l'arbre et le déroulement de la recherche.

Le faite d'implémenter deux modes d'exécution: exécution à la fois et exécution pas à pas
totalement contrôlé par l'utilisateur à pour intérêt de ne pas bloquer l’utilisateur avec des
effets qui prennent le contrôle de l’application.
3. Calculer taille de l'arbre
Figure 2.5. Fenêtre de dialogue de l'opération de calcul de la taille
Pour comprendre le déroulement d'un traitement, l'utilisateur doit bien comprendre le

traitement en lui-même c'est à dire de quoi il s'agit pour cela et pour enlever toutes sortes
d'ambiguïté nous avons équipé cette fenêtre par une étiquette définissant le concept taille d'un
arbre binaire. Les fonctionnalités de cette fenêtre sont décrites par le diagramme suivant:
Calcul de la taille de l’arbre binaire

L’appui sur le bouton calculer permet le calcul et l'affichage du résultat, pour convaincre
l'utilisateur cette fenêtre de dialogue propose deux boutons précédant et suivant permettant de
suivre pas à pas le comptage des nœuds internes en indiquant graphiquement à chaque pas la
nature du nœud parcouru.
4. Calculer nombre de feuilles de l'arbre
Figure 2.6. Fenêtre de dialogue de calcul du nombre de feuille
Comme pour la fenêtre de dialogue du calcul de la taille de l'arbre, cette fenêtre fonctionne
conformément au diagramme de séquences suivant:
Calcul du nombre de feuilles de l’arbre binaire
De même, cette fenêtre propose une exécution pas à pas permettant d'expliquer à l'utilisateur
le déroulement du comptage.

5. Transformer l'arbre binaire en arbre binaire de recherche
Figure 2.7. Fenêtre de dialogue de l'opération de transformation
Cette fenêtre est composé d'un ensemble de check box permettant à l'utilisateur de choisir un
ordre de création plutôt d'insertion dans l'arbre binaire de recherche à créer conformément au
rendu de l'un des parcours proposés. Les fonctionnalités de cette fenêtre sont résumées par le
diagramme suivant:
Transformation en arbre binaire de recherche

Le faite d'appuyer sur le bouton insérer engendre l'insertion d'un nœud avec la donnée
figurant dans la liste ordonnée de rendu de parcours, ce nœud sera accroché à la racine créée
suite à l'appui sur le bouton valider, l'arbre binaire est de nouveau redessiné mais plus le
nouveau nœud inséré notre application permet de représenter sur la zone de dessin les
opérations de comparaison effectué à chaque insertion.
L'utilisateur peut ne pas terminer la transformation de son arbre binaire est ceci se fait par
fermeture de la boite de dialogue.
6. Ajout d'un élément aux feuilles
Figure 2.8. Fenêtre de dialogue de l'opération d'ajout
Cette fenêtre a pour rôle de permettre à l'utilisateur de faire entrer la donnée à stocker dans le
nœud à ajouter ainsi lui permettre de commander le déroulement de cette opération.
Ajout d’un élément aux feuilles

L'ajout d'un nœud est l'une des opérations basiques de manipulation des arbres binaires de
recherche, elle obéit à des règles d'infériorité et de supériorité qui régissent l'agencement des
nœuds dans ce type d'arbre, donc pour bien comprendre ce traitement l'utilisateur est invité à
suivre pas à pas les opérations de comparaison avant d'achever l'insertion et l'affichage de
l'arbre modifié.
7. Suppression d'un nœud
Figure 2.9. Fenêtre de dialogue de l'opération de suppression
Cette fenêtre est conçue conformément à l'algorithme de suppression d'un nœud, en effet, elle
présente en plus de l'outil de sélection du nœud à supprimer trois boutons:
• Un bouton supprimer permettant la suppression du nœud et par la suite l'affichage de

l'arbre modifié.
• Deux boutons recherche MIN et recherche MAX permettant à l'utilisateur de faire son
choix pour remplacer le nœud à supprimer si ce dernier possède deux fils (3éme cas).
Cet organisation pressente l'avantage de permettre à l'utilisateur de comprendre de façon

implicite le principe adopté dans l'algorithme de suppression ce qui reflète l'intérêt
pédagogique d'une telle organisation.

Suppression d’un élément
IV. Conclusion
Nous avons présenté dans ce chapitre l’organisation de l’interface graphique de l’application
ainsi nous avons donné une description détaillée de l’ensemble des interactions utilisateur
application afin de préciser l’ensemble des fonctionnalités à implémenter, cette phase
d’implémentation sera alors le sujet du chapitre suivant.

Chapitre III
Implémentation des fonctionnalités
Suite à la phase conceptuelle présentée dans le chapitre précédant ou on a fixé l'aspect

graphique et les fonctions de l'interface, nous présentons ici la phase d'implémentation des
divers fonctionnalités offertes par notre application.
I. Modularité
L’une des avantages du concept orienté objet est d'assurer une organisation en module de
façon à avoir un code simple facilement maintenable.
Notre application est organisée en 3 modules:
• Un module d'affichage qui traite toute la partie graphique du logiciel et interaction

avec l'utilisateur. Il permet ainsi d'afficher les résultats et les données traitées par le
modèle et de récupérer les commandes de l'utilisateur.
• Un module de traitement qui effectue toutes les opérations sur l'objet arbre notamment
dérouler les algorithmes à utiliser.
• Un module de gestion des fichiers qui permet la manipulation de différents types de

fichier employés dans l'application.
Cette décomposition rend le traitement des données indépendant de l'affichage et vice versa.
Par exemple l’affichage d'un arbre ne tient pas compte du format utilisé pour représenter
l'arbre.

Module d’affichage
LabelMult PanelAvecFond Splash Info
MainFrame
Arbre Help ReadPDF OpenSav

e
Nœud ElementFile TableEng
Module de traitement Module de gestion de fichier

Code source de l’application
Figure 3.1. Modularité de l’application
II. Présentation des principales classes
Nous allons présenter les classe module par module pour pouvoir saisir l’utilité de
chacune.
1. Module d'affichage
Ce module détermine l'aspect graphique de l'interface: son composition, son organisation et

son thème. Ce module renferme plusieurs classes:
La classe Splash: cette classe implémente le splashscreen, la méthode adoptée est

l'affichage d'un image dans un Jwindow pendant un intervalle de temps qu'on a jugé
satisfaisant pour le chargement de l'application.

La classe MainFrame: c'est la classe principale de notre programme, il contient la

fonction main, de même c'est dans cette classe qu'on définit la construction en
composants de l'interface ainsi les évènements déclenchés par les actions utilisateur.
La classe PanelAvecFond: Cette classe hérite de la classe JPanel de JAVA , il permet

la création d'un panel avec une image en arrière-plan, c'est ce qu'on a utilisé pour la
zone de dessin et la zone d'explication de la fenêtre principale.
La classe LabelMult: cette classe est créée afin de pouvoir instancier une étiquette
multiligne ce qui n'est pas fournie par la bibliothèque graphique Swing, Ce genre
d'étiquette est utilisé pour la zone d'explication. La méthode employé est basé sur
l'utilisation de la classe StringTokenizer de JAVA qui nous a permis de découper une
chaine de caractère en sous chaines à la rencontre du caractère de retour à la ligne
« \n » et associer à chaque sous chaine obtenu un Jlabel.
2. Module de traitement
Un arbre binaire est un arbre enraciné c'est à dire qu'elle peut être accessible à partir d'un
nœud qu'est sa racine. En se basant sur ce concept, pour pouvoir manipuler les arbres binaires
nous avons fait recours à deux classes:
• La classe Nœud: dans cette classe on a représenté un objet Nœud principalement par 3
attributs: sa valeur, son fils gauche et son fils droite et bien d'autres attributs mais qui
ne sont pas liés au concept nœud mais plutôt utilisé par les méthodes de dessin qu'on
va l'expliciter plus tard.
• La classe Arbre: cette classe renferme les fonctions de traitement des arbres:
Création d'arbre binaire.
Affichage d’un arbre binaire.
Calcul taille.
Calcul nombre de feuilles.
Parcours en largeur.
Parcours en profondeur infixe, postfixe et prefixe.
Insertion aux feuilles d'un élément dans un arbre binaire de

recherche.

Suppression d'un élément d'un arbre binaire de recherche.
Recherche MIN d'un arbre.
Recherche MAX d'un arbre.
Recherche nœud père d'un nœud.
• Création d'arbre binaire
L’opération de création d’arbre n’est pas implémentée par une fonction mais elle est
formulée par un ensemble de fonctionnalités offertes par la classe arbre et la classe
d’affichage mainFrame.
L’organigramme ci-dessous explicite le déroulement de l’opération de création, cette dernière

utilise un écouteur d’évènement de la souris pour identifier le nœud sélectionné par
l’utilisateur, cette fonction est implémentée dans la classe Arbre.
Une fois un nœud sera sélectionné la détection d’une action sur l’un des boutons d’ajout des
fils permet d’additionner un fils gauche ou droite au nœud sélectionné ceci est assuré par la
classe mainFrame ce dernier permet de mettre fin à cette opération suite à une action sur le
bouton terminer.

Début
non
Double clic
oui
Détermination du nœud sélectionné
oui Nœud sélectionné=nil?
non
Nœud sélectionné est encadré en rouge
oui
Double clic
non
Ajouter fils gauche ou fils droite au nœud sélectionné si possible
non
Terminer=faux
oui
Fin
• Affichage d’un arbre binaire
Après la création de l’arbre, il est très utile pour l’utilisateur de l’application ainsi pour nous
en tant que développeur d’effectuer un aspect visuel à cette structure qu’on est en train de
traiter.
Un arbre binaire est représenté graphiquement par un graphe se caractérisant par :
• Non orienté
• Sans cycle
• Connexe
• Représenté par niveau

Plus simplement un arbre binaire peut être représenté complétement par des structures
géométriques : un ensemble de cercles reliés par des lignes. Une telle structure est fournie par
les classes awt.Graphics et awt.Graphics2D, ces dernières offrent un ensemble de fonctions
permettant de dessiner et de mettre en forme des objets graphiques.
Ce problème d’affichage peut être résolu par l’utilisation de deux bibliothèques externes
JAVA : JGraphic et Jung.
Solution Graphics JGraphic Jung
• Bibliothèque • Plus rapide pour • Gestion

standard. le automatique de
Avantages développement. positionnement
• Facilité de prise
en main. • Dédié aux des nœuds.
• Plus flexible. graphes. • Plus rapide pour

le
développement.
• Gérer le • Bibliothèque • Bibliothèque
positionnement externe externe.
des nœuds volumineuse • Ecriture
manuellement. • Des nœuds impossible dans
manuellement. les nœuds donc
Inconvénients • Difficile pour la l’identification
prise en main par des labels
(problème de
chevauchement).
• Difficile pour la
prise en main.
Table.3.1. Les différentes solutions technologiques envisageables
Comme nous l’avons vu, plusieurs bibliothèques peuvent être utilisée mais nous avons choisi
d’utiliser les classes Graphics et Graphics2D puisque elles sont internes et plus simple à gérer.
Ainsi, l’algorithme adopter pour réaliser la fonctionnalité d’affichage est le suivant:

Procédure dessiner_Arbre (DON A :arbre, posX :entier, posY :entier pasX :entier,pasY :entier)
Debut
Si (A< > nil) alors
Si (A .fg < >nil)
Dessiner_ligne(posX+10 , posY+20 , posX – pasX/2 , posY+ pasY)
Dessiner_Arbre (A .fg , posX-pasX/2 – 10, posY+pasY , pasX/2 , pasY)
Fin Si
Dessiner_nœud (A , A .info , posX , posY)
Si (A .fd < > nil )
Dessiner_ligne(posX+10 , posY+20 , posX + pasX/2+10 , posY+ pasY)
Dessiner_Arbre (A .fd , posX+pasX/2 – 10, posY+pasY , pasX/2 , pasY)
Fin Si
Fin Si
Fin
Les autres fonctionnalités de SimBTree tel que calcul_taille, calcul_nbr_feilles,

recherche_min, recherche_max et les 3 types de parcours sont implémentées suivant les
fameux algorithmes de traitement des arbres binaires.
Afin de mettre en œuvre les fonctions de suppression et d’ajout d’un élément dans une ABR,
on a suivi aussi les algorithmes usuels. Mais la comparaison faite lors de la réalisation de ces
opérations est de deux types : lexicographique et numérique.
Suivant le types du donnés saisies lors de la création de arbre on choisit l’une des deux
comparaisons :
Si l’arbre comprend au moins un élément non numérique, il sera considéré comme

étant un arbre de chaine de caractères et la comparaison se basera sur un ordre
alphabétique.
Si tous les éléments de l’arbre sont des donnés numérique, on considère que ce dernier
est un arbre de nombres réels et la comparaison se basera sur un ordre numérique.
Cette distinction de types est faite grâce au mécanisme des exceptions.

Début
Donné saisie par l’utilisateur
Conversion du donné en un réel
Génération d’une non

erreur
oui Chaine de caractères=faux

Chaine de caractères = vrai
Fin
3. Module de gestion de fichiers
Le développement de notre application SimBTree nous a permis de manipuler en JAVA la

notion de fichier en trois occasions:
Équiper l'application d'un manuel d'utilisation.
Équiper l'application d'un ensemble de ressources pédagogiques (cours et exercices).
Manipuler en lecture et en écriture des fichiers représentant la structure arbre.
3.1. Manuel d'utilisation
Afin de faciliter à l'utilisateur l'usage de l'application nous avons doté SimBTree par un
manuel accessible à partir de la barre de menu.
Vu les fonctionnalités un peu limités de notre application, un fichier HTML contenant une
explication détaillé de chacune des opérations offertes est satisfaisant pour représenter ce
manuel. Pour la création de ce manuel nous avons utilisé NVU.
Du coté JAVA, la lecture de ce manuel est géré par la classe Help qui à pour rôle de charger
le fichier HTML correspondant dans un JEditorPane doté d'un écouteur des liens hypertextes.

3.2. Ressources pédagogiques
Nous avons choisis le format PDF pour représenter les cours et les exercices fournies avec
SimBTree. Ce choix est justifié par le fait que ce format a l'avantage de préserver la version
d'origine d'un document destiné à être converti en ce format sans nuire à la mise en forme
(polices d'écritures, images, objets graphiques…) de plus le format PDF présente une
indépendance vis à vis de l’application et le système d’exploitation utilisés pour le lire ou
l’imprimer ce qui coïncide avec notre objectif d'avoir une application portable.
Java ne fournit pas une bibliothèque standard pour la manipulation du format PDF d'où il faut
utiliser une bibliothèque externe. Vu que le caractère ouvert de ce format, plusieurs
bibliothèques java sont fournies. Parmi lesquelles nous avons choisi ICEpdf qu'est une
librairie Java, open-source, gratuite, qui permet de générer, afficher et imprimer des fichiers
PDF,de même, ICEpdf est très léger et simple à implémenter.
L'implémentation de cette fonctionnalité est réalisée via la classe ReadPDF.
3.3. Enregistrement et chargement d'un arbre
SimBTree offre à l'utilisateur la possibilité d'enregistrer sous la forme d'un fichier de caractère
un arbre créé au sein de l'application pour pouvoir le charger et le réutiliser ultérieurement.
Le format de fichier est illustré par la figure suivante:
Figure3.2. Format d’un fichier représentant un arbre binaire

Chaque ligne représente un nœud, il est composé de quatre champs:

numéro de ligne:valeur du nœud:numéro de ligne de fils droite:numéro de ligne de fils gauche
L’ordre d'enregistrement des nœuds est celui l'ordre résultant d'un parcours en largeur.
Le chargement d'un arbre à partir d'un fichier respectant le format déclaré ci-dessus consiste à
construire un arbre à partir des nœuds décrits par chacun des lignes de fichier.
Les opérations d'enregistrement et de chargement sont implémentées par deux méthodes
statiques de la classe OpenSave.
III. Améliorations possibles
L’application est maintenant fonctionnelle. Cependant, de nombreuses nouveautés peuvent

encore être ajoutées lors d’une reprise future du projet. Sans être exhaustive, la liste ci-
dessous, permet de se faire une idée de ce qui pourrait être ajouté.
1. Utiliser des onglets
Afin de rendre l'utilisation du logiciel plus intéressante on pourra utiliser des onglets qui
permettront de traiter plusieurs graphes en même temps. On pourra donc dérouler les
algorithmes sur deux arbres différents et pouvoir comparer les résultats en basculant entre les
différents onglets. Cela apportera une plus grande facilité d'utilisation et évitera d'ouvrir
plusieurs instances du logiciel pour manipuler plusieurs arbres.
2. Pouvoir imprimer les arbres
L'utilisateur peut être intéressé par l'idée de garder une trace graphique d'un arbre sur lequel il
travaille. L'option d'impression lui sera ainsi d'une grande utilité. En plus les résultats sont
mieux interprétés lorsqu'on les a sous les yeux.
3. Intégration d’autres fonctions
Le logiciel peut être compléter par l’implémentation de nouveaux algorithmes de traitement

des arbres binaires citons la rotation gauche et droite et le calcul hauteur. En raison de la
modularité du code, on peut facilement greffer de nouvelles fonctionnalités.

4. Discussion en ligne
Etant donné que notre application est principalement pédagogique, il sera utile d’ajouter une
rubrique dont les étudiants peuvent s’interagir à distance avec leurs professeurs d’ASD1 afin
de les interroger et de leurs demander l’aide dans le cadre d’un forum sur internet.
IV.Conclusion
Dans ce chapitre, nous avons présenté l’application conçue pour la simulation graphique
des traitements sur les arbres binaires, par le langage de programmation JAVA. On a essayé
de développer une interface graphique présentable, fiable et interactif tout en explicitant le
principe de programmation adopté.
1
Algorithmique et Structure de Donnés
Conclusion
Comme nous l’avons vu lors de la partie de présentation du projet, les applications

pédagogiques traitant la structure arborescente sont rares.
Ce qui est important, c’est que nous ne sommes pas les seuls sur cette idée de projet mais la
distinction de cette première version de SimBTree se manifeste dans les différentes options
qu’elle offre : explication détaillée des algorithmes accompagnée des cours et des exercices,
gestion des fichiers, interface graphique agréable incitant les étudiant au cours…
Ainsi, SimBTree est une application simple à utiliser simplifiant la compréhension de
l’une des structures de donnée les plus complexe et apte à être évoluer facilement du fait
qu’elle est écrite en java (programmation modulaire orienté objet).
Pour mener à bien ce projet de première année, nous avons dû approfondir nos
connaissances autant du point de vue de la manipulation des arbres binaires que du point de
vue de la programmation Java ; ceci nous a offert l’occasion de mettre en pratique ce que
nous avons appris.
De plus, ce projet nous a permis de nous familiariser avec la démarche de création d’une
application pédagogique complète. En effet, nous avons développé cette application afin
qu’elle soit utilisée au cours de l’ASD, d’où l’implémentation d’une interface et des
fonctionnalités dans ce cadre.
Ensuite, le travail en binôme a été une nouveauté pour nous les deux et nous a montré
qu’il est indispensable pour atteindre les meilleurs résultats. En effet, travailler à deux permet
d’apprendre mutuellement et d’échanger des connaissances et de penser et trouver les
solutions ensemble.
Compte tenu du succès de cette expérience, nous visons réaliser d’autres applications
pédagogiques manipulant d’autres structures de données comme les fils, les piles, les listes
chainées et les graphes et pourquoi ne pas assembler toutes ces dernières dans une seule
application facilitant la compréhension de l’ASD aux étudiants.

ANNEXE I

ANNEXE II

Bibliographie
[1] E. Anuuf, “The JAVA sourcebook”, SYBEX, 1996
[2] A. Tasso, “ Le livre de JAVA premier langage”, PEFC, 2009
[3] H. Laugié, “ JAVA et Eclipse Développez une application JAVA ”, ENI, 2008
[4] G.Bracha. J.Gosling. G.Steele and B.Joy, “The JAVA Language Specification, Second
Edition”, Sun, 2000
[5] S.Rohaut, “Algorithmique Techniques fondamentales”, ENI, 2001
Netographie
[1]http://www.icepdf.org/docs/v4_0_0/viewer/javadocs/org/icepdf/ri/common/package-
summary.html le 15 Juillet 2010
[2] http://www.javadocexamples.com/java_source/org/jgraph/GPGraphpad.java.html le 15
Juillet 2010
[3] http://java.sun.com/j2se/1.4/pdf/j2d-book.pdf le 30 Juillet 2010
[4] http://forum.hardware.fr/hfr/Programmation/Java/dessiner-arbre-java-sujet_100000_1.htm
le 01 Aout 2010
[5] http://java.sun.com/developer/technicalArticles/J2SE/Desktop/new_tech/ le 02 Aout 2010
[6] http://fr.wikipedia.org/wiki/Java_%28langage%29 le 11 Aout 2010
[7] http://www.ceremade.dauphine.fr/~touati/PAYS2_www/pays2.pdf le 22 Aout 2010
[8]http://www.commentfaiton.com/fiche/voir/6221/comment-rediger-un-rapport- le 01
Septembre 2010

Simulation Graphique Des Traitements Sur Les Arbres Binaires

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Simulation Graphique Des Traitements Sur Les Arbres Binaires

Transféré par

Droits d'auteur :

Formats disponibles

Ministère de l’enseignement supérieur et Recherche scientifique

Simulation Graphique des traitements sur les

Rapport de stage de programmation élaboré par :

Année Universitaire : 2010 - 2011

En préambule à ce rapport, nous souhaitions adresser nos remerciements les plus

Nous tenons à remercier dans un premier temps, toute l’équipe pédagogique

Figure1.1 Le parcours en largeur ……………….......................................................................8

L’évolution des technologies de la communication d’une part et l’analyse des besoins

Mais l’utilisation des nouvelles technologies n’est pas en elle-même un objectif,

Ce rapport s’articule ainsi en trois parties. Le premier chapitre est consacré à la

Département Informatique 5 EDDAHECH.S & KHAYAT.A /2010

Dans le cadre de notre formation d’ingénieurs informaticiens à l’Ecole Nationale des

La compréhension des algorithmes constitue un problème qui se pose à chacun de l’étudiant

1. Intégration de TIC dans l'enseignement

Département Informatique 6 EDDAHECH.S & KHAYAT.A /2010

citation de Debray : «Si les technologies ne permettent pas d’accomplir le processus de

2. Les arbres binaires

2.1.2 Opérations élémentaires

Département Informatique 7 EDDAHECH.S & KHAYAT.A /2010

Le calcul du nombre de feuille repose sur la définition récursive suivante:

Figure1.1. Le parcours en largeur

Création d’un arbre binaire de recherche

Département Informatique 8 EDDAHECH.S & KHAYAT.A /2010

2.2. Utilités des structures arborescentes

Dans les organisations, décomposition en parties, plans de recherche, …

Département Informatique 9 EDDAHECH.S & KHAYAT.A /2010

Ensuite, si on mesure le temps et l’espace nécessaire à un algorithme pour résoudre un

II. Travail demandé

Département Informatique 10 EDDAHECH.S & KHAYAT.A /2010

• Simulation des traitements sur les arbres

Apprenant Manuel Quitter

Figure1.5. Les fonctionnalités offertes par le projet

Département Informatique 11 EDDAHECH.S & KHAYAT.A /2010

III. Langage de programmation

Plusieurs solutions technologiques peuvent être adoptées. Dans le cas de développement

Table1.1.Tableau comparatif des solutions technologiques envisageables

Comme nous l’avons vu précédemment, plusieurs langages de programmation peuvent être

Département Informatique 12 EDDAHECH.S & KHAYAT.A /2010

• Portabilité excellente: A la différence des langages comme le C ou le C++, Java ne fournit

Département Informatique 13 EDDAHECH.S & KHAYAT.A /2010

L'interface est un élément primordiale puisqu'elle permet à l'utilisateur d'agir sur le

Notre interface sera composée principalement de 3 objets:

Pour donner une touche professionnelle à notre application, on a décidé de réaliser un

Figure 2.1. Le splashscreen de l'application

Département Informatique 14 EDDAHECH.S & KHAYAT.A /2010

II. La fenêtre principale

Comme elle appelée cette fenêtre présente l'application proprement dite.

Figure 2.2. La fénetre principal

Département Informatique 15 EDDAHECH.S & KHAYAT.A /2010

Barre de menu: Cette partie concerne des fonctionnalités permettant la gestion et

Fichier Traitement Ressources Aide

Table 2.1. Contenu de la barre de menu

Département Informatique 16 EDDAHECH.S & KHAYAT.A /2010

III. Les fenêtres de dialogue

1. Création d'un arbre binaire

Figure 2.3. Fenêtre de dialogue de l'opération de création

Création d’un arbre binaire

Département Informatique 17 EDDAHECH.S & KHAYAT.A /2010

2. Recherche d'un élément dans l'arbre binaire

Département Informatique 18 EDDAHECH.S & KHAYAT.A /2010

Cette fenêtre permet à l'utilisateur de saisir la valeur du nœud à rechercher et de choisir le

Recherche d’un élément dans l’arbre binaire

Ce diagramme de séquence montre le déroulement de l'opération de recherche, après la saisie