Cours d’Algorithmique

1. Cours d’Algorithmique Parcours d’arbres. Induction sur la structure. Back-track. Minimax. Cours d'algorithmique 3 - Intranet

2. Les grandes lignes du cours • Trier et chercher • Listes et arbres • Le back-track • Arbres équilibrés • Récursivité etinduction sur la structure • Divide and conquer • Minimax • Dérécursion • NP-complétude • Logique de Hoare • Programmation dynamique • Complexité et calculabilité Cours d'algorithmique 3 - Intranet

3. Fibonnacci et les arbres----------------------------------------------------------------- Fibonnacci est une fonction qui comporte deux appels récursifs. Tout appel construit donc deux autres appels. Construisons cet arbre. int fibonnacci (int n) {if ( n == 0 ) return(0); else if ( n == 1 ) return(1); else return( fibonnacci(n-1) + fibonnacci(n-2) ); } Cours d'algorithmique 3 - Intranet

4. Fibonnacci et les arbres----------------------------------------------------------------- Fibonnacci est une fonction qui comporte deux appels récursifs. Tout appel construit donc deux autres appels. Construisons cet arbre. int fibonnacci (int n) {if ( n == 0 ) return(0); else if ( n == 1 ) return(1); else return( fibonnacci(n-1) + fibonnacci(n-2) ); } Les cas d’arrêt. Les appels récursifs. Cours d'algorithmique 3 - Intranet

5. Fibonnacci et les arbres----------------------------------------------------------------- ptr_arbre arbre_fibo (int n) {if ( n == 0 ) return( cree_feuille(0) ); else if ( n == 1 ) return( cree_feuille(1) ); else return( cree_noeud( arbre_fibo(n-1), arbre_fibo(n-2) ) ) ; } Cours d'algorithmique 3 - Intranet

6. 5 3 4 2 3 0 2 2 1 1 1 1 1 0 0 Fibonnacci et les arbres----------------------------------------------------------------- arbre_fibo(5) Cours d'algorithmique 3 - Intranet

7. 5 3 4 2 3 0 2 2 1 1 1 1 1 0 0 Fibonnacci et les arbres----------------------------------------------------------------- On observe que de nombreux calculs sont répétés ! arbre_fibo(5) Cours d'algorithmique 3 - Intranet

8. Calcul de la somme des feuilles----------------------------------------------------------------- int somme_arbre_fibo (ptr_arbre arbre) {if ( est_feuille(arbre) ) return( valeur_feuille(arbre) ); else return( somme_arbre_fibo(fils_gauche(arbre)) +somme_arbre_fibo(fils_droit(arbre)) ) ; } Cours d'algorithmique 3 - Intranet

9. 5 3 4 2 3 0 2 2 1 1 1 1 1 0 0 Calcul de la somme des feuilles----------------------------------------------------------------- arbre_fibo(5) 1 1 0 Cours d'algorithmique 3 - Intranet

10. 5 3 4 2 3 0 2 2 1 1 1 1 1 0 0 Calcul de la somme des feuilles----------------------------------------------------------------- arbre_fibo(5) 2 1 1 1 0 Cours d'algorithmique 3 - Intranet

11. 5 3 4 2 3 0 2 2 1 1 1 1 1 0 0 Calcul de la somme des feuilles----------------------------------------------------------------- 5 somme_arbre_fibo(5) = 5 3 2 1 1 2 1 1 1 0 Cours d'algorithmique 3 - Intranet

12. Types de parcours----------------------------------------------------------------- Parcours préfixe res_fg = appel ( fg(a) ); res_fd = appel ( fd(a) ); return( ... res_fg ... res_fd ... ); Cours d'algorithmique 3 - Intranet

13. Types de parcours----------------------------------------------------------------- Parcours préfixe res_fg = appel ( fg(a) ); res_fd = appel ( fd(a) ); return( ... res_fg ... res_fd ... ); Cours d'algorithmique 3 - Intranet

