Algorithme et Structures de

Données
Wurtz Jean-Marie

Université Louis Pasteur

Wurtz@igbmc.u-strasbg.fr

Les tas
• Une structure de donnée abstraite
• Utilisée pour implémenter des queues de priorité
• Dans un tas les clefs sont stockées dans un tableau
• Ces clefs vérifient les 2 propriétés suivantes :
– la clef en position i est plus grande que la clef en position 2i
L’algorithme de Heap Sort – la clef en position i est plus grande que la clef en position 2i+1

• L’adjonction d’un élément perturbe

l’ordre du tas !!

Copyright " 'Algorithms in Java'; Robert Sedgewick & Michael Shildlowsky; Third edition, Parts 1-4; Addison-Wesley "
Reproduction ULP Strasbourg. Autorisation CFC - Paris

1
 class PQ { // Priority Queue

Les tas (2) private boolean less(int i, int j)

{ return pq[i].less(pq[j]); } Les tas (3)
private void exch(int i, int j)
• Trier des éléments : HeapSort { ITEM t = pq[i]; pq[i] = pq[j]; pq[j] = t; }
• Utiliser pour implémenter des queues de priorité private void swim(int k)
// voir suite
private void sink(int k, int N)
// voir suite
interface PQinterface { private ITEM[] pq;
boolean empty(); private int N;
Object insert(ITEM); PQ(int maxN)
ITEM getmax(); { pq = new ITEM[maxN+1]; N = 0; }
void change(Object, ITEM); boolean empty()
void remove(Object); { return N == 0; }
void join(PQfull); void insert(ITEM v)
}; { pq[++N] = v; swim(N); }
ITEM getmax()
{ exch(1, N); sink(1, N-1); return pq[N--]; }
};
Copyright " 'Algorithms in Java'; Robert Sedgewick & Michael Shildlowsky; Third edition, Parts 1-4; Addison-Wesley " Copyright " 'Algorithms in Java'; Robert Sedgewick & Michael Shildlowsky; Third edition, Parts 1-4; Addison-Wesley "
Reproduction ULP Strasbourg. Autorisation CFC - Paris Reproduction ULP Strasbourg. Autorisation CFC - Paris

Rétablir l’ordre d’un tas :

du bas vers le haut
• L’arbre du haut est un tas sauf pour le nœud « T »

• Restitution du tas par propagation du bas vers le haut

Rétablir l’ordre d’un tas private void swim(int k) {

while (k > 1 && less(k/2, k)) {
exch(k, k/2); k = k/2;
} 1 2 3 4 5 6 7 8 9 10 11 12 13
} X S P G R O N A E T A I M
X S P G T O N A E R A I M
X T P G S O N A E T A I M

Copyright " 'Algorithms in Java'; Robert Sedgewick & Michael Shildlowsky; Third edition, Parts 1-4; Addison-Wesley "
Reproduction ULP Strasbourg. Autorisation CFC - Paris

2
 Rétablir l’ordre d’un tas (2) : •
•
Exemple : ASORTINGE EXAMPLE
Rajout en queue de tableau
du haut vers le bas • Puis positionnement correct de l’élément par « swim() »
• La remonté de l’élément : un coût proportionnel à lgN
• L’élément « O » n’est pas à la bonne place •
1
Insertion de l’élément « I »
2 3 4 5 6 7 8 9 comparer
Construction
• Restitution du tas par propagation du haut
vers le bas
A
A S 2,1
d’un tas
S A
private void sink(int k, int N) { S A O 3,1
while (2*k <= N) { S A O R 4,2
int j = 2*k; S R O A 2,1
if (j < N && less(j, j+1)) j++; S R O A T 5,2
S T O A R 2,1
if (!less(k, j)) break; 1 2 3 4 5 6 7 8 9 10 11 12 13 T S O A R
exch(k, j); k = j; O T X G S P N A E R A I M T S O A R I 6,3
} T S O A R I N 7,3
X T O G S P N A E R A I M
} T S O A R I N G 8,4
X T P G S O N A E R A I M T S O G R I N A 4,2
Copyright " 'Algorithms in Java'; Robert Sedgewick & Michael Shildlowsky; Third edition, Parts 1-4; Addison-Wesley " Copyright " 'Algorithms in Java'; Robert Sedgewick & Michael Shildlowsky; Third edition, Parts 1-4; Addison-Wesley "
Reproduction ULP Strasbourg. Autorisation CFC - Paris Reproduction ULP Strasbourg. Autorisation CFC - Paris

Supprimer le maximum du tas

Insertion (suite) • Revient à enlever la racine
• Puis restituer un tas
• Comment ?
• A vous !!
• Principe :
• échanger le premier et le dernier élément
Coût de la construction ? • puis appliquer la méthode sink() E

