3MIA303 – 2ÈME ANNEE

MATHEMATIQUES POUR L’INFORMATIQUE

ALGORITHMES ET PROGRAMMATION

DIEU-DONNÉ OKALAS-OSSAMI
DÉPARTEMENT MATH-INFO
(ANNÉE ACADÉMIQUE 2016-2017)
Déroulement

Lundi
(20/03/17
)
Déroulement

INTRODUCTION

• ALGORITHMIQUE

• PROGRAMMATION
Introduction
Généralités
 Problème du logiciel:
 Taille
 Coût : développement et maintenance
 Fiabilité

 Solutions :
 Modularité
 Réutiliser le logiciel
 Certification
 Comment?
Introduction

Objectifs généraux

Il s'agit d'un cours d'approfondissement:

 On consolide ses bases d'algorithmique

 On perfectionne sa programmation Java
Introduction

Objectifs de ce cours

Il s'agit d'un cours d‘introduction:

 A la programmation JAVA
Pourquoi programmer ?

L'informatique est une science et une technique

 les détails sont importants (il n'y a pas de

différence entre la théorie et la pratique, en
théorie)

 il faut comprendre ce que la programmation

permet
 de faire (de façon réaliste)
 coûte (en moyens humains notamment)
Introduction à Java
INFO
– Université des Sciences et Technique de Masuku
Références Web

• The Java Tutorial from Sun

http://java.sun.com/docs/books/tutorial/

• The Java Developer Connection

http://developer.java.sun.com/developer/index.html

• Gamelan
http://www.gamelan.com

• Java Applet Rating Services

http://www.jars.com

Introduction à la POO INFO 114

JOUR 1

I. Introduction et historique
Introduction
Généralités
 Problème du logiciel:
 Taille
 Coût : développement et maintenance
 Fiabilité

 Solutions :
 Modularité
 Réutiliser le logiciel
 Certification
 Comment?
Pourquoi programmer ?

L'informatique est une science et une technique

 les détails sont importants (il n'y a pas de

différence entre la théorie et la pratique, en
théorie)

 il faut comprendre ce que la programmation

permet
 de faire (de façon réaliste)
 coûte (en moyens humains notamment)
Pourquoi Java ?

On limite les langages à l’USTM: C, C++, Matlab,

JAVA
 Java est un bon compromis

Ne vous trompez pas :

 Vous apprenez un langage, c'est vrai !

 Mais vous apprenez surtout a programmer

JOUR 1

I. Survol du chapitre
Survol du chapitre
• Qu’est-ce que Java ?

• Java comme langage de programmation

• La plateforme Java
 La Java Virtual Machine
 Les interfaces de programmation d’application (API)

• Déploiement d’un programme

• Quelques notions historiques

Introduction à la POO INFO 114

Les langages
Pourquoi Java ?

Crée par James Gosling en 1991 (Canadien)

8
Java - Historique

• Objectif
 Langage sûr (fortement typé)

 Gestion automatique de la mémoire

 Usage sur le web

9
Aperçu de Java

Comparable au C++ … mais différent

 Syntaxe très proche du C++  Interprété
 Prog. Orienté-objet  Gestion implicite de la
mémoire
 … et prog. structurée
 Existence d’une classe
 Fortement typé Objet
 Types de bases  Bibliothèque de base très
 Gestion des tableaux développée
 Pas de gestion explicite
 Exceptions des pointeurs
 Pas de surcharge
d’opérateurs
Qu’est-ce que Java ?

• Java est un langage de programmation

 Voir le « white paper » de J.Gosling
 Un programme Java est compilé et interprété

• Java est une plateforme

 La plateforme Java, uniquement software, est exécutée
sur la plateforme du système d’exploitation
 La « Java Platform » est constituée de :
 La « Java Virtual Machine » (JVM)
 Des interfaces de programmation d’application (Java API)

Introduction à la POO INFO 114

Java comme langage de programmation

Java est un langage de programmation particulier qui

possède des caractéristiques avantageuses:
 Simplicité et productivité:
 Intégration complète de l’OO
 Gestion mémoire (« Garbage collector »)
 Robustesse, fiabilité et sécurité
 Indépendance par rapport aux plateformes
 Ouverture:
 Support intégré d’Internet
 Connexion intégrée aux bases de données (JDBC)
 Support des caractères internationaux
 Distribution et aspects dynamiques
 Performance

Introduction à la POO INFO 114

Java comme langage de programmation
Neutre architecturalement
• Il existe une grande diversité de
MyProgram.java
systèmes d’exploitation

• Le compilateur Java génère un

bytecode, c’est à dire un format Java Compiler
intermédiaire, neutre
architecturalement, conçu pour
faire transiter efficacement le
code vers des hardware différents MyProgram.class
et/ou plateformes différentes = bytecode

• Le bytecode ne peut-être JVM JVM JVM

interprété que par le processeur Mac Windows Unix
de la JVM

Introduction à la POO INFO 114

Petit rappel
Java comme Plateforme

• Plateforme = environnement hardware ou software sur

lequel le programme est exécuté.
• La Java « Platform » se compose de:
 la Java Virtual Machine (Java VM)
 la Java Application Programming Interface (Java API)

Introduction à la POO INFO 114

Java comme Plateforme
Java Application Programming Interface (API)
• L’API Java est structuré en libraires (packages). Les packages
comprennent des ensembles fonctionnels de composants (classes)..
• Le noyau (core) de l’API Java (incluse dans toute implémentation
complète de la plateforme Java) comprend notamment :
 Essentials (data types, objects, string, array, vector, I/O,date,…)
 Applet
 Abstract Windowing Toolkit (AWT)
 Basic Networking (URL, Socket –TCP or UDP-,IP)
 Evolved Networking (Remote Method Invocation)
 Internationalization
 Security
 …..

Introduction à la POO INFO 114

Déploiement d’un programme (1/2)
Paradigme classique de la compilation

MyProgram.c

Exécuté une seule fois Génère du code natif directement

Mais différent pour Compiler exécutable, mais spécifique à
chaque environnement chaque environnement

MyProgram.o

010110…

