Nel frammento di codice sottostante viene presentato l’algoritmo di ordinamento Heap Sort.

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

#define scambia(a, b, t) {(t)=(a); (a)=(b); (b)=(t);}

void stampa(int *a, int n);
void createHeap(int *a, int n);
void aggiornaHeap(int *a, int k, int j);
void heapSort(int *a, int n);

int main(void) {
  int a[10] = {5, 1, 3, 99, 45, 63, 21, 34, 0, 84}; // elementi da ordinare
  int n = 10;  // numero di elementi

  stampa(a, n);
  createHeap(a, n-1);
  stampa(a, n);
  heapSort(a, n-1);
  stampa(a, n);

  return 1;
}

// stampo tutti i valori presenti nel vettore
void stampa(int *a, int n) {
  int i;

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

  printf("\n");
}

void createHeap(int *a, int n) {
  int i;

  for(i=n/2; i>=0; i--) {
    aggiornaHeap(a, i, n);
  }
}

// j è l'ultimo elemento dell'intervallo considerato, inoltre per costruzione i<j, il nodo i sta sopra al nodo j
void aggiornaHeap(int *a, int i, int j) {
  int k, t;

  if(2*i==j) {                 // se j è figlio sx di i, i è padre dell'ultima foglia considerata
    if(a[i]<a[j])              // se il valore del figlio sx (j) è maggiore di quello del padre (i)
      scambia(a[i], a[j], t);        // inverto (se il figlio non è il più piccolo)
  }
  else if(2*i<j) {             // altrimenti se j è figlio dx di i, oppure è un'altra foglia sotto i
    if(a[2*i]>a[(2*i)+1]) {    // se il figlio sx (2i) di i è maggiore del dx (2i+1)
      k = 2*i;
    }
    else {                     // altrimenti
      k = (2*i)+1;
    }

                               // k contiene l'indice del figlio più grande

    if(a[i]<a[k]) {            // se il valore di i è minore di quello del suo figlio più grande
      scambia(a[i], a[k], t);  // inverti
      aggiornaHeap(a, k, j);   // reitera
    }
  }
}

// passo alla funzione il puntatore al vettore da ordinare e la sua dimensione
void heapSort(int *a, int n) {
  int j, t;

  createHeap(a, n);            // creo la struttura heap corrispondente al vettore a

  for(j=n; j>=0; j--) {
    scambia(a[0], a[j], t);    // sposto il primo elemento dello heap(il più grande) in ultima posizione
    aggiornaHeap(a, 0, j-1);   // ricalcolo l'heap sul nuovo intervallo
  }
}

Per maggiori informazioni circa la sintassi del linguaggio si faccia riferimento alla guida al Linguaggio C.