• lg1+lg2+...+lgN
X
• borné par N*lgN
1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
X T P G S O N A E R A I M L E avant
E T P G S O N A E R A I M L X apres

Copyright " 'Algorithms in Java'; Robert Sedgewick & Michael Shildlowsky; Third edition, Parts 1-4; Addison-Wesley " Copyright " 'Algorithms in Java'; Robert Sedgewick & Michael Shildlowsky; Third edition, Parts 1-4; Addison-Wesley "
Reproduction ULP Strasbourg. Autorisation CFC - Paris Reproduction ULP Strasbourg. Autorisation CFC - Paris

3
 Suppressions successives
Propagation de « E » ? 1
4
11

E
5 8
2 12

X
6 13
9
1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 3
X T P G S O N A E R A I M L E avant 14
7 10
E T P G S O N A E R A I M L X apres
15
Coût ?

Copyright " 'Algorithms in Java'; Robert Sedgewick & Michael Shildlowsky; Third edition, Parts 1-4; Addison-Wesley " Copyright " 'Algorithms in Java'; Robert Sedgewick & Michael Shildlowsky; Third edition, Parts 1-4; Addison-Wesley "
Reproduction ULP Strasbourg. Autorisation CFC - Paris Reproduction ULP Strasbourg. Autorisation CFC - Paris

Coût des suppressions Tri avec un tas

• A chaque étape : 2 comparaisons class Sort {
• Pour un tas de taille N : lgN étapes static void sort(ITEM[] a, int l, int r) { PQsort(a, l, r); }
• Donc supprimer le maximum d’un tas de taille N nécessite 2*lgN
static void PQsort(ITEM[] a, int l, int r) {
comparaisons
• En combinant la construction d’un tas et la suppression du maximun int k;
les éléments peuvent être triés PQ pq = new PQ(r-l+1);
• Méthode de tri : for (k = l; k <= r; k++) // création du tas
– construire un tas de N pq.insert(a[k]);
– puis retirer successivement le maximum for (k = r; k >= l; k--) // extraction du maximum
– coût ? : a[k] = pq.getmax();
• la construction : N*lgN
}
• et ensuite extractions successives: 2N*lgN
}
Copyright " 'Algorithms in Java'; Robert Sedgewick & Michael Shildlowsky; Third edition, Parts 1-4; Addison-Wesley "
Reproduction ULP Strasbourg. Autorisation CFC - Paris

4
 12 3 4 5 6 7 8 901 2 34 5
• Une amélioration de l’algorithme consiste à ne pas
utiliser d’espace de stockage supplémentaire et de faire
HeapSort •
le tri dans le tableau directement
Chaque position en partant de la droite est considérée HeapSort
comme un tas
• Démarre en N/2 car les feuilles n’ont pas d’enfant •Première étape construction du tas
La construction est linéaire : •Deuxième étape :
N = 2n-1, n=8 •on place le maximum à la fin
pour N = 127 •en gris les éléments à la bonne
on décompte : position
32 tas de taille 3
16 tas de taille 7
8 tas de taille 15 for (int k = N/2; k >= 1; k--)
4 tas de taile 31 sink(k, N);
2 tas de taille 63 while (N > 1) {
exch(1, N);
1 tas de taill 127
sink(1, --N);
Le nombre de promotion est < N }
k*2n-k-1
Copyright " 'Algorithms in Java'; Robert Sedgewick & Michael Shildlowsky; Third edition, Parts 1-4; Addison-Wesley " Copyright " 'Algorithms in Java'; Robert Sedgewick & Michael Shildlowsky; Third edition, Parts 1-4; Addison-Wesley "
Reproduction ULP Strasbourg. Autorisation CFC - Paris Reproduction ULP Strasbourg. Autorisation CFC - Paris

Caractéristique Peformance de HeapSort

dynamique de
HeapSort

• A gauche : Construction des tas

• A droite : le tri

Copyright " 'Algorithms in Java'; Robert Sedgewick & Michael Shildlowsky; Third edition, Parts 1-4; Addison-Wesley " Copyright " 'Algorithms in Java'; Robert Sedgewick & Michael Shildlowsky; Third edition, Parts 1-4; Addison-Wesley "
Reproduction ULP Strasbourg. Autorisation CFC - Paris Reproduction ULP Strasbourg. Autorisation CFC - Paris

5
 Intérêt des tas
• Queue de priorité
• Méthodes :
– construction à partir de N éléments
– supprimer le max
– suppression d’un élément quelconque
– changer la priorité, utiliser :
• swim si la priorité est augmentée
• sink si la priorité est diminuée
– fusion de deux tas