Trier des tableaux

/* GNU example - Sort integers */
#include <stdio.h>
#include <stdlib.h>

int compare (const void * a, const void * b)
{
  return ( *(int*)a - *(int*)b );
}

int main ()
{
  int n;
  int i[15]={102,89,69,9,56,59,85,44,66,12,36,458,965,254,666};

  qsort (i, 15, sizeof(int), compare);

  for (n=0; n<15; n++)
    printf ("%d ",i[n]);
  puts("");

  return 0;
}

//  quickSort
//
//  This public-domain C implementation by Darel R. Finley.
//  http://alienryderflex.com/quicksort/
//
//  * Returns true if sort was successful, or false if the nested
//    pivots went too deep, in which case your array will have
//    been re-ordered, but probably not sorted correctly.
//
//  * This function assumes it is called with valid parameters.
//
//  * Example calls:
//    quickSort(&myArray[0],5); // sorts elements 0, 1, 2, 3, and 4
//    quickSort(&myArray[3],5); // sorts elements 3, 4, 5, 6, and 7

#include <stdio.h>
#include <stdlib.h>

char quickSort(int *arr, int elements) {

  #define MAX_LEVELS 1000

  int  piv, beg[MAX_LEVELS], end[MAX_LEVELS], i=0, L, R ;

  beg[0]=0; end[0]=elements;
  while (i>=0) {
    L=beg[i]; R=end[i]-1;
    if (L<R) {
      piv=arr[L]; if (i==MAX_LEVELS-1) return 0;
      while (L<R) {
        while (arr[R]>=piv && L<R) R--; if (L<R) arr[L++]=arr[R];
        while (arr[L]<=piv && L<R) L++; if (L<R) arr[R--]=arr[L]; }
      arr[L]=piv; beg[i+1]=L+1; end[i+1]=end[i]; end[i++]=L; }
    else {
      i--; }}
  return 1; }

int main ()
{
  int n;
  int i[15]={102,89,69,9,56,59,85,44,66,12,36,458,965,254,666};

  n = quickSort(i, 15);

  for (n=0; n<15; n++)
    printf ("%d ",i[n]);
  puts("");

  return 0;
}

/*
  Sort integers without qsort,
  using algorithm "counting sort"
  source: http://en.wikipedia.org/wiki/Counting_sort
*/
#include <stdio.h>
#include <time.h>
#include <stdlib.h>

/* end is the last index + 1 */
void csort(int array[], const int end, const int max, const int min)
{
  int i;
  const int range = max-min+1;
  int count[range+1], scratch[end];

  for(i=0; i<range+1; i++)
    count[i] = 0;

  /* Set the value of count[i] to the number of
   * elements in array with value i+min-1. */
  for(i=0; i<end; i++) {
    int c = array[i]+1-min;
    count[c]++;
  }

  /* Update count[i] to be the number of
   * elements with value less than i+min. */
  for(i=1; i<range; i++)
    count[i] += count[i-1];

  /* Copy the elements of array into scratch in
   * stable sorted order. */
  for(i=(end-1); i>=0; i--) {
    int c = array[i]-min;
    int s = count[c];
    scratch[s] = array[i];
    /* Increment count so that the next element
     * with the same value as the current element
     * is placed into its own position in scratch. */
    count[c]++;
  }

  for(i=0; i<end; i++)
    array[i] = scratch[i];
}

int main(int argc, char* argv[])
{
  int n;
  int i[15]={102,89,69,9,56,59,85,44,66,12,36,458,965,254,666};

  csort(i, 15, 965, 9);

  for (n=0; n<15 ; n++)
   printf("%d ", i[n]);
  puts("");

  return 0;
}

  #include <stdio.h>

  int main()
  {
    int i[]={102,89,69,9,56,59,85,44,66};

    int count = sizeof (i) / sizeof (int);
    printf("nombre d' éléments: %d ", count);

    return 0;
  }

  #include <stdlib.h>
  #include <stdio.h>
  #include <string.h>

  void sort_tableau_int(int *t, int COUNT)
  {
    int i, j, k, nb=0; // nombre d' éléments vus
    int tabi[COUNT];
    int tabv[COUNT];

    // Ajoute le premier
    tabi[nb++] = 0;

    for (i=1; i<COUNT; i++)
    {
      if (t[i] >= t[tabi[i-1]]) // Maximum: met en dernier (nb)
        tabi[nb++]= i;
      else if (t[i] <= t[tabi[0]] ) // Minimum: décale et met en premier
      {
        for (j=nb-1; j>-1; j--)
          tabi[j+1] = tabi[j];
        tabi[0] = nb++;
      }
      else // ni min, ni max
      {
        for (j=1; j<nb; j++) //du 1er au nb ième
        {
          if (t[tabi[j]]>=t[i]) //s'il est supérieur,
          {
            for (k=nb-1; k>j-1; k--) //décale
              tabi[k+1]= tabi[k];
            tabi[j] = nb++; //et insère
            break;
          }
        }
      }
    } // for

    // remplit tabv avec les index de tabi et les valeurs de t
    for(i=0; i<COUNT; i++)
      tabv[i] = t[tabi[i]];
    // pour copier tableau tabv vers original
    for(i=0; i<COUNT; i++)
      t[i] = tabv[i];
  }

  int main (void)
  {
    int n;
    int i[15]={102,89,69,9,56,59,85,44,66,12,36,458,965,254,666};

    // trie le tableau ...
    sort_tableau_int(i, 15);

    // ... vérifie son contenu
    for (n=0; n<15; n++)
      printf ("%d ", i[n]);
    printf ("\n");

    return 0;
  }

  /* qsort: trier un tableau de doubles */
  #include <stdio.h>
  #include <stdlib.h>

  int compare_doubles (const void *a, const void *b)
  {
    const double *da = (const double *) a;
    const double *db = (const double *) b;  
    return (*da > *db) - (*da < *db);
  }

  int main ()
  {
    int n, size=5;
    double vals[] = { 40.5, 40.22, 100, 90.455, 20.11 };

    for (n=0; n<size; n++)
      printf ("%.2lf ", vals[n]);
    puts("");

    qsort (vals, size, sizeof (double), compare_doubles);

    for (n=0; n<size; n++)
      printf ("%.2lf ", vals[n]);
    puts("");

    return 0;
}