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

Th_Info_B - 80 M. BENJELLOUN 2003-2004 Arbres Un arbre est soit un arbre atomique (une feuille), soit un noeud et une suite de sous-arbres. racine feuilles.

Présentations similaires


Présentation au sujet: "Th_Info_B - 80 M. BENJELLOUN 2003-2004 Arbres Un arbre est soit un arbre atomique (une feuille), soit un noeud et une suite de sous-arbres. racine feuilles."— Transcription de la présentation:

1 Th_Info_B - 80 M. BENJELLOUN 2003-2004 Arbres Un arbre est soit un arbre atomique (une feuille), soit un noeud et une suite de sous-arbres. racine feuilles noeud interne fils droit fils gauche père L'ensemble des noeuds est constitué des nœuds internes et des feuilles

2 Th_Info_B - 81 M. BENJELLOUN 2003-2004 Lintérêt de cette organisation est de laisser à lutilisateur le soin de regrouper les fichiers à sa convenance tout en maintenant une structure hiérarchique.

3 Th_Info_B - 82 M. BENJELLOUN 2003-2004 Représentation symbolique des arbres Arbre videArbre singletonArbre quelconque Arbre binaire CECI N'EST PAS UN ARBRE deux pères

4 Th_Info_B - 83 M. BENJELLOUN 2003-2004 Par définition un arbre est une structure de données constituée dun nœud appelé racine et de sous-arbres fils de la racine. Cest donc une définition récursive. Un nœud peut contenir une ou plusieurs valeurs, et on parlera alors d'arbres étiquetés et de la valeur (ou des valeurs) d'un nœud. racine

5 Th_Info_B - 84 M. BENJELLOUN 2003-2004 Les caractéristiques dun arbre sont : La taille de larbre est le nombre total de nœuds. La hauteur ou niveau dun nœud x est le nombre de liens sur lunique chemin allant de la racine à x, notée h(x). La hauteur ou profondeur de larbre A, h(A) = max { h(x) } x racine x

6 Th_Info_B - 85 M. BENJELLOUN 2003-2004 La longueur de cheminement de larbre A, LC(A) = h(x) x hauteur d'un nœud dans un arbre de racine r: si x = r h(x) = 0 sinon h(x) = 1 + h(père(x)) La profondeur d'un nœud est la longueur du chemin qui le joint à la racine. La racine est de hauteur 0, ses fils de hauteur 1 et les k autres nœuds de hauteur supérieure à 1.

7 Th_Info_B - 86 M. BENJELLOUN 2003-2004 Exemple de mesures profondeur # noeuds # feuilles 0 1 0 1 2 0 2 3 2 3 1 0 4 2 1 5 1 0 6 2 2 Taille = 12Nbrf = 5h = 6 LC(A) = h(x) x

8 Th_Info_B - 87 M. BENJELLOUN 2003-2004 a b c d e f g La recherche d'une clé d'un côté sera plus lente qu'une recherche de l'autre côté. Arbres binaires a b c d e f g arbre équilibré La différence entre la hauteur du sous-arbre gauche et la hauteur du sous-arbre droit est d'au plus une unité.

9 Th_Info_B - 88 M. BENJELLOUN 2003-2004 Arbre binaire typedef struct cellule { int data; struct noeud *fils_gauche; struct noeud *fils_droit; } nœud;

10 Th_Info_B - 89 M. BENJELLOUN 2003-2004 Un Arbre est un pointeur sur un nœud, la racine de larbre : typedef nœud *arbre; Un Arbre vide est un pointeur NULL : arbre = NULL; Nouveau : il faut faire une allocation mémoire et placer létiquette. En cas derreur dallocation le pointeur renvoyé est NULL (larbre est vide) : arbre nouveau_binaire(int elt, arbre racine) { racine = (nœud *) malloc(sizeof (nœud )); if (racine != NULL)){ racine data = elt; racine fils_gauche= NULL; racine fils_droit=NULL; } return(racine); } NULL elt

