Plan Langage Java
• Paquetages et classes publiques Algorithmique
• Graphes
• Arbres
• Tas
• Tri par tas
Paquetages
package paquet.test class ClasseTest
{ ...
}
La ligne de code
package paquet.test
doit être la première ligne du fichier (hors commentaires). Elle indique que toutes les classes définies dans le fichier feront partie du paquetage paquet.test
Ex: java.awt
Classes publiques
Par défaut, une classe n'est accessible qu'aux autres classes du même paquetage. Pour être accessible ailleurs, une classe doit être déclarée "public".
Règles
(1) Un fichier ne peut contenir qu'une classe "public".
(2) Dans ce cas, le fichier doit porter le nom de la classe
"public", au suffixe près.
Exemple : package X.PC
package X.PC public class Tri {...}
class Element // Invisible hors de X.PC
{...}
Fichier Tri.java
package X.PC public class Pile {
...
}
Fichier Pile.java
• Un graphe est un couple G = (S, A)
où S est un ensemble (l'ensemble des sommets) et A est une partie de S x S, l'ensemble des arêtes.
• Deux arêtes (s, t) et (s', t') sont consécutives si t = s'
A = {(1, 2), (1, 4), (2, 4), (3, 3), (4, 3)}
Arêtes consécutives (1, 2) et (2, 4) Graphes
1 2
3 4
Graphes
• Un chemin dans un graphe est une suite d'arêtes consécutives.
(1, 4)(4, 3)(3, 3)(3, 3) : chemin
• On convient de définir un chemin vide autour de chaque sommet.
• Graphe non dirigé : si (s, t) est une arête, (t, s) est une arête
1 2
3 4
Arbres
Un arbre est un graphe non dirigé muni d'un sommet distingué (la racine) et tel qu'il existe un chemin unique de la racine à un sommet quelconque.
Vocabulaire sur les arbres
• Noeuds, branches, feuilles, nœuds internes, arité, parents, enfants, frères ou sœurs, ancêtres, descendants, niveau, hauteur (ou profondeur!)
• Forêts, arbres ordonnés
• Arbre binaire, ternaire, etc. sous- arbre gauche ou droit
• Arbre binaire homogène, plein, complet
• Arbre étiqueté
Parcours en largeur
1
2 3
4 5 6 7
8 9 10
En largeur : 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
Parcours d'arbres
Préfixe : 1, 2, 4, 8, 9, 5, 10, 3, 6, 7 (VGD)
Infixe : 8, 4, 9, 2, 10, 5, 1, 6, 3, 7 (GVD)
Suffixe : 8, 9, 4, 10, 5, 2, 6, 7, 3, 1 (GDV)
1
2 3
4 5 6 7
8 9 10
Prop 1 Il existe un chemin (réduit) et un seul entre deux sommets.
Prop 2 Tout nœud, sauf la racine, a un unique parent. Deux nœuds quelconques ont un plus petit ancêtre commun.
Prop 3 Un arbre ayant n nœuds possède n-1 arêtes. Un arbre binaire ayant n nœuds internes possède n+1 feuilles.
Prop 4 La hauteur d'un arbre binaire complet de n sommets est O(log n).
Tas
Propriété de base : Pour chaque noeud N de valeur v, les noeuds du sous-arbre issu de N ont une valeur < v.
1
2 3
4 5 6 7
8 9 10
23
15 7
6 1
12
4 8
5
2
Tas
Opérations de base :
• Trouver le maximum
• Insertion d'un nouvel élément
• Modifier la valeur de la racine
• Supprimer le maximum
1
2 3
4 5 6 7
8 9 10
23
15 7
6 1
12
4 8
5
2
Représentation par tableau
Racine : 1
Parent (i) : i/2
Fils gauche : 2i, Fille droite : 2i+1
1
2 3
4 5 6 7
8 9 10
23
15 7
6 1
12
4 8
5
2
23 15 7 12 5 6 1 4 8 2
1 2 3 4 5 6 7 8 9 10 11 12 … 16
Insertion
Nouveau nœud d'étiquette 21
• Le placer dans la première position libre (N° 11)
• Permuter avec le parent jusqu'à ce qu'on obtienne un tas
1
2 3
4 5 6 7
8 9 10
23
15 7
6 1
12
4 8
5
2 21
11
Modifier la valeur de la racine
Passer de 23 à 3 : on remplace 23 par 3, puis on échange 3 avec le plus grands des enfants (ici 15) et on continue le processus d'échange
23
15 7
6 1
12
4 8
5
2
Suppression de la racine
Pour retirer 23, il suffit de supprimer 2 et de remplacer 23 par 2 …
1
2 3
4 5 6 7
8 9 10
23
15 7
6 1
12
4 8
5
2
Tri par Tas (HeapSort)
• On construit un tas dans le tableau en ajoutant les élements un à un.
• On retire ensuite les élements un par un pour les mettre à droite du tableau (position N, puis N-1, etc.)
public class TriTas {
final static int N = 10;
static int[] a = new int[N];
static int nTas = 0;
static void Ajouter(int v) {
int i;
++nTas;
i = nTas - 1;
while (i > 0 &&
a[(i - 1)/2] <= v) {
a[i] = a[(i - 1)/2];
i = (i - 1)/2;
}
a[i] = v;
}
static int Maximum() { return a[0];
}
static void Supprimer() { int i, j;
int v;
a[0] = a[nTas - 1];
--nTas;
i = 0;
v = a[0];
while (2 * i + 1 < nTas) { j = 2*i + 1;
if (j + 1 < nTas)
if (a[j + 1] > a[j]) if (v >= a[j])++j;
break;
a[i] = a[j];
i = j;
}a[i] = v;
}
static void HeapSort() { int i;
int v;
nTas = 0;
for (i = 0; i < N; ++i) Ajouter(a[i]);
for (i = N - 1; i >= 0; --i) { v = Maximum();
Supprimer();
a[i] = v;
} }
Tri par Tas
