Structures de données indexées Licence 1 MASS - Introduction à Java et l'algorithmique Sébastien Verel verel@i3s.unice.fr www.i3s.unice.fr/

(1)

Licence 1 MASS - Introduction à Java et l'algorithmique Sébastien Verel

verel@i3s.unice.fr www.i3s.unice.fr/∼verel

Équipe ScoBi - Université de Nice Sophia-Antipolis

20 février 2012

(2)

Objectifs de la séance 5

1 Lire et enregistrer une valeur dans un tableau

2 Recherche des valeurs extrémales d'un tableau

3 Utilisation d'un accumulateur pour réaliser un calcul dans un tableau

4 Savoir concevoir un jeu de tests pour un algorithme

5 Savoir inspecter les valeurs de certaines données d'un algorithme

Questions principales du jour :

Comment traiter les données indexées ?

(3)

A quoi ça sert ?

Algorithme moyenne(n1 , n2 , n3 , n4 , n5 , n6 , n7 , n8 , n9 , n10 , n11 , n12 : réel) : réel

début

variable m : réel

m←(n1+n2+n3+n4+n5+n6+n7+n8+n9+n10+n11+n12)/12 retourner m

n

Ce n'est pas tenable :

lorsqu'on passe à une échelle de 1000 notes ou plus, lorsque le nombre de notes n'est pas déterminé à l'avance

(4)

Finalement souvenez-vous (cm04)

Algorithme moyenne(n : entier) : réel début

variable m, a : réel variable i : entier pour i de 1 à n faire

a←lire("Entrer une note") m←m+a

n pour m←m/n retourner m n

→ATTENTION : oublie de l'initialisation de accumulateur

(5)

Finalement souvenez-vous (cm03)

variable m, a : réel variable i : entier m←0

pour i de 1 à n faire

a←lire("Entrer une note") m←m+a

n pour m←m/n retourner m n

Mais :

algorithme eectue deux choses :

lecture des notes et calcul de la moyenne Les valeurs des notes sont perdues :

Par exemple, il n'est plus possible de calculer l'écart-type

(6)

Vers une solution

Noter (enregistrer) les notes quelque part : Algorithme moyenne(notes : ? ? ?) : réel notes :

12 8 17 5 16 18 18 11 14 12

possibilité de les lire de nouveau sans avoir à demander de nouveau les notes

Aujourd'hui : Apprendre à utiliser ces tableaux de données !

(7)

Plan

1 Introduction

2 Dénition de la structure

3 Algorithmes sur les tableaux

(8)

Besoin en tableaux

Le besoin de stocker pour traiter les données sont énormes : les images : tableau en deux dimensions

répertoire de noms les factures

les calendriers

les numéros de téléphones les placards

...

(9)

Caractéristiques de ces structures de données

0 1 2 3 4 5 6 7 8 12 3 4 78 12 3 9 11 12 De taille nie :

le nombre maximum de données est déterminée les données sont "numérotables" : indexables

lecture de données dont l'indice (le rang) est déterminé

(10)

Déclaration tableau

Déclaration d'un tableau t de type typeElement avec N valeurs variable t : tableau de N typeElement

0 1 2 3 4 5 6 7 8 12 3 4 78 12 3 9 11 12 variable t : tableau de 9 entiers

Déclaration d'un tableau contenant 12 caractères : variable c : tableau de 12 caractères

Déclaration d'un tableau contenant n nombres réels (n est une variable) :

(11)

Remarques

données d'un tableau : de même type

taille du tableau : nombre maximal de donnée que peut contenir le tableau

taille est déterminé avant l'utilisation du tableau taille est xe

(12)

Lecture des valeurs

lecture de la valeur d'indice i du tableau t t[i]

0 1 2 3 4 5 6 7 8 12 3 4 78 12 3 9 11 12 t[3]a pour valeur 78

tous les t[.]sont des variables classiques : t[3] +10 a pour valeur 88

t[7] +t[0]a pour valeur 23

(13)

Remarques

Beaucoup de langage de programmation ont pour convention que nous adopterons.

Supposons que la taille du tableau est n.

indice 0 : premier élément du tableau indice n−1 : dernier indice du taille

Conséquence : il n'est pas possible de lire une donnée en dehors des bornes (t[n+1], t[n]ou t[−1])

ATTENTION :

Il n'est pas possible d'accéder à tous les éléments du tableau en même temps : seulement élément par élément (traitement séquenciel)

Ne pas confondre indice et valeur : t[i]6=i

(14)

Remarques

0 1 2 3 4 5 6 7 8 12 3 4 78 12 3 9 11 12

i ←3

la case après i t[i+1]

12 la case avant i

t[i−1]

4

(15)

Aectation des valeurs

Aectation de la valeur a à la case d'indice i du tableau t t[i]←a

0 1 2 3 4 5 6 7 8 12 3 4 78 12 3 9 11 12 t[3]←15

t[2]←t[0] t[8]←t[1]²+1

0 1 2 3 4 5 6 7 8 12 3 12 15 12 3 9 11 10

(16)

