Tri par tas

Tri par tas

1 Tas

Il s'agit d'un arbre binaire qu'on représentera par un tableaut ; on fait les hypothèses suivantes :

- le noeud j a pour ls 2j + 1 et 2j+ 2 ; exceptionnellement un seul, 2j+ 1.

- la valeur d'un noeud est supérieure ou égale à celle de ses ls : t[j]≥t[2j+ 1], t[j]≥t[2j+ 2]

Questions

- Ecrire trois fonctions pere(j), lsG(j), lsD(j).

- Ecrire une fonction est_un_tas (t) qui vérie sit est un tas.

- Ecrire une fonction cree_un_tas(taille, entier_max) qui construit un tas aléatoire.

2 Insertion dans un tas

Soitt un tas ; on souhaite ajouter un élémentx.

Si on exécute seulement t.append(x),t peut ne plus être un tas.

Question

Ecrire une fonction insere_dans_tas(t,x) qui ajoute x au tas t et qui restaure la structure de tas en faisant remonterxvers la racine.

3 Suppression

On souhaite extraire l'élément qui est à la racine de l'arbre ; pour cela, on le remplace par le dernier élément du tableau :

t[0] =t[n−1]

Ensuite, pour restaurer la structure de tas, on fait descendre cet élément dans l'arbre en le remplaçant, si nécessaire, par le maximum de ses deux ls, qui à son tour est remplacé...

Questions

- Ecrire une fonction plus_grand_ls(t,j) qui renvoie2j+ 1, ou2j+ 2, ou−1dans le cas où j est une feuille.

- Ecrire une fonction extrait_racine(t) qui extrait la racine de l'arbre et restaure la structure de tas.

4 Tri par tas

Pour trier une listeL:

- on crée un tas en insérant successivement les éléments deL. - on les extrait un à un.

On obtient ainsi un tri de complexitén.lnndans le pire des cas ; ce qui est aussi le cas du tri... ?

Questions

- Ecrire une fonction tri_par_tas(L) qui utilise ce qui précède.

- Comment faire pour obtenir un 'tri en place', c'est à dire sans utilisation de listes auxiliaires ?

def pere(k):

return (k - 1)//2 def filsG(k):

return 2*k + 1 def filsD(k):

return 2*k + 2

def est_un_tas(t):

for k in range(1, len(t)):

if t[pere(k)] < t[k]:

return False return True

def cree_un_tas(taille, entier_max):

t = [rd.randint(0, entier_max)]

for k in range(1, taille):

t.append(rd.randint(0, t[pere(k)])) return t

import random as rd def pere(k):

return (k - 1)//2 def filsG(k):

return 2*k + 1 def filsD(k):

return 2*k + 2

def insere_dans_tas(t, x):

n = len(t) t.append(x)

p, f = pere(n), n

while p >= 0 and t[p] < x:

t[f] = t[p]

p, f = pere(p), p t[f] = x

def plus_grand_fils(t,j):

n, fg, fd = len(t), filsG(j), filsD(j) if fg >= n:

return -1

if fd < n and t[fg] < t[fd]:

return fd return fg

def extrait_racine(t):

racine, dernier = t[0], t[-1]

p, f = 0, plus_grand_fils(t, 0) while f != -1 and t[f] > dernier:

t[p] = t[f]

p = f

f = plus_grand_fils(t, p) t[p] = dernier

t.pop()

return racine def tri_par_tas(t):

tas = []

for x in t:

insere_dans_tas(tas, x) for j in range(len(t)):

t[-j-1] = extrait_racine(tas)

# Tri par tas en place def pere(j):

return (j-1)//2

# Insertion de t[k] en supposant que t[:k] est déjà un tas def construit_tas(t, k):

x = t[k]

f, p = k, pere(k)

while p >= 0 and x > t[p]:

t[f] = t[p]

p, f = pere(p), p t[f] = x

# Plus grand des deux fils de j dans le tas t[:n]

def plus_grand_fils(t, n, j):

fg, fd = 2*j + 1, 2*j + 2

if fg >= n: # cas d'une feuille return -1

if fd < n and t[fg] < t[fd]:

return fd return fg

# Extraction de la racine du tas t[:k]

def extrait_racine(t, k):

racine, dernier = t[0], t[k-1]

p, f = 0, plus_grand_fils(t, k, 0) while f != -1 and t[f] > dernier:

t[p] = t[f]

p, f = f, plus_grand_fils(t, k, f) t[p] = dernier

return racine def tri_par_tas(L):

for k in range(len(L)):

construit_tas(L, k) for k in range(len(L)):

L[-k-1] = extrait_racine(L, len(L) - k)

import random as rd N = 10

L = [rd.randint(0, 3*N) for k in range(N)]

print(L)

tri_par_tas(L)

print(L)