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

Algorithmes et structures de données 4ème cours Patrick Reuter maître de conférences

Présentations similaires


Présentation au sujet: "Algorithmes et structures de données 4ème cours Patrick Reuter maître de conférences"— Transcription de la présentation:

1 Algorithmes et structures de données 4ème cours Patrick Reuter maître de conférences http://www.labri.fr/~preuter

2 Ingrédients dalgorithmes Affectation (ex. mois := 6) Condition/Comparaison (ex. mois <= 12) Appel de fonction (ex. writeln(mois)) Structure de contrôle –Branchements conditionnels (multiples) (si.. Alors.. Sinon) –Boucles (tant que.. faire, pour.. faire) Bloc dinstructions (begin.. end)

3 Aujourdhui Types de base Type « tableau »

4 Mémoire vive Proc 64bit 2,93 GHz : 2,93 Giga-Instructions par seconde

5 Organisation de la mémoire Un octet peut prendre 2 8 =256 valeurs différentes, entre 00000000 et 11111111. 1 kilo-octet (ko ou Ko) = 2 10 octets = 1 024 octets –(et pas 1 000 octets comme on pourrait le supposer), soit 2 à la puissance 10. 1 méga-octet (Mo) = 2 20 octets = 1 024 ko = 1 048 576 octets. 1 giga-octet (Go) = 2 30 octets = 1 024 Mo = 1 073 741 824 octets. 1 téra-octet (To) = 2 40 octets = 1 024 Go = 1 099 511 627 776 octets.

6 Organisation de la mémoire Mémoire de 512 MegaOctets #0 #1 #2 #3 #4 #5... #536.870.910 #536.870.911 #1.000... # : adresse dans la mémoire vive

7 Déclaration de variables Comme dans un livre de recettes Ingrédients(pour 8-10 personnes) : - 1 kg de couscous roulé - 1 kg de mouton - 1 poignée de pois chiches - 2 oignons secs - 3-4 tomates fraîches ou 1 cuillère. à soupe de concentré de tomate - 3-4 pommes de terre - 3-4 navets - 3-4 carottes - 3-4 courgettes - 1 tranche de courge - 4 cuillères à soupe d'huile - 1/2 cuillère à café de cannelle - 1 pincée de poivre noir - 1/2 cuillère à soupe de piment rouge doux ou de paprika - 1/2 cuillère à soupe de ras-el-hanout - 1 piment rouge sec - 100 g de beurre ou 3 cuillères à soupe d'huile - sel Préparation : La veille, mettez les pois chiches dans un bol d'eau. Le jour même, roulez le couscous. Si vous utilisez du couscous roulé et séché, rincez-le à l'eau froide, égouttez-le et laissez- le gonfler pendant 30 mn. Coupez la viande en morceaux. Pelez les oignons et coupez-en 1 en morceaux. Lavez et passez les tomates à la moulinette. Mettez la viande dans une marmite et ajoutez les morceaux d'oignon, les tomates ou le concentré de tomate dilué dans 1 verre d'eau, l'huile, le poivre, le piment, la cannelle et du sel. Faites revenir …..

8 Déclaration de variables var compteur : integer; var diviseur : float; var c : char; var precision : double; var nom : string; var masculin : boolean; diviseur := 1.1; compteur : = 1; Nom := Gerhard; Nombre entier Nombre à virgule flottante Nombre à virgule flottante avec double précision caractère Chaîne de caractères VRAI/FAUX

9 Types de base Type binaire : Boolean (bool)1 bitFALSE, TRUE (FAUX, VRAI) Nombre entiers : Unsigned char (byte)1 Octet0 à 255 Signed char(byte)1 Octet-128 à 127 Unsigned integer4 Octets0 à 4294967295 Signed Integer4 Octets-2147483648 à +2147483647 Nombre à virgule flottante : Real (Single, float)4 Octets-3.4*10 -38 à 3.4*10 38 (7 décimales) Double 8 Octets1.8 * 10 -308 à 1.8 * 10 308 (15 décim) Rappel : 1 Octet = 8 bits = 2 8 possibilités 4 Octets = 32 bits = 2 32 possibilités

10 Octet, byte (caractère) var c : char; (byte) valeurs de 0..255 Quest-ce quon peut faire avec un octet ? Code ASCII (American Standard Code for Information Interchange) 95 caractères imprimables

11 Octet - Code ASCII

12 Organisation de la mémoire Un octet peut prendre 2 8 =256 valeurs différentes, entre 00000000 et 11111111. Octets non- signés : Par exemple : 1 1 0 0 0 1 0 0 128 64 32 16 8 4 2 1

13 Organisation de la mémoire Octet signé de -128 jusquà 127 Valeurs négatives : 1111 1111 = -1 à 1000 0000 = -128. Valeurs positives : 0000 0000 = 0 à 1111 1111 = 127 Calculer les valeurs négatives : -Prendre le complément -Ajouter 1 -Exemple: - 65 01000001 Complément10111110 Ajouter 110111111