Remarques sur l'aectation

t : tableau de 5 entiers t[0]←3

t[1]←6 t[2]←98 t[3]←23 t[4]←91

t[0]se comporte comme une variable classique La case d'avant i reçoit la case i :

i ←3

t[i−1]←t[i]

La case d'après i reçoit la case d'avant : i ←3

t[i+1]←t[i]

(17)

Quand utiliser un tableau ?

Les questions que l'on doit se poser :

Le nombre de données est-il déterminé à l'avance ?

Le nombre maximal de données est-il déterminé à l'avance ? Les données ont-elles besoin d'être indexées (numérotées) ? A-t-on besoin d'accéder à une donnée dont l'indexe doit être déterminé ?

Si oui, oui, oui, oui,

il est surement conseillé d'utiliser un tableau

(18)

En Java : déclaration

Déclaration d'un tableau t de taille quelconque : type[] t ;

type : int, oat, double, char, String, boolean, etc.

les [] : indique que la variable est de type tableau

(19)

En Java : déclaration et initialisation

Déclaration et initialisation d'un tableau t :

type[] t = { val0, val1, val2, ... , valn };

les [] : indique que la variable est de type tableau toutes les valeurs des cases du tableau sont données en extension

(20)

Déclaration et initialisation : exemples

int[] notes = { 12, 8, 17, 5, 16, 18, 18, 11, 14, 12 };

String[] phrase = { "rien", "ne", "vaut", "un",

"bon", "exemple" };

(21)

Un truc génial en Java

La taille du tableau : t.length

Exemple :

int[] notes = { 12, 8, 17, 5, 16, 18, 18, 11, 14, 12 };

print(notes.length);

(22)

Déclaration et initialisation vide

Déclaration et initialisation avec la valeur nulle d'un tableau t de taille n :

type[] t = new type[n];

les [] : indique que la variable est de type tableau

new : indique qu'il faut réserver de la mémoire de l'ordinateur n : nombre entier indiquant la taille

(23)

Déclaration et initialisation vide : Exemple

int[] t = new int[100];

int n = 55;

boolean[] table = new boolean[n];

(24)

Tableau et déclaration de méthode

Déclaration de méthode dont un paramètre est de type tableau :

float moyenne(int[] notes)

Déclaration de méthode dont la valeur nale est de type tableau :

int[] saisirTableau(int n) { ...

}

