In formatique de base Cours 3 ème

Informatique de base Cours 3ème Mohammed BENJELLOUN Service d’Informatique Faculté Polytechnique de Mons Mohammed.Benjelloun@fpms.ac.be 2004-2005

Le but L’informatique ne se limite pas à : la programmation et l’utilisation des outils informatiques, mais la meilleure manière de résoudre le problème :  nécessite réflexion mathématique, structuration et organisation le bon algorithme,  la bonne structure de données Se faire une idée sur : La complexité, taille des données et place mémoire, modularité, temps d’exécution, portabilité … Connaissance des principaux types d’algorithmes et de structures de données afin d’éviter de « réinventer la roue »

Les notions fondamentales de structures de données et de leur utilisation • Comment les implanter à bon escient (en C) • Comprendre l'importance de la spécification rigoureuse des structures • La complexité des algorithmes • Les principes de mise en oeuvre de ces structures.

tab[0] tab[1] tab[2] tab[3] - Listes chaînées(linked lists en anglais), -Arbres binaires(binary trees). Les structures de données présentées ici sont: • Tableaux(arrays en anglais), . . . . . . -les piles(stacks), -les files(queues),

tab[0] 5 10 tab[1] 7 tab[2] 16 tab[3] Tableaux int int int int Un tableau est une collection de variables de même type, appelées éléments TypeNom_Tableau[dim]; int tab[4];déclare un tableau de 4 valeurs entières Tableaux et structures struct Date{ int jour; int mois; int an; } hier, demain; struct Date D_Nais[7]; // D_Nais[3].anest le champ ande la 4è position // du tableau de structure Date; 1995

Complexité Mesure intrinsèque de l’efficacité d’un algorithme, indépendante de l’environnement d’exécution. On peut la considérer comme une fonction exprimant le nombre d’opérations nécessaires ou d’instructions exécutées en fonction de la taille des données à traiter. Ordre d’une fonction O(f) Evaluer l’ordre d’une fonction  ‘’supprime’’ tout ce qui devient négligeable à l’infini. Exemple : n(n-1) O(n2); n3+n2+8n+9  O(n3)

