Exercice 1:

Le tri à bulles est l'algorithme de tri le plus simple qui fonctionne en échangeant à plusieurs reprises les
éléments adjacents s'ils ne sont pas dans l' ordre.
Exemple:
Première passe:
( 5 1 4 2 8 ) –> ( 1 5 4 2 8 ), Compare les deux premiers éléments puis échange 5 et 1 puisque 5 > 1.
( 1 5 4 2 8 ) –> ( 1 4 5 2 8 ), échange 5 > 4
( 1 4 5 2 8 ) –> ( 1 4 2 5 8 ), échange 5 > 2
( 1 4 2 5 8 ) –> ( 1 4 2 5 8 ), 5 et 8 sont dans l'ordre (8 > 5), pas d'échange.
Seconde passe:
( 1 4 2 5 8 ) –> ( 1 4 2 5 8 )
( 1 4 2 5 8 ) –> ( 1 2 4 5 8 ), échange puisque 4 > 2
( 1 2 4 5 8 ) –> ( 1 2 4 5 8 )
( 1 2 4 5 8 ) –> ( 1 2 4 5 8 )
Maintenant, le tableau est déjà trié, mais notre algorithme n' est pas encore terminé. L'algorithme a besoin
d'une passe entière sans échange pour que l'algorithme termine.

Troisième Passe:
( 1 2 4 5 8 ) –> ( 1 2 4 5 8 )
( 1 2 4 5 8 ) –> ( 1 2 4 5 8 )
( 1 2 4 5 8 ) –> ( 1 2 4 5 8 )
( 1 2 4 5 8 ) –> ( 1 2 4 5 8 )
le code en C est le suivant:
#include <stdio.h>
void echange(int *xp, int *yp)
{
int temp = *xp;
*xp = *yp;
*yp = temp;
}
void bulle(int arr[], int n)
{
int i, j;
for (i = 0; i < n-1; i++)
for (j = 0; j < n-i-1; j++)
if (arr[j] > arr[j+1])
echange(&arr[j], &arr[j+1]);
}
void affiche(int arr[], int size)
{
int i;
for (i=0; i < size; i++)
printf("%d ", arr[i]);
printf("\n");
}
int main()
{
 int arr[] = {64, 34, 25, 12, 22, 11, 90};
int n = sizeof(arr)/sizeof(arr[0]);
bulle(arr, n);
printf("Tri: \n");
affiche(arr, n);
return 0;
}
a)Cette implémentation est itérative , faites une récursive avec les pointeurs.
b)De même faire une implémentation récursive pour le tri par insertion.
Exercice 2:
Comme le tri Rapide, Tri par fusion est un algorithme basé sur le principe "diviser pour régner".
Il divise le tableau d'entrée en deux moitiés, s'appelle lui-même pour les deux moitiés, puis
fusionne les deux moitiés triées. La fonction fusionner () est utilisée pour fusionner deux moitiés.
fusionner (arr, l, m, r) est un processus clé qui suppose que arr [l..m] et arr [m + 1..r] sont triés et
fusionne les deux sous-tableaux triés en un seul.
fusionner (arr [], l, r)
Si r> l
1. Trouvez le point central pour diviser le tableau en deux moitiés:
milieu m = (l + r) / 2
2. Appelez fusion_tri pour la première partie:
Appelez fusion_tri (arr, l, m)
3. Appelez fusion_tri pour le seconde partie:
Appelez fusion_tri (arr, m + 1, r)
4. Fusionnez les deux moitiés triées aux étapes 2 et 3:
Appel fusionner (arr, l, m, r)
Exemple: soit à trier {38, 27, 43, 3, 9, 82, 10}
a) Ecrire l'algorithme fusion récursive en C
b) Faire une version itérative de tri par fusion
Exercice 3:
Voici une implémentation de tri rapide:

#include<stdio.h>

void echange(int* a, int* b)

{
int t = *a;
*a = *b;
*b = t;
}

int partition (int arr[], int low, int high)

{ int j;
 int pivot = arr[high]; // pivot
int i = (low - 1);

for ( j= low; j <= high- 1; j++)

{

if (arr[j] < pivot)

{
i++;
echange(&arr[i], &arr[j]);
}
}
echange(&arr[i + 1], &arr[high]);
return (i + 1);
}

void tri_rapide(int arr[], int low, int high)

{
if (low < high)
{

int pi = partition(arr, low, high);

// Separately sort elements before

// partition and after partition
tri_rapide(arr, low, pi - 1);
tri_rapide(arr, pi + 1, high);
}
}

void affiche(int arr[], int size)

{
int i;
for (i=0; i < size; i++)
printf("%d ", arr[i]);
printf("\n");
}
int main()
{
int arr[] = {10, 7, 8, 9, 1, 5};
int n = sizeof(arr)/sizeof(arr[0]);
affiche(arr, n);
tri_rapide(arr, 0, n-1);
printf("Tri: \n");
affiche(arr, n);
return 0;
}
a) Faire une implémentation avec les pointeurs
b) Faire une implémentation itérative.