14 1,4 0,001231 1,231*10^-3 -9866-9,866*10^3 1,451,45*10^1 …

15 1,4 0,001231 1,231*10^-3 -9866-9,866*10^3 1,451,45*10^1 … base b=10 mantisse m (entier, sans la virgule) signe s {+1,-1} exposant e

16 Nombre à virgule flottante var c : real; (single, double, real,..) Approximations rationnelles de nombres réels.nombres réels Les nombres à virgule flottante possèdent –un signe s (dans {-1, 1}) –une mantisse entière m (parfois appelée significande)mantisseentière –un exposant e.exposant s * m * b e - Avec b la base de représentation (parfois 2, 10, 16, ou autre) - En faisant varier e, on fait « flotter » la virgule décimale.

17 Nombre à virgule flottante Float, single, double, real,.. Approximations rationnelles de nombres réels.nombres réels Les nombres à virgule flottante possèdent –un signe s (dans {-1, 1}) –une mantisse entière m (parfois appelée significande)mantisseentière –un exposant e.exposant s * m * b e -Avec b la base de représentation (parfois 2, 16, ou autre) signeexposantmantisse Simple précision (float, 32 bits)1 bit8 bits23 bits Double précision(double,64 bits)1 bit11 bits52 bits Simple précision (b=2): (-1)S * (1 + M/2 23 ) * 2 (E-127) Double précision (b=2):(-1) S * (1 + M/2 52 ) * 2 (E-1023)

18 Conversion dun nombre x Nombre x = (-1) s * m * 2 e (base b = 2) –signe s : 0 pour positive, 1 pour négative –Exposant e: e = log 2 (x) –Mantisse m: m = (x/2 e – 1) * 2 23

19 Conversion dun nombre x Rappel : Nombre x = (-1) s * m * 2 e (base b = 2) –signe s : 0 pour positive, 1 pour négative –Exposant e: e = log 2 (x) –Mantisse m: m = (x/2 e – 1) * 2 23 Exemple : x = +11,25 Signe s = positive -> 0 binaire Exposant e = log 2 (11,25) = 3,49 = 3 + 127 = 130 -> 10000010 binaire Mantisse m = (11,25/2 3 – 1) * 2 23 = 3407872 ) = 01101000000000000000000 binaire Solution : 0 10000010 01101000000000000000000 pour chiffres négatifs

20 Nombre à virgule flottante Float, single, double, real,.. Approximations rationnelles de nombres réels.nombres réels Les nombres à virgule flottante possèdent –un signe s (dans {-1, 1}) –une mantisse entière m (parfois appelée significande)mantisseentière –un exposant e.exposant s * m * b e Limitation : précision limitée qui se traduit par des arrondis qui peuvent s'accumuler de façon gênante.

21 Organisation de la mémoire var lettre : char; ( 1 octet (byte) ) #0 #1 #2 #3 #4 #5... #536.870.910 #536.870.911 #1.000...

22 Organisation de la mémoire var lettre : signed char; lettre := -65; #0 #1 #2 #3 lettre #4 #5... #536.870.910 #536.870.911 #1.000... 191

23 Organisation de la mémoire var lettre1,lettre2,lettre3,lettre4 : char; lettre1 := 60; lettre2 := 80; lettre3 := 50; lettre4 := 30;... #1.000... lettre4 #3 lettre3 #2 lettre2 #1 lettre1 #0 50 80 60 30

24 Organisation de la mémoire var nombre : integer; #4 #5... #1.000... nombre #0 nombre

25 Organisation de la mémoire var nombre : integer; ( 4 byte (octets) ) nombre := 125; nombre #0 #4 #5... #536.870.910 #536.870.911 #1.000... 0 0 0 125 nombre 0 0 0 125 nombre

26 Organisation de la mémoire var nombre : integer; ( 4 byte (octets) ) nombre := 260; nombre #0 #4 #5... #536.870.910 #536.870.911 #1.000... 0 0 0 125 nombre 0 0 1 4 1*256 + 4*1

27 Organisation de la mémoire var resultat : REAL; #4 #5... #536.870.910 #536.870.911 #1.000... resultat #0 resultat

28 Exercice Déclarer le nombre de jours dans chaque mois Ecrire un algorithme qui compte le nombre de mois à 30 jours

29 var janvier: byte; var fevrier: byte; var mars: byte; … var decembre: byte; var compteur : integer; janvier := 31; fevrier := 28; mars := 31; avril := 30; … decembre := 31; compteur := 0; si janvier = 30 alors compteur := compteur + 1; fin si si fevrier = 30 alors compteur := compteur + 1; fin si... si decembre = 30 alors compteur := compteur + 1; fin si

