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

Algorithmique Cours ENSG 2A, Septembre 2002 Guillaume Caumon

Présentations similaires


Présentation au sujet: "Algorithmique Cours ENSG 2A, Septembre 2002 Guillaume Caumon"— Transcription de la présentation:

1 Algorithmique Cours ENSG 2A, Septembre 2002 Guillaume Caumon

2 Introduction Algorithme = suite dactions que devra effectuer un automate pour arriver à partir dun état initial, en un temps fini, à un résultat Un cours dalgorithmique a Géol… !???

3 Plan n Mémoire, pointeurs (1h) n Organisation dun programme (1h) n Structures de données: listes, arbres, tables... (8h) n Algorithmique: exemple des tris (2h)

4 Partie I La mémoire

5 Les mémoires... n RAM (Random Access Memory): 32 / 64 Mo n Le disque dur: quelques Go n La mémoire virtuelle: temps daccès 1000 fois plus long.

6 Mémoire et exécution Code Données statiques Tas Code objet du programme Valeurs constantes Piles dappels de fonctions Allocation dynamique de mémoire Pile

7 Intérêts des pointeurs éé Gestion de lespace mémoire en cours dexécution éèé Représentation de tableaux: accès direct et indexé éè Modifications de variables passées en paramètres de fonction ééé Références croisées Fonctions virtuelles en programmation objet

8 Rappels sur les pointeurs int* a; Déclaration dun pointeur vers un entier a

9 Rappels sur les pointeurs int* a; Déclaration dun pointeur vers un entier et initialisation à NULL et initialisation à NULL int* a = NULL; a

10 malloc(3*sizeof(int)); Allocation dynamique de place mémoire (pour 3 entiers) Rappels sur les pointeurs

11 int* a = malloc(3*sizeof(int)); Allocation dynamique et assignement int* a = (int*)malloc(3*sizeof(int)); Rappels sur les pointeurs a *a

12 Désallocation dynamique free(a); Rappels sur les pointeurs a a = NULL; *a

13 int* a = (int*)malloc(3*sizeof(int)); int* a = (int*)calloc(3, sizeof(int)); Rappels sur les pointeurs a = (int*)realloc(4*sizeof(int));

14 Partie II Survol darchitecture logicielle

15 Programme ?? Programme include Fichiers de description (header).h src Fichiers dimplantation (source code).c lib Librairies et fichiers objets bin Exécutable(s) a.out.exe.o.so.lib.dll

16 But du Jeu Application, qui parle directement a lordinateur Fichiers source = Instructions dans un langage de programmation

17 Problèmes a résoudre temps taille Complexité, Coût de maintenance

18 Organisation et réutilisation… n Organisation du code : –En fonctions, structures, etc. –En fichiers n Réutilisation : –Du code (fichiers source) –Des fichiers binaires n Réutilisation dun programme à lautre

19 Programmes et librairies En C : Exécutable main() Pour la réutilisation, on utilise des bibliothèques (ou librairies) de fonctions : dune description de chaque fonction (dans des fichier.h den-tête, ou header), et du code compilé correspondant (des.lib et.dll sous PC, des.so et.a sous UNIX)

20 La Compilation : Résumé Code source C Code pré-processé exécutable Librairies Fichier(s) Objet.o.so.lib.h.c a.out.exe Fichiers den-tête C Préprocesseur Editeur de liens Compilateur

21 Qualité dun programme Architecture claire Réutilisabilité Structures de données + Algorithmes + Documentation + Tests de robustesse +

22 Partie III Introduction aux structures de données

23 Comment Organiser au Mieux lInformation dans un Programme ? Introduction Problème métaphysique: Tableaux int tab[10]; struct Data_t { int index_; int index_; char* value_; char* value_; } Data_t; Structures Structures de données

24 Les tableaux Taille fixe, en général Réajustement de taille coûteux en temps Insertion délément onéreuse en temps. Accès indexé (de 0 à n-1 pour un tableau de n éléments) Stockage compact

25 Liste chaînée : Sp écifications Créer une liste vide Ajouter un élément (début / fin / milieu) Retirer un élément (début / fin / milieu) Détruire une liste Trier les éléments dune liste

26 Liste chaînée : Structures Tête Noeud Noeud

27 Liste chaînée : Structures List_t p_first p_last nb_elements Node_t p_datap_next Data_t

