La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

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

Présentations similaires


Présentation au sujet: "Cours d'algorithmique 2 - Intranet 1 8 novembre 2006 Cours dAlgorithmique Listes, piles et files. Arbres. Types de données abstraits. Implantations."— Transcription de la présentation:

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

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

3 8 novembre 2006Cours d'algorithmique 2 - Intranet3 Voici des listes ! Tableau

4 8 novembre 2006Cours d'algorithmique 2 - Intranet Tableau Voici des listes !

5 8 novembre 2006Cours d'algorithmique 2 - Intranet5 Voici des listes ! Tableau

6 8 novembre 2006Cours d'algorithmique 2 - Intranet6 Voici des listes ! Tableau

7 8 novembre 2006Cours d'algorithmique 2 - Intranet7 Voici des listes ! Tableau

8 8 novembre 2006Cours d'algorithmique 2 - Intranet8 Voici des listes ! Tableau FIN

9 8 novembre 2006Cours d'algorithmique 2 - Intranet9 Caractérisations dune liste ! Un élément plus un lien vers le suivant. Un élément plus un lien vers le suivant. Séquence ordonnée finie. 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. 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 Une liste est caractérisée par – ses propriétés et fonctions daccès – et non sa réalisation.

10 8 novembre 2006Cours d'algorithmique 2 - Intranet10 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

11 8 novembre 2006Cours d'algorithmique 2 - Intranet11 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

12 8 novembre 2006Cours d'algorithmique 2 - Intranet12 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

13 8 novembre 2006Cours d'algorithmique 2 - Intranet13 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 ». La seule liste vide est celle créée par « cree_vide ». Aucune liste obtenue par adjonction dun élément « a » à une liste « l » nest vide. Aucune liste obtenue par adjonction dun élément « a » à une liste « l » nest vide. Salutations de la part de Monsieur de la Palisse ! Salutations de la part de Monsieur de la Palisse !

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

15 8 novembre 2006Cours d'algorithmique 2 - Intranet15 Fonctions daccès sur listes La fonction daccès à lélément : tete_liste : LT -> T La fonction daccè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

16 8 novembre 2006Cours d'algorithmique 2 - Intranet16 Fonctions daccès sur listes Les limitations dapplication de ces fonctions, les appels suivants sont interdits : tete_liste ( cree_vide () ) queue_liste ( cree_vide () )

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

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

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

20 8 novembre 2006Cours d'algorithmique 2 - Intranet20 Types de données abstraits Nous nous sommes donné des noms de types : 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 : Nous nous sommes donné des fonctions et leurs propriétés : – cree_vide,..., – est_vide ( cree_vide () ) = Vrai, ….

21 8 novembre 2006Cours d'algorithmique 2 - Intranet21 Types de données abstraits Nous nous sommes donné des noms de types : 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 : Nous nous sommes donné des fonctions et leurs propriétés : – cree_vide,..., – est_vide ( cree_vide () ) = Vrai, …. Nous navons pas besoin de devenir plus concrets. Nous navons pas besoin de devenir plus concrets.

22 8 novembre 2006Cours d'algorithmique 2 - Intranet22 Types de données abstraits Nous nous sommes donné des noms de types : 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 : Nous nous sommes donné des fonctions et leurs propriétés : – cree_vide,..., – est_vide ( cree_vide () ) = Vrai, …. Nous navons pas besoin de devenir plus concrets. Nous navons pas besoin de devenir plus concrets. Cest un type de données abstrait.

23 8 novembre 2006Cours d'algorithmique 2 - Intranet23 Exemple dimplantation ajout_liste ( 5, ) 21 5 ajout_liste ( 5, cree_vide () ) 5

24 8 novembre 2006Cours d'algorithmique 2 - Intranet24 Exemple dimplantation tete_liste ( ) queue_liste ( ) 21 5

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

26 8 novembre 2006Cours d'algorithmique 2 - Intranet26 Listes et piles

27 8 novembre 2006Cours d'algorithmique 2 - Intranet27 Listes et piles

28 8 novembre 2006Cours d'algorithmique 2 - Intranet28 Listes et piles Pile ( dassiettes ) stack en anglais

29 8 novembre 2006Cours d'algorithmique 2 - Intranet29 Listes et piles Pile ( dassiettes ) stack en anglais ajout_liste = push = empiler tete_liste = top = sommet queue_liste = pop = dépiler

