Vous êtes sur la page 1sur 33

NFP 135 : VARI 1

Valeur d’Accueil et de Reconversion en


Informatique (niveau 1)

Séance 09 : Aller plus loin avec Java


Objectifs de la séance

1. Algorithme
2. Calcul de la complexité d'un algorithme
3. Les tableaux en Java
4. Un algorithme de tri en Java

2 NFP135 – Séance 09 : Aller plus loin avec Java


Algorithme :
Une définition

Algorithme :

Méthode de calcul qui indique la démarche à


suivre pour résoudre une série de problèmes
équivalents en appliquant dans un ordre
précis une suite finie de règles.

3 NFP135 – Séance 09 : Aller plus loin avec Java


Algorithme :

Trois questions à se poser sur tout algorithme :

1. Est-il correct?
2. Quelle est sa complexité?
3. Peut-on faire mieux?

4 NFP135 – Séance 09 : Aller plus loin avec Java


Algorithme :
Un premier support d’exemple

Exemple 1 :
Ecrire un algorithme qui permet d’afficher la
table du 9.

Ex: 0 9 18 27 … 81 90

5 NFP135 – Séance 09 : Aller plus loin avec Java


Exemple 1 :
Afficher la table du 9

// Exemple en pseudo code


Variables N, i en Entier

Début
N ← 9
Ecrire "La table de multiplication de ce nombre est:"
Pour i de 0 a 10
Ecrire N, " x ", i, " = ", N*i
i Suivant
FinPour
Fin
6 NFP135 – Séance 09 : Aller plus loin avec Java
Algorithme :
un deuxième exemple

Exemple 2 : Compte à rebours


Écrire l'algorithme de la fonction qui, à partir d'un
nombre entier positif n, affiche tous les nombres
entiers par ordre décroissant jusqu'à 0.

(eg pour n=5 : 5 4 3 2 1 0 )

7 NFP135 – Séance 09 : Aller plus loin avec Java


Exemple 2 :
Compte à rebours

// Exemple en pseudo code


Variables X, n en Entier

Début
X ← 5
n ← X
TantQue n > 0
Ecrire n
n ← n - 1
FinTantQue
Fin
8 NFP135 – Séance 09 : Aller plus loin avec Java
Objectifs de la séance

1. Algorithme
2. Calcul de la complexité d’un algorithme
3. Les tableaux en Java
4. Un algorithme de tri en Java

9 NFP135 – Séance 09 : Aller plus loin avec Java


Efficacité d’un algorithme
La notation grand O()

 Soient f (n) et g(n) les temps d’exécution de deux algorithmes sur


un jeu de données de taille n.
 f (n) et g(n) sont deux fonctions de N+

 On dit que f = O(g)


 (ce qui signifie “f ne grandit pas plus vite que g”)
 Si il existe une constante c > 0 telle que f (n) ≤ c . g(n)

10 NFP135 – Séance 09 : Aller plus loin avec Java


Efficacité d’un algorithme
La notation grand O()

 Trouver un majorant du nombre d’opérations réalisées par notre


algorithme

 c et n0 tq  n si n n0 alors f(n) < cg(n)


f=O(g)
11 NFP135 – Séance 09 : Aller plus loin avec Java
Efficacité d’un algorithme
La notation grand O() : exemple

 EXEMPLE
 Imaginons un algorithme dont la complexité est
 f(n) = 3n2+4n+5 opérations

 La notation O équivaut à trouver un majorant de f


 pour tout n ≥ 1 on a f(n) ≤ 12n2
 n0=1 c=12 g(n)=n2
 donc f(n) = O(n2)

12 NFP135 – Séance 09 : Aller plus loin avec Java


Efficacité d’un algorithme
Comparaison de la complexité de deux algorithmes

 Le même problème peut souvent être résolu par plusieurs


algorithmes

 x0 tq  x si x x0 alors exp(x) > x 3 > x 2 > x.ln(x) > x > x > ln(x) > 1/x

 O(nn) > O(en) > O(n3) > O(n2) > O(n.log(n)) > O(n) > O(n) > O(ln(n))

13 NFP135 – Séance 09 : Aller plus loin avec Java


Ex 1 : Afficher la table du 9
Calcul de la complexité (p1/3)

// Exemple en pseudo code


Variables N, i en Entier

Début
N ← 9
Ecrire "La table de multiplication de ce nombre est:"
Pour i de 0 a 10
Ecrire N, " x ", i, " = ", N*i
i Suivant
FinPour
Fin
14 NFP135 – Séance 09 : Aller plus loin avec Java
Ex 1 : Afficher la table du 9
Calcul de la complexité (p 2/3)