permuter Exemple : Le Tri à bulle void TriaBulles(int x[], int N) { int i, perm=1, tmp; // variables locales à TriaBulles while (perm==1) { perm =0; for (i=0;i<N-1;i++) { if(x[i]>x[i+1]) { tmp = x[i]; x[i] = x[i+1]; x[i+1] = tmp; perm = 1; } } } } La mesure de complexité est le nombre de fois où le corps de la boucle interne est exécuté et on évalue la complexité dans le pire des cas, c’est à dire : le tableau ne se révèle trié qu’à la dernière étape.

while (perm==1) { for (i=0;i<N-1;i++) { if(x[i]>x[i+1]) … } } j tab[j] 0 2 1 6 2 4 3 8 4 12 5 13 6 14 tab[j] < tab[j+1] • 2 • 6 4 2 • 4 8 2 • 6 4 8 12 2 …… 1ère étape : la boucle interne est exécutée n-1 fois, 2 ème étape : la boucle interne est exécutée n-2 fois, … complexité i i[1, n-1] n(n-1)/2 O(n2) n-1 + n-2 + …. 2 + 1 =

#define ….. #define MAX 30 struct Article{char nom[Max]; int prix; }; void main(void){ struct Article Tab_article[MAX]; int i, dim = 10; for (i = 0; i < dim; i++) { printf("Entrez le nom");scanf("%s", Tab_article[i].nom); printf(" \n Entrez le prix ");scanf("%d", &Tab_article[i].prix); } … } Article1 Article2 Article3

do{ p=0; for (i=0;i< NE-1;i++) { a = strcmp (tab[i].nom,tab[i+1].nom); if (a>0){ permute(&tab[i],&tab[i+1]); p=1; } } }while (p==1); do{p=0; for (i=0;i< NE-1;i++){ a = strcmp (tab[i].nom,tab[i+1].nom); if (a==0){q=1; if (tab[i].prix>tab[i+1].prix){ permute(&tab[i],&tab[i+1]); p=1; } } } }while (p==1); struct Article{ char nom[Max]; int prix; }; struct Articletab[20]; O(n2) • void permute(int *x,int *y){ • int tmp; • tmp= *x; • *x = *y; • *y = tmp; • } O(n2)

struct Article{ char nom[Max]; int prix; }; struct Articletab[20]; i=-1;permut=1; while(i< NE-1 && permut) { permut=0; for(j=…..) if( (strcmp(tab[j].nom,tab[j+1].nom)>0) || (((strcmp(tab[j].nom,tab[j+1].nom)==0) && (tab[j].prix>tab[j+1].prix)))){ permut=1; tempo=tab[j]; tab[j]=tab[j+1]; tab[j+1]=tempo; } i++; } O(n2)

B R B B b B b B R B B b b R b b b B b R b b R B B R R R R b b R Drapeau tricolore (Dijkstra) Soit un tableau Tab de N cases contenant NB boules bleues (B), Nb boules blanches (b) et NR boules rouges (R). On souhaite classer ces boules de sorte que Solution Trier les boules par valeurs croissantes en prenant, par exemple, B = 1, b = 2 et R = 3. La complexité : O(N2) Pas nécessaire d'utiliser un algorithme de tri car il y a beaucoup de valeurs égales qui nécessitent des comparaisons inutiles.

permutation de k et j. j++, k++et Clas-- 0 i j k Algorithme itératif Hypothèse : Les k premiers éléments sont classés, le tableau se présente comme suit: 0 i j k boules à classer : Clas 0 <= i <= j <= k <= N-1 Si en k la boule est R pas de permutation. k = k+1 et Clas=Clas-1 Si en k la boule est b

permutation de k et j puis i et j. i++,j++, k++et Clas-- 0 i j k Si en k la boule est B 0 i j kk++ 0 ii++ jj++ k

permutation de k et j. j++, k++et Clas-- 0 i j k Complexité ?? La complexité de l'algorithme est obtenue en comptant le nombre de permutations qui est égal à 0 x NR + 1 x Nb + 2 x NB. Si en k la boule est R pas de permutation. k = k+1 et Clas=Clas-1 Si en k la boule est b Si en k la boule est B permutation de k et j puis i et j. i++,j++, k++et Clas-- 0 i j kk++

la boule est R pas de permutation. k = k+1 et Clas=Clas-1 la boule est b permutation de k et j. j++, k++et Clas-- la boule est B permutation de k et j puis i et j. i++,j++, k++et Clas-- La complexité de l'algorithme est obtenue en comptant le nombre de permutations qui est égal à 0 x NR + 1 x Nb + 2 x NB. En moyenne, on a NB = Nb = NR = N/3, et la complexité moyenne est d'ordre N L'algorithme itératif se révèle donc bien meilleur que l'algorithme immédiat.

void Drapeau( int Tab[], int N) { int i=0,j=0,k; for (k=0; k<N; k++){ if (Tab[k] == Bleu){ permute(Tab[k], Tab[j]); permute(Tab[j], Tab[i]); i++; j++; } else{ if (Tab[k] == blanc){ permute(Tab[k], Tab[j]); j++; } } }

Est-il possible de l'améliorer? Nous constatons qu'avec les boules bleues, il est nécessaire de réaliser deux permutations. Comment en faire moins en sachant que toute permutation débute à partir de la zone à classer?

Plaçons la zone à classer "au milieu" du tableau comme représenté ci-dessous. j 0 i k boules à classer : Clas 0 <= i <= k <= j <= N-1 j = Indice de la dernière boule non classée.

et la complexité moyenne est d'ordre 2N/3. Le second algorithme paraît meilleur que le premier. j 0 i k boules à classer : Clas Si en k la boule est b pas de pérmutation k++et Clas-- Si en k la boule est R pérmutation (k, j-1), j-- et Clas-- Si en k la boule est B pérmutation (k, i), k++, i++ et Clas-- Le nombre de permutations est égal à 1 x NR + 0 x Nb + 1 x NB. Complexité ? En moyenne, on a NB = Nb = NR = N/3,

2d > 1er NR + NB >Nb + 2 x NB NR>Nb + NB NR + Nb + NB =N NR> N -NR NR> N/2 Donc, si le nombre de boules rouges est supérieur au nombre total de boules / 2, le premier algorithme est meilleur. Toutefois il peut parfois être moins bon En effet, 1er : 0 x NR + 1 x Nb + 2 x NB 2d : 1 x NR + 0 x Nb + 1 x NB 2d - bon1er ??  nbOP2 > nbOP1

Programmation Récursive Une procédure P est dite récursive si son exécution peut provoquer un ou plusieurs appels (dits récursifs) à P. On distingue: - la récursivité simple (appel direct à P) - la récursivité croisée (appel à la procédure Q qui appelle P). int fact (int n ) { if ( n < 0) return –1; //code d'erreur else if ( n == 0 ) return 1; // 0! = 1 else return n*fact( n-1 ); // n! = n*(n-1)! } Récursivité simple

Factorielle void CalculFact( int num) { int fact = 1; int temp; while ( num >0 ) { Push( num ) num--; } while ( Pop(&temp) ) { fact *= temp; } } int fact (int n ) { if ( n < 0) return –1; //code d'erreur else if ( n == 0 ) return 1; // 0! = 1 else return n*fact( n-1 ); // n! = n*(n-1)! } Les piles sont commodes pour dé-récursiver un problème.

Fractales Floconsde von Koch Le résultat ressemble à un flocon de neige idéalisé. Programmation fct(sin, cos) Le flocon d'ordre 0 est un triangle équilatéral. Le flocon d'ordre 1 est ce même triangle dont les côtés sont découpés en trois et sur lequel s'appuie un autre triangle équilatéral au milieu. Le flocon d'ordre n+1consiste à prendre le flocon d'ordre nen appliquant la même opération sur chacun de ses côtés.

Les tours de Hanoï Récursivité simple

Pour déplacer N anneaux d'une colonne de départ à une colonne d'arrivée en utilisant une colonne intermédiaire, on suppose que l'on peut déplacer N – 1 anneaux du départ à l'intermédiaire, déplacer l'anneau restant du départ à l'arrivée et déplacer les N – 1 anneaux de l'intermédiaire à l'arrivée.

void Hanoi( int N, int x, int y) { … if (N==1) Deplacer(1, x, y); else{ Hanoi( N-1, x, 3-x-y); // on a posé x=0, y=1, z=2 donc x+y+z=3 Deplacer(N, x, y); Hanoi( N-1, 3-x-y, y); } } L'ordre de complexité est donné par le nombre de déplacements d'anneaux. A chaque appel récursif, on appelle deux fois la procédure dans laquelle on réalise un déplacement. Le nombre de déplacements est donc égal à 2N – 1 et la complexité est d'ordre 2N

Tableaux et structures struct Date { int jour; int mois; int an; } hier, demain; struct Date D_Nais[7]; // D_Nais[3].anest le champ ande la 4è position // du tableau de structure Date; 1995 Avantages : Facilité de création et de manipulation (accès à un élément, …) Inconvénients : place mémoire, difficilement extensible, insertion n’est possible que par décalage de tous les éléments suivants.

Listes Chaînées • JJ Les listes sont des structures de données dynamiques, linéaires. Elles sont composées de celluleschaînées les unes aux autres parpointeurs. Une liste simplement chaînée : une cellule est un enregistrement qui peut être déclarée comme suit: struct Node { int data; /* les informations */ struct Node *suiv; /* le lien */ }; Une liste doublement chaînée struct Node { int data; /* les informations */ struct Node *suiv; /* lien vers le suivant */ struct Node *prec; /* lien vers le précédent */ };

Elm1 Elm2 Elm3 Elm4 Tête Listes Chaînées Liste simplement chaînée Une cellule étant une structure qui contient un élément à stocker et un pointeur sur la prochaine cellule de la liste. struct Cellule{ ELEMENT Data; // une structure définie préalablement struct Cellule*suiv; // pointeur sur le prochain maillon }; Modéliser une liste chaînée consiste à allouer dynamiquement les cellules chaque fois que cela est nécessaire.

Elem1 @ 0700 Elem2 @ 0900 Elem3 @ 2170 Elem4 NULL Elem1 @ 0700 Elem2 @ 0900 Elem3 @ 2170 Elem4 NULL @4000 Tête_List @0700 @0900 @2170 @4000 Autres modélisations @2170 Fin_List @4000 Tête_List @0700 @0900 @2170 @4000

Elem1 @ 0700 Elem2 @ 0900 Elem3 @ 2170 Elem4 NULL Elem4 @4000 Elem3 @ 2170 Elem2 @ 0900 Elem1 @ 0700 @0700 Courant_List @2170 Fin_List @4000 Tête_List @0700 @0900 @2170 @4000 @4000 Tête_List @0700 @0900 @2170 @4000 Liste circulaire

Les différentes opérations et fonctions Initialiser une liste Initialiser les valeurs de la structure représentant la liste pointée par Debut pour que celle-ci soit vide. Une liste est vide lorsque Tête_List (Fin_List) pointe sur Vide. typedefstruct Cellule{ ELEMENT Data; // une structure struct Cellule*next;// pointeur sur la prochainecellule }CEL; typedef: mot réservé, crée de nouveaux noms de types de données Ex : typedef char * STRING; fait de STRING un synonyme de "char * " Portée : comme les variables. CEL *debut; debut = (CEL *)malloc( sizeof(CEL)); debut=NULL ;

Types de base en C

4 octets 12FF80 12FF84 =Adr i+1 Adr i = int Mémoire l'adresse de l'élément i est &i int i; i=8; &i= 12FF80 12FF04 12FF84 pointeur Le pointeur prend comme valeurs des adresses de données en mémoire *pest le contenu pointé par p 35 p est l’adressse  12FF84 int *p;

int *var1  5 int i=5; 5 var1 = &i voidmain(void){ int *var1 ; *var1 = 5; Il faut réserver la mémoire

(CEL *)malloc( sizeof(CEL)); CEL *debut; int *var1  debut = (CEL *)malloc( sizeof(CEL)); var1 = (int *) malloc (sizeof(int)); + free void main(void){ int *var1 ; var1 = (int *) malloc (sizeof(int)); *var1 = 5; … }

Allouer et assigner une Cellule Cette fonction réserve l'espace mémoire nécessaire pour une nouvelle Cellule dans la liste, assigne les données, et retourne un pointeur sur cette Cellule. typedef struct Cellule{ Type Data; struct Cellule* suiv; }CEL; CEL * new_node(int value) { CEL * nouv; nouv= (CEL*)malloc(sizeof(CEL)); nouvData  value(s); nouvsuiv = NULL; return nouv; } nouv=new CEL; NULL nouv

Si typedef struct Cellule{ char nom[30]; struct Cellule* suiv; }CEL; Nouvelle cellule dans une liste chaînée vide typedef struct Cellule{ Type Data; struct Cellule* suiv; }CEL; CEL *debut; debut = (CEL *) malloc (sizeof(CEL)); strcpy ( debutname, “Denis”); debutsuiv = NULL; Denis\0 NULL debut Le début de la liste est indiqué par un pointeur indépendant (debut) et la fin par NULL

debut Claire prec Ajouter une nouvelle cellule en tête de liste CEL *prec; prec = (CEL *) malloc (sizeof(CEL)); strcpy ( precname, “Claire”); precsuiv = debut; debut = prec; Denis NULL debut

CEL *prec; prec = (CEL *) malloc (sizeof(CEL)); strcpy ( precname, “Claire”); precsuiv = debut; debut = prec; Claire Denis NULL debut Ajouter une nouvelle cellule en tête de liste prec CEL *insere_en_tete(char nom[] , CEL *deb ) { CEL*prec; prec = (CEL *) malloc(sizeof(CEL)); // créer une cellule if (prec!=NULL){ strcpy ( precname, nom);// assignation de nom precsuiv=deb; // assignation de suivant : chaîner avec la première cellule de la liste deb=prec; // chaînage : faire pointer la tête de liste vers la nouvelle cellule. } return (deb); }

CEL *p; p = (CEL *) malloc (sizeof(CEL)); strcpy ( pname, “Alfred”); psuiv = precsuiv; precsuiv = p; Alfred Alfred Claire Denis Claire Denis p p NULL prec debut Insérer une nouvelle cellule après la cellule prec debut NULL prec

CEL *p; p = (CEL *) malloc (sizeof(CEL)); strcpy ( pname, “Alfred”); precsuiv = p; psuiv = precsuiv; Alfred Claire Denis p Que fait ce code ? CEL *p; p = (CEL *) malloc (sizeof(CEL)); strcpy ( pname, “Alfred”); psuiv = precsuiv; precsuiv = p; debut NULL prec

Alfred Claire Denis Que pensez-vous de la fonction Affichage? CEL *p; .. p=Saisie(..); Affichage(..); Affichage(..); p=Ajout(..); Affichage(..); … void Affichage (CEL *debut) { while (debut != NULL) { printf (“%s\n”, debutname); debut = debutsuiv; } } NULL debut

Alfred Claire Denis Parcourir une liste void parcours (CEL *debut) { CEL *p; p = debut; while ( p != NULL) { printf (“%s\n”, pname); p = psuiv; } } debut est un pointeur sur la cellule qui contient le premier élément de la liste Liste identifier par l'adresse de sa première cellule NULL debut

Alfred Claire Denis Liberation NULL tmp void liberation (CEL *L) { CEL *tmp; while ( L != NULL) { tmp = L; L=Lsuiv; free(tmp); } } • void liberation(CEL *L){ • if (L) { • CEL *tmp = Lsuiv; • free(L); • liberation(tmp); • } • }

Liberation Si typedef struct Cellule{ char *nom; struct Cellule* suiv; }CEL; malloc malloc void liberation (CEL *L){ … free(nom); free(tmp); … } Pour chaque Cellule

Alfred Alfred Claire Denis Claire Denis 2 1 3 TRI NULL NULL

Alfred Claire Claire Denis Alfred Denis 2 NULL 2 3 1 1 3 TRI NULL

Autres fonctions Supprimer une cellule Libérer une cellule Rechercher unecellule Ajouter en queue de liste Retirer la tête de liste … En résumé, une liste chaînée par pointeurs permet une insertion et une suppression rapide des éléments. Cependant, contrairement au tableau, une liste chaînée interdit un accès direct aux éléments (mis à part la tête et la queue). Si l’ordre d’insertion et de suppression des éléments dans la liste importe, deux structures dedonnées sont particulièrement adaptées : la pile et la file.

In formatique de base Cours 3 ème