Tri dans un tableau

int RechercheDichotomieIterative(Element* pTtab, Element valRecherche) 
{
    int milieu;
    int deb=0;
    // détermination de la taille du tableau
    int fin = sizeof(pTab) / sizeof(pTab[0]) -1;;
    // tant que l'intégralité du tableau n'a pas été parcouru
    while (deb 

int RechercheDichotomiqueRecursive(Element* pTab,
                       Element valRecherche,
                       int deb,
                       int fin) {
    // calcul de l'index de l'élément central
    int milieu=(fin-deb)/2;
    // Si l'élément est le bon...
    if (IsEgal(valRecherche, ptab[milieu]))
    {
        // ... il est retourné
        return milieu;
    }
    // Si l'élément cherché est "avant"...
    if (IsAvant(valRecherche, pTab[milieu])) 
    {
        // ...rappel de la fonction entre debut et milieu
        RechercheDichotomiqueRecursive(pTab, valRecherche, deb, milieu-1);
    } 
    // Si l'élément cherché est "plus loin"...
    if (IsApres(valRecherche, pTab[milieu])) 
    {
        // ...rappel de la fonction entre milieu et fin
        RechercheDichotomiqueRecursive(pTab, valRecherche, milieu+1, fin);
    } 
    // Ici: c'est que l'élément n'est pas dans le tableau
    return -1;
}

void TriSelection(Element* pTab) 
{
    int i, j, min = 0;
    // détermination de la taille du tableau
    int iNbElements = sizeof(pTab) / sizeof(pTab[0]);
    // pour chaque éléments du tableau
    for (i=0; i

void TriABulle(Element* pTab) {
    int i, j, ordonne=0;
    // détermination de la taille du tableau
    int iNbElements = sizeof(pTab) / sizeof(pTab[0]);
    // au maximum n tour:
    for (i=0; ((i

void TriRapide(int tableau[], int debut, int fin)
{
    // gauche et droite seront nos marqueurs pour l'algorithme
    int gauche = debut;
    int droite = fin;
 
    // initialisation de rand
    srand(time(NULL)); 
    // choix aléatoire d'un pivot
    int indicePivot = rand()%(fin-debut) + debut;
    // création du pivot 
    Element pivot = pTab[indicePivot];
 
    // Si le tableau est de longueur nulle, il n'y a rien à faire.
    if(debut >= fin)
        return;
 
    // sauvegarde du pivot en fin de tableau
    Echanger(pTab[droite], pivot);
 
    // cette boucle représente une passe d'un étage de la récursivité
    while(gauche!=droite)
    {
        // Recherche du premier élément supérieur au pivot par la gauche
        while(IsAvant(pTab[gauche], pivot))
        {
            gauche++;
        }
        // Recherche du premier élément inférieur au pivot par la droite
        while(IsApres(pTab[droite], pivot))
        {
            droite--;
        }
        // échange des deux éléments
        Echanger(pTab[gauche], pTab[droite]);
    }
    // replace le pivot dans le tableau
    Echanger(pTab[droite], pivot);
 
    // Tous les éléments inférieurs au pivot sont à gauche du margeur 'gauche'
    // Tous les éléments supérieur au pivot sont à droite du margeur 'droite'
    TriRapide(pTab, debut, gauche-1);
    TriRapide(pTab, droite+1, fin);
 
    // Fin du tri
    return;
}