14. Types de parcours----------------------------------------------------------------- Parcours préfixe res_fg =appel ( fg(a) ); res_fd = appel ( fd(a) ); return( ... res_fg ... res_fd ... ); Cours d'algorithmique 3 - Intranet

15. Types de parcours----------------------------------------------------------------- Parcours préfixe res_fg =appel ( fg(a) ); res_fd = appel ( fd(a) ); return( ... res_fg ... res_fd ... ); Cours d'algorithmique 3 - Intranet

16. Types de parcours----------------------------------------------------------------- Parcours préfixe res_fg =appel ( fg(a) ); res_fd =appel ( fd(a) ); return( ... res_fg ... res_fd ... ); Cours d'algorithmique 3 - Intranet

17. Types de parcours----------------------------------------------------------------- Parcours suffixe ou postfixe res_fg = appel ( fd(a) ); res_fd = appel ( fg(a) ); return( ... res_fg ... res_fd ... ); Cours d'algorithmique 3 - Intranet

18. Types de parcours----------------------------------------------------------------- Parcours avec opérateur commutatif : l’ordre de parcours est sans importance ! ... oper_commute ( fg(a) , fd(a) ) ... ... oper_commute ( fd(a) , fg(a) ) ... Exemple : notre calcul de la somme de Fibonnacci. Cours d'algorithmique 3 - Intranet

19. 1 3 Types de parcours avec étiquettes----------------------------------------------------------------- Traitement de l’étiquette, soit avant, soit après, soit pendant ! * + 5 Cours d'algorithmique 3 - Intranet

20. 1 3 Types de parcours avec étiquettes----------------------------------------------------------------- Traitement de l’étiquette, soit avant, soit après, soit pendant ! • Impression préfixe de l’arbre : *+ 1 5 3 * + 5 Cours d'algorithmique 3 - Intranet

21. 1 3 Types de parcours avec étiquettes----------------------------------------------------------------- Traitement de l’étiquette, soit avant, soit après, soit pendant ! • Impression préfixe de l’arbre : *+ 1 5 3 • Impression postfixe de l’arbre : 1 5 + 3 * * + 5 Cours d'algorithmique 3 - Intranet

22. 1 3 Types de parcours avec étiquettes----------------------------------------------------------------- Traitement de l’étiquette, soit avant, soit après, soit pendant ! • Impression préfixe de l’arbre : *+ 1 5 3 • Impression postfixe de l’arbre : 1 5 + 3 * • Impression infixe parenthésée : ( ( 1 + 5 ) * 3 ) ( ) * ( ) + 5 Cours d'algorithmique 3 - Intranet

23. 1 3 Types de parcours avec étiquettes----------------------------------------------------------------- Traitement de l’étiquette, soit avant, soit après, soit pendant ! • Impression préfixe de l’arbre : *+ 1 5 3 • Impression postfixe de l’arbre : 1 5 + 3 * • Impression infixe parenthésée : ( ( 1 + 5 ) * 3 ) * + 5 Cours d'algorithmique 3 - Intranet

24. 1 3 Types de parcours avec étiquettes----------------------------------------------------------------- Traitement de l’étiquette, soit avant, soit après, soit pendant ! • Impression préfixe de l’arbre : *+ 1 5 3 • Impression postfixe de l’arbre : 1 5 + 3 * • Impression infixe parenthésée : ( ( 1 + 5 ) * 3 ) * + 5 Cours d'algorithmique 3 - Intranet

25. Modification d’un arbre----------------------------------------------------------------- • Nous savons créer un arbre, nous savons parcourir un arbre ! • Pouvons-nous modifier un arbre ? • OUI • soit, en le reconstruisant, • soit, en le modifiant physiquement. Cours d'algorithmique 3 - Intranet

