```/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        T E S T   C R O I S S A N T   D ' U N   T R I   E N   ' N * L O G ( N ) '   E N   M O D E   V I R T U E L  :               */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '\$xtc/tri_NLogN.02\$c' :                                                                                          */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, AAAAMMJJhhmmss).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#include  <stdio.h>

extern    double    drand48();
#define   RANDOM                                                                                                                        \
(drand48()-0.5)

#define   FACTEUR                                                                                                                       \
100

#define   INDEX0                                                                                                                        \
0
#define   INDEXn                                                                                                                        \
10

#define   VRAI                                                                                                                          \
1
#define   FAUX                                                                                                                          \
0

#define   compcl(index1,index2)                                                                                                         \
(tableau[permutation[index1]]-tableau[permutation[index2]])

#define   echang(index1,index2)                                                                                                         \
{                                                                                                                   \
int       tempo=permutation[index1];                                                                                \
permutation[index1] = permutation[index2];                                                                          \
permutation[index2] = tempo;                                                                                        \
}

static    int       tableau[INDEXn-INDEX0+1];
static    int       permutation[INDEXn-INDEX0+1];

tri(debut,fin)
int       debut;
int       fin;
{
int       index=fin/2;

while     (index>=debut)
{
reorg(index,fin);
index=index-1;
}

index=fin;

while     (index>debut)
{
echang(debut,index);
/* Cette echange ne conserve malheureusement pas l'ordre des elements de meme "clef"...      */
index=index-1;
reorg(debut,index);
}

return(VRAI);
}

reorg(debut,fin)
{
int       j=debut;
int       iter=VRAI;

while     (iter==VRAI)
{
int       gauche=2*j;

if        (gauche>fin)
{
iter=FAUX;
}
else
{
int       indmax=gauche;
int       droite=gauche+1;

if        (droite>fin)
{
}
else
{
if        (compcl(gauche,droite)<0)
/* Rappelons que le tri est croissant...                                                     */
{
indmax=droite;
}
else
{
}
}

if        (compcl(indmax,j)<=0)
/* Rappelons que le tri est croissant...                                                     */
{
iter=FAUX;
}
else
{
echang(j,indmax);
/* Cette echange ne conserve malheureusement pas l'ordre des elements de meme "clef"...      */
j=indmax;
}
}
}
return(VRAI);
}

main()
{
int       n;

for       (n=INDEX0 ; n<=INDEXn ; n++)
{
tableau[n] = (int)(FACTEUR*RANDOM);
permutation[n] = n;
printf("\n tableau[%02d]=%d",n,tableau[n]);
}
printf("\n");

tri(INDEX0,INDEXn);

for       (n=INDEX0 ; n<=INDEXn ; n++)
{
printf("\n tableau[%02d-->%02d]=%d",permutation[n],n,tableau[permutation[n]]);
}
}
```