15 NFP135 – Séance 09 : Aller plus loin avec Java


Ex 1 : Afficher la table du 9
Calcul de la complexité (p 3/3)

Pour N=9 la complexité est :


11 affectations
10 additions
10 multiplications
10 comparaisons
Ce nombre 10 est indépendant de N = {1,2,3,4,5,6,7,8,9}
Pour N=8 la complexité serait la même.
Pour N=7 la complexité serait la même.

La complexité de cet algorithme est constante (indépendante de N)
On dit que la complexité de cet algorithme est en O(1)

16 NFP135 – Séance 09 : Aller plus loin avec Java


Ex 2 : Compte à rebours
Calcul de la complexité (p 1/3)

// Exemple en pseudo code


Variables X, n en Entier

Début
X ← 5
n ← X
TantQue n > 0
Ecrire n
n ← n - 1
FinTantQue
Fin
17 NFP135 – Séance 09 : Aller plus loin avec Java
Ex 2 : Compte à rebours
Calcul de la complexité (p 1/3)

18 NFP135 – Séance 09 : Aller plus loin avec Java


Ex 2 : Compte à rebours
Calcul de la complexité (p 3/3)
Pour N=5 la complexité est :
5+2 affectations
5+1 comparaisons
5 soustractions

Cette complexité varie linéairement avec le nombre N.

Pour N=8 la complexité serait la suivante :


8+1 affectations
8+1 comparaisons
8 soustractions

La complexité de cet algorithme varie linéairement en fonction de N


On dit que la complexité de cet algorithme est en O(n)

19 NFP135 – Séance 09 : Aller plus loin avec Java


Objectifs de la séance

1. Algorithme
2. Calcul de la complexité d’un algorithme
3. Les tableaux en Java
4. Un algorithme de tri en Java

20 NFP135 – Séance 09 : Aller plus loin avec Java


Les tableaux en Java (1)

- Un tableau pourquoi faire ? : Besoin de stocker et manipuler un grand nombre de valeurs


( ex : Les noms de 1000 étudiants et leurs notes)

- Un tableau c’est quoi ? : des cases mémoire d’un type donné


 // Exemples de déclarations et d’allocation de tableaux en java :
 // Ex1 : déclare un tableau pouvant contenir jusqu'a 50 entiers :
 int notes[] = new int[50]; //déclare un tableau pouvant contenir jusqu'a 50 entiers

 // Ex2 : déclare et initialise un tableau de 2 chaînes de caractères :


 String eleves [] = {″dupont″, ″durand″};

Comment utiliser un tableau ? : préciser le nom du tableau et l’indice de l’élément du tableau


 // initialisation et/ou changement de la valeur des éléments :
 notes[0] = 15 ; // fixe la valeur du premier élément du tableau (indice 0)
 notes[1] = 12 ; // fixe la valeur du deuxième élément du tableau (indice 1)
 ...
 notes[49] = 18 ; // fixe la valeur du dernier élément du tableau (indice 49)
 eleves [0] = ″dupond″;
 eleves [0] = ″Dupond″;
 eleves [1] = ″Durant″;

21 NFP135 – Séance 09 : Aller plus loin avec Java


Les tableaux en Java (2)
utilisation… (suite)
Utilisation d’un tableau dans une boucle :

// Exemples en java :
 for (int j=0 ; j < notes.length ; j++ ) {
 System.out.println(" notes[" + j + "]=" + notes[j] );
 }

 /* La boucle ci-dessus affichera


 notes[0]=15
 notes[1]=12
 notes[2]=0
 notes[3]=0
 ..
 notes[48]=0
 notes[49]=18
 */

22 NFP135 – Séance 09 : Aller plus loin avec Java


Les tableaux en Java (3)
utilisation… (fin)

Utilisation d’un tableau dans une boucle :

// Exemples en java :
 for (int indice=0 ; indice < eleves.length ; indice++ ) {
 System.out.println(" élève[" + indice + "]= " + eleves[indice] );
 }

 /* La boucle ci-dessus affichera


 élève[0]= Dupond
 élève[1]= Durant
 */

23 NFP135 – Séance 09 : Aller plus loin avec Java


Les tableaux en Java (3)
utilisation… (fin)

Utilisation d’un tableau dans une boucle :