26. Modification d’un arbre----------------------------------------------------------------- • Nous savons créer un arbre, nous savons parcourir un arbre ! • Pouvons-nous modifier un arbre ? • OUI • soit, en le reconstruisant, • soit, en le modifiant physiquement. Remplacer 1 5 3 7 par dans 1 2 4 6 Cours d'algorithmique 3 - Intranet

27. Modification d’un arbre----------------------------------------------------------------- • En reconstruisant : Partie qui doit être reconstruite. 5 3 7 2 4 6 Cours d'algorithmique 3 - Intranet

28. Modification d’un arbre----------------------------------------------------------------- • En reconstruisant : Partie qui doit être reconstruite. 5 3 7 2 4 6 cree_noeud(fg(arbre) , cree_noeud(fg(fd(arbre)), cree_noeud(cree_noeud(cree_feuille(4) , cree_feuille(6)), fd(fd(fd(arbre))) ) ) ) ; Cours d'algorithmique 3 - Intranet

29. Modification d’un arbre----------------------------------------------------------------- • En reconstruisant : Partie qui doit être reconstruite. 5 3 7 2 4 6 cree_noeud(fg(arbre), cree_noeud(fg(fd(arbre)), cree_noeud(cree_noeud(cree_feuille(4) , cree_feuille(6)), fd(fd(fd(arbre)))) ) ) ; Cours d'algorithmique 3 - Intranet

30. Modification d’un arbre----------------------------------------------------------------- • En modifiant : Pointeur qui est modifié. 5 3 7 2 4 6 Cours d'algorithmique 3 - Intranet

31. Modification d’un arbre----------------------------------------------------------------- • En modifiant : Pointeur qui est modifié. 5 3 7 2 4 6 modifie_fg_noeud(fd(fd(arbre)), cree_noeud( cree_feuille(4) , cree_feuille(6) )) ; Cours d'algorithmique 3 - Intranet

32. 5 3 Modification d’un arbre----------------------------------------------------------------- Attention aux partages de structure avec modifications physiques ! sous_arbre = cree_noeud( cree_feuille(3) , cree_feuille(5) ); arbre = cree_noeud( sous_arbre , sous_arbre ); Représentation physique ! Cours d'algorithmique 3 - Intranet

33. 5 5 5 3 3 3 Modification d’un arbre----------------------------------------------------------------- Attention aux partages de structure avec modifications physiques ! sous_arbre = cree_noeud( cree_feuille(3) , cree_feuille(5) ); arbre = cree_noeud( sous_arbre , sous_arbre ); Représentation physique ! L’arbre logique ! ! ! Cours d'algorithmique 3 - Intranet

34. 5 3 Modification d’un arbre----------------------------------------------------------------- Attention aux partages de structure avec modifications physiques ! sous_arbre = cree_noeud( cree_feuille(3) , cree_feuille(5) ); arbre = cree_noeud( sous_arbre , sous_arbre ); Représentation physique ! L’arbre logique ! ! ! Modification physique. Reconstruction d’arbre. 5 9 5 9 Cours d'algorithmique 3 - Intranet

35. 5 3 Modification d’un arbre----------------------------------------------------------------- Attention aux partages de structure avec modifications physiques ! sous_arbre = cree_noeud( cree_feuille(3) , cree_feuille(5) ); arbre = cree_noeud( sous_arbre , sous_arbre ); Pas pareil ! ! ! Représentation physique ! L’arbre logique ! ! ! Modification physique. Reconstruction d’arbre. 5 9 5 9 Cours d'algorithmique 3 - Intranet

36. 5 3 Modification d’un arbre----------------------------------------------------------------- Attention aux partages de structure avec modifications physiques ! sous_arbre = cree_noeud( cree_feuille(3) , cree_feuille(5) ); arbre = cree_noeud( sous_arbre , sous_arbre ); Pas pareil ! ! ! Représentation physique ! L’arbre logique ! ! ! Modification physique. Vous faites ce que vous voulez ! Mais, de grâce, assumez ! ! ! Reconstruction d’arbre. 5 9 5 9 Cours d'algorithmique 3 - Intranet