30 8 novembre 2006Cours d'algorithmique 2 - Intranet30 Listes et piles Pile ( dassiettes ) stack en anglais ajout_liste = push = empiler tete_liste = top = sommet queue_liste = pop = dépiler LIFO !

31 8 novembre 2006Cours d'algorithmique 2 - Intranet31 Listes et piles : les différences Les piles sont restreintes aux opérations : 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 dun tableau !!!

32 8 novembre 2006Cours d'algorithmique 2 - Intranet32 Listes et piles : les différences Les piles sont restreintes aux opérations : 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 dun tableau !!! Les listes peuvent comporter entre autres : 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 !

33 8 novembre 2006Cours d'algorithmique 2 - Intranet33 Listes et piles : les différences Les piles sont restreintes aux opérations : 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 dun tableau !!! Les listes peuvent comporter entre autres : 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

34 8 novembre 2006Cours d'algorithmique 2 - Intranet34 Listes et piles : les différences Les piles sont restreintes aux opérations : 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 dun tableau !!! Les listes peuvent comporter entre autres : 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

35 8 novembre 2006Cours d'algorithmique 2 - Intranet35 Listes en langage C #include typedef int type_base; typedef struct moi_meme {type_base valeur; struct moi_meme *suivant; } t_maillon, *ptr_liste;

36 8 novembre 2006Cours d'algorithmique 2 - Intranet36 Listes en langage C #include 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.

37 8 novembre 2006Cours d'algorithmique 2 - Intranet37 Listes en langage C #include 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.

38 8 novembre 2006Cours d'algorithmique 2 - Intranet38 Listes en langage C #include 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 sappelle t_maillon.

39 8 novembre 2006Cours d'algorithmique 2 - Intranet39 Listes en langage C #include 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 sappelle t_maillon. Le type du pointeur sur une telle structure sappelle ptr_liste.

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

41 8 novembre 2006Cours d'algorithmique 2 - Intranet41 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) {assert( liste != (ptr_liste)NULL ); return( liste->suivant ); }

42 8 novembre 2006Cours d'algorithmique 2 - Intranet42 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) {assert( liste != (ptr_liste)NULL ); return( liste->suivant ); } Création de la liste vide.

43 8 novembre 2006Cours d'algorithmique 2 - Intranet43 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) {assert( liste != (ptr_liste)NULL ); return( liste->suivant ); } Création de la liste vide. Le prédicat de liste vide ou non. vide ou non.

44 8 novembre 2006Cours d'algorithmique 2 - Intranet44 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) {assert( liste != (ptr_liste)NULL ); return( liste->suivant ); } Création de la liste vide. Le prédicat de liste vide ou non. vide ou non. Rendre la tête dune liste non vide.

45 8 novembre 2006Cours d'algorithmique 2 - Intranet45 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) {assert( liste != (ptr_liste)NULL ); return( liste->suivant ); } Création de la liste vide. Le prédicat de liste vide ou non. vide ou non. Rendre la tête dune liste non vide. On sassure que la liste nest pas la liste vide. Préférable : ( liste != cree_vide() )

46 8 novembre 2006Cours d'algorithmique 2 - Intranet46 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) {assert( liste != (ptr_liste)NULL ); return( liste->suivant ); } Création de la liste vide. Le prédicat de liste vide ou non. vide ou non. Rendre la tête dune liste non vide. Rendre la queue dune liste non vide.

47 8 novembre 2006Cours d'algorithmique 2 - Intranet47 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 );}

48 8 novembre 2006Cours d'algorithmique 2 - Intranet48 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???

49 8 novembre 2006Cours d'algorithmique 2 - Intranet49 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_listeelt ???

50 8 novembre 2006Cours d'algorithmique 2 - Intranet50 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_listeelt liste

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

52 8 novembre 2006Cours d'algorithmique 2 - Intranet52 Exporter les types --- fichier adt_liste.c #include 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 ); }...

53 8 novembre 2006Cours d'algorithmique 2 - Intranet53 Exporter les types --- fichier adt_liste.c #include 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.

54 8 novembre 2006Cours d'algorithmique 2 - Intranet54 Exporter les types --- fichier adt_liste.c #include 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

55 8 novembre 2006Cours d'algorithmique 2 - Intranet55 Exporter les types --- fichier adt_liste.c #include 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

56 8 novembre 2006Cours d'algorithmique 2 - Intranet56 Exporter les types --- fichier adt_liste.c #include #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

57 8 novembre 2006Cours d'algorithmique 2 - Intranet57 prog.c qui utilise le type de données liste : #include #include type_liste.h #include adt_liste.h int main (void)... Lutilisateur voit la structure du type de liste. Lutilisateur voit les signatures des fonctions sur les listes.

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

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