Introduction à la POO INFO 114

Déploiement d’un programme (2/2)
Changement de la vision traditionnelle de la compilation
• Chaque programme est compilé et interprété
• « Write once run everywhere »

MyProgram.java

Traduit le programme en un code intermédiaire

Exécuté une seule fois Compiler Appelé bytecode – indépendant de la machine

MyProgram.class

Chaque fois que le

programme est exécuté Interpreter Lit le bytecode et exécute sur la machine

010110…

Introduction à la POO INFO 114

Une vérité

Il n'y a pas de bon langage,

seulement de bons programmeurs
JOUR 1

II. Les bases du langage: Variables

Installer les outils

 J2SE(Java 2 Standard Edition, celui qui nous intéresse dans cet

ouvrage) : permet de développer des applications dites « client lourd
», par exemple Word, Excel, la suite OpenOffice.org… Toutes ces
applications sont des « clients lourds » . C'est ce que nous allons
faire dans ce cours

 J2EE(Java 2 Enterprise Edition) : permet de développer des

aplications web en Java. On parle aussi de clients légers.

 J2ME(Java 2 Micro Edition) : permet de développer des applications

pour appareils portables, comme des téléphones portables, des
PDA…

 IDE (Eclipse, Netbeans, Adroid Studio, etc.).

Introduction à la POO INFO 114

Poids des variables

Le tableau suivant présente les poids les plus fréquemment rencontrés :

Raccourcis Traduction Correspondance

b Bit C'est la plus petite valeur
informatique : soit 0 soit 1
o Octet regroupement de 8 bits, par
exemple : 01011101
Ko Kilo Octet regroupement de 1024
octets
Mo Mega Octet regroupement de 1024 ko
Go Giga Octet regroupement de 1024 Mo
To Tera Octet regroupement de 1024 Go
Poids des variables

Le tableau suivant présente les poids les plus fréquemment rencontrés :

Raccourcis Traduction Correspondance

b Bit C'est la plus petite valeur
informatique : soit 0 soit 1
o Octet regroupement de 8 bits, par
exemple : 01011101
Ko Kilo Octet regroupement de 1024
octets
Mo Mega Octet regroupement de 1024 ko
Go Giga Octet regroupement de 1024 Mo
To Tera Octet regroupement de 1024 Go
Poids des variables

Nous allons commencer par découvrir comment créer des variables dans la
mémoire. Pour cela, il faut les déclarer. Une déclaration de variable se fait comme
ceci :

Cette opération se termine toujours par un point-virgule « ; » (comme toutes les

instructions de ce langage). Ensuite, on l'initialise en entrant une valeur.

En Java, nous avons deux types de variables :

1.des variables de type simple ou « primitif » ;
2.des variables de type complexe ou des « objets ».

types simples ou types primitifs, en Java, ce sont tout bonnement des nombres
entiers, des nombres réels, des booléens ou encore des caractères, et vous allez
voir qu'il y a plusieurs façons de déclarer certains de ces types.
Variables
Variables
Variables
Variables
Variables
Variables
Variables
Variables
Variables
Variables
Variables
Variables
Variables
Variables
Variables
Variables
JOUR 1

II. Les bases du langage: Entrées/Sorties

Entrées/Sorties
Entrées/Sorties
Entrées/Sorties
Entrées/Sorties
Entrées/Sorties
Entrées/Sorties
Entrées/Sorties
Entrées/Sorties
Entrées/Sorties
JOUR 1

II. Les bases du langage: Conditions

Conditions
Conditions
Conditions
Conditions
Conditions
Conditions
Conditions
Conditions
Conditions
Conditions
Conditions
Conditions
Conditions
JOUR 1

II. Les bases du langage: Boucles

Conditions
Conditions
Conditions
Conditions
Conditions
Boucles
Boucles
Boucles
Boucles
Boucles
Boucles
Boucles
Boucles
Boucles
Boucles
JOUR 1

II. Les bases du langage: Tableaux

Tableaux à une dimension
Tableaux à une dimension
Tableaux à deux dimensions
Tableaux à deux dimensions
Tableaux à deux dimensions
TD/TP

Exercice sur les tableaux

Exo

Essayer de faire une recherche dans un tableau.

Il va falloir effectuer une saisie clavier et regarder si
celle-ci est présente dans le tableau…
Gardez la partie de code permettant de faire plusieurs
fois la même action ; ensuite, faites une boucle de
recherche incluant la saisie clavier, un message si la
saisie est trouvée dans le tableau, et un autre message
si celle-ci n'est pas trouvée.
CORRECTION TD/TP

Exercice sur les tableaux

Sol Exo
Sol Exo
Sol Exo
Sol Exo 2
Sol Exo
Sol Exo
Sol Exo
TD/TP

Variables, Conditions, Boucles

TD/TP
TD/TP
TD/TP
TD/TP
TD/TP
CORRECTION TD/TP

Variables, Conditions Boucles

TD/TP
TD/TP
TD/TP
import java.util.Scanner;

class Sdz1 {
public static void main(String[] args) {
//Notre objet Scanner
Scanner sc = new Scanner(System.in);

//initialisation des variables

double aConvertir, convertit=0;
char reponse=' ', mode = ' ';

System.out.println("CONVERTISSEUR DEGRÉS CELSIUS ET DEGRÉS FAHRENHEIT");

System.out.println("-------------------------------------------------");

do{//tant que reponse = O //boucle principale

do{//tant que reponse n'est pas O ou N

mode = ' ';
System.out.println("Choisissez le mode de conversion : ");
System.out.println("1 - Convertisseur Celsius - Fahrenheit");
System.out.println("2 - Convertisseur Fahrenheit - Celsius ");
mode = sc.nextLine().charAt(0);

if(mode != '1' && mode != '2')

System.out.println("Mode inconnu, veuillez réitérer votre choix.");

}while (mode != '1' && mode != '2');

TD/TP //saisie de la température à convertir
System.out.println("Température à convertir :");
aConvertir = sc.nextDouble();
//Pensez à vider la ligne lue
sc.nextLine();

//Selon le mode, on calcule différemment et on affiche le résultat

if(mode == '1'){
convertit = ((9.0/5.0) * aConvertir) + 32.0;
System.out.print(aConvertir + " °C correspond à : ");
System.out.println(arrondi(convertit, 2) + " °F.");
}
else{
convertit = ((aConvertir - 32) * 5) / 9;
System.out.print(aConvertir + " °F correspond à : ");
System.out.println(arrondi(convertit, 2) + " °C.");
}

//On invite l'utilisateur à recommencer ou à quitter

do{
System.out.println("Souhaitez-vous convertir une autre température ?(O/N)");
reponse = sc.nextLine().charAt(0);

}while(reponse != 'O' && reponse != 'N');

}while(reponse == 'O');

System.out.println("Au revoir !");

//Fin de programme
}

public static double arrondi(double A, int B) {

return (double) ( (int) (A * Math.pow(10, B) + .5)) / Math.pow(10, B);
}
}
INTRODUCTION A JAVA