37. Induction sur les structures----------------------------------------------------------------- • Induction simple sur les entiers naturels : • On démontre la propriété pour 0, le premier entier naturel. • On démontre que la propriété reste vraie pour i+1, si elle est vraie pour i . C’est le pas d’induction ! • Donc, elle est vraie pour tout entier naturel. Cours d'algorithmique 3 - Intranet

38. Induction sur les structures----------------------------------------------------------------- • Induction simple sur les entiers naturels : • On démontre la propriété pour 0, le premier entier naturel. • On démontre que la propriété reste vraie pour i+1, si elle est vraie pour i . C’est le pas d’induction ! • Donc, elle est vraie pour tout entier naturel. • Induction totale sur les entiers naturels : • On démontre la propriété pour 0, le premier entier naturel. • On démontre que la propriété reste vraie pour i+1, si elle est vraie pour tous les entiers de 0 à i . C’est le pas d’induction ! • Donc, elle est vraie pour tout entier naturel. Cours d'algorithmique 3 - Intranet

39. Induction sur les listes----------------------------------------------------------------- • Induction sur les listes : • On démontre la propriété pour la liste vide (ceci ne marche donc pas pour les listes circulaires !). • On suppose la propriété vraie pour une liste de longueur i • et on démontre qu’elle reste vraie pour la liste de longueur i+1 que l’on obtient en ajoutant un élément (bien choisi) en tête de liste. Cours d'algorithmique 3 - Intranet

40. Induction sur les listes----------------------------------------------------------------- • Induction sur les listes : • On démontre la propriété pour la liste vide (ceci ne marche donc pas pour les listes circulaires !). • On suppose la propriété vraie pour une liste de longueur i • et on démontre qu’elle reste vraie pour la liste de longueur i+1 que l’on obtient en ajoutant un élément (bien choisi) en tête de liste. • Variantes : éventuellement, une propriété n’est vraie que pour une liste de longueur au moins k : • On démontre pour k • et on démontre qu’elle reste vraie pour les listes plus longues. Cours d'algorithmique 3 - Intranet

41. Induction sur les arbres----------------------------------------------------------------- • Induction sur les arbres : • On démontre la propriété pour une feuille quelconque. • On suppose la propriété vraie pour les sous-arbres • et on démontre qu’elle reste vraie pour l’arbre que l’on obtient en ajoutant un nœud père au-dessus des différents sous-arbres (bien choisis). Cours d'algorithmique 3 - Intranet

42. Induction sur les arbres----------------------------------------------------------------- • Induction sur les arbres : • On démontre la propriété pour une feuille quelconque. • On suppose la propriété vraie pour les sous-arbres • et on démontre qu’elle reste vraie pour l’arbre que l’on obtient en ajoutant un nœud père au-dessus des différents sous-arbres (bien choisis). • Remarque : • Le raisonnement de correction d’une fonction récursive sur arbres, listes, etc, se fait de la même manière : • On démontre la correction du cas de base, • on suppose les appels récursifs corrects • et on démontre la correction de l’appel courant. Cours d'algorithmique 3 - Intranet

43. Correction d’une fonction récursive----------------------------------------------------------------- • La fonction ci-dessous calcule la profondeur d’un arbre ! • La profondeur d’un nœud ou d’une feuille dans un arbre correspond au nombre de fois où l’on doit « descendre » vers un fils avant d’atteindre le nœud ou la feuille en question. • La profondeur d’un arbre est la profondeur de la feuille la plus profonde. Cours d'algorithmique 3 - Intranet