60 8 novembre 2006Cours d'algorithmique 2 - Intranet60 Compilation séparée gcc –o executable prog.c gcc –o executable prog.c – On ne peut pas générer lexé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 gcc –o executable prog.c adt_liste.c – On peut compiler les deux fichiers en même temps.

61 8 novembre 2006Cours d'algorithmique 2 - Intranet61 Compilation séparée gcc –o executable prog.c gcc –o executable prog.c – On ne peut pas générer lexé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 gcc –o executable prog.c adt_liste.c – On peut compiler les deux fichiers en même temps. gcc –c prog.c gcc –c prog.c – Nous compilons prog.c pour générer « prog.o ». – Nous navons pas besoin des définitions sur les listes, car nous ne créons pas encore lexécutable. – De même, gcc –c adt_liste.c crée « adt_liste.o ».

62 8 novembre 2006Cours d'algorithmique 2 - Intranet62 Compilation séparée gcc –o executable prog.c gcc –o executable prog.c – On ne peut pas générer lexé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 gcc –o executable prog.c adt_liste.c – On peut compiler les deux fichiers en même temps. gcc –c prog.c gcc –c prog.c – Nous compilons prog.c pour générer « prog.o ». – Nous navons pas besoin des définitions sur les listes, car nous ne créons pas encore lexécutable. – De même, gcc –c adt_liste.c crée « adt_liste.o ». gcc –o executable prog.o adt_liste.o gcc –o executable prog.o adt_liste.o

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

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

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

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

67 8 novembre 2006Cours d'algorithmique 2 - Intranet67 Créer et utiliser les librairies Il existe des librairies statiques, dynamiques et archives. 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.

68 8 novembre 2006Cours d'algorithmique 2 - Intranet68 Créer et utiliser les librairies Il existe des librairies statiques, dynamiques et archives. 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 « 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

69 8 novembre 2006Cours d'algorithmique 2 - Intranet69 Créer et utiliser les librairies Il existe des librairies statiques, dynamiques et archives. 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 « 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 Lordre des arguments importe : Lordre des arguments importe : – OK : gcc prog-math.c -lm – KO : gcc -lm prog-math.c

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

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

72 8 novembre 2006Cours d'algorithmique 2 - Intranet72 Les files LIFO : listes et piles. LIFO : listes et piles. – Les accès en « ajout », « lecture » et « suppression » se font en tête de liste : InsertionLectureSuppression FIFO : files. FIFO : files. – First In – First Out, cest plus équitable ! – Linsertion se fait à la fin et cest la seule différence. LectureSuppression Insertion Insertion … …

73 8 novembre 2006Cours d'algorithmique 2 - Intranet73 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 ); }}

74 8 novembre 2006Cours d'algorithmique 2 - Intranet74 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.

75 8 novembre 2006Cours d'algorithmique 2 - Intranet75 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 !

76 8 novembre 2006Cours d'algorithmique 2 - Intranet76 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 jusquau dernier maillon,

77 8 novembre 2006Cours d'algorithmique 2 - Intranet77 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 !

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

79 8 novembre 2006Cours d'algorithmique 2 - Intranet79 Les files Souvent, on maintient deux pointeurs : Souvent, on maintient deux pointeurs : tête tête queue queue Cest plus pratique davoir une structure de synthèse : Cest plus pratique davoir une structure de synthèse :file … …

80 8 novembre 2006Cours d'algorithmique 2 - Intranet80 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 !

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

82 8 novembre 2006Cours d'algorithmique 2 - Intranet82 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.

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

84 8 novembre 2006Cours d'algorithmique 2 - Intranet84 Les arbres NON enracinés Les liens sont bi-directionnels. Il ny a pas de racine.

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

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

87 8 novembre 2006Cours d'algorithmique 2 - Intranet87 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. Concernantlapplication, les nœuds peuventcomporter des valeurs, que lon appelle aussi des étiquettes. x +

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

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

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

91 8 novembre 2006Cours d'algorithmique 2 - Intranet91 Les arbres enracinés (binaires) comme ADT Création dune feuille : Création dune 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 valeur_feuille : A -> int

92 8 novembre 2006Cours d'algorithmique 2 - Intranet92 Les arbres enracinés (binaires) comme ADT Création dune feuille : Création dune 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 valeur_feuille : A -> int Création dun nœud binaire : Création dun 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 etiquette_arbre : A -> int

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

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

