Implémenter une version générique de tri (cf Figure 2). Implémenter une version générique de l arbre binaire vu précédemment en cours (cf Figure 3).

Dimension: px

Commencer à balayer dès la page:

Download "Implémenter une version générique de tri (cf Figure 2). Implémenter une version générique de l arbre binaire vu précédemment en cours (cf Figure 3)."

Claire Albert
il y a 6 ans
Total affichages :

1 Générécité Implémenter une version générique de tri (cf Figure ). Implémenter une version générique de l arbre binaire vu précédemment en cours (cf Figure 3). Recherche textuelle Proposer un algorithme de recherche textuelle ; Essayons le code Figure avec (motif en e non trouvé) : $ gcc -Wall naive.c -o naive $./naive hehe 33hehehe hehehe993hehe Motif trouve en 9ieme position Motif trouve en 3ieme position Motif trouve en 3ieme position L algorithme KMP : Knuth-Morris-Pratt. Essayons le code Figure avec : $ gcc -Wall KnuthMorrisPratt.c -o kmp $./kmp ABCABCABCABABABC "ABCABCABABABCABCABCABABABC 33 3 ABCABCABCABABABC" Motif trouve en ieme position Motif trouve en 39ieme position 3 Codage de Huffman Vu en cours : Définition du codage statique, semi-adaptatif et adaptatif. Le codage semi-adaptatif : création de l histogramme, de l arbre et son utilisation en codage / décodage. Un exemple de text encodé et de l arbre utilisé est donné Figure ).

2 char(3) e 9 i 8 8 o 7 t s n u d a r l m g f y v p c b S H char() Figure Text encodé Huffman

3 #include <stdio.h> #include <stdlib.h> 3 #include <assert.h> #include <string.h> typedef struct point point; 6 struct point { 7 float x; 8 long long t; 9 }; void triinsertion(void * t, int n, size_t s, int (*compfunc)(const void *, const void *)) { int i, j; 3 unsigned char * t = t; unsigned char * v = malloc(s); assert(v); for(i = ; i < n; i++) { 6 memcpy(v, &t[(j = i) * s], s); 7 while(j > && compfunc(&t[(j - ) * s], v) > ) { 8 memcpy(&t[j * s], &t[(j - ) * s], s); 9 j--; } memcpy(&t[j * s], v, s); } 3 free(v); } 6 int comppoint(const void * ptr, const void * ptr) { 7 point * p = (point *)ptr; 8 point * p = (point *)ptr; 9 return p->x > p->x? : (p->x < p->x? - : ); 3 } 3 3 int main(void) { 33 point p[]; 3 int i; 3 for(i = ; i < ; i++) { 36 p[i].x = rand() / (RAND_MAX +.); 37 } 38 for(i = ; i < ; i++) 39 printf("%f ", p[i].x); printf("\n"); triinsertion(p,, sizeof *p, comppoint); //ici le quicksort de la lib standard : 3 //qsort(p,, sizeof *p, comppoint); for(i = ; i < ; i++) printf("%f ", p[i].x); 6 printf("\n"); 7 return ; 8 } 9 Figure Généricité du tri insertion (recopie de données contigues) 3

