Cours d’Algorithmique Listes, piles et files. Arbres. Types de données abstraits. Implantations. 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Présentation générale Les grandes lignes du cours Trier et chercher Listes et arbres Le back-track Arbres équilibrés Récursivité et induction sur la structure Divide and conquer Minimax Dérécursion Divers problèmes particuliers Logique de Hoare Programmation dynamique Complexité et calculabilité 8 novembre 2006 Cours d'algorithmique 2 - Intranet Cours d'algorithmique

Présentation générale Voici des listes ! 2 4 2 1 2 4 6 8 10 Tableau 4 6 2 2 2 10 1 -1 4 8 novembre 2006 Cours d'algorithmique 2 - Intranet Cours d'algorithmique

Présentation générale Voici des listes ! 2 4 2 1 2 4 6 8 10 Tableau 4 6 2 2 2 10 1 -1 4 8 novembre 2006 Cours d'algorithmique 2 - Intranet Cours d'algorithmique

Présentation générale Voici des listes ! 2 4 2 1 2 4 6 8 10 Tableau 4 6 2 2 2 10 1 -1 4 8 novembre 2006 Cours d'algorithmique 2 - Intranet Cours d'algorithmique

Présentation générale Voici des listes ! 2 4 2 1 2 4 6 8 10 Tableau 4 6 2 2 2 10 1 -1 4 8 novembre 2006 Cours d'algorithmique 2 - Intranet Cours d'algorithmique

Présentation générale Voici des listes ! 2 4 2 1 2 4 6 8 10 Tableau 4 6 2 2 2 10 1 -1 4 8 novembre 2006 Cours d'algorithmique 2 - Intranet Cours d'algorithmique

Présentation générale Voici des listes ! 2 4 2 1 2 4 6 8 10 Tableau 4 6 2 2 2 10 1 -1 4 FIN 8 novembre 2006 Cours d'algorithmique 2 - Intranet Cours d'algorithmique

Caractérisations d’une liste ! Un élément plus un lien vers le suivant. Séquence ordonnée finie. Suite ordonnée des mathématiques. Un tableau peut être vu comme une liste, si on limite les accès aléatoires. On lit T[0], puis T[1], etc, par exemple. Une liste est caractérisée par ses propriétés et fonctions d’accès et non sa réalisation. 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Soit LT le type des listes d’éléments de type T. Constructeurs et prédicats sur listes ----------------------------------------------------------------- Soit LT le type des listes d’éléments de type T. Le constructeur de la liste vide : cree_vide : void -> LT 8 novembre 2006 Cours d'algorithmique 2 - Intranet

cree_vide : void -> LT ajout_liste : T x LT -> LT Constructeurs et prédicats sur listes ----------------------------------------------------------------- Soit LT le type des listes d’éléments de type T. Le constructeur de la liste vide : cree_vide : void -> LT Le constructeur général : ajout_liste : T x LT -> LT 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Soit LT le type des listes d’éléments de type T. Constructeurs et prédicats sur listes ----------------------------------------------------------------- Soit LT le type des listes d’éléments de type T. Le constructeur de la liste vide : cree_vide : void -> LT Le constructeur général : ajout_liste : T x LT -> LT Le prédicat qui distingue les deux cas : est_vide : LT -> BOOL 8 novembre 2006 Cours d'algorithmique 2 - Intranet

est_vide ( ajout_liste ( e , l ) ) = Faux Constructeurs et prédicats sur listes ----------------------------------------------------------------- Les propriétés vérifiées par ces fonctions : est_vide ( cree_vide () ) = Vrai est_vide ( ajout_liste ( e , l ) ) = Faux La seule liste vide est celle créée par « cree_vide ». Aucune liste obtenue par adjonction d’un élément « a » à une liste « l » n’est vide. Salutations de la part de Monsieur de la Palisse ! 8 novembre 2006 Cours d'algorithmique 2 - Intranet

queue_liste : LT -> LT Fonctions d’accès sur listes ----------------------------------------------------------------- La fonction d’accès à l’élément : tete_liste : LT -> T La fonction d’accès à la suite de la liste : queue_liste : LT -> LT 8 novembre 2006 Cours d'algorithmique 2 - Intranet

queue_liste : LT -> LT Fonctions d’accès sur listes ----------------------------------------------------------------- La fonction d’accès à l’élément : tete_liste : LT -> T La fonction d’accès à la suite de la liste : queue_liste : LT -> LT Les propriétés vérifiées par ces fonctions : tete_liste ( ajout_liste ( a , l ) ) = a queue_liste ( ajout_liste ( a , l ) ) = l 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Les limitations d’application de ces fonctions, Fonctions d’accès sur listes ----------------------------------------------------------------- Les limitations d’application de ces fonctions, les appels suivants sont interdits : tete_liste ( cree_vide () ) queue_liste ( cree_vide () ) 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Les limitations d’application de ces fonctions, Fonctions d’accès sur listes ----------------------------------------------------------------- Les limitations d’application de ces fonctions, les appels suivants sont interdits : tete_liste ( cree_vide () ) queue_liste ( cree_vide () ) Ce qui est vraiment caractéristique d’une liste : tete_liste ( ajout_liste ( a , l ) ) = a 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Les limitations d’application de ces fonctions, Fonctions d’accès sur listes ----------------------------------------------------------------- Les limitations d’application de ces fonctions, les appels suivants sont interdits : tete_liste ( cree_vide () ) queue_liste ( cree_vide () ) Ce qui est vraiment caractéristique d’une liste : tete_liste ( ajout_liste ( a , l ) ) = a On parle d’une structure Last In - First Out (LIFO) 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Types de données abstraits ----------------------------------------------------------------- Nous nous sommes donné des noms de types : un type de base T, un type de liste LT sur ce type de base. 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Types de données abstraits ----------------------------------------------------------------- Nous nous sommes donné des noms de types : un type de base T, un type de liste LT sur ce type de base. Nous nous sommes donné des fonctions et leurs propriétés : cree_vide , ... , est_vide ( cree_vide () ) = Vrai , … . 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Types de données abstraits ----------------------------------------------------------------- Nous nous sommes donné des noms de types : un type de base T, un type de liste LT sur ce type de base. Nous nous sommes donné des fonctions et leurs propriétés : cree_vide , ... , est_vide ( cree_vide () ) = Vrai , … . Nous n’avons pas besoin de devenir plus concrets. 8 novembre 2006 Cours d'algorithmique 2 - Intranet

