Tri à bulle (langage C) [Fermé]

Bonjour,

J'ai un exercice en langage C et je n'y comprend absolument rien. J'espère que vous pourrez m'aidez.

// Les fonctions generique //
// //
// Fonctions ou procedures pour initialiser et pour //
// afficher les contenus d'un tableau des valeurs //
// reel. Faire comme pour les tableaux d'entiers //
// //
//////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////
// //
// Tri par insertion //
// ================= //
// //
// procedure triInsertion(array[] : réél, size : entier) //
// variables //
// i, j : entier //
// temp : reel //
// debut //
// pour i variant de 1 a (size - 1) faire //
// temp <-- array[i] //
// j <-- i - 1 //
// tant que (temp < array[j] et j >= 0) faire //
// array[j + 1] <-- array[j] //
// j <-- j - 1 //
// fin tant que //
// array[j + 1] <-- temp //
// fin pour //
//fin //
// //
//////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////
// //
// Tri par tas //
// =========== //
// //
// /*La fonction permute est la même que pour la tri à //
// bulles, sauf qu'ici on utilise les valeurs réels //
// */ //
// //
// procedure tamiser(array[] : reel , root, bottom : entier)//
// variables //
// done : booleen //
// maxChild : entier //
// temp : reel //
// debut //
// done <-- faux //
// tant que (root * 2 <= bottom et non done) faire //
// si(root * 2 == bottom) alors //
// maxChild <-- root * 2 //
// sinon //
// si(array[root] < array[maxChild]) alors //
// maxChild <-- root * 2 //
// sinon //
// maxChild <-- root * 2 + 1 //
// fin si //
// fin si //
// si(array[root] < array[maxChild]) alors //
// permute(array, root, maxChild) //
// root <-- maxChild //
// sinon //
// done <-- vrai //
// fin si //
// fin tant que //
// fin //
// //
// procedure triTas (array[] : reel, size : entier) //
// varaibles //
// i : entier //
// temp : reel //
// debut //
// pour i variant de size / 2 à 0 faire //
// tamiser(array, i, size - 1) //
// fin pour //
// pour i variant de size - 1 à 1 faire //
// permute(array, 0, i) //
// tamiser(array, 0, i-1) //
// fin pour //
// fin //
// //
//////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////
// //
// Tri shell //
// ========= //
// //
// /* La fonction arrondi() est dans la bibliotheque math.h //
// Il s'appelle round() //
// */ //
// //
// procedure triShell(array[] : reel, size : entier) //
// variables //
// i,j : entier //
// temp : reel //
// inc : entier //
// debut //
// inc = arrondi(size / 2) //
// tant que (inc > 0 ) faire //
// pour i variant de inc à size - 1 faire //
// temp <-- array[i] //
// j <-- i //
// tant que(j >= inc et array[j - inc] > temp) faire //
// array[j] <-- array[j - inc] //
// j <-- j -inc //
// fin tant que //
// array [j] <-- temp //
// fin pour //
// inc = arroindi(inc / 2.2) //
// fin tant que //
// fin //
// //
//////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////
// //
// Fonction main() //
// //
// Créer une fonction main, qui permet de créer un tableau //
// de 15 valeurs réels, le remplir avec la bonne fonction, //
// et afficher les contenus. //
// Puis utiliser un de vos tris pour le trier et l'afficher //
// encore. //
// Repeter les etapes ci-dessus en utilisant votre 2eme tri. //
// //

Merci de votre compréhension.