{@{@}
{@    int i;@}
{@    T2[n] = t2, Lev[n] = lev;@}

{@    if (lev % H == 0) t2 = n;@}

{@    if (lev % H @}=={@ 0) t2 = n;@}

{@    for (i = 0; i < N; i++)@}

{@        if (T[i] == n) DF(i, t2, lev+1);@}

{@        if (T[i] @}=={@ n) DF(i, t2, lev+1);@}

{@}@}
Operatia de LCA se va realiza apoi foarte usor, urcand pe tatii din intervale, pana se ajunge la doua noduri in acelasi interval, apoi folosindu-se metoda clasica. Cod:

{@void merge_sort(int l, int r)@}
{@{@}
{@    int m = (l + r) >> 1, i, j, k;@}

{@    if (l == r) return;@}

{@    if (l @}=={@ r) return;@}

{@    merge_sort(l, m);@}
{@    merge_sort(m + 1, r);@}
{@    for (i=l, j=m+1, k=l; i<=m || j<=r; )@}

{@ @}
{@node* insert(node *n, int key)@}
{@{@}

{@      if (n == NIL)@}

{@      if (n @}=={@ NIL)@}

{@      {@}
{@              n = (node *) malloc(sizeof(node));@}
{@              n->key = key, n->h = 1, n->l = n->r = NIL;@}

{@node* erase(node *n, int key)@}
{@{@}
{@      node *t;@}

{@      if (n == NIL) return n;@}
{@      if (n->key == key)@}

{@      if (n @}=={@ NIL) return n;@}
{@      if (n->key @}=={@ key)@}

{@      {@}

{@              if (n->l == NIL || n->r == NIL)@}

{@              if (n->l @}=={@ NIL || n->r == NIL)@}

{@              {@}

{@                      t = n->l == NIL ? n->r : n->l;@}

{@                      t = n->l @}=={@ NIL ? n->r : n->l;@}

{@                      free(n); return t;@}
{@              }@}
{@              else@}

{@ @}
{@int search(node *n, int key)@}
{@{@}

{@      if (n == NIL) return 0;@}
{@      if (n->key == key) return 1;@}

{@      if (n @}=={@ NIL) return 0;@}
{@      if (n->key @}=={@ key) return 1;@}

{@      if (key < n->key)@}
{@              return search(n->l, key);@}
{@      else@}