Première application en JAVA

Comment développer une application?

Deux façons d’écrire des programmes Java:

• En écrivant le code dans un simple éditeur de texte
 Compilation et exécution du code en ligne de commande DOS

• En utilisant un environnement de développement (IDE)

 Netbeans (http://www.netbeans.com)
 Borland JBuilder (http://www.borland.com/jbuilder)
 IBM WebSphere Studio (http://www.ibm.com/software/awdtools)
 Sun ONE Studio (http://wwws.sun.com/software/sundev)
 Microsoft .Net Studio (http://msdn.microsoft.com/vstudio)
 Eclipse (https://eclipse.org/)
 … Crimson Editor !!!!

Introduction à la POO INFO 114

Une première application EX 2.1

Application HelloWorld
• Créer un fichier texte : HelloWorld.java
• Règle de bonne pratique : 1 classe par fichier et 1 fichier par classe

public class HelloWorld La première ligne du programme doit être la

{ déclaration de la classe

public static void main (String[]args) Tout programme doit contenir une méthode
{ main qui porte la signature ci-contre
System.out.println("Hello the World");
Écrire à l’écran “Hello the World”
}
} Fermer les accolades

• Compiler le programme : javac HelloWorld.java

• Le compilateur génère le bytecode dans le fichier : HelloWorld.class
• Exécuter l’application : java HelloWorld
• « Hello the World » s’affiche à l’écran

Introduction à la POO INFO 114

Java Program Structure

// comments about the class

public class MyProgram
{
class header

class body

Comments can be placed almost anywhere

}

© 2004 Pearson Addison-Wesley. All rights reserved

122
Java Program Structure

// comments about the class

public class MyProgram
{

// comments about the method

public static void main (String[] args)
{
method header
method body
}

© 2004 Pearson Addison-Wesley. All rights reserved

Comments
• Comments in a program are called inline documentation
• They should be included to explain the purpose of the program
and describe processing steps
• They do not affect how a program works
• Java comments can take three forms:

// this comment runs to the end of the line

/* this comment runs to the terminating

symbol, even across line breaks */

/** this is a javadoc comment */

© 2004 Pearson Addison-Wesley. All rights reserved

JAVA

Syntaxe du langage Java

Survol du chapitre
• Conventions d’écriture
• Commentaires dans le code source
• Identificateurs
• Mots-clé
• Types primitifs et types de références
• La classe String
• Arithmétique et opérateurs
• Instructions de contrôle
 If, then, else
 For
 While
 Do… While
 Break et Continue
• Les tableaux (« Array »)

Introduction à la POO INFO 114

Conventions d’écriture
Classes
class BankAccount
class RacingBike
Interfaces
interface Account
Méthodes
deposit()
getName()
Packages
package coursTechnofutur3.bank ;
Variables
int accountNumber
Constantes
MAXIMUM_SIZE

Introduction à la POO INFO 114

Commentaires dans le code source

Trois façons d’inclure des commentaires :

 Tout texte entre « // » et la fin de la ligne
// Commentaires sur une seule ligne

 Tout texte entre « /* » et « */ »

/* Commentaires
sur un nombre important voire très important
de lignes */

 Les textes entre « /** » et « */ » sont utilisés pour créer des commentaires que
l’exécutable JAVADOC pourra traiter afin de produire une documentation (cf.
documentation de l’API Java)
/** Commentaires destinés
à la documentation */

Introduction à la POO INFO 114

Identificateurs

• Un identificateur (identifier) permet de désigner une classe, une

méthode, une variable …
• On ne peut utiliser ce que l’on veut :
 Interdiction d’utiliser les mots-clés
 Commencent par :
 Une lettre
 Un « $ »
 Un « _ » (underscore)
 Ne commencent pas par :
 Un chiffre
 Un signe de ponctuation autre que « $ » ou « _ »

Introduction à la POO INFO 114

Mots-clé

abstract double int strictfp **

boolean else interface super
break extends long switch
byte final native synchronized
case finally new this
catch float package throw
char for private throws
class goto * protected transient
const * if public try
continue implements return void
default import short volatile
do instanceof static while

* Indique un mot clé qui est peu utilisé

** A partir de la plate-forme Java2

Introduction à la POO INFO 114

Types primitifs et types de référence

• Java est un langage fortement typé

• Le type de données précise
 les valeurs que la variable peut contenir
 les opérations que l’on peut réaliser dessus
• Deux types de données:
 Donnée primitive: contient physiquement la valeur
(caractère, nombre, booléen)
 Référence: contient l’adresse mémoire où l’information relative à l’objet,
l’interface, etc. est réellement stockée

Référence: Adresse

Introduction à la POO INFO 114

Types primitifs et types de référence
Types de données primitifs (1/4)

Chart Title

Primitive Data Types

Integral Floating

byte 8bits -128 to 127 float 32bits 1.4E-45 3.4E38

short 16bits -32768 to 32767 double 64bits 4.9E-324 1.8E308
int 32bits -2^31 to 2^31-1
long 64 bits -2^63 to 2^63-1

Textual Logical

char 16bits 0 to 65535 one bit : true or false

Introduction à la POO INFO 114

Types primitifs et types de référence
Types de données primitifs (2/4)
• Explication:
 byte : codé sur 8 bits  28 valeurs  (–27) to (27–1) = -128 à 127
 int : codé sur 32 bits  232 valeurs  (–231) to (231–1)

• Déclaration et initialisation :
 int int x=12;
 short short x= 32; (short x=33000; // Hors limite)
 long long x= 200L; // Nombre accolé à un L
 byte byte x=012; // Nombre commençant avec un 0
 double double x=23.2323;
 float float x= 23.233F; // Nombre accolé à un F
 char char c=‘a’; char c=‘\u0061’; char c=(char)97;
 boolean boolean b=true;

Introduction à la POO INFO 114

Types primitifs et types de référence
Types de données primitifs (3/4)
Déclaration, Initialisation et Assignation des types primitifs

int t; Déclaration d’un entier t (t est l’identificateur)

int u = 3; Déclaration et initialisation d’un entier
t=7; Initialisation de t à la valeur 7
u=t; Assignation (affectation) de la valeur de t à u
m=9; Erreur déclaration préalable nécessaire
char c; Déclaration
c=‘a’; Initialisation

Introduction à la POO INFO 114

Types primitifs et types de référence
Types de données primitifs (4/4)
Exemple:

int a = 5;
Déclaration et initialisation de 2 entiers: a et b
int b = 8;

a=b; Affectation de la valeur de b à a

Désormais, il existe deux variables en mémoire qui ont la

a=8 b=8 même valeur

Introduction à la POO INFO 114

Types primitifs et types de référence
Types de référence
• Tous les types hormis les types primitifs
• « Pointeur implicite » sur un objet

Référence: Adresse

Introduction à la POO INFO 114

La classe String

• String n’est pas un type primitif, c’est une classe

• Déclaration de deux String:
String s1, s2;
• Initialisation :
s1 = "Hello";
s2 = "le monde";
• Déclaration et initialisation :
String s3 = "Hello";
• Concaténation :
String s4 = s1 + " " + s2;

Introduction à la POO INFO 114

Arithmétique et opérateurs
Arithmétique élémentaire
• Quelle est la valeur de : 5+3*4+(12/4+1)
• Règles de précédences sur les opérateurs:

Niveau Symbole Signification

1 () Parenthèse
* Produit
2 / Division
% Modulo
+ Addition ou concaténation
3
- Soustraction

Introduction à la POO INFO 114

Arithmétique et opérateurs
Opérateurs de comparaison
• Pour comparer deux valeurs:
Opérateur Exemple Renvoie TRUE si
> v1 > v2 v1 plus grand que v2
>= v1 >= v2 Plus grand ou égal
< v1 < v2 Plus petit que
<= v1 <= v2 Plus petit ou égal à
== v1 == v2 égal
!= v1 != v2 différent

• Opérateurs logiques:
Opérateur Usage Renvoie TRUE si
&& expr1 && expr2 expr1 et expr2 sont vraies
& expr1 & expr2 Idem mais évalue toujours les 2 expressions
|| expr1 || expr2 Expr1 ou expr2, ou les deux sont vraies
| expr1 | expr2 idem mais évalue toujours les 2 expressions
! ! expr1 expr1 est fausse
!= expr1 != expr2 si expr1 est différent de expr2

Introduction à la POO INFO 114

Arithmétique et opérateurs
Opérateurs d’assignation (d’affectation)
• L’opérateur de base est ‘=‘
• Il existe des opérateurs d’assignation qui réalisent à la fois
 une opération arithmétique, logique, ou bit à bit
 et l’assignation proprement dite

Opérateur Exemple Équivalent à

+= expr1 += expr2 expr1 = expr1 + expr2

-= expr1 -= expr2 expr1 = expr1 – expr2

*= expr1 *= expr2 expr1 = expr1 * expr2

/= expr1 /= expr2 expr1 = expr1 / expr2

%= expr1 %= expr2 expr1 = expr1 % expr2

Introduction à la POO INFO 114

Instructions et structures de contrôle
Déclarations, instructions, blocs
• Une instruction
 Réalise un traitement particulier:
 Renvoie éventuellement le résultat du calcul
 Est comparable à une phrase du langage naturel
 Constitue l’unité d’exécution
 Est toujours suivie de « ; »
 Instruction d’affectation (d’assignation), instruction de déclaration …
• Un bloc
 Est une suite d’instructions entre accolades « { » et « } »
 Délimite la portée des variables qui y sont déclarées
• Une déclaration
 Constitue la signature d’un élément (classe, variable ou méthode)
 Annonce la définition de cet élément
 Est (normalement) toujours suivie d’un bloc d’instructions

Introduction à la POO INFO 114

Instructions et structures de contrôle
Structures de contrôle
• Les structures de contrôles permettent d’arrêter l’exécution linéaire
des instructions (de bas en haut et de gauche à droite)
• Elles permettent d’exécuter conditionnellement une instruction, ou de
réaliser une boucle

Type d’instruction Mots clés utilisés

Décision if() else – switch() case

Boucle for( ; ; ) – while () – do while()

Traitement d’exceptions try catch finally – throw

Branchement label : -- break – continue -- return

Introduction à la POO INFO 114

Instructions et structures de contrôle
Structures de contrôle
IF – THEN – ELSE

if (expression)
{
//instructions
}

if (expression)
{
//instructions
}
else
{
//instructions dans les autres cas
}

Introduction à la POO INFO 114

Instructions et structures de contrôle
Structures de contrôle
SWITCH – CASE

switch (number)
{
case 1 : instructions;
case 2 : instructions; break;
default : instructions;
}

Introduction à la POO INFO 114

Instructions et structures de contrôle
Structures de contrôle
FOR
for (initialisation; condition; mise à jour de valeurs){
// instructions
}
• Initialisation: à exécuter lorsque le programme rentre pour la première
fois dans la boucle
• Condition : à remplir pour recommencer le bloc d’instructions
• Mise à jour: instruction exécutée chaque fois que la boucle est terminée

Exemples:
for (int i=0 ; i<10 ; i++) {
System.out.println("The value of i is : " + i);
}

Introduction à la POO INFO 114

Instructions et structures de contrôle
Structures de contrôle
WHILE – DO WHILE
while (test logique) {
//instructions
}

Si le code de la boucle doit être exécuté la première fois de toute façon:

do {
// code to perform
} while (logical_test)

Boucle infinie:
while (true) {
//instructions
}
Introduction à la POO INFO 114
Instructions et structures de contrôle
Structures de contrôle
• BREAK / CONTINUE

• BREAK: achève immédiatement la boucle

• CONTINUE: ignore le reste des instructions et recommence au début
de la boucle

for (int i=0; i<10 ;i++){

if (i==5) continue; // Si i=5, on recommence au début
if (i==7) break; /* Si i=7, on sort de la boucle et
les instructions suivantes sont
exécutées */
System.out.println("The value of i is : " + i);
}

Introduction à la POO INFO 114

Instructions et structures de contrôle
Structures de contrôle
BREAK [LABEL]
CONTINUE [LABEL]
outer:
for (int i=0 ; i<10 ; i++) {
for(int j=20;j>4;j--){
if (i==5) continue; // if i=5, you jump to the beginning of the loop

if (i==7) break outer; // if i=7, you jump outside the loop and continue
System.out.println(«The value of i,j is :»+i+ «,»+j);
}

Introduction à la POO INFO 114

Exercices
• Ding Ding Bottle
EX 3.1
 Ecrire un programme qui compte de 1 à 100
 Affiche ces nombres à l’écran
 Remplace les multiples de 5 par « Bottle »
 Remplace les multiples de 7 par « Ding Ding »
 Remplace les multiples de 5 et 7 par « Ding Ding Bottle »

• Calcul de factorielle EX 3.2

 Ecrire un programme qui calcule la factorielle d’un nombre
 Essayer d’optimiser le code en gardant en mémoire les factorielles déjà
calculées et en utilisant la méthode récursive
 S’assurer que la factorielle calculée ne dépasse pas 20 (limite de capacité des
entiers de type LONG)

• Compiler et exécuter les programmes créés

• Visiter le site de Sun (java.sun.com) pour consulter la documentation

Introduction à la POO INFO 114

Les tableaux (“Array”) (1/3)

• Un tableau est utilisé pour stocker une collection de variables de

même type
• On peut créer des tableaux de types primitifs ou de types de
références
(cf. argument de la fonction main : String[] args)
• Un tableau doit être
 Déclaré
 Créé
 Ses variables initialisées

int[] nombres; // déclaration

nombres = new int[10]; // création
int[] nombres = new int[10]; // déclaration et création
nombres[0] = 28;

Introduction à la POO INFO 114

Les tableaux (“Array”) (2/3)
• On peut construire des tableaux à plusieurs dimensions
• Des tableaux à plusieurs dimensions sont en fait des tableaux de tableaux

« matrice » est une référence vers

int[][] matrice = new int[3][]; un tableau contenant lui-même 3
tableaux de taille non définie
matrice[0] = new int[4]; Le premier élément de la matrice
matrice[1] = new int[5]; est une référence vers un tableau
matrice[2] = new int[3]; de 4 entiers,…
Le premier élément du premier
matrice[0][0] = 25; tableau de la matrice est un entier
de valeur 25

Exemple:
• Créer et initialiser une matrice contenant deux tableaux de 2 et 3 points respectivement
• Créer 5 objets de type « Point »
• Affecter ces 5 objets aux 5 éléments de la matrice

Introduction à la POO INFO 114

Les tableaux (“Array”) (3/3)
Point[][] matriceDePoints;
matriceDePoints
matriceDePoints = new Point[2][];
matriceDePoints[0] = new Point[2];
matriceDePoints[1] = new Point[3];
[0]
Point p1, p2, p3, p4, p5;
10,15 ox0adfc12 p1
p1 = new Point(10,15); [0]
p2 = new Point(11,16); [1]
p3 = new Point(12,17); 11,16 ox0adfc43 p2

p4 = new Point(13,18);
p5 = new Point(14,19); 12,17 dy0adfc14 p3 [1]
matriceDePoints[0][0] = p1; [0]
matriceDePoints[0][1] = p2; ox0fdfc17 p4 [1]
13,18
matriceDePoints[1][0] = p3; [2]
matriceDePoints[1][1] = p4;
14,19 ox0agrc57 p5
matriceDePoints[1][2] = p5;

Introduction à la POO INFO 114

Exercices

• Etudiants EX 3.3
 Vous recevez une à une les notes de vos N étudiants (/10). N est donné par
l’utilisateur au début.
 Notez pour chaque étudiant s’il réussit ou échoue et, à la fin, indiquez le
nombre de ceux qui échouent, le nombre de ceux qui réussissent, la moyenne
totale et les deux moyennes de ceux qui échouent et réussissent

EX 3.4
• NameTest
 Analyser la classe NameTest
 Observer la méthode main et la façon dont elle récupère les arguments

• Word Scramble EX 3.5

 Analyser la classe WordScrambler
 Que réalise-t-elle?

• Exécuter les programmes et observer le résultat

ALGORITHMES DE BASE

Recherche, Tri
 ALGORITHMES
TRI ET RERCHERCHE

TRI

RECHERCHE

154
 ALGORITHMES
TRI PAR SÉLECTION

TRI
o PAR SÉLECTION
o TRIS PAR INSERTION
o TRI A BULLES
o LE TRI RAPIDE OU QUICKSORT

RECHERCHE
o RECHERCHE SÉQUENTIELLE
o RECHERCHE DICHOTOMIQUE
o RECHERCHE PAR INTERPOLATION

155
 ALGORITHMES

TRI
o PAR SÉLECTION
o TRIS PAR INSERTION
o TRI A BULLES
o TRI RAPIDE OU QUICKSORT

156
 ALGORITHMES

TRI PAR SÉLECTION

157
 ALGORITHMES DE TRI

UTILITÉ:
➢ Les algorithmes de tri servent principalement à ordonner les données, mais ils participent
aussi à la conception d’autres algorithmes, comme les recherches, en organisant
préalablement les données.

➢ Les algorithmes de tri ne sont pas tous équivalents, et certains sont spécifiques aux
données numériques, ce qui les rend inopérants dans d’autres contextes.

o La gestion de la mémoire diffère également selon les algorithmes.

o Certains effectuent un tri sur place, c’est-à-dire dans le même espace mémoire,
alors que d’autres utilisent un espace supplémentaire pour y copier les données
triées.

158
 ALGORITHMES DE TRI

UTILITÉ:
Deux catégories d’algorithmes étudiés dans ce cours: les tris élémentaires et les tris
avancés.

➢ Les tris élémentaires se basent sur des méthodes simples, que l’on retrouve parfois dans
la vie courante, comme la classification d’une pile de chèques par le déplacement de
chaque chèque à sa position finale.

➢ Les tris avancés s’appuient sur des méthodes plus sophistiquées, qui nécessitent une
organisation particulière des données ou une programmation spécifique, comme l’appel de
fonctions récursives

159
 ALGORITHMES DE TRI

TRI PAR SÉLECTION:

➢ Un des Tris les plus simples à mettre en œuvre

➢ Il s’inspire d’une méthode empirique qui consiste à

o rechercher la plus petite valeur et à l’inverser avec la première position, puis à
o rechercher la deuxième plus petite valeur et à l’inverser avec la deuxième
o position, et
o ainsi de suite.

➢ L’inversion de deux valeurs est souvent employée dans les algorithmes de tri.

160
 ALGORITHMES DE TRI

TRI PAR SÉLECTION:

Le tri par sélection est basé sur DEUX BOUCLES POUR (FOR) imbriquées:

➢ La PREMIÈRE BOUCLE parcourt la liste des valeurs du début à la fin.

➢ La DEUXIÈME BOUCLE
o recherche la plus petite valeur de la position courante (compteur de la première boucle), à
la fin du tableau

o puis l’inverse avec la position courante. La partie gauche de la liste est triée au fur et à
mesure de l’avancement de la première boucle.

161
 ALGORITHMES DE TRI

TRI PAR SÉLECTION:

La figure ci-dessous présente les étapes
du tri, lorsque la boucle principale pointe sur
la 3ème case du tableau Tab.

162
 ALGORITHMES DE TRI

TRI PAR SÉLECTION:

Pseudo-code
Procédure Tri_sélection(Tab, nb)
Déclarations
Paramètre Tab en Tableau[20] d’Entiers
Paramètre nb en Entier
Variables i, j, k, IndMin en Entier
Début
Pour i variant de 0 à nb-1 Faire
IndMin ← i

/* localisation du minimum */
Pour j variant de i+1 à nb-1 Faire
Si (Tab[j] < Tab[IndMin]) Alors
IndMin ← j
FinSi
FinPour
Si (IndMin <> i) Alors
// inversion
k ← Tab[i] // étape 1
Tab[i] ← Tab[IndMin] // étape 2
Tab[IndMin] ← k // étape 3
FinSi
FinPour
Fin
163
 ALGORITHMES

TRI PAR INSERTION

164
 ALGORITHMES DE TRI

TRI PAR INSERTION

Le tri par insertion s’inspire d’un processus naturel utilisé dans le tri des cartes qu’un joueur
possède dans sa main.

Pour organiser son jeu, le joueur prend chaque carte et l’insère à sa place en décalant les autres.

Ce type de tri peut être effectué sur place, ou bien utiliser un deuxième espace mémoire qui reçoit
les données triées.

Le tri par insertion n’est pas le plus performant pour un grand ensemble de données, mais il devient
intéressant quand il faut insérer une seule donnée dans un ensemble déjà trié.

165
 ALGORITHMES DE TRI

TRI PAR INSERTION

Le tri par insertion s’inspire d’un processus naturel utilisé dans le tri des cartes qu’un joueur
possède dans sa main.

Pour organiser son jeu, le joueur prend chaque carte et l’insère à sa place en décalant les autres.

Ce type de tri peut être effectué sur place, ou bien utiliser un deuxième espace mémoire qui reçoit
les données triées.

Le tri par insertion n’est pas le plus performant pour un grand ensemble de données, mais il devient
intéressant quand il faut insérer une seule donnée dans un ensemble déjà trié.

166
 ALGORITHMES DE TRI

TRI PAR INSERTION

Le tri par insertion utilise le processus élémentaire d’insertion d’un élément dans
la liste des valeurs:

1. Décalage vers la droite des données situées à droite de la position d’insertion en partant de la
fin, pour libérer la case d’insertion.

2. La dernière case est copiée dans la case suivante, puis c’est au tour de l’avant-dernière case, et
de proche en proche, on remonte jusqu’à la case à libérer.

3. Une fois cette case libre, on y copie la donnée à insérer.

167
 ALGORITHMES DE TRI

TRI PAR INSERTION

Une première boucle POUR parcourt chaque élément
du tableau, et l’insère à sa place dans la partie gauche
du tableau. Pour effectuer cette insertion:
1. On conserve la valeur indiquée par le compteur de
la boucle principale (étape 1), puis

2. On effectue une boucle de décalage des cases

précédentes d’une case vers la droite, tant que la
valeur à insérer est plus petite que la valeur
précédente (étape 2).

3. Quand cette boucle interne s’arrête, la valeur

d’insertion a trouvé sa position. Il suffit de la copier
dans la case libérée (étape 3).

168
 ALGORITHMES DE TRI
TRI PAR INSERTION
Pseudo-code
Procédure Tri_insertion(Tab, nb)
Déclarations
Paramètre Tab en Tableau[20] d’Entiers
Paramètre nb en Entier
Variables
i, j, val en Entier
Début
// boucle de traitement
Pour i variant de 0 à nb-1 Faire
val ← Tab[i]
// boucle de déplacement des éléments de gauche
plus petits
j←i
Tant que ( (j > 0 ) ET (val < Tab[j-1]) ) Faire
Tab[j] ← Tab[j-1]
j ← j-1
FinTantQue

// insertion de la valeur à sa place

Tab[j] ← val
FinPour
Fin

169
 ALGORITHMES

TRI A BULLE

170
 ALGORITHMES DE TRI

TRI A BULLES

Le tri à bulles propose une approche assez déroutante. On peut même se demander
comment la méthode proposée aboutit au tri des données.

Ce tri fait partie des grands classiques des cours d’algorithmique, à l’instar du tri par insertion.

Il est construit à partir de deux boucles imbriquées qui évoluent en sens inverse l’une de l’autre, et
d’un processus d’inversion des éléments successifs qui ne sont pas ordonnés.

171
 ALGORITHMES DE TRI

TRI A BULLES
1ère Boucle régresse de la fin du tableau vers le début (la figure présente la deuxième itération de cette boucle).

2ème Boucle interne progresse du début du tableau jusqu’à la case pointée par le
premier compteur (celui de la boucle principale). À l’intérieur de cette deuxième
boucle, qui ne gère que la partie gauche du tableau, on compare les éléments situés
dans les deux cases successives, et on les inverse s’ils ne sont pas dans l’ordre.
La 1ère valeur (9) est plus grande que la deuxième (5), donc on les inverse.
Ensuite, on compare la deuxième valeur (qui est 9 à la suite de la première inversion)
avec la troisième (12).
Elles sont dans l’ordre, donc on ne les inverse pas. On effectue le même traitement
avec le troisième élément (12) et le quatrième (45), qui sont déjà ordonnés.
Le quatrième élément (45) est inversé avec le cinquième (4).
Le cinquième élément (45 à la suite de l’inversion précédente) est inversé avec le
sixième (3).
Le sixième élément (45 à la suite de l’inversion précédente) est inversé avec le
septième (41).
La boucle interne s’arrête enfin, car la partie gauche du tableau (du début jusqu’à la
case indiquée par l’indice de la première boucle) a été totalement parcourue. La
boucle interne a pour effet de faire remonter vers la fin du tableau les éléments de
poids fort.

La figure montre que la valeur 45 remonte jusqu’à la fin du tableau et vient se « coller » à la partie droite déjà triée. Quand la boucle
interne est terminée, la boucle principale effectue une nouvelle itération en régressant d’une case, ce qui fait passer le dernier élément
(la valeur 45) dans la partie droite du tableau, qui ne contient que les données à leur place finale. La boucle interne est à nouveau
déroulée sur la partie gauche du tableau, moins une case, et le processus recommence
 ALGORITHMES DE TRI

TRI A BULLES
Pseudo-code

Procédure Tri_à_bulles(Tab, nb)

Déclarations
Paramètre Tab en Tableau[20] d’Entiers
Paramètre nb en Entier
Variables i, j, val en Entier
Début
// boucle principale
Pour i variant de nb-1 à 1 par pas de -1 Faire
Pour j variant de 1 à i Faire // boucle
d’inversion
Si (Tab[j-1] > Tab[j]) Alors
val ← Tab[j]
Tab[j] ← Tab[j-1]
Tab[j-1] ← val
FinSi
FinPour
FinPour
Fin
 ALGORITHMES

TRI RAPIDE OU QUICKSORT

174
 ALGORITHMES DE TRI

TRI RAPIDE OU QUICKSORT

Le tri rapide, aussi appelé quicksort, est probablement l’algorithme de tri le plus employé de tous.

Il possède trois qualités fondamentales : il est performant dans de nombreux cas, il effectue un tri sur place,
donc sans allouer d’espace mémoire supplémentaire, et
il est facile à écrire.

L’algorithme de base a été découvert par C.A.R. Hoare en 1960. Il a depuis reçu quelques petites
modifications qui améliorent encore ses performances.

175
 ALGORITHMES DE TRI

TRI RAPIDE OU QUICKSORT

Ce tri fonctionne sur le modèle « diviser pour résoudre ».
Il partitionne l’ensemble des données en deux sous-ensembles, qui sont eux-mêmes triés
indépendamment. C’est donc un algorithme récursif.
La procédure de partitionnement est la clé de voûte de cet algorithme.
Elle utilise l’un des éléments de la liste comme valeur pivot. Elle bascule ensuite les éléments qui lui
sont supérieurs et qui sont situés à sa gauche dans la partition de droite, et les éléments qui lui sont
inférieurs et qui sont situés à sa droite dans la partition de gauche.
Ainsi, à la fin du partitionnement, la valeur pivot est à sa place définitive.
La partition de gauche ne contient que des valeurs plus petites que le pivot, et celle de droite, que des
valeurs plus grandes.
Le choix de la valeur pivot est donc crucial.

176
 ALGORITHMES DE TRI

TRI RAPIDE OU QUICKSORT

Fonctionnement de l’algorithme:
La valeur pivot est d’abord choisie. C’est la valeur 41 (dernière
valeur) dans le premier partitionnement.

On parcourt ensuite le tableau depuis la gauche jusqu’à rencontrer

une valeur supérieure au pivot (45).

On parcourt le tableau depuis la droite jusqu’à trouver une valeur

plus petite que le pivot (3).

Les deux éléments ainsi trouvés (45 et 3) ne sont pas dans la

bonne partie du tableau, donc on les inverse.

On poursuit le traitement jusqu’à ce que le compteur de la boucle

qui progresse rencontre celui de la boucle qui régresse.

Les valeurs 78 et 9 sont inversées. Enfin, quand les deux boucles

sont terminées, on place la valeur pivot à sa position définitive
(inversion de 41 et 78). On appelle récursivement la procédure de
tri sur la partition de gauche et sur la partition de droite.

La condition récursive terminale est atteinte quand il n’y a plus

qu’une seule valeur dans la partition. Le tableau est alors trié.

177
 ALGORITHMES DE TRI

Fonction partition(Tab, gauche, droite)

TRI RAPIDE OU QUICKSORT Déclarations
Paramètre Tab en Tableau[20] d’Entiers
Paramètres gauche, droite en Entier
Procédure Tri_rapide(Tab, gauche, droite) Variables clef, i, j, temp en Entier
Début
Déclarations clef ← Tab[droite]
Paramètre Tab en Tableau[20] d’Entiers i ← gauche-1
Paramètres gauche, droite en Entier j ← droite
Variable pivot en Entier Tant que (i<=j) Faire
i ← i+1
Début Tant que ((i<droite) ET (Tab[i] < clef)) Faire
Si (gauche < droite) Alors i ← i+1
pivot ← partition(Tab, gauche, droite) FinTantQue
Tri_rapide(Tab,gauche,pivot-1) j ← j-1
Tri_rapide(Tab,pivot+1,droite)
FinSi Tant que ((i > gauche-1) ET (Tab[j] > clef)) Faire
j ← j-1
Fin FinTantQue
Si ( i< j) Alors // échange des cases
temp ← Tab[i]
Tab[i] ← Tab[j]
Tab[j] ← temp
FinSi
FinTantQue

// échange final avec le pivot

temp ← Tab[i]
Tab[i] ← Tab[droite]
Tab[droite] ← temp
retourner i
Fin
 ALGORITHMES DE TRI

TRI RAPIDE OU QUICKSORT

Choix de la valeur pivot:
L’une des améliorations proposées pour cet algorithme est de choisir la valeur pivot de manière
aléatoire, ce qui est une façon assez sûre pour éliminer le pire des cas et obtenir une performance
optimale de cet algorithme.

Un algorithme qui se base sur une valeur aléatoire pour tendre vers un comportement «idéal» est appelé
algorithme probabiliste.

Le pivot peut donc être choisi au hasard parmi les valeurs à trier. Mais il existe une meilleure technique
appelée partitionnement par la médiane des trois, qui consiste à prendre au hasard trois valeurs parmi
les valeurs à trier, à les ordonner, puis à prendre la valeur médiane comme pivot. Ce type d’optimisation
se justifie dès que le nombre de données est important.

179
 ALGORITHMES

TP
Ecrire en Java les algorithmes de Tri vus en cours.
Le programme demandera à l’utilisateur:
• de saisir les données à trier
• de choisir l’algorithme à utiliser.

180
 ALGORITHMES

ALGORITHMES DE RECHERCHE

181
 ALGORITHMES
RECHERCHE

RECHERCHE
o RECHERCHE SÉQUENTIELLE
o RECHERCHE DICHOTOMIQUE
o RECHERCHE PAR INTERPOLATION

182
 ALGORITHMES

RECHERCHE SÉQUENTIELLE

183
 ALGORITHMES DE RECHERCHE

RECHERCHE SÉQUENTIELLE
La recherche séquentielle est une méthode élémentaire qui Fonction recherche_séquentielle(tab,nb,valrech)
consiste à comparer la clef recherchée à toutes les autres clefs. Déclarations
Paramètre tab en Tableau[20] d’Entiers
Rechercher une valeur entière dans une liste d’entiers se résume à Paramètres nb, valrech en Entier
Variables i en Entier
• parcourir chaque élément de la liste, et à
Variable trouvé en Booléen
• vérifier s’il s’agit de l’élément recherché.
Constante NON_TROUVÉ = -1
Début
Dans cet exemple, la clef et la donnée sont confondues. i←0
trouvé ← FAUX
La boucle utilisée dans une recherche séquentielle est une boucle // boucle de recherche
TANT QUE avec un double critère d’arrêt : Tant que ( ( NON trouvé) ET (i < nb)) Faire
• on s’arrête quand on a trouvé la donnée ou Si (tab[i] = valrech) Alors
• quand on atteint la fin de la liste. trouvé ← VRAI
Sinon
Voici la fonction recherchant une valeur dans une liste de valeurs i ← i+1
entières contenues dans un tableau. Les paramètres sont: FinSi
• le tableau des données (tab), FinTantQue
• le nombre d’éléments dans le tableau (nb) et
Si (trouvé = VRAI) Alors
• La valeur recherchée (valrech).
retourner i
Sinon
Cette fonction retourne le numéro de la case du tableau dans retourner NON_TROUVÉ
laquelle se trouve la donnée, ou –1 (représenté par la constante FinSi
NON_TROUVÉ) si elle n’est pas trouvée. Fin

184
 ALGORITHMES

RECHERCHE DICHOTOMIQUE

185
 ALGORITHMES DE RECHERCHE

RECHERCHE DICHOTOMIQUE
Dès que le nombre de données devient important, la recherche Fonction recherche_dichotomique(tab,début,fin,valrech)
séquentielle n’est plus envisageable. Déclarations
Paramètre tab en Tableau[20] d’Entiers
• Cet algorithme est basé sur le principe de «diviser pour Paramètres début, fin, valrech en Entier
résoudre». On divise l’ensemble de recherche en deux sous- Variables milieu, résultat en Entier
ensembles égaux. Constante NON_TROUVÉ = -1
Début
• On détermine ensuite dans quel sous-ensemble doit se trouver
milieu ← (début + fin) DIV 2
la clef de recherche, puis on poursuit la recherche dans ce Si (valrech=tab[milieu]) Alors
sous-ensemble. résultat ← milieu
Le préalable à cette méthode de recherche est de disposer d’un
ensemble trié de données, car la détermination du sous-ensemble Sinon Si (début >= fin) Alors
dans lequel se poursuit la recherche se fait par comparaison entre résultat ← NON_TROUVÉ
la valeur recherchée et les valeurs de début et de fin du sous-
Sinon Si (valrech < tab[milieu]) Alors
ensemble. résultat ←
La recherche dichotomique est récursive dans son approche, mais recherche_dichotomique(tab,début,milieu-
il est aussi possible d’avoir une version itérative. 1,valrech)
Sinon
La version récursive présentée travaille sur le tableau d’entiers résultat ←
utilisé comme exemple dans la recherche séquentielle. Chaque recherche_dichotomique(tab,milieu+1,fin,va
appel de la fonction indique les bornes de lrech)
l’intervalle de recherche (début, fin) dans le tableau de données FinSi
(tab). retourner résultat
Fin
Le paramètre valrech correspond à l’entier recherché. L’opérateur
DIV renvoie le quotient de la division entière.

186