Реализация двоичной кучи

//(C) Igor Kvasov
const
  maxsize = 1000;

var
  s:longint;
  A:array[1..maxsize] of longint;

procedure heapify(i:longint);
var
  min,l,r,buf:longint;
begin
  l:=i*2; r:=l+1;
  if (l<=s)and(A[l]<A[i]) then min:=l else min:=i;
  if (r<=s)and(A[r]<A[min])then min:=r;
  if min<>i then begin
    buf:=A[i]; A[i]:=A[min]; A[min]:=buf;
    heapify(min);
  end;
end;

procedure makeheap;
var
  i:longint;
begin
  for i:=s div 2 downto 1 do heapify(i);
end;

procedure heapsort;
var
  i,buf:longint;
begin
  makeheap;
  for i:=s downto 1 do begin
    buf:=A[1]; A[1]:=A[s]; A[s]:=buf;
    dec(s);
    heapify(1);
  end;
end;

procedure insert(x:longint);
var
  i:longint;
begin
  inc(s); i:=s;
  while (i>1)and(A[i div 2]>x) do begin
    A[i]:=A[i div 2]; i:=i div 2;
  end;
  A[i]:=x;
end;

procedure delete(i:longint);
begin
  A[i]:=A[s]; dec(s);
  heapify(i);
end;

function minimum:longint;
begin
  minimum:=A[1];
end;

function extractmin:longint;
begin
  extractmin:=minimum;
  delete(1);
end;

procedure decreasekey(i,x:longint);
begin
  while (i>1)and(A[i div 2]>x) do begin
    A[i]:=A[i div 2]; i:=i div 2;
  end;
  A[i]:=x;
end;

begin
end.

//"Всплывание" n-ого элемента кучи

procedure siftup(n : integer);
var
  t : integer;
begin
  if n = 1 then exit;
  if heap[n] > heap[n div 2] then begin
    t := heap[n];
    heap[n] := heap[n div 2];
    heap[n div 2] := t;
    place[heap[n]] := n;
    place[heap[n div 2]] := n div 2;
    siftup(n div 2);
  end;
end;

//"Утопление" s-ого элемента в куче

procedure sift_down(s : integer);
var
  l, r, max, t : integer;
begin
  l := s * 2;
  r := s * 2 + 1;
  max := s;
  if (l <= hs) and (heap[l] > heap[max]) then max := l;
  if (r <= hs) and (heap[r] > heap[max]) then max := r;
  if s <> max then begin
    t := heap[s];
    heap[s] := heap[max];
    heap[max] := t;
    place[heap[s]] := s;
    place[heap[max]] := max;
    sift_down(max)
  end;
end;

// Удаление n-го элемента из кучи

procedure del(n : integer);
var t : integer;
begin
  t := heap[n];
  heap[n] := heap[hs];
  heap[hs] := t;
  place[heap[n]] := n;
  dec(hs);
  sift_down(n);
end;

//Добавление элемента x в кучу

procedure ins(x : integer);
begin
  inc(hs);
  heap[hs] := x;
  place[x] := hs;
  siftup(hs);
end;

#include<stdio.h>
#include<malloc.h>
typedef int key_t;
typedef unsigned int value_t;

typedef struct {
   key_t key;
   value_t value;
} pair_t ;

typedef struct {
    pair_t *data;
    unsigned int size;
    unsigned int data_size;
} bheap_t;

bheap_t*
bheap_new( unsigned int initial_data_size ) {
    bheap_t *h = (bheap_t*) malloc( sizeof(bheap_t) );
    h->data = (pair_t*) malloc( sizeof(pair_t) * (1 + initial_data_size) );
    h->data_size = 1 + initial_data_size;
    h->size = 0;
    return h;
}

void
bheap_delete(bheap_t *h) {
    if( h ) {
       if( h->data ) {
            free( h->data );
       }
       free(h);
    }
}

void
bheap_checkup( bheap_t *h, unsigned int c ) {
    unsigned int p;
    for( p = c / 2; p > 0 ; c = p , p = c / 2 ) {
       if( h->data[p].key > h->data[c].key ) {
            pair_t tmp = h->data[p]; h->data[p] = h->data[c]; h->data[c] = tmp;
       } else {
            break;
       }
    }
}

void
bheap_checkdown( bheap_t *h, unsigned int p ) {
    unsigned int c;
    for( c = 2 * p ; c <= h->size ; p = c, c = 2 *p ) {
       if( c + 1 <= h->size && h->data[c + 1].key < h->data[c].key ) c++;
       if( h->data[c].key < h->data[p].key ) {
            pair_t tmp;
            tmp = h->data[c]; h->data[c] = h->data[p]; h->data[p] = tmp;
       } else {
            break;
       }
    }
}

void
bheap_add( bheap_t *h, pair_t v ) {
    if( h->size + 1 >= h->data_size ) {
       h->data_size *= 2;
       h->data = (pair_t*) realloc( h->data, h->data_size * sizeof(pair_t) );
    }
    h->data[ ++(h->size) ] = v ;
    bheap_checkup( h, h->size );
}

int
bheap_extract_min(bheap_t *h, pair_t *v) {
    if( h->size == 0 ) return 0;
    *v = h->data[1];
    h->data[1] = h->data[ (h->size)--];
    bheap_checkdown( h, 1 );
    return 1;
}

int main() {
    bheap_t *h = bheap_new(1000);
    unsigned int n, i;
    pair_t v = {0, 0};

    scanf("%u", &n);
    for( i = 0; i < n; i++ ){
       scanf("%d", &v.key);
       v.value = i;
       bheap_add(h, v);
    }

    while( bheap_extract_min(h, &v) ) {
       printf("%d ", v.key);
    }
    printf("\n");
    bheap_delete( h );
    return 0;
}

#include<stdio.h>

typedef struct {
// int value;
    int key;
} ITEM;

class HEAP {
public:
    ITEM *h;
    int size;
   
    HEAP(unsigned int n) {
       size = 0;
       h = (ITEM*) malloc( sizeof(ITEM) * n);
    }
   
    ~HEAP() {
       if(h) free(h);
    }

    int add(ITEM x) {
       h[++size]=x;
       checkup(size);
       return 1;
    }

    int extract_min(ITEM *x) {
      if(size ==0) return 0;
      *x = h[1];
      h[1] = h[size--];
      checkdown(1);
      return 1;
    }

private:
    void checkup(int c) {
       int p;
       p = c / 2;
       if( p == 0 )return;
       if(h[p].key > h[c].key) {
          ITEM tmp;
          tmp = h[p]; h[p] = h[c]; h[c] = tmp;
          checkup(p);
       }
    }
   
    void checkdown(int p) {
       int c;
       c = 2*p;
       if( c > size ) return;
       if( c+1 <= size && h[c + 1].key < h[c].key ) c++;
   
       if( h[c].key < h[p].key ) {
          ITEM tmp;
          tmp = h[c]; h[c] = h[p]; h[p] = tmp;
          checkdown(c);
       }
    }
};

int main() {
    HEAP heap(1000);
    int n, i;
    ITEM x;
   
    scanf("%d", &n);
   
    for(i = 0; i < n; i++){
       scanf("%d", &x.key);
       heap.add(x);
    }
   
    while( heap.extract_min(&x) ) {
       printf("%d ", x.key);
    }
   
    return 0;
}