30 Type : tableaux (angl. ARRAY) Déclaration dune variable de type tableau Définition : var nom_du_tableau : Array[MinDim..MaxDim] of type ; Exemples : var mot: array[0..10] of char; var jours: array[1..12] of char; … -structure de données la plus connue -structure homogène, chaque élément est du même type de base

31 Type : tableaux (angl. ARRAY) Déclaration dune variable de type tableau var jours : array[1..12] of byte; var mot : array[0..10] of char; Affectation : nom_du_tableau[index] := valeur ; Exemples : jours[1] := 31; jours[2] := 28; … jours[12] := 31; jours[13] ----- Erreur !!! jours[14] ----- Erreur !!! …

32 Type : tableaux (angl. ARRAY) Exemple dun algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31;

33 Type : tableaux (angl. ARRAY) Exemple dun algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0;

34 Type : tableaux (angl. ARRAY) Exemple dun algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0;

35 Type : tableaux (angl. ARRAY) Exemple dun algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0; {boucle} Tant que i<=12 faire Début Fin

36 Type : tableaux (angl. ARRAY) Exemple dun algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0; {boucle} Tant que i<=12 faire Début si (jours[i] = 30) alors nombre := nombre + 1; i := i +1; Fin

37 Type : tableaux (angl. ARRAY) Exemple dun algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0; {boucle} Tant que i<=12 faire Début si (jours[i] = 30) alors nombre := nombre + 1; i := i +1; Fin Afficher(« Il y a », nombre, « de mois à 30 jours »);

38 Type : tableaux (angl. ARRAY) Exemple dun algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0; {boucle} Tant que i<=12 faire Début si (jours[i] = 30) alors nombre := nombre + 1; i := i +1; Fin Afficher(« Il y a », nombre, « de mois à 30 jours »); Jours[1]Jours[2]...Jours[12]inombre

39 Type : tableaux (angl. ARRAY) Exemple dun algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0; {boucle} Tant que i<=12 faire Début si (jours[i] = 30) alors nombre := nombre + 1; i := i +1; Fin Afficher(« Il y a », nombre, « de mois à 30 jours »); Jours[1]Jours[2]...Jours[12]inombre 31

40 Type : tableaux (angl. ARRAY) Exemple dun algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0; {boucle} Tant que i<=12 faire Début si (jours[i] = 30) alors nombre := nombre + 1; i := i +1; Fin Afficher(« Il y a », nombre, « de mois à 30 jours »); Jours[1]Jours[2]...Jours[12]inombre 31 28

41 Type : tableaux (angl. ARRAY) Exemple dun algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0; {boucle} Tant que i<=12 faire Début si (jours[i] = 30) alors nombre := nombre + 1; i := i +1; Fin Afficher(« Il y a », nombre, « de mois à 30 jours »); Jours[1]Jours[2]...Jours[12]inombre 31 28 31

42 Type : tableaux (angl. ARRAY) Exemple dun algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0; {boucle} Tant que i<=12 faire Début si (jours[i] = 30) alors nombre := nombre + 1; i := i +1; Fin Afficher(« Il y a », nombre, « de mois à 30 jours »); Jours[1]Jours[2]...Jours[12]inombre 31 28 31 1

43 Type : tableaux (angl. ARRAY) Exemple dun algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0; {boucle} Tant que i<=12 faire Début si (jours[i] = 30) alors nombre := nombre + 1; i := i +1; Fin Afficher(« Il y a », nombre, « de mois à 30 jours »); Jours[1]Jours[2]...Jours[12]inombre 31 28 31 1 0

44 Type : tableaux (angl. ARRAY) Exemple dun algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0; {boucle} Tant que i<=12 faire Début si (jours[i] = 30) alors nombre := nombre + 1; i := i +1; Fin Afficher(« Il y a », nombre, « de mois à 30 jours »); Jours[1]Jours[2]...Jours[12]inombre 31 28 31 1 0 ….

45 Type : tableaux (angl. ARRAY) Exemple dun algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0; {boucle} Tant que i<=12 faire Début si (jours[i] = 30) alors nombre := nombre + 1; i := i +1; Fin Afficher(« Il y a », nombre, « de mois à 30 jours »); Jours[1]Jours[2]...Jours[12]inombre 31 28 31 1 0 ….

46 Type : tableaux (angl. ARRAY) Exemple dun algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0; {boucle} Tant que i<=12 faire Début si (jours[i] = 30) alors nombre := nombre + 1; i := i +1; Fin Afficher(« Il y a », nombre, « de mois à 30 jours »); Jours[1]Jours[2]...Jours[12]inombre 31 28 31 1212 0 ….