C’est un type de données abstrait. Types de données abstraits ----------------------------------------------------------------- Nous nous sommes donné des noms de types : un type de base T, un type de liste LT sur ce type de base. Nous nous sommes donné des fonctions et leurs propriétés : cree_vide , ... , est_vide ( cree_vide () ) = Vrai , … . Nous n’avons pas besoin de devenir plus concrets. C’est un type de données abstrait. 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Exemple d’implantation ----------------------------------------------------------------- ajout_liste ( 5 , ) 2 1 2 1 5 ajout_liste ( 5 , cree_vide () ) 5 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Exemple d’implantation ----------------------------------------------------------------- tete_liste ( ) 2 1 5 queue_liste ( ) 5 2 1 2 1 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Listes et piles ----------------------------------------------------------------- L I S T E S E T P I L E S ! ! ! 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Listes et piles ----------------------------------------------------------------- 2 1 5 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Listes et piles ----------------------------------------------------------------- 2 1 5 5 2 1 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Listes et piles ----------------------------------------------------------------- 2 1 5 5 2 Pile ( d’assiettes ) stack en anglais 1 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Listes et piles ----------------------------------------------------------------- 2 1 5 ajout_liste = push = empiler tete_liste = top = sommet queue_liste = pop = dépiler 5 2 Pile ( d’assiettes ) stack en anglais 1 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Listes et piles ----------------------------------------------------------------- LIFO ! 2 1 5 ajout_liste = push = empiler tete_liste = top = sommet queue_liste = pop = dépiler 5 2 Pile ( d’assiettes ) stack en anglais 1 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Listes et piles : les différences ----------------------------------------------------------------- Les piles sont restreintes aux opérations : top , pop et push ( et la détection de la pile vide ), celles-ci sont réalisées de façon efficace dans le processeur, par le biais d’un tableau !!! 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Listes et piles : les différences ----------------------------------------------------------------- Les piles sont restreintes aux opérations : top , pop et push ( et la détection de la pile vide ), celles-ci sont réalisées de façon efficace dans le processeur, par le biais d’un tableau !!! Les listes peuvent comporter entre autres : en plus de ajout_liste , tete_liste et queue_liste (+ liste vide), des fonctions comme inserer_liste , supprimer_liste, … , être doublement chaînées ( cf. TD ) ou circulaires, et ne sont plus des tableaux ! 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Listes et piles : les différences ----------------------------------------------------------------- Les piles sont restreintes aux opérations : top , pop et push ( et la détection de la pile vide ), celles-ci sont réalisées de façon efficace dans le processeur, par le biais d’un tableau !!! Les listes peuvent comporter entre autres : en plus de ajout_liste , tete_liste et queue_liste (+ liste vide), des fonctions comme inserer_liste , supprimer_liste, … , être doublement chaînées ( cf. TD ) ou circulaires, et ne sont plus des tableaux ! 2 6 4 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Listes et piles : les différences ----------------------------------------------------------------- Les piles sont restreintes aux opérations : top , pop et push ( et la détection de la pile vide ), celles-ci sont réalisées de façon efficace dans le processeur, par le biais d’un tableau !!! Les listes peuvent comporter entre autres : en plus de ajout_liste , tete_liste et queue_liste (+ liste vide), des fonctions comme inserer_liste , supprimer_liste, … , être doublement chaînées ( cf. TD ) ou circulaires, et ne sont plus des tableaux ! 2 6 4 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Listes en langage C ----------------------------------------------------------------- #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <assert.h> typedef int type_base; typedef struct moi_meme {type_base valeur; struct moi_meme *suivant; } t_maillon, *ptr_liste; 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Listes en langage C ----------------------------------------------------------------- #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <assert.h> typedef int type_base; typedef struct moi_meme {type_base valeur; struct moi_meme *suivant; } t_maillon, *ptr_liste; Le nom du type de base. 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Listes en langage C ----------------------------------------------------------------- #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <assert.h> typedef int type_base; typedef struct moi_meme {type_base valeur; struct moi_meme *suivant; } t_maillon, *ptr_liste; Le nom du type de base. La structure elle-même. 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Listes en langage C ----------------------------------------------------------------- #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <assert.h> typedef int type_base; typedef struct moi_meme {type_base valeur; struct moi_meme *suivant; } t_maillon, *ptr_liste; Le nom du type de base. La structure elle-même. La structure s’appelle t_maillon. 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Listes en langage C ----------------------------------------------------------------- #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <assert.h> typedef int type_base; typedef struct moi_meme {type_base valeur; struct moi_meme *suivant; } t_maillon, *ptr_liste; Le nom du type de base La structure elle-même Le type du pointeur sur une telle structure s’appelle ptr_liste. La structure s’appelle t_maillon. 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Listes en langage C ----------------------------------------------------------------- S o y o n s p l u s c o n c r e t s !!! 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Listes en langage C ----------------------------------------------------------------- ptr_liste cree_vide (void) { return( (ptr_liste)NULL ); } int est_vide (ptr_liste liste) { return( liste == (ptr_liste)NULL ); } type_base tete_liste (ptr_liste liste) {assert( liste != (ptr_liste)NULL ); return( liste->valeur ); } ptr_liste queue_liste (ptr_liste liste) return( liste->suivant ); } 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Listes en langage C ----------------------------------------------------------------- ptr_liste cree_vide (void) { return( (ptr_liste)NULL ); } int est_vide (ptr_liste liste) { return( liste == (ptr_liste)NULL ); } type_base tete_liste (ptr_liste liste) {assert( liste != (ptr_liste)NULL ); return( liste->valeur ); } ptr_liste queue_liste (ptr_liste liste) return( liste->suivant ); } Création de la liste vide. 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Listes en langage C ----------------------------------------------------------------- ptr_liste cree_vide (void) { return( (ptr_liste)NULL ); } int est_vide (ptr_liste liste) { return( liste == (ptr_liste)NULL ); } type_base tete_liste (ptr_liste liste) {assert( liste != (ptr_liste)NULL ); return( liste->valeur ); } ptr_liste queue_liste (ptr_liste liste) return( liste->suivant ); } Création de la liste vide. Le prédicat de liste vide ou non. 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Listes en langage C ----------------------------------------------------------------- ptr_liste cree_vide (void) { return( (ptr_liste)NULL ); } int est_vide (ptr_liste liste) { return( liste == (ptr_liste)NULL ); } type_base tete_liste (ptr_liste liste) {assert( liste != (ptr_liste)NULL ); return( liste->valeur ); } ptr_liste queue_liste (ptr_liste liste) return( liste->suivant ); } Création de la liste vide. Le prédicat de liste vide ou non. Rendre la tête d’une liste non vide. 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Listes en langage C ----------------------------------------------------------------- ptr_liste cree_vide (void) { return( (ptr_liste)NULL ); } int est_vide (ptr_liste liste) { return( liste == (ptr_liste)NULL ); } type_base tete_liste (ptr_liste liste) {assert( liste != (ptr_liste)NULL ); return( liste->valeur ); } ptr_liste queue_liste (ptr_liste liste) return( liste->suivant ); } Création de la liste vide. Le prédicat de liste vide ou non. Rendre la tête d’une liste non vide. On s’assure que la liste n’est pas la liste vide. Préférable : ( liste != cree_vide() ) 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Listes en langage C ----------------------------------------------------------------- ptr_liste cree_vide (void) { return( (ptr_liste)NULL ); } int est_vide (ptr_liste liste) { return( liste == (ptr_liste)NULL ); } type_base tete_liste (ptr_liste liste) {assert( liste != (ptr_liste)NULL ); return( liste->valeur ); } ptr_liste queue_liste (ptr_liste liste) return( liste->suivant ); } Création de la liste vide. Le prédicat de liste vide ou non. Rendre la tête d’une liste non vide. Rendre la queue d’une liste non vide. 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Listes en langage C ----------------------------------------------------------------- ptr_liste ajout_liste (type_base elt, ptr_liste liste) {ptr_liste ptr_auxil; ptr_auxil = (ptr_liste)malloc(sizeof(t_maillon)); ptr_auxil->valeur = elt; ptr_auxil->suivant = liste; return( ptr_auxil );} 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Listes en langage C ----------------------------------------------------------------- ptr_liste ajout_liste (type_base elt, ptr_liste liste) {ptr_liste ptr_auxil; ptr_auxil = (ptr_liste)malloc(sizeof(t_maillon)); ptr_auxil->valeur = elt; ptr_auxil->suivant = liste; return( ptr_auxil );} ptr_liste ??? ??? 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Listes en langage C ----------------------------------------------------------------- ptr_liste ajout_liste (type_base elt, ptr_liste liste) {ptr_liste ptr_auxil; ptr_auxil = (ptr_liste)malloc(sizeof(t_maillon)); ptr_auxil->valeur = elt; ptr_auxil->suivant = liste; return( ptr_auxil );} ptr_liste elt ??? 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Listes en langage C ----------------------------------------------------------------- ptr_liste ajout_liste (type_base elt, ptr_liste liste) {ptr_liste ptr_auxil; ptr_auxil = (ptr_liste)malloc(sizeof(t_maillon)); ptr_auxil->valeur = elt; ptr_auxil->suivant = liste; return( ptr_auxil );} ptr_liste elt liste 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Compilation séparée ----------------------------------------------------------------- C O M P I L A T I O N S E P A R E E 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Exporter les types --- fichier adt_liste.c ----------------------------------------------------------------- ... #include <assert.h> typedef int type_base; typedef struct moi_meme {type_base valeur; struct moi_meme *suivant; } t_maillon, *ptr_liste; ptr_liste cree_vide (void) { return( (ptr_liste)NULL ); } 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Exporter les types --- fichier adt_liste.c ----------------------------------------------------------------- ... #include <assert.h> typedef int type_base; typedef struct moi_meme {type_base valeur; struct moi_meme *suivant; } t_maillon, *ptr_liste; ptr_liste cree_vide (void); int est_vide (ptr_liste liste); ptr_liste ajout_liste (type_base elt, ptr_liste liste); type_base tete_liste (ptr_liste liste); ptr_liste queue_liste (ptr_liste liste); ptr_liste cree_vide (void) { return( (ptr_liste)NULL ); } Nous insérons les prototypes. 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Exporter les types --- fichier adt_liste.c ----------------------------------------------------------------- ... #include <assert.h> typedef int type_base; typedef struct moi_meme {type_base valeur; struct moi_meme *suivant; } t_maillon, *ptr_liste; ptr_liste cree_vide (void); int est_vide (ptr_liste liste); ptr_liste ajout_liste (type_base elt, ptr_liste liste); type_base tete_liste (ptr_liste liste); ptr_liste queue_liste (ptr_liste liste); ptr_liste cree_vide (void) { return( (ptr_liste)NULL ); } type_liste.h #include ‘’type_liste.h ’’ 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Exporter les types --- fichier adt_liste.c ----------------------------------------------------------------- ... #include <assert.h> typedef int type_base; typedef struct moi_meme {type_base valeur; struct moi_meme *suivant; } t_maillon, *ptr_liste; ptr_liste cree_vide (void); int est_vide (ptr_liste liste); ptr_liste ajout_liste (type_base elt, ptr_liste liste); type_base tete_liste (ptr_liste liste); ptr_liste queue_liste (ptr_liste liste); ptr_liste cree_vide (void) { return( (ptr_liste)NULL ); } type_liste.h #include ‘’type_liste.h ’’ adt_liste.h #include ‘’adt_liste.h’’ 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Exporter les types --- fichier adt_liste.c ----------------------------------------------------------------- ... #include <assert.h> #include ‘’type_liste.h’’ #include ‘’adt_liste.h’’ ptr_liste cree_vide (void) { return( (ptr_liste)NULL ); } Les définitions viennent ici ! Le fichier adt_liste.c 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet prog.c qui utilise le type de données liste : ----------------------------------------------------------------- ... #include <assert.h> #include ‘’type_liste.h’’ #include ‘’adt_liste.h’’ int main (void) L’utilisateur voit la structure du type de liste. L’utilisateur voit les signatures des fonctions sur les listes. 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet prog.c qui utilise le type de données liste : ----------------------------------------------------------------- ... #include <assert.h> #include ‘’type_liste.h’’ #include ‘’adt_liste.h’’ int main (void) L’utilisateur voit la structure du type de liste. L’utilisateur voit les signatures des fonctions sur les listes. L’utilisateur ne voit pas la réalisation des fonctions, c’est-à-dire le contenu de adt_liste.c ! Souvent, c’est mieux fait dans d’autres langages comme Ada , Modula , C++ et plein d’autres. 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Compilation séparée ----------------------------------------------------------------- gcc –o executable prog.c On ne peut pas générer l’exécutable. On connaît les signatures des fonctions sur les listes. Mais, on ne connaît pas leurs réalisations ! 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Compilation séparée ----------------------------------------------------------------- gcc –o executable prog.c On ne peut pas générer l’exécutable. On connaît les signatures des fonctions sur les listes. Mais, on ne connaît pas leurs réalisations ! gcc –o executable prog.c adt_liste.c On peut compiler les deux fichiers en même temps. 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Compilation séparée ----------------------------------------------------------------- gcc –o executable prog.c On ne peut pas générer l’exécutable. On connaît les signatures des fonctions sur les listes. Mais, on ne connaît pas leurs réalisations ! gcc –o executable prog.c adt_liste.c On peut compiler les deux fichiers en même temps. gcc –c prog.c Nous compilons prog.c pour générer « prog.o » . Nous n’avons pas besoin des définitions sur les listes, car nous ne créons pas encore l’exécutable. De même, gcc –c adt_liste.c crée « adt_liste.o ». 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Compilation séparée ----------------------------------------------------------------- gcc –o executable prog.c On ne peut pas générer l’exécutable. On connaît les signatures des fonctions sur les listes. Mais, on ne connaît pas leurs réalisations ! gcc –o executable prog.c adt_liste.c On peut compiler les deux fichiers en même temps. gcc –c prog.c Nous compilons prog.c pour générer « prog.o » . Nous n’avons pas besoin des définitions sur les listes, car nous ne créons pas encore l’exécutable. De même, gcc –c adt_liste.c crée « adt_liste.o ». gcc –o executable prog.o adt_liste.o 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les fichiers .h ----------------------------------------------------------------- Les fichiers « .h » donnent les « types » et/ou les « prototypes ». 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les fichiers .h ----------------------------------------------------------------- Les fichiers « .h » donnent les « types » et/ou les « prototypes ». #include <file.h> file.h est cherché dans les répertoires standard, mais aussi dans tout répertoire indiqué par -Irép. Exemple : gcc … -I. -I../local/include … 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les fichiers .h ----------------------------------------------------------------- Les fichiers « .h » donnent les « types » et/ou les « prototypes ». #include <file.h> file.h est cherché dans les répertoires standard, mais aussi dans tout répertoire indiqué par -Irép. Exemple : gcc … -I. -I../local/include … #include ‘’file.h’’ file.h est cherché dans le répertoire courant. 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les fichiers .h ----------------------------------------------------------------- Les fichiers « .h » donnent les « types » et/ou les « prototypes ». #include <file.h> file.h est cherché dans les répertoires standard, mais aussi dans tout répertoire indiqué par -Irép. Exemple : gcc … -I. -I../local/include … #include ‘’file.h’’ file.h est cherché dans le répertoire courant. gcc -Wmissing-prototypes … L’absence de prototypes est signalée par un avertissement. 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Créer et utiliser les librairies ----------------------------------------------------------------- Il existe des librairies statiques, dynamiques et archives. « ar r libadtl.a adt_liste.o » crée la librairie « libadtl.a » à partir du contenu de « adt_liste.o », « ar t libadtl.a » affiche le contenu de la librairie. 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Créer et utiliser les librairies ----------------------------------------------------------------- Il existe des librairies statiques, dynamiques et archives. « ar r libadtl.a adt_liste.o » crée la librairie « libadtl.a » à partir du contenu de « adt_liste.o », « ar t libadtl.a » affiche le contenu de la librairie. « gcc -o executable -L. prog.c -ladtl » compile prog.c Le répertoire . est inspecté lors de la recherche des librairies, on recherche la librairie libadtl.a 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Créer et utiliser les librairies ----------------------------------------------------------------- Il existe des librairies statiques, dynamiques et archives. « ar r libadtl.a adt_liste.o » crée la librairie « libadtl.a » à partir du contenu de « adt_liste.o », « ar t libadtl.a » affiche le contenu de la librairie. « gcc -o executable -L. prog.c -ladtl » compile prog.c Le répertoire  . est inspecté lors de la recherche des librairies, on recherche la librairie libadtl.a L’ordre des arguments importe : OK : gcc prog-math.c -lm KO : gcc -lm prog-math.c 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les files ----------------------------------------------------------------- L E S F I L E S 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les files ----------------------------------------------------------------- LIFO : listes et piles. Les accès en « ajout », « lecture » et « suppression » se font en tête de liste : Insertion Lecture Suppression … 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les files ----------------------------------------------------------------- LIFO : listes et piles. Les accès en « ajout », « lecture » et « suppression » se font en tête de liste : Insertion Lecture Suppression FIFO : files. First In – First Out, c’est plus équitable ! L’insertion se fait à la fin et c’est la seule différence. … 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les files en langage C ----------------------------------------------------------------- ptr_liste ajout_file (type_base elt, ptr_file file) {ptr_file ptr_auxil; ptr_auxil = (ptr_file)malloc(sizeof(t_maillon)); ptr_auxil->valeur = elt; ptr_auxil->suivant = (ptr_file)NULL; if ( file == (ptr_file)NULL ) return( ptr_auxil ); else {ptr_file ptr_local = file; while ( ptr_local->suivant != (ptr_file)NULL ) ptr_local = ptr_local->suivant; ptr_local->suivant = ptr_auxil; return( file ); }} 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les files en langage C ----------------------------------------------------------------- ptr_liste ajout_file (type_base elt, ptr_file file) {ptr_file ptr_auxil; ptr_auxil = (ptr_file)malloc(sizeof(t_maillon)); ptr_auxil->valeur = elt; ptr_auxil->suivant = (ptr_file)NULL; if ( file == (ptr_file)NULL ) return( ptr_auxil ); else {ptr_file ptr_local = file; while ( ptr_local->suivant != (ptr_file)NULL ) ptr_local = ptr_local->suivant; ptr_local->suivant = ptr_auxil; return( file ); }} Création du nouveau maillon qui sera le dernier. 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les files en langage C ----------------------------------------------------------------- ptr_liste ajout_file (type_base elt, ptr_file file) {ptr_file ptr_auxil; ptr_auxil = (ptr_file)malloc(sizeof(t_maillon)); ptr_auxil->valeur = elt; ptr_auxil->suivant = (ptr_file)NULL; if ( file == (ptr_file)NULL ) return( ptr_auxil ); else {ptr_file ptr_local = file; while ( ptr_local->suivant != (ptr_file)NULL ) ptr_local = ptr_local->suivant; ptr_local->suivant = ptr_auxil; return( file ); }} Il est peut-être le seul ! 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les files en langage C ----------------------------------------------------------------- ptr_liste ajout_file (type_base elt, ptr_file file) {ptr_file ptr_auxil; ptr_auxil = (ptr_file)malloc(sizeof(t_maillon)); ptr_auxil->valeur = elt; ptr_auxil->suivant = (ptr_file)NULL; if ( file == (ptr_file)NULL ) return( ptr_auxil ); else {ptr_file ptr_local = file; while ( ptr_local->suivant != (ptr_file)NULL ) ptr_local = ptr_local->suivant; ptr_local->suivant = ptr_auxil; return( file ); }} Nous avançons jusqu’au dernier maillon, 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les files en langage C ----------------------------------------------------------------- ptr_liste ajout_file (type_base elt, ptr_file file) {ptr_file ptr_auxil; ptr_auxil = (ptr_file)malloc(sizeof(t_maillon)); ptr_auxil->valeur = elt; ptr_auxil->suivant = (ptr_file)NULL; if ( file == (ptr_file)NULL ) return( ptr_auxil ); else {ptr_file ptr_local = file; while ( ptr_local->suivant != (ptr_file)NULL ) ptr_local = ptr_local->suivant; ptr_local->suivant = ptr_auxil; return( file ); }} Nous chaînons et rendons le résultat ! 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les files ----------------------------------------------------------------- Souvent, on maintient deux pointeurs : tête queue … 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les files ----------------------------------------------------------------- Souvent, on maintient deux pointeurs : tête queue C’est plus pratique d’avoir une structure de synthèse : file … 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres ----------------------------------------------------------------- E T P O U R T E R M I N E R , L E S A R B R E S ! 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres enracinés ----------------------------------------------------------------- racine 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres enracinés ----------------------------------------------------------------- racine Il y a un nœud qui est la « racine ». Il y a une orientation de la racine vers les autres. 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres enracinés ----------------------------------------------------------------- autre racine 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres NON enracinés ----------------------------------------------------------------- Les liens sont bi-directionnels. Il n’y a pas de racine. 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres NON enracinés ----------------------------------------------------------------- Pourquoi d’ailleurs faire la distinction entre feuilles et nœuds ? C’est ainsi que nous verrons un arbre en théorie des graphes. 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres enracinés ----------------------------------------------------------------- racine Les feuilles sont les extrémités de l’arbre. Du point de vue de l’arbre, elles sont atomiques (sans successeur). Concernant l’application, elles comportent souvent des valeurs. 5 13 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres enracinés ----------------------------------------------------------------- racine Il y a des nœuds (internes) qui ont des « fils » en nombre variable. Chaque fils est à son tour un arbre. Concernant l’application, les nœuds peuvent comporter des valeurs, que l’on appelle aussi des étiquettes. + x 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres enracinés ----------------------------------------------------------------- racine Sous-arbres ! 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres enracinés ----------------------------------------------------------------- Un arbre est soit, simplement une feuille : racine 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres enracinés ----------------------------------------------------------------- Un arbre est soit, simplement une feuille : racine soit, un nœud (racine) avec un ou plusieurs fils qui sont des arbres (enracinés) à leur tour : arbre arbre arbre 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres enracinés (binaires) comme ADT ----------------------------------------------------------------- Création d’une feuille : cree_feuille : void -> A cree_feuille : int -> A pour créer une feuille qui comporte une valeur entière, avec : valeur_feuille : A -> int 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres enracinés (binaires) comme ADT ----------------------------------------------------------------- Création d’une feuille : cree_feuille : void -> A cree_feuille : int -> A pour créer une feuille qui comporte une valeur entière, avec : valeur_feuille : A -> int Création d’un nœud binaire : cree_arbre : A x A -> A cree_arbre : A x int x A -> A pour créer un nœud qui comporte une étiquette entière, avec : etiquette_arbre : A -> int 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres enracinés (binaires) comme ADT ----------------------------------------------------------------- Distinction entre feuilles et noeuds : est_feuille : A -> BOOL est_feuille( cree_feuille() ) = Vrai est_feuille( cree_noeud( x , y ) ) = Faux 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres enracinés (binaires) comme ADT ----------------------------------------------------------------- Distinction entre feuilles et noeuds : est_feuille : A -> BOOL est_feuille( cree_feuille() ) = Vrai est_feuille( cree_noeud( x , y ) ) = Faux Décomposition d’un nœud binaire : fils_gauche : A -> A fils_droit : A -> A fils_gauche ( cree_arbre ( g , d ) ) = g fils_droit ( cree_arbre ( g , d ) ) = d 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres enracinés (binaires) comme ADT ----------------------------------------------------------------- arbre_un = cree_arbre ( cree_feuille(5) , cree_feuille(7) ); arbre_deux = cree_arbre ( cree_feuille(2) , cree_arbre ( arbre_un , cree_feuille(1) ) ); arbre_trois = cree_arbre ( cree_feuille(3) , cree_feuille(7) ); arbre = cree_arbre ( arbre_deux , arbre_trois ); 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres enracinés (binaires) comme ADT ----------------------------------------------------------------- arbre_un = cree_arbre ( cree_feuille(5) , cree_feuille(7) ); arbre_deux = cree_arbre ( cree_feuille(2) , cree_arbre ( arbre_un , cree_feuille(1) ) ); arbre_trois = cree_arbre ( cree_feuille(3) , cree_feuille(7) ); arbre = cree_arbre ( arbre_deux , arbre_trois ); 5 7 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres enracinés (binaires) comme ADT ----------------------------------------------------------------- arbre_un = cree_arbre ( cree_feuille(5) , cree_feuille(7) ); arbre_deux = cree_arbre ( cree_feuille(2) , cree_arbre ( arbre_un , cree_feuille(1) ) ); arbre_trois = cree_arbre ( cree_feuille(3) , cree_feuille(7) ); arbre = cree_arbre ( arbre_deux , arbre_trois ); 2 5 7 1 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres enracinés (binaires) comme ADT ----------------------------------------------------------------- arbre_un = cree_arbre ( cree_feuille(5) , cree_feuille(7) ); arbre_deux = cree_arbre ( cree_feuille(2) , cree_arbre ( arbre_un , cree_feuille(1) ) ); arbre_trois = cree_arbre ( cree_feuille(3) , cree_feuille(7) ); arbre = cree_arbre ( arbre_deux , arbre_trois ); 2 3 7 5 7 1 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres enracinés (binaires) comme ADT ----------------------------------------------------------------- arbre_un = cree_arbre ( cree_feuille(5) , cree_feuille(7) ); arbre_deux = cree_arbre ( cree_feuille(2) , cree_arbre ( arbre_un , cree_feuille(1) ) ); arbre_trois = cree_arbre ( cree_feuille(3) , cree_feuille(7) ); arbre = cree_arbre ( arbre_deux , arbre_trois ); 2 3 7 5 7 1 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres en langage C ----------------------------------------------------------------- Un pointeur sur un arbre est : soit, un pointeur sur une feuille, soit, un pointeur sur un nœud. 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres en langage C ----------------------------------------------------------------- Un pointeur sur un arbre est : soit, un pointeur sur une feuille, soit, un pointeur sur un nœud. Il faut donc une structure capable de contenir les deux : les champs d’une feuille, les champs d’un nœud, un indicateur booléen qui distingue les deux cas de figure. 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres en langage C ----------------------------------------------------------------- Un pointeur sur un arbre est : soit, un pointeur sur une feuille, soit, un pointeur sur un nœud. Il faut donc une structure capable de contenir les deux : les champs d’une feuille, les champs d’un nœud, un indicateur booléen qui distingue les deux cas de figure. Exemple, (expressions arithmétiques) : toute feuille est un entier, chaque nœud comporte : un opérateur parmi « + », « * » et « - », deux fils qui sont des sous-expressions. 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres en langage C ----------------------------------------------------------------- typedef struct moi_meme {int est_feuille; int valeur; char etiq; struct moi_meme *fg; struct moi_meme *fd; } t_arbre, *ptr_arbre; 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres en langage C ----------------------------------------------------------------- typedef struct moi_meme {int est_feuille; vaudra VRAI int valeur; aura une valeur char etiq; struct moi_meme *fg; struct moi_meme *fd; } t_arbre, *ptr_arbre; Si c’est une feuille … 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres en langage C ----------------------------------------------------------------- typedef struct moi_meme {int est_feuille; vaudra VRAI int valeur; aura une valeur char etiq; struct moi_meme *fg; struct moi_meme *fd; } t_arbre, *ptr_arbre; Si c’est une feuille … Ces champs n’ont simplement aucun sens dans ce contexte ! 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres en langage C ----------------------------------------------------------------- typedef struct moi_meme {int est_feuille; vaudra FAUX int valeur; char etiq; aura une valeur struct moi_meme *fg; aura une valeur struct moi_meme *fd; aura une valeur } t_arbre, *ptr_arbre; Si c’est un noeud … 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres en langage C ----------------------------------------------------------------- typedef struct moi_meme {int est_feuille; vaudra FAUX int valeur; char etiq; aura une valeur struct moi_meme *fg; aura une valeur struct moi_meme *fd; aura une valeur } t_arbre, *ptr_arbre; Si c’est un noeud … Le champ « valeur » n’a simplement aucun sens dans ce contexte ! 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres en langage C ----------------------------------------------------------------- typedef struct moi_meme {int est_feuille; vaudra FAUX int valeur; char etiq; aura une valeur struct moi_meme *fg; aura une valeur struct moi_meme *fd; aura une valeur } t_arbre, *ptr_arbre; Si c’est un noeud … Le champ « valeur » n’a simplement aucun sens dans ce contexte ! En Pascal, ADA et d’autres, il existe des structures variables ! 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres en langage C ----------------------------------------------------------------- int est_feuille (ptr_arbre arbre) {return(arbre->est_feuille); } ptr_arbre cree_feuille (int val) {ptr_arbre arbre; arbre = (ptr_arbre)malloc(sizeof(t_arbre)); arbre->est_feuille = 1; arbre->valeur = val; return(arbre); 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres en langage C ----------------------------------------------------------------- int est_feuille (ptr_arbre arbre) {return(arbre->est_feuille); } ptr_arbre cree_feuille (int val) {ptr_arbre arbre; arbre = (ptr_arbre)malloc(sizeof(t_arbre)); arbre->est_feuille = 1; arbre->valeur = val; return(arbre); C’est précisément un champ qui mémorise si c’est une feuille. 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres en langage C ----------------------------------------------------------------- int est_feuille (ptr_arbre arbre) {return(arbre->est_feuille); } ptr_arbre cree_feuille (int val) {ptr_arbre arbre; arbre = (ptr_arbre)malloc(sizeof(t_arbre)); arbre->est_feuille = 1; arbre->valeur = val; return(arbre); L’allocation de la mémoire. Définition des champs concernés. 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres en langage C ----------------------------------------------------------------- ptr_arbre cree_noeud (ptr_arbre fg, ptr_arbre fd, char symbole) {ptr_arbre arbre; arbre = (ptr_arbre)malloc(sizeof(t_arbre)); arbre->est_feuille = 0; arbre->etiq = symbole; arbre->fg = fg; arbre->fd = fd; return(arbre); } 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres en langage C ----------------------------------------------------------------- ptr_arbre cree_noeud (ptr_arbre fg, ptr_arbre fd, char symbole) {ptr_arbre arbre; arbre = (ptr_arbre)malloc(sizeof(t_arbre)); arbre->est_feuille = 0; arbre->etiq = symbole; arbre->fg = fg; arbre->fd = fd; return(arbre); } L’allocation de la mémoire. Définition des champs concernés. 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres en langage C ----------------------------------------------------------------- ptr_arbre fils_gauche (ptr_arbre arbre) {assert( !est_feuille(arbre) ); return(arbre->fg); } ptr_arbre fils_droit (ptr_arbre arbre) return(arbre->fd); 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Les arbres en langage C ----------------------------------------------------------------- ptr_arbre fils_gauche (ptr_arbre arbre) {assert( !est_feuille(arbre) ); return(arbre->fg); } ptr_arbre fils_droit (ptr_arbre arbre) return(arbre->fd); Vérification que l’arbre est bien un nœud interne. Retour du résultat demandé. 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Listes, arbres et le pointeur NULL ----------------------------------------------------------------- Une liste peut être vide ! Elle sera représentée par le pointeur NULL ! La raison profonde est le fait que l’opération de base est : la concaténation, qui est associative et possède la liste vide comme élément neutre ! 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Listes, arbres et le pointeur NULL ----------------------------------------------------------------- Une liste peut être vide ! Elle sera représentée par le pointeur NULL ! La raison profonde est le fait que l’opération de base est : la concaténation, qui est associative et possède la liste vide comme élément neutre ! Nous avons les fonctions suivantes : cree_vide ajout_liste est_vide tete_liste queue_liste 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Listes, arbres et le pointeur NULL ----------------------------------------------------------------- Un arbre n’est jamais NULL ! C’est juste le programmeur qui l’est ! ! ! La raison profonde est le fait que l’opération de base est : la construction d’arbre, qui n’est pas associative et la question de l’élément neutre ne se pose même pas ! 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Listes, arbres et le pointeur NULL ----------------------------------------------------------------- Un arbre n’est jamais NULL ! C’est juste le programmeur qui l’est ! ! ! La raison profonde est le fait que l’opération de base est : la construction d’arbre, qui n’est pas associative et la question de l’élément neutre ne se pose même pas ! Arbre ( A , Arbre ( B , C ) ) = Arbre ( Arbre ( A , B ) , C ) / A C B C A B 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Listes, arbres et le pointeur NULL ----------------------------------------------------------------- Un arbre n’est jamais NULL ! C’est juste le programmeur qui l’est ! ! ! La raison profonde est le fait que l’opération de base est : la construction d’arbre, qui n’est pas associative et la question de l’élément neutre ne se pose même pas ! Nous avons les fonctions suivantes : cree_feuille cree_noeud est_feuille fils_gauche fils_droit 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Il n'y a pas de fonctions : Listes, arbres et le pointeur NULL ----------------------------------------------------------------- Un arbre n’est jamais NULL ! C’est juste le programmeur qui l’est ! ! ! La raison profonde est le fait que l’opération de base est : la construction d’arbre, qui n’est pas associative et la question de l’élément neutre ne se pose même pas ! Nous avons les fonctions suivantes : cree_feuille cree_noeud est_feuille fils_gauche fils_droit Il n'y a pas de fonctions : cree_arbre_vide est_arbre_vide 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Listes, arbres et le pointeur NULL ----------------------------------------------------------------- Je peux éventuellement écrire ceci : typedef struct moi_meme { struct moi_meme fg , fd ; } . . . ptr_arbre cree_feuille (int valeur) {ptr_arbre arbre; arbre = (ptr_arbre)malloc(sizeof(t_arbre)); arbre->fg = NULL ; arbre->fd = (int *) valeur ; return ( arbre ) ; } 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Listes, arbres et le pointeur NULL ----------------------------------------------------------------- Je peux éventuellement écrire ceci : typedef struct moi_meme { struct moi_meme fg , fd ; } . . . ptr_arbre cree_feuille (int valeur) {ptr_arbre arbre; arbre = (ptr_arbre)malloc(sizeof(t_arbre)); arbre->fg = NULL ; arbre->fd = (int *) valeur ; return ( arbre ) ; } Nous utilisons le champ fg pour indiquer que l’arbre est une feuille, . . . et le fils droit pour mémoriser sa valeur ! 8 novembre 2006 Cours d'algorithmique 2 - Intranet

C'est juste de la mauvaise programmation ! ! ! Listes, arbres et le pointeur NULL ----------------------------------------------------------------- Je peux éventuellement écrire ceci : typedef struct moi_meme { struct moi_meme fg , fd ; } . . . ptr_arbre cree_feuille (int valeur) {ptr_arbre arbre; arbre = (ptr_arbre)malloc(sizeof(t_arbre)); arbre->fg = NULL ; arbre->fd = (int *) valeur ; return ( arbre ) ; } Nous utilisons le champ fg pour indiquer que l’arbre est une feuille, . . . et le fils droit pour mémoriser sa valeur ! 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet Synthèse ----------------------------------------------------------------- Listes. Piles. Files. Arbres. Types de données abstraits. 8 novembre 2006 Cours d'algorithmique 2 - Intranet

Cours d'algorithmique 2 - Intranet m E r C i e T b O n N e J o U r N é E ! ! ! n ‘ O u B l I e Z p A s D e p R é P a R e R v O s T D ! ! ! 8 novembre 2006 Cours d'algorithmique 2 - Intranet