4 #include <stdio.h> #include <stdlib.h> 3 #include <assert.h> typedef struct node_t { 6 void * data; 7 struct node_t * fg, *fd; 8 } node_t; 9 #define N 6 #define MAX(a, b) ((a) > (b)? (a) : (b)) 3 node_t * newnode(void * data) { node_t * n = malloc( * sizeof *n); assert(n); n->data = data; n->fg = n->fd = NULL; 6 return n; 7 } 8 node_t ** findposition(void * data, node_t ** tree, int (*compar)(const void *, const void *)) { 9 if(*tree == NULL) return tree; if(compar(data, (*tree)->data) < ) return findposition(data, &((*tree)->fg), compar); return findposition(data, &((*tree)->fd), compar); } 3 void printtree(node_t * ptr, void (*printfunc)(const void * data)) { if(ptr == NULL) return; printtree(ptr->fg, printfunc); printfunc(ptr->data); printtree(ptr->fd, printfunc); 6 } 7 int maxdepth(node_t * ptr, int cd) { 8 int a, b; 9 if(ptr == NULL) return cd; 3 a = maxdepth(ptr->fg, ++cd); b = maxdepth(ptr->fd, cd); 3 return MAX(a, b); 3 } 33 void freetree(node_t * ptr) { 3 node_t * tmp; 3 if(ptr == NULL) return; 36 freetree(ptr->fg); 37 tmp = ptr->fd; 38 free(ptr->data); 39 free(ptr); freetree(tmp); } int comp(const void * ptr, const void * ptr) { 3 return *((float *)ptr) < *((float *)ptr)? - : ; } void print(const void * data) { 6 printf("%f ", *((float *)data)); 7 } 8 int main(void) { 9 node_t * a = NULL; int i, n =, p; float * v; for(i = ; i < n; i++) { 3 v = malloc(sizeof *v); assert(v); *v = (float)n * (rand() / (RAND_MAX +.)); *(findposition(v, &a, comp)) = newnode(v); 6 } 7 p = maxdepth(a, ); assert(p <= N); 8 printf("profondeur de l arbre : %d\n", p); 9 /* Imprimer l arbre récursivement */ 6 printtree(a, print); printf("\n"); 6 /* Libérer l arbre */ 6 freetree(a); a = NULL; 63 return ; 6 } Figure 3 Généricité des arbres binaires

5 #include <stdio.h> #include <stdlib.h> 3 #include <string.h> int recherchenaive(char * m, char * t) { 6 int i, j, lm, lt; 7 lm = strlen(m); lt = strlen(t); 8 for(i = j = ; j < lm && i < lt; i++, j++) 9 while(t[i]!= m[j]) { i -= j - ; j = ; } if(j == lm) return i - lm; return i; } 3 int main(int argc, char ** argv) { int p = ; 6 if(argc!= 3) { 7 fprintf(stderr, "usage : %s MOTIF TEXTE\n", argv[]); 8 exit(); 9 } while( (p += recherchenaive(argv[], &argv[][p])) < strlen(argv[]) ) { printf("motif trouve en %dieme position\n", p + ); p += strlen(argv[]); 3 } return ; } 6 Figure Recherche naïve #include <stdio.h> #include <stdlib.h> 3 #include <string.h> #include <assert.h> 6 int * initialiserautomate(char * m) { 7 int i, j, lm = strlen(m); 8 int * back = malloc(lm * sizeof back[]); 9 assert(back); for(i =, j = -; i < lm; i++, j++) { back[i] = j; while( j >= && m[i]!= m[j] ) j = back[j]; 3 } for(i = ; i < lm; i++) printf("%d ", back[i]); 6 printf("\n"); 7 return back; 8 } 9 int recherchekmp(int * back, char * m, char * t) { int i, j, lm, lt; lm = strlen(m); lt = strlen(t); 3 for(i = j = ; j < lm && i < lt; i++, j++) while( j >= && t[i]!= m[j] ) { j = back[j]; } if(j == lm) return i - lm; 6 return i; 7 } 8 9 int main(int argc, char ** argv) { 3 int p =, * back; 3 if(argc!= 3) { 3 fprintf(stderr, "usage : %s MOTIF TEXTE\n", argv[]); 33 exit(); 3 } 3 back = initialiserautomate(argv[]); 36 while( (p += recherchekmp(back, argv[], &argv[][p])) < strlen(argv[]) ) { 37 printf("motif trouve en %dieme position\n", p + ); 38 p += strlen(argv[]); 39 } free(back); return ; } 3 Figure Algorithme Knuth-Morris-Pratt

Documents pareils

Brefs rappels sur la pile et le tas (Stack. / Heap) et les pointeurs

Brefs rappels sur la pile et le tas (Stack / Heap) et les pointeurs (exemples en C) v1.11 - Olivier Carles 1 Pile et Tas Mémoire allouée de manière statique Mémoire Allouée Dynamiquement variables locales