28 Liste chaînée : Header typedef struct List_t { struct Node_t* p_first_; struct Node_t* p_first_; struct Node_t* p_last_; struct Node_t* p_last_; int nb_elements_; int nb_elements_; } List_t; typedef struct Node_t { struct Data_t* p_data_; struct Data_t* p_data_; struct Node_t* p_next_; struct Node_t* p_next_; } Node_t; typedef struct Data_t { } Data_t;

29 Liste chaînée : Header List_t* list_create( void ); int list_insert_item( List_t* list, Data_t* item ); int list_append_item( List_t* list, Data_t* item List_t* list, Data_t* item); int list_insert_item_before( List_t* list, Data_t* to_insert, Data* list_item Data* list_item);

30 Liste chaînée : Header int list_destroy( List_t* list ); Data_t* list_remove_head( List_t* list ); int list_empty( List_t* list ); Data_t* list_remove_tail( List_t* list ); int list_remove_item( List_t* list Data_t* item ); int list_sort( List_t* list );

31 Liste chaînée : Utilisation Avant daller plus loin, vérifions si nos spécifications sont suffisantes... Pour cela, nous allons écrire un programme qui utilise les fonctions du fichier list.h, sans nous préoccuper de la façon dont elles sont implantées. But du programme: construire et trier une liste dentiers par ordre croissant.

32 Liste chaînée : Implantation Cf. code écrit au tableau; pour résumer les principales règles à suivre: Toujours tester la validité dun pointeur avant de lutiliser. Toujours tester la validité dun pointeur avant de lutiliser. Sassurer de ne jamais perdre ladresse dune zone allouée dynamiquement. Sassurer de ne jamais perdre ladresse dune zone allouée dynamiquement. Dans un programme, toute allocation par malloc ou calloc doit être suivie dune désallocation par free Dans un programme, toute allocation par malloc ou calloc doit être suivie dune désallocation par free

33 Liste chaînée : Spécialisations Pile, ou Tas (Stack): structure LIFO void push(Data_t*) Data_t* pop(void)

34 Liste chaînée : Spécialisations File, ou queue : structure FIFO void push(Data_t*) Data_t* pop(void)

35 Introduction à la complexité Annuaire avec noms et coordonnées temps t nombre dabonnés N t = a · N t = a · 2 N t = a · N 2 t = a · logN

36 Sets ou Bags et tables Stocker une seule fois le même élément dans le conteneur. Pas dordre Accès rapide Tables : Associent une clé a un élément dans le conteneur. Besoin de fonctions de hachage

37 Structures de données linéaires Tableaux Sets, Bags Listes chaînées Tables Taille fixe Accès direct Taille variable Accès séquentiel Unicité des éléments Accès rapide Associe une clé unique et une valeur. Accès rapide

38 Structures de données hiérarchiques: les Arbres Racine B1B2B3 B7B6B5B4F2F1 B8B10B9F4F5F3 F7F8F6F10F9

39 Arbres: Sp écifications Créer un arbre Ajout / retrait dun noeud Détruire un arbre Parcours pre-order Parcours post-order Parcours in-order

40 Arbres: Structure de données TreeNode_t p_datap_next Data_t p_first_childp_parent

41 Tree.h typedef struct TreeNode_t { struct TreeNode_t* p_parent_; struct TreeNode_t* p_parent_; struct TreeNode_t* p_first_child_; struct TreeNode_t* p_first_child_; Data_t* p_data_; Data_t* p_data_; struct TreeNode_t* p_next_; struct TreeNode_t* p_next_; } TreeNode_t; TreeNode_t* tree_add_node( TreeNode_t* p_parent, Data_t* p_data );

42 Tree.h TreeNode_t* tree_find_root( TreeNode_t* p_parent, Data_t* p_data ); void tree_preorder( TreeNode_t* p_root, void(* do_it)( Data_t* ) ); void tree_postorder( TreeNode_t* p_root, void(* do_it)( Data_t* ) );

43 Tree.h TreeNode_t* tree_delete_branch( TreeNode_t* branch ); void tree_inorder( TreeNode_t* p_root, void(* do_it)( Data_t* ) );

44 Arbres: parcours pre-order Pointeurs de fonctions... Pointeurs de fonctions...

45 Arbres: parcours post-order

46 Arbres: parcours in-order

47 Structures de données complexes: Les Graphes N1N2N3 N9N7N6N5N8N4 N10 N12 N11N14N13 N16N15N18N17

48 Partie IV Algorithmes et complexité : exemple des tris

49 Exemple : Algorithmes de tri Tri dun tableau de taille n : n! possibilités Applications: bases de données géométrie algorithmique.... Fonctions: de comparaison < dechange