47 Type : tableaux (angl. ARRAY) Exemple dun algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0; {boucle} Tant que i<=12 faire Début si (jours[i] = 30) alors nombre := nombre + 1; i := i +1; Fin Afficher(« Il y a », nombre, « de mois à 30 jours »); Jours[1]Jours[2]...Jours[12]inombre 31 28 31 1212 0 ….

48 Type : tableaux (angl. ARRAY) Exemple dun algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0; {boucle} Tant que i<=12 faire Début si (jours[i] = 30) alors nombre := nombre + 1; i := i +1; Fin Afficher(« Il y a », nombre, « de mois à 30 jours »); Jours[1]Jours[2]...Jours[12]inombre 31 28 31 1212 0 ….

49 Type : tableaux (angl. ARRAY) Exemple dun algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0; {boucle} Tant que i<=12 faire Début si (jours[i] = 30) alors nombre := nombre + 1; i := i +1; Fin Afficher(« Il y a », nombre, « de mois à 30 jours »); Jours[1]Jours[2]...Jours[12]inombre 31 28 31 123123 0 ….

50 Type : tableaux (angl. ARRAY) Exemple dun algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0; {boucle} Tant que i<=12 faire Début si (jours[i] = 30) alors nombre := nombre + 1; i := i +1; Fin Afficher(« Il y a », nombre, « de mois à 30 jours »); Jours[1]Jours[2]...Jours[12]inombre 31 28 31 123123 0 ….

51 Type : tableaux (angl. ARRAY) Exemple dun algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0; {boucle} Tant que i<=12 faire Début si (jours[i] = 30) alors nombre := nombre + 1; i := i +1; Fin Afficher(« Il y a », nombre, « de mois à 30 jours »); Jours[1]Jours[2]...Jours[12]inombre 31 28 31 123123 0 ….

52 Type : tableaux (angl. ARRAY) Exemple dun algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0; {boucle} Tant que i<=12 faire Début si (jours[i] = 30) alors nombre := nombre + 1; i := i +1; Fin Afficher(« Il y a », nombre, « de mois à 30 jours »); Jours[1]Jours[2]...Jours[12]inombre 31 28 31 12341234 0 ….

53 Type : tableaux (angl. ARRAY) Exemple dun algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0; {boucle} Tant que i<=12 faire Début si (jours[i] = 30) alors nombre := nombre + 1; i := i +1; Fin Afficher(« Il y a », nombre, « de mois à 30 jours »); Jours[1]Jours[2]...Jours[12]inombre 31 28 31 12341234 0 1 ….

54 Type : tableaux (angl. ARRAY) Exemple dun algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0; {boucle} Tant que i<=12 faire Début si (jours[i] = 30) alors nombre := nombre + 1; i := i +1; Fin Afficher(« Il y a », nombre, « de mois à 30 jours »); Jours[1]Jours[2]...Jours[12]inombre 31 28 31 12341234 0 1 ….

55 Type : tableaux (angl. ARRAY) Exemple dun algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0; {boucle} Tant que i<=12 faire Début si (jours[i] = 30) alors nombre := nombre + 1; i := i +1; Fin Afficher(« Il y a », nombre, « de mois à 30 jours »); Jours[1]Jours[2]...Jours[12]inombre 31 28 31 12341234 0 1 ….

56 Organisation de la mémoire var jours : array[1..12] of byte; {12 octets} #0 jours[1] #2000... #536.870.910 #536.870.911... jours[3] #2002 jours[12] #2011... jours[2] #2001...

57 Organisation de la mémoire Jours[1]:=31; jours[2]:=30; … #0 jours[1] #2000... #536.870.910 #536.870.911... jours[3] #2002 jours[12] #2011... jours[2] #2001 31 28 31

58 Organisation de la mémoire var jours : array[1..12] of byte; {12 octets} #0 jours[1] #2000... #536.870.910 #536.870.911... jours[3] #2002 jours[12] #2011... Occupe de la place successive dans la mémoire jours[2] #2001 31 28 31

59 Organisation de la mémoire var jours : array[1..12] of byte; {12 octets} #0 jours[1] #2000... #536.870.910 #536.870.911... jours[index] #(2000+index-1) jours[3] #2002 jours[12] #2011... Occupe de la place successive dans la mémoire jours[2] #2001 31 28 31

60 Organisation de la mémoire var jours : array[1..12] of byte; {12 octets} jours[1] #2000... #536.870.910 #536.870.911... jours[3] #2002 jours[12] #2011... jours[2] #2001 31 28 31 i #0

61 Type : tableaux (angl. ARRAY) -structure de données la plus connue -structure homogène, chaque élément est du même type de base -occupe de la place successive dans la mémoire -« random access » = laccès aux différents éléments se fait à coût égal est donc à un coût constant

62


Télécharger ppt "Algorithmes et structures de données 4ème cours Patrick Reuter maître de conférences"

Présentations similaires


Annonces Google