// Exemples en java :
 for (int indice=0 ; indice < eleves.length ; indice++ ) {
 System.out.println(" élève[" + indice + "]= " + eleves[indice] );
 }

 /* La boucle ci-dessus affichera


 élève[0]= Dupond
 élève[1]= Durant
 */

24 NFP135 – Séance 09 : Aller plus loin avec Java


Objectifs de la séance

1. Algorithme
2. Calcul de la complexité d’un algorithme
3. Les tableaux en Java
4. Un algorithme de tri en Java

25 NFP135 – Séance 09 : Aller plus loin avec Java


Trier un tableau en Java (1)

 Les tableaux permettent de stocker des valeurs qui ont


parfois liées par une relation d’ordre (par exemple un
tableau d’entiers)
Exemple de valeurs non triées :
{4, 1, 3, -23};

 On peut vouloir trier par ordre croissant ou décroissant les


éléments d’un tableau d’entiers.

Exemple après un tri par ordre croissant:


{-23, 1, 3, 4};

26 NFP135 – Séance 09 : Aller plus loin avec Java


Un exemple :
sort() : Trier un tableau

// Exemple de tri sur des entiers en java :


int[] monTableau = new int[] {4, 1, 3, -23};

System.out.println("Avant tri du tableau, éléments dans cet ordre :");


for (int i=0 ; i < monTableau.length ; i++ ) {
System.out.println(" monTableau[" + i + "]=" + monTableau[i] );
}

Arrays.sort(monTableau); // apres tri : [-23, 1, 3, 4]

System.out.println("Après tri du tableau, éléments dans cet ordre :");


for (int i=0 ; i < monTableau.length ; i++ ) {
System.out.println(" monTableau[" + i + "]=" + monTableau[i] );
}

27 NFP135 – Séance 09 : Aller plus loin avec Java


Trier un tableau en Java (1)

 /* Le code ci-dessus affiche ceci :

 Avant tri du tableau, éléments dans cet ordre :


 monTableau[0]=4
 monTableau[1]=1
 monTableau[2]=3
 monTableau[3]=-23

 Après tri du tableau, éléments dans cet ordre :

 monTableau[0]=-23
 monTableau[1]=1
 monTableau[2]=3
 monTableau[3]=4

 */

28 NFP135 – Séance 09 : Aller plus loin avec Java


Tri par minimum successif
(aka Le Tri par Sélection)

Principe
Pour une place donnée, on sélectionne l'élément qui
doit y être positionné
De ce fait, si on parcourt la tableau de gauche à droite,
on positionne à chaque fois le plus petit élément qui
se trouve dans le sous tableau droit

Ou plus généralement :
Pour trier le sous-tableau t[i...nbElements]
il suffit de positionner au rang i le plus petit élément
de ce sous-tableau et de trier le sous-tableau
t[i+1...nbElements]

29 NFP135 – Séance 09 : Aller plus loin avec Java


Tri par minimum successif
(aka Le Tri par Sélection)

Par exemple, pour trier {101, 115, 30, 63, 47, 20}
on va avoir les boucles suivantes :
i=1 {101, 115, 30, 63, 47, 20}
i=2 {20, 115, 30, 63, 47, 101}
i=3 {20, 30, 115, 63, 47, 101}
i=4 {20, 30, 47, 63, 115, 101}
i=5 {20,30, 47, 63, 115, 101}

Donc en sortie : {20, 30, 47, 63, 101, 115}

30 NFP135 – Séance 09 : Aller plus loin avec Java


Complexité du tri par
Minimum Successif
Complexité de cet Algorithme :

Pour calculer la complexité de cet algorithme, on va raisonner par récursivité.

En effet, si l'on savait calculer la complexité de ce tri sur un tableau de taille n, on saurait
calculer la complexité pour un tableau de taille n+1.

Sur un tableau de taille n :


la complexité vaut : T(n) = n + T(n-1)

(Vous souvenez-vous de la somme des n premiers nombres entiers naturels ?)


=> T(n) = n(n+1)/2

Complexité en O(n2)

31 NFP135 – Séance 09 : Aller plus loin avec Java


Echanger deux valeurs
Echanger deux variables requiert une 3e variable
// Exemple en pseudo code
Déclaration
a : Entier
b : Entier
temp : Entier
Début
temp ← a // sauve la valeur de a dans la variable intermédiaire
a←b // écrase l’ancienne valeur de a
b ← temp // restaure dans b l’ancienne valeur de a
Fin
32 NFP135 – Séance 09 : Aller plus loin avec Java
Merci de votre attention