50 Tri par remplacement n Complexité en temps : o(n(n-1)) ~ o(n 2 ) n Mémoire: duplication du tableau. n Besoins min_index, max_value, comp tableaux entree, sortie int max = max_value(entree) Pour i de 1 à n Faire: int j <- min_index(entree) sortie[i] <- entree[j] entree[j] <- max FinPour n Algo

51 Tri par permutation n Complexité en temps : o(n(n-1)/2) ~ o(n 2 ) n Mémoire: tableau non dupliqué n Besoins min_index, swap, comp Tableau entrée Pour i de 1 à n Faire: int j <- min_index(entree,i) Si j i Faire Si j i Faire swap(entree[i],entree[j]) swap(entree[i],entree[j]) FinSi FinSiFinPour n Algo

52 Tri à bulles: Principe n Besoins swap, comp Echange de deux éléments adjacents du tableau.

53 Tri à bulles: Algo Tableau tab Booleen permute <- vrai int i <- 0 Tant que permute Faire permute = faux permute = faux Pour j de n-1 à i + 1 Faire Pour j de n-1 à i + 1 Faire Si tab[j-1] > tab[j] Faire Si tab[j-1] > tab[j] Faire swap( tab[j-1], tab[j] ) swap( tab[j-1], tab[j] ) permute = vrai permute = vrai FinSi FinSi FinPour FinPour i++ i++Finttque

54 Tri à bulles: Commentaires n Complexité en temps : o(n(n-1)/2) ~ o(n 2 ) n Mémoire: tableau non dupliqué

55 Tri par s é lection 4 que On sépare le tableau en p ensembles. On cherche un minimum pour chaque sous- ensemble On prend le minimum de ces minima. On échange cet élément avec le premier élément etc. n ( p + n/p ) tests n ( p + n/p ) tests o( n n ) pour p = n o( n n ) pour p = n trié sous-table 1 sous-table p...

56 Tri par segmentation (quicksort) On recherche une valeur pivot T j. On échange les valeurs de sorte que : tout élément de [T 0,T j-1 ] soit inférieur a T j, tout élément de [T 0,T j-1 ] soit inférieur a T j, tout élément de [T j+1, T n ] soit supérieur a T j tout élément de [T j+1, T n ] soit supérieur a T j Méthode diviser pour régner : On pivote récursivement sur [T 0,T j-1 ] et [T j+1, T n ].

57 Tri par segmentation (quicksort) seg (0,11) seg (0,4); seg (4,11) seg (0,2); seg(3,4); seg(5,11) seg (0,11) seg (0,4); seg (5,11) seg(5,10) seg(6,10) seg(7,10) seg(7,10)

58 n Complexité dans le cas favorable : – log 2 (n) nombre de segmentations – 0 permutations – o(n log 2 n) comparaisons n Complexité dans le cas défavorable : – n nombre de segmentations – o(n 2 ) permutations – o(n 2 ) comparaisons Tri par segmentation (quicksort)

59 Conclusion Algorithmique et structures de données sont liées. Les exemples étudiés ont été implantés en C, mais le langage est plus un outil quune fin en soi. Bon courage pour vos projets ! Fonctionnement dun programme et dun ordinateur Programmation en C

60 References n Web n Aho et al. Structures de donnees et algorithmes, Addisson-Wesley / InterEditions n Aho et Ullman. Concepts fondamentaux de linformatique, Dunod n Sedgewick. Algorithmes en C. Addisson-Wesley / InterEditions

61 Annexe: Pointeurs de fonction Déclaration : type (* nom_de_fonction) ([arguments]); type (* nom_de_fonction) ([arguments]); Utilisation : (* nom_de_fonction) (arg1, arg2, arg3,...); (* nom_de_fonction) (arg1, arg2, arg3,...); But : paramétrer des fonctions par dautres fonctions pour modifier leur actions.

62 Annexe: Pointeurs de fonction short tab[10] short carre( short v ) { return a * a; } void imprimer( int nb_elems, short (* function )( short ) ) { for( i = 0; i < nb_elems; ++i ) { printf( %d, (* function) ( tab[i] ) ); }} int main() { for( i = 0; i < 10; i++ ) { tab[i] = n; } imprimer( 10, carre ); } Retour aux arbres Retour aux arbres


Télécharger ppt "Algorithmique Cours ENSG 2A, Septembre 2002 Guillaume Caumon"

Présentations similaires


Annonces Google