void setup() {

int[] tab = saisirTableau(10);

(25)

Lecture et aectation

Lecture :

println(t[0]);

int a = t[3] + 1;

Aectation : t[4] = 8;

int i = 3;

t[i] = t[i - 1] + 1;

(26)

Souvenir de CM04

Portée des variables locales

les variables locales (m, a et i) ne sont accessibles que dans cet algorithme, c'est-à-dire entre début et n.

variable m, a : réel variable i : entier ...retourner m n

moyenne(5) m← m+3

Cette dernière ligne n'a pas de sens, m n'existe pas à l'extérieur de

(27)

Souvenir de CM04

Porté des variables locales

Les valeurs des variables locales n'altèrent pas les valeurs des variables portant le même nom à l'extérieur de l'algorithme.

variable m : réel m← 2

moyenne(5) m← m+3 écrire(m)

(28)

Tableaux et méthodes

void test(int[] t) { t[1] = 20;

}

void setup() {

int[] tab = {16, 9, 17, 18};

test(tab);

println(tab[1]);

}

Qu'est-ce qui s'ache ?

20

(29)

Tableaux et méthodes

Les valeurs contenues dans un tableau donné en paramètre peuvent être modiées par une méthode

dans int[]t

t est une adresse vers une zone mémoire où sont contenus les éléments du tableau d'entier

L'adresse t n'est pas modiée par la méthode Mais la zone mémoire peut être modiée

(30)

Itération et tableaux

L'itération devient l'outil indispensable pour parcourir un tableau.

Algorithme acher(t : tableau de chaine de caractères) : rien début

variable i : entier

pour i de 0 à t.taille - 1 faire ecrire(t[i])

n pour n

(31)

En Java : achage

/*******************************************

* affichage d'un tableau contenant des chaines de caractères

** entree :

* - t : tableau de chaines de caractères

** sortie :

* - aucune

*******************************************/

void afficher(String[] t) {

(32)

En Java

void afficher(String[] t) {

for(int i = 0; i < t.length; i++) println(t[i]);

}

void setup() {

String[] phrase = { "rien", "ne", "vaut", "un", "bon", "exemple" };

afficher(phrase);

}

(33)

Itération et tableaux : saisie au clavier

Algorithme enregistrer(n : entier) : tableau d'entier début

variable a : entier variable i : entier

variable t : tableau de n entiers pour i de 0 à n-1 faire

a← lire("Entrer un nombre") t[i]←a

n pour retourner t n

(34)

Itération et tableaux : saisie au clavier

Mieux

Algorithme enregistrer(n : entier) : tableau d'entier début

variable i : entier

variable t : tableau de n entiers pour i de 0 à n-1 faire

t[i]← lire("Entrer un nombre") n pour

retourner t n

(35)

En Java : lecture

/*******************************************

* lecture au clavier d'un tableau de nombres réels

** entree :

* - n : taille du tableau

** sortie :

* - tableau de nombres entiers

*******************************************/

int[] lecture(int n) {

(36)

En Java

int[] lecture(int n) { int[] t = new int[n];

for(int i = 0; i < t.length; i++) t[i] = lire("Entrer un nombre");

return t;

}

(37)

En Java

void setup() { int n = 3;

int[] t = lecture(n);

affiche(t);

}

(38)

En Java

/*******************************************

* affichage d'un tableau contenant des entiers

** entree :

* - t : tableau de chaines d'entier

** sortie :

* - aucune

*******************************************/

void affiche(int[] t) {

for(int i = 0; i < t.length; i++) println(t[i]);

}

(39)

Calcul de la moyenne

Algorithme moyenne(t : tableau de réel) : réel début

variable m : réel variable i : entier m← 0

pour i de 0 à t.length - 1 faire m ←m+t[i]

n pour m← m/n retourner m n

(40)

En Java : moyenne

/*******************************************

* calcul de la moyenne des nombres du tableau

** entree :

* - t : tableau d'entiers

** sortie :

* - moyenne des nombres

*******************************************/

float moyenne(int[] t) {

(41)

En Java

float moyenne(int[] t) { float m;

m = 0;

for(int i = 0; i < t.length; i++) m = m + t[i];

m = m / t.length;

return m;

}

(42)

En Java

void setup() { int n = 3;

int[] t = lecture(n);

println("la moyenne est " + moyenne(t));

}

(43)

Utilisation d'un accumulateur

Comme dans le cas de calcul de la moyenne,

un certain nombre d'algorithmes nécessite de mémoriser un calcul partiel.

On nomme souvent paraccumulateur la variable qui permet de mémoriser ce résultat.

ATTENTION !

Il faut toujours aecter une valeur initiale (initialiser) à l'accumulateur avant le commencement du calcul.

(44)

Somme des carrés

Calculer S_n=P_n−1

k=0u_k² où u_k est enregistré à l'incide k du tableau t :

Algorithme sommeCarre(t : tableau de réel) : réel début

variable m : réel variable i : entier m← 0

pour i de 0 à t.taille - 1 faire m ←m+t[i]²

n pour retourner m n

(45)

En java : sommeCarre

/*******************************************

* calcul de la somme des carrés des nombres du tableau

** entree :

* - t : tableau de réels

** sortie :

* - somme des carrés

*******************************************/

float sommeCarre(float[] t) {

(46)

En java : sommeCarre

float sommeCarre(float[] t) { float m;

m = 0;

for(int i = 0; i < t.length; i++) m = m + t[i] * t[i];

return m;

}

(47)

Trouver le maximum des éléments d'un tableau

Algorithme max2(a, b : réel) : réel début

si a>b alors retourner a sinon

retourner b nn si

Algorithme max3(a, b, c : réel) : réel début

retourner max2(max2(a, b), c) n

Algorithme max4(a, b, c, d : réel) : réel début

retourner max2(max3(a, b, c), d) n

(48)

Trouver le maximum des éléments d'un tableau

Algorithme max(t : tableau de réel, n : entier) : réel début

si n=1 alors retourner t[0] sinon

retourner max2(max(t, n−1), t[n−1]) nn si

(49)

Element maximum

Trouver le maximum des éléments d'un tableau Algorithme maximum(t : tableau de réel) : réel début

variable max : réel variable i : entier max ← t[0]

pour i de 1 à t.taille - 1 faire si max <t[i]alors

max ← t[i] n pourn si

retourner max n

(50)

En java : maximum

/*******************************************

* calcul le nombre maximum du tableau

* le tableau ne doit pas être vide

** entree :

* - t : tableau de réels

** sortie :

* - maximum

*******************************************/

float maxTab(float[] t) {

(51)

En java : maximum

float maxTab(float[] t) { float m;

m = t[0];

for(int i = 1; i < t.length; i++) if (m < t[i])

m = t[i];

return m;

}

void setup() {

float[] t = { 12, 18, 10, 17, 9 };

println(maxTab(t));

}

Sébastien Verel Structures de données indexées

(52)

Achage d'une image avec Processing : image

// déclaration et chargement de l'image au format jpeg PImage img = loadImage("DSC00024.JPG");

// taille de l'écran size(400,300);

// position du coin supérieure gauche et dimensions de l'affichage image(img, 0, 0, width, height);

(53)

Exercice

Acher successivement les images marey_0.gif, marey_1.gif, ..., marey_9.gif

(54)

Objectifs de la séance 5

1 Lire et enregistrer une valeur dans un tableau

2 Recherche des valeurs extrémales d'un tableau

3 Utilisation d'un accumulateur pour réaliser un calcul dans un tableau

4 Savoir concevoir un jeu de tests pour un algorithme

5 Savoir inspecter les valeurs de certaines données d'un algorithme

Questions principales du jour :

Comment traiter les données indexées ?