11 Th_Info_B - 90 M. BENJELLOUN 2003-2004 Il faut relier un noeud à un ou plusieurs sous arbres. arbre cons_binaire (arbre racine, arbre s_arb_g, arbre s_arb_d) { racine fils_gauche = s_arb_g; racine fils_droit = s_arb_d; return(racine); }

12 Th_Info_B - 91 M. BENJELLOUN 2003-2004 Hauteur int HauteurArbre(arbre A) { if(A non vide) return (1 + Max(HauteurArbre(Ag), HauteurArbre(Ad)) ); else return 0; } Complexité : O(n) Nombre noeud int NbrNoeud(arbre A) { if(A non vide) return (1 + NbrNoeud(Ag) + NbrNoeud(Ad) ); else return 0; }

13 Th_Info_B - 92 M. BENJELLOUN 2003-2004 Max noeud int MaxNoeud(arbre A) { if(A non vide) return Max(data, MaxNoeud(Ag), MaxNoeud(Ad)); else return 0; } Min noeud int MinNoeud(arbre A) { if(A non vide) return Min(data, MinNoeud (Ag), MinNoeud (Ad)) ; else return 0; }

14 Th_Info_B - 93 M. BENJELLOUN 2003-2004 Arbre binaire de recherche ABR Un arbre binaire de recherche est un arbre binaire tel que pour tout nœud x, les nœuds de son sous arbre-gauche sils en existent ont des valeurs inférieures ou égales à celle de x, et les nœuds de son sous arbre-droit des valeurs strictement supérieures. X <=X>X Ce que lon traduit par g(A) racine(A) < d(A). Utilisation importante en Info pour la localisation, +, -, tri … 24 10 37

15 Th_Info_B - 94 M. BENJELLOUN 2003-2004 Un arbre binaire est soit vide, noté Ø, soit de la forme où r est la racine et où Ag et Ad sont des arbres binaires. r <= r> r AgAd

16 Th_Info_B - 95 M. BENJELLOUN 2003-2004 24 2929 35 16 1 272720 8 15 Exemple darbre binaire de recherche Tout sous-arbre dun ABR est un ABR Ag Ad

17 Th_Info_B - 96 M. BENJELLOUN 2003-2004 test si arbre binaire et de recherche bool TestABR(arbre T){ if(T non vide){ if( TestABR(Td) est un ABR && TestABR(Tg) est un ABR) { if((Td pas vide) && (Td data <= T data)) return (probleme) else { if((Tg pas vide) && (Tg data > T data)) return (probleme) else return (OK) } else return (???) } else return (???) } Complexité : O(2n+1) * O(1) = O(n) x <= x> x TgTd racine

18 Th_Info_B - 97 M. BENJELLOUN 2003-2004 12 23 78 9 - 77 2210 -2 9 Parcours en profondeur d'un arbre binaire de recherche On considère lopération de parcours dun arbre binaire qui consiste à examiner systématiquement dans un certain ordre tous les nœuds de larbres pour effectuer un traitement de données.

19 Th_Info_B - 98 M. BENJELLOUN 2003-2004 Parcours préfixe : 12, 9, -2, -77, 9, 10, 23, 22, 78 12 23 78 9 - 77 2210 -2 9 Parcours préfixe Le parcours en profondeur à gauche consiste à partir de la racine et à tourner autour de larbre en allant toujours le plus à gauche possible. void Prefixe(arbre racine) { if (! vide(racine)) { printf(%d\t,racine data); Prefixe(racine fils_gauche); Prefixe(racine fils_droit); } Lister Père Prefixe(Fils_G) Prefixe(Fils_autres)

20 Th_Info_B - 99 M. BENJELLOUN 2003-2004 I III II SI ABR Le parcours infixe affiche les éléments dans lordre croissant. 12 23 78 9 - 77 2210 -2 9 Parcours infixe infixe : -77, -2, 9, 9, 10, 12, 22, 23, 78 void infixe(arbre racine) { if (! vide(racine)) { infixe(racine fils_gauche); printf(%d\t,racine data); infixe(racine fils_droit); } Infixe(Fils_G) Lister Père Infixe(Fils_autres)

21 Th_Info_B - 100 M. BENJELLOUN 2003-2004 III II I Parcours Postfixe : - 77, 9, -2, 10, 9, 22, 78, 23, 12 12 23 78 9 - 77 2210 -2 9 Parcours suffixe ou Postfixe void Postfixe(arbre racine) { if (! vide(racine)) { Postfixe(racine fils_gauche); Postfixe(racine fils_droit); printf(%d\t,racine data); }

22 Th_Info_B - 101 M. BENJELLOUN 2003-2004 Exemple: Parcours 3 1 5 02 6 Parcours préfixe : Parcours infixe : Infixe(Fils_G) Lister Père Infixe(Fils_autres) 0, 1, 2, 3, 4, 5, 6 3, 1, 0, 2, 5, 4, 6 Parcours postfixe : 0, 2, 1, 4, 6, 5, 3 Posfixe(Fils_G) Posfixe(Fils_autres) Lister Père 4

23 Th_Info_B - 102 M. BENJELLOUN 2003-2004 Exemple: Parcours 1 234 567 Parcours préfixe : Parcours infixe : Infixe(Fils_G) Lister Père Infixe(Fils_autres) Parcours postfixe : Posfixe(Fils_G) Posfixe(Fils_autres) Lister Père

24 Th_Info_B - 103 M. BENJELLOUN 2003-2004 rechercher : valeur x dans arbre == Rech(x,arbre) booléen On compare lélément à la valeur de la racine : - si le sous-arbre sélectionné est vide, lélément est absent échec rechercher ( x, ) = faux - si égalité succès x = r rechercher (x, ) = vraie Recherche dun élément Recherche dichotomoque - si la valeur est plus petite, on recommence récursivement dans le sous-arbre gauche ; et réciproquement si la valeur est plus grande dans le sous-arbre droit x ) = rechercher (x, g ) x > r rechercher (x, ) = rechercher (x, d ) Complexité : La complexité au pire est en O ( hauteur de larbre ). 24 2929 35 16 272720 3 5 1

25 Th_Info_B - 104 M. BENJELLOUN 2003-2004 24 2929 35 16 1 272720 3 5 Soit à rechercher 20 dans l'arbre suivant 20 est plus petit que 24 20 est plus grand que 16 20 est trouvé

26 Th_Info_B - 105 M. BENJELLOUN 2003-2004 Adjonction dun élément aux feuilles Ladjonction aux feuilles dun élément se réalise en deux étapes : - étape de recherche pour savoir où insérer le nouvel élément ; - adjonction elle-même. arbre ajout_feuille (arbre A, int e ) { if (A== ) return else if ( e racine(A) ) return else return } La complexité dune adjonction est O ( h(A) ). e

27 Th_Info_B - 106 M. BENJELLOUN 2003-2004 arbre insert(arbre T, int x) { if(T vide) { //sommet vide T = (struct nœud *) malloc(sizeof(struct nœud)) T data = x T droit = NULL T gauche = NULL }else{//sommet non vide if(T data == x) //ne rien faire !! else { if(x < T data) //inserer ds arbre gauche Tg = insert(Tg, x) else //inserer ds arbre droit Td = insert(Td, x) } return T } NULL x

28 Th_Info_B - 107 M. BENJELLOUN 2003-2004 ABR réduire la complexité en temps Alors que linsertion dans un tableau nécessite de déterminer sa place, en parcourant le tableau depuis le début (k comparaisons) puis de décaler les (n-k) éléments successeurs pour ménager une place. Donc une complexité en O(n) avec n le nombre déléments du tableau. La complexité dun ajout est O ( h(A) ). mais pas la complexité de la programmation !!!

29 Th_Info_B - 108 M. BENJELLOUN 2003-2004 soit on remplace le nœud à supprimer par le plus grand élément de son sous-arbre gauche, soit on le remplace par le plus petit élément de son sous-arbre droit. Suppression dun élément arbre supprimer (arbre, valeur) arbre recherche de lélément à supprimer suppression qui dépend de la place de lélément nœud sans filsnœud avec un seul filsnoeud avec deux fils immédiate remplace le nœud par son fils

30 Th_Info_B - 109 M. BENJELLOUN 2003-2004 arbre suppression ( arbre A, int e ) { if (A== ) // recherche de lélément à supprimer return erreur; if ( e < racine(A) ) return < racine(A), suppression( g(A), e ), d(A) ); else if ( e > racine(A) ) return < racine(A), g(A), suppression( d(A), e ) ); else { // on la trouver donc suppression if est_feuille(A) return ( ); else if (g(A) == ) return d(A); else if (d(A) == ) return g(A); else { // on ajoute lélément le plus à droite du sous-arbre gauche retourner }

31 Th_Info_B - 110 M. BENJELLOUN 2003-2004 int max_noeud ( arbre A) { // retourne le plus grand élément de larbre A, le plus à droite if ( d(A) == )return racine(A); elsereturn max_noeud(d(A)) ; } // retourne larbre privé de son plus grand élément arbre retire_max ( arbre A ) { if ( d(A) == )return g(A); elsereturn ; } La complexité est O ( h(A) ).

32 Th_Info_B - 111 M. BENJELLOUN 2003-2004 La structure de tas est un arbre vérifiant les deux propriétés suivantes: Larbre est un arbre binaire parfait La valeur de tout nœud est >= à celle de ses descendants La structure de tas Arbres binaires complets Un arbre binaire est complet si tous les nœuds qui ne sont pas des feuilles ont 2 fils. 15 14 2 8 13 7 5

33 Th_Info_B - 112 M. BENJELLOUN 2003-2004 Arbres binaires parfaits, ordre hiérarchique Un arbre binaire est parfait si toutes ses feuilles sont situées sur les deux derniers niveaux, lavant dernier étant complet, et les feuilles du dernier sont le plus à gauche possible. Attention ! un arbre binaire parfait nest pas forcément complet. tas 15 14 2 8 13

34 Th_Info_B - 113 M. BENJELLOUN 2003-2004 Tas = arbre binaire parfait partiellement ordonné arbre parfait: – toutes les feuilles sont sur les deux derniers niveaux, – l'avant dernier niveau est complet – les feuilles du dernier niveau sont le plus à gauche possible partiellement ordonné: – tout nœud est plus grand que ses deux fils 24 23 7 16 1 2210 8 5 4

35 Th_Info_B - 114 M. BENJELLOUN 2003-2004 15 14 2 8 7 5 Arbres binaires complets Un arbre binaire est complet si tous les nœuds qui ne sont pas des feuilles ont 2 fils. Tests !! Arbre binaire complet ?

36 Th_Info_B - 115 M. BENJELLOUN 2003-2004 15 14 2 8 13 7 5 Arbre binaire complet ? 9 Arbres binaires complets Un arbre binaire est complet si tous les nœuds qui ne sont pas des feuilles ont 2 fils. Tests !!

37 Th_Info_B - 116 M. BENJELLOUN 2003-2004 Arbres binaires parfaits, ordre hiérarchique Un arbre binaire est parfait si toutes ses feuilles sont situées sur les deux derniers niveaux, lavant dernier étant complet, et les feuilles du dernier sont le plus à gauche possible. Attention ! un arbre binaire parfait nest pas forcément complet. 15 14 2 8 13 7 5 Arbre binaire complet ? Arbre binaire parfait? Tests !!

38 Th_Info_B - 117 M. BENJELLOUN 2003-2004 24 23 7 16 1 2210 8 5 Exemple de tas Profondeur ou Nbr nœuds Niveau Max 0 2 0 = 1 1 2 1 = 2 2 2 2 = 4 h=3 au Max 2 3 = 8 Racine = + gd valeur = 2 h+1 - 1 N <= La structure de tas

39 Th_Info_B - 118 M. BENJELLOUN 2003-2004 Nœud x en i, son père est en i/2 Nœud x en i, son fils gauche en 2*i Nœud x en i, son fils droit en 2*i+1 24 23 7 16 1 2210 8 5 Exemple de tas Profondeur ou Nbr nœuds Niveau Max 0 2 0 = 1 1 2 1 = 2 2 2 2 = 4 3 au Max 2 3 = 8 1 23 2*2=456 2*3+1=7 89 10 Index 2*Index2*Index + 1 4

40 Th_Info_B - 119 M. BENJELLOUN 2003-2004 24 23 7 16 1 2210 8 5 1 23 2*2=456 2*3+1=7 89 10 Index 4 24 1623 7 12210 8 5 4 i 1 2 3 4 5 6 7 8 9 10 tab[i] int pere(i){ return (i/2); } int gauche(i){ return (2 * i); } int droit(i){ return (2 * i + 1); } Relation entre un tas et tableau

41 Th_Info_B - 120 M. BENJELLOUN 2003-2004 Opérations sur les tas Insertion dun élément dans un tas 24 23 7 16 1 2210 8 5 4 22 24 23 7 16 1 22 8 5 4 10 Nouveau nœud insérer le plus à gauche possible sur le niveau de profondeur le plus élevée. tjr arbre binaire complet mais pas forcement un tas.

42 Th_Info_B - 121 M. BENJELLOUN 2003-2004 24 23 7 16 1 22 8 5 4 10 24 23 7 22 1 16 8 5 4 10 Compléxité : O(h) avec h : hauteur du tas Or la hauteur dun tas de taille n = log 2 n linsertion requiert un temps O(logn) tant que ( y racine ) et ( y > père(y) ) faire échanger y et père(y) 1 2 3 4567 891011 Insertion de n éléments O(nlogn)

43 Th_Info_B - 122 M. BENJELLOUN 2003-2004 void ajouter (int tab[], int ntas, int val ) { // ajoute lélément x au tas de ntas éléments int i; ntas ++ ; i =ntas ; tab[i] = val ; while ( ( i > 1 ) && ( tab[i/2] < tab[i] ) ){ Echanger ( tab[i], tab[i / 2] ); i = i/2 ; } VERIFICATION

44 Th_Info_B - 123 M. BENJELLOUN 2003-2004 24 1623 7 12210 8 5 4 i 1 2 3 4 5 6 7 8 9 10 tab[i] Avant lajout while ( tab[i /2] < tab[i ] ) { Echanger ( tab[i], tab[i / 2] ); i = i/2 ; } 24 1623 7 122 8 5 4 tab[i] 10 Echanger i = i/2 i=11/2=5 Echanger i = i/2 i=5/2=2 24 2223 7 12216 8 5 4 tab[i] 10 22 + 11

45 Th_Info_B - 124 M. BENJELLOUN 2003-2004 24 2223 7 12216 8 5 4 tab[i] 10 i 1 2 3 4 5 6 7 8 9 10 11 24 23 7 22 1 16 8 5 4 10 1 2 3 4567 89 11 CQFD

46 Th_Info_B - 125 M. BENJELLOUN 2003-2004 Exce : Construction dun tas 8 15 2 3 51413 tab[i] i 1 2 3 4 5 6 7 8 15 8 tas+ 15 8 2 8 2 13 15 13 2 8 + 15 13 2 8 14 tas 15 14 2 8 13 + + tas 15 14 5 8 13 2 3

47 Th_Info_B - 126 M. BENJELLOUN 2003-2004 8 15 2 3 51413 tab[i] i 1 2 3 4 5 6 7 int i; ntas ++ ; i =ntas ; tab[i] = val ; while ( ( i > 1 ) && ( tab[i/2] < tab[i] ) ){ Echanger ( tab[i], tab[i / 2] ); i = i/2 ; } 8 15 tab[2/2] < tab[2] 8 15 13 15 2 3 514 8 13 15 2 3 514 8 15 2 3 513 8 8 15 2 3 51413 tab[i] i 1 2 3 4 5 6 7 8 15 2 3 51413 tab[i]

48 Th_Info_B - 127 M. BENJELLOUN 2003-2004 tab[i] i 1 2 3 4 5 6 7 14 15 2 3 513 8 int i; ntas ++ ; i =ntas ; tab[i] = val ; while ( ( i > 1 ) && ( tab[i/2] < tab[i] ) ){ Echanger ( tab[i], tab[i / 2] ); i = i/2 ; } 14 15 5 3 213 8 14 15 5 3 213 8 14 15 5 3 213 8 15 14 5 8 13 2 3

49 Th_Info_B - 128 M. BENJELLOUN 2003-2004 Suppression dun élément On remplace la valeur du nœud par celle du nœud le plus à droite possible sur le niveau de profondeur le plus élevée, nœud que lon supprime alors, puis permutations. Exp: racine : suppression du premier élément de la file 24 23 7 16 1 2210 8 5 4 4 23 7 16 1 2210 8 5 4

50 Th_Info_B - 129 M. BENJELLOUN 2003-2004 4 23 7 16 1 2210 8 5 23 4 7 16 1 2210 8 5 23 2 7 16 1 410 8 5

51 Th_Info_B - 130 M. BENJELLOUN 2003-2004 Tri par tas [Heap sort] Principe : deux phases - Construire un tas contenant les n éléments par adjonction successives ; en O (n log n). - Tant que le tas nest pas vide, répéter l'opération de prendre l'élément de la racine (max), le retirer du tas avec réorganisation, mettre ce max à sa place définitive ; en O (n log n). 15 14 5 8 13 2 3 3 14 5 8 13 2 15 réorganisation Suppression

52 Th_Info_B - 131 M. BENJELLOUN 2003-2004 3 14 5 8 13 2 15 réorganisation 14 13 5 8 3 2 15 2 13 5 8 3 14 15 Suppression

53 Th_Info_B - 132 M. BENJELLOUN 2003-2004 trier_tas(A) { construire_tas(A) while( …) { echanger A[1] avec A[taille] supprimer A[taille] taille = taille – 1 reorganisation() }

54 Th_Info_B - 133 M. BENJELLOUN 2003-2004 Test !!! 8 15 2 3 51413 tab[i] i 1 2 3 4 5 6 7 1: construction dun tas 2: ajout de 20

55 Th_Info_B - 134 M. BENJELLOUN 2003-2004 15 1314 3 2 5 8 20 1514 13 2 5 8 3 15 1314 3 2 5 8 20 + i 1 2 3 4 5 6 7 Test !!!

56 Th_Info_B - 135 M. BENJELLOUN 2003-2004 Test !!! 5, 1, 7, 3, 4, 6, 2 Construction dun arbre binaire de recherche (ABR). i 1 2 3 4 5 6 7 r <= r> r AgAd Prefixe, Infixe, Postfixe ??

57 Th_Info_B - 136 M. BENJELLOUN 2003-2004 Application : Imprimante en réseau JbU5 Tri: Arbre JbUn JbU1 JbUn JbU1 User1 User2 UserN JbUnJbU1 FIFO

58 Th_Info_B - 137 M. BENJELLOUN 2003-2004 Diviser pour régner Existe-t-il une méthode pour rechercher une récursivité et évaluer a priori sa complexité? On peut couper un problème de taille N en A problèmes identiques Recomposition de ces A problèmes se fait en un temps d'ordre N

59 Th_Info_B - 138 M. BENJELLOUN 2003-2004 Exemple : TRI par FUSION Pour trier un tableau t de n éléments, on le scinde en deux tableaux de même taille (à un élément près). On les note t1 de taille n1 et t2 de taille n-n1. Ces deux tableaux sont ensuite triés (appel récursif) et enfin fusionnés de manière à reformer le tableau t trié. scinder fusionne r T(N) = 2 * T(N/2) + ordre N d'où T(N) = N log 2 N tableau t

60 Th_Info_B - 139 M. BENJELLOUN 2003-2004 Quicksort : tri rapide Principe : diviser pour régner On prend un élément au hasard dans le tableau à trier. Soit p (pivot) sa valeur. On partitionne le reste du tableau en 2 zones: les éléments plus petits ou égaux à p, et les éléments plus grands à p. Si on arrive à mettre en tête du tableau les plus petits que p et en fin du tableau les plus grands, on peut mettre p entre les deux zones à sa place définitive. On recommence récursivement la procédure Quicksort sur chacune des partitions tant qu'elles ne sont pas réduites à un élément. A la fin, la liste est triée par ordre croissant. p> pivot pivot g > pivotG pivotG d > pivotD pivotD

61 Th_Info_B - 140 M. BENJELLOUN 2003-2004 p> pivot pivot void Quicksort ( int tab[], int g, int d ) { // Quicksort ( tab, 0, n ) int k; //position du pivot if( g < d){ Placer (tab, g, d, &k); Quicksort (tab, g, k - 1); Quicksort (tab, k + 1, d); } g d

62 Th_Info_B - 141 M. BENJELLOUN 2003-2004 p p p p > p p x iL K j j+1 La fonction Placer : La partition et le placement du pivot ne nécessitent quun parcours. On utilise deux compteurs L et K qui partent des extrémités du sous- tableau, et qui vont lun vers lautre : - L part de i+1 et avance tant que lon rencontre un élément à p. - K part de j et recule tant que lon rencontre un élément > à p. On échange les deux éléments et on recommence la progression jusquà ce que les deux compteurs se croisent : la place définitive du pivot est en k, et on y place le pivot p par échange avec un élément à p. complexité en moyenne O (n log n).

63 Th_Info_B - 142 M. BENJELLOUN 2003-2004 Exemple de tri rapide 53264137 3264137 ij 53264137 3234167 32341675

64 Th_Info_B - 143 M. BENJELLOUN 2003-2004 Arbres balancés ou B-arbres prendre en compte la taille des blocs disques regrouper les nœuds voisins dans un même bloc Les B_arbres sont des arbres de recherche équilibrés conçus pour être efficaces sur des disques ou d'autres unités de stockage secondaire à accès direct. Dans une application classique ayant recours aux B_arbres, la quantité de données gérées est si grande quelles ne tiennent pas toutes en même temps dans la mémoire principale. Généralisation des ABR

65 Th_Info_B - 144 M. BENJELLOUN 2003-2004 Éclatement d'une racine

66 Th_Info_B - 145 M. BENJELLOUN 2003-2004 Soient - B boules blanches et N boules noires dans une urne. - B 0, N 0, B+N 1 - Une réserve infinie de boules Mode de fonctionnement Tirage aveugle de 2 boules - si les boules sont de même couleur, on remet une boule noire dans l'urne - sinon, on remet une boule blanche Le jeu se termine lorsqu'il ne reste plus qu'une boule dans l'urne Question Quelle est la couleur de la dernière boule connaissant les nombres initiaux N et B? Jeu de l'urne Éviter de réinventer la roue

67 Th_Info_B - 146 M. BENJELLOUN 2003-2004 Le jeu se terminera-t-il ou pas? Le jeu se terminera car à chaque tirage, le nombre de boules dans l'urne diminue de 1. Tirage aveugle de 2 boules - si les boules sont de même couleur, on remet une boule noire dans l'urne - sinon, on remet une boule blanche

68 Th_Info_B - 147 M. BENJELLOUN 2003-2004 RESOLUTION : Le jeu se terminera car à chaque tirage, le nombre de boules dans l'urne diminue de 1. Exemple avec 3 Boules: GENERALISER 2Bles de même couleur N sinon, on remet boule blanche

69 Th_Info_B - 148 M. BENJELLOUN 2003-2004 GENERALISER !! Impensable

70 Th_Info_B - 149 M. BENJELLOUN 2003-2004 AUTRE APPROCHE : Tirages possibles et propriétés? (B-2) + (N+1) B + (N-1) Conclusion La parité des blanches est inchangée. Donc, si le nombre initial B est impair, la dernière boule sera blanche, sinon, elle sera noire.


Télécharger ppt "Th_Info_B - 80 M. BENJELLOUN 2003-2004 Arbres Un arbre est soit un arbre atomique (une feuille), soit un noeud et une suite de sous-arbres. racine feuilles."

Présentations similaires


Annonces Google