Revision Algo

Exercice Tri et Récursvivité
Définition des tri:
Le tri à bulles est un algorithme de tri simple qui compare chaque paire
d'éléments adjacents et les échange s'ils sont dans le mauvais ordre. Ce processus
est répété jusqu'à ce que la liste soit triée.
Le tri par insertion construit la liste triée une élément à la fois, en insérant
chaque nouvel élément à sa position correcte parmi les éléments déjà triés.
Le tri par sélection divise la liste en deux parties : la sous-liste triée et la
sous-liste non triée. Il trouve le plus petit élément de la sous-liste non triée
et l'échange avec le premier élément de cette sous-liste.
Le tri par comptage est efficace pour trier des listes d'entiers dans une plage
limitée. Il compte le nombre d'occurrences de chaque valeur, puis utilise ces
comptes pour déterminer les positions finales des éléments.
1. Tri
a) Tri à Bulles
Début
T <- []
N <- 0
Afficher("Combien de nombres il y aura dans le tableau ?")
Saisir(N)
Afficher("Saisir un tableau de", N ,"nombres")
Saisir(T)
j <- 1
Tant que (j<N): faire
i <- N
Tant que (i > j): faire
Si(T[i]>T[i-1]): alors
temp <- T[i]
T[i] <- T[i-1]
T[i-1] <- temp
Fin si
i <- i-1
Fin tant que
j <- j+1
Fin tant que
Renvoyer T
Fin
b) Tri par insertion
Début
T <- []
N <- 0

Afficher ("Combien d'éléments dans le tableau ?")
Saisir(N)
Afficher("Entrer un tableau de", N, "éléments")
Saisir(T)
Pour i allant de 1 à N-1, par pas de 1 : faire
temp = T[i]
j = i-1
tant que j >= 0 et T[j] > temp : faire
T[j+1] = T[j]
j = j-1
fin tant que
T[j+1] = temp
fin pour
Fin
c) Tri par sélection
Début
T <- []
N <- 0
Afficher ("Combien d'éléments dans le tableau ?")
Saisir(N)
Afficher("Entrer un tableau de", N, "éléments")
Saisir(T)
Pour i, allant de 0 à N-1, par pas de 1: faire
min_index = i
Pour j, allant de de (i+1) à N-1, par pas de 1: faire
si T[j] < T[min_index]
min_index = j
fin si
fin pour
temp <- T[j]
T[j] <- T[min_index]
T[min_index] <- temp
fin pour
Fin
d) Tri par compteur
Début
T <- [] // Tableau d'entrée
N <- 0 // Nombre d'éléments dans le tableau
compteur <- [] // Tableau de comptage
Afficher("Combien d'éléments dans le tableau ?")
Saisir(N)
Afficher("Entrer un tableau de", N, "éléments")
Saisir(T)
// Initialiser le tableau de comptage

Pour i de 0 à 9 Faire
compteur[i] <- 0
FinPour
// Compter les occurrences de chaque élément
Pour i de 0 à N - 1 Faire
Si (T[i] >= 0) et (T[i] <= 9) Alors
compteur[T[i]] <- compteur[T[i]] + 1
Sinon
Afficher("Ce tableau est incorrect")
Retourner
FinSi
FinPour
// Construire le tableau trié
index <- 0
Pour i de 0 à 9 Faire
Tant que (compteur[i] > 0) Faire
T[index] <- i
index <- index + 1
compteur[i] <- compteur[i] - 1
FinTantQue
FinPour
Renvoyer T
Fin