44. Correction d’une fonction récursive----------------------------------------------------------------- • La fonction ci-dessous calcule la profondeur d’un arbre ! • La profondeur d’un nœud ou d’une feuille dans un arbre correspond au nombre de fois où l’on doit « descendre » vers un fils avant d’atteindre le nœud ou la feuille en question. • La profondeur d’un arbre est la profondeur de la feuille la plus profonde. int profond (ptr_arbre arbre) {if ( est_feuille(arbre) ) return( 0 ); else return( 1 + max( profond(fg(arbre)), profond(fd(arbre)) )); } Cours d'algorithmique 3 - Intranet

45. Correction d’une fonction récursive----------------------------------------------------------------- • La fonction ci-dessous calcule la profondeur d’un arbre ! • La profondeur d’un nœud ou d’une feuille dans un arbre correspond au nombre de fois où l’on doit « descendre » vers un fils avant d’atteindre le nœud ou la feuille en question. • La profondeur d’un arbre est la profondeur de la feuille la plus profonde. int profond (ptr_arbre arbre) {if ( est_feuille(arbre) ) return( 0 ); else return( 1 + max( profond(fg(arbre)), profond(fd(arbre)) )); } Le cas d’arrêt est trivialement correct ! Cours d'algorithmique 3 - Intranet

46. Correction d’une fonction récursive----------------------------------------------------------------- • La fonction ci-dessous calcule la profondeur d’un arbre ! • La profondeur d’un nœud ou d’une feuille dans un arbre correspond au nombre de fois où l’on doit « descendre » vers un fils avant d’atteindre le nœud ou la feuille en question. • La profondeur d’un arbre est la profondeur de la feuille la plus profonde. int profond (ptr_arbre arbre) {if ( est_feuille(arbre) ) return( 0 ); else return( 1 + max( profond(fg(arbre)), profond(fd(arbre)) )); } Les appels récursifs sont corrects par hypothèse ! Cours d'algorithmique 3 - Intranet

47. Correction d’une fonction récursive----------------------------------------------------------------- • La fonction ci-dessous calcule la profondeur d’un arbre ! • La profondeur d’un nœud ou d’une feuille dans un arbre correspond au nombre de fois où l’on doit « descendre » vers un fils avant d’atteindre le nœud ou la feuille en question. • La profondeur d’un arbre est la profondeur de la feuille la plus profonde. int profond (ptr_arbre arbre) {if ( est_feuille(arbre) ) return( 0 ); else return( 1 + max(profond(fg(arbre)), profond(fd(arbre)))); } Les appels récursifs sont corrects par hypothèse ! La plus grande des profondeurs. Cours d'algorithmique 3 - Intranet

48. Correction d’une fonction récursive----------------------------------------------------------------- • La fonction ci-dessous calcule la profondeur d’un arbre ! • La profondeur d’un nœud ou d’une feuille dans un arbre correspond au nombre de fois où l’on doit « descendre » vers un fils avant d’atteindre le nœud ou la feuille en question. • La profondeur d’un arbre est la profondeur de la feuille la plus profonde. int profond (ptr_arbre arbre) {if ( est_feuille(arbre) ) return( 0 ); else return( 1 +max(profond(fg(arbre)), profond(fd(arbre)))); } Les appels récursifs sont corrects par hypothèse ! La plus grande des profondeurs. La profondeur de notre arbre ! ! ! Cours d'algorithmique 3 - Intranet

49. Preuves par induction sur les arbres----------------------------------------------------------------- • Soient F ( A ) le nombre de feuilles et N ( A ) le nombre de nœuds internes d’un arbre A. • Si A est binaire, alors : F ( A ) = N ( A ) + 1 Cours d'algorithmique 3 - Intranet

50. Preuves par induction sur les arbres----------------------------------------------------------------- • Soient F ( A ) le nombre de feuilles et N ( A ) le nombre de nœuds internes d’un arbre A. • Si A est binaire, alors : F ( A ) = N ( A ) + 1 • Preuve : • A est une feuille : F ( A ) = 1 = 0 + 1 = N ( A ) + 1 ! Cours d'algorithmique 3 - Intranet