95 8 novembre 2006Cours d'algorithmique 2 - Intranet95 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 );

96 8 novembre 2006Cours d'algorithmique 2 - Intranet96 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 ); 57

97 8 novembre 2006Cours d'algorithmique 2 - Intranet97 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 );

98 8 novembre 2006Cours d'algorithmique 2 - Intranet98 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 );

99 8 novembre 2006Cours d'algorithmique 2 - Intranet99 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 );

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

101 8 novembre 2006Cours d'algorithmique 2 - Intranet101 Les arbres en langage C Un pointeur sur un arbre est : 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 : Il faut donc une structure capable de contenir les deux : – les champs dune feuille, – les champs dun nœud, – un indicateur booléen qui distingue les deux cas de figure.

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

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

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

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

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

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

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

109 8 novembre 2006Cours d'algorithmique 2 - Intranet109 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 = (ptr_arbre)malloc(sizeof(t_arbre)); arbre->est_feuille = 1; arbre->est_feuille = 1; arbre->valeur = val; arbre->valeur = val; return(arbre); return(arbre);}

110 8 novembre 2006Cours d'algorithmique 2 - Intranet110 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 = (ptr_arbre)malloc(sizeof(t_arbre)); arbre->est_feuille = 1; arbre->est_feuille = 1; arbre->valeur = val; arbre->valeur = val; return(arbre); return(arbre);} Cest précisément un champ qui mémorise si cest une feuille. mémorise si cest une feuille.

111 8 novembre 2006Cours d'algorithmique 2 - Intranet111 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 = (ptr_arbre)malloc(sizeof(t_arbre)); arbre->est_feuille = 1; arbre->est_feuille = 1; arbre->valeur = val; arbre->valeur = val; return(arbre); return(arbre);} Lallocation de la mémoire. Définition des champs concernés.

112 8 novembre 2006Cours d'algorithmique 2 - Intranet112 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 = (ptr_arbre)malloc(sizeof(t_arbre)); arbre->est_feuille = 0; arbre->est_feuille = 0; arbre->etiq = symbole; arbre->etiq = symbole; arbre->fg = fg; arbre->fg = fg; arbre->fd = fd; arbre->fd = fd; return(arbre); return(arbre);}

113 8 novembre 2006Cours d'algorithmique 2 - Intranet113 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 = (ptr_arbre)malloc(sizeof(t_arbre)); arbre->est_feuille = 0; arbre->est_feuille = 0; arbre->etiq = symbole; arbre->etiq = symbole; arbre->fg = fg; arbre->fg = fg; arbre->fd = fd; arbre->fd = fd; return(arbre); return(arbre);} Lallocation de la mémoire. Définition des champs concernés.

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

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

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

117 8 novembre 2006Cours d'algorithmique 2 - Intranet117 Listes, arbres et le pointeur NULL Une liste peut être vide ! Une liste peut être vide ! Elle sera représentée par le pointeur NULL ! Elle sera représentée par le pointeur NULL ! La raison profonde est le fait que lopération de base est : La raison profonde est le fait que lopé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 : Nous avons les fonctions suivantes : – cree_vide – ajout_liste – est_vide – tete_liste – queue_liste

118 8 novembre 2006Cours d'algorithmique 2 - Intranet118 Listes, arbres et le pointeur NULL Un arbre nest jamais NULL ! Un arbre nest jamais NULL ! Cest juste le programmeur qui lest ! ! ! Cest juste le programmeur qui lest ! ! ! La raison profonde est le fait que lopération de base est : La raison profonde est le fait que lopération de base est : – la construction darbre, – qui nest pas associative – et la question de lélément neutre ne se pose même pas !

119 8 novembre 2006Cours d'algorithmique 2 - Intranet119 Listes, arbres et le pointeur NULL Un arbre nest jamais NULL ! Un arbre nest jamais NULL ! Cest juste le programmeur qui lest ! ! ! Cest juste le programmeur qui lest ! ! ! La raison profonde est le fait que lopération de base est : La raison profonde est le fait que lopération de base est : – la construction darbre, – qui nest 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 BC C AB

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

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

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

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

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

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

126 8 novembre 2006Cours d'algorithmique 2 - Intranet126 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 ! ! !


Télécharger ppt "Cours d'algorithmique 2 - Intranet 1 8 novembre 2006 Cours dAlgorithmique Listes, piles et files. Arbres. Types de données abstraits. Implantations."

Présentations similaires


Annonces Google