Нисходящая сортировка методом слияния

void TForm1::MergeSort(float data[99], int lend)
{
    if (lend > 1) {
        int middle = lend / 2;
        int rem = lend - middle;
        float* L = new float[middle];
        float* R = new float[rem];
        for (i = 0; i < lend; i++) {
            if (i < middle) {
                L[i] = data[i];
            }
            else {
                R[i-middle] = data[i];
            }
        }
        MergeSort(L, middle);
        MergeSort(R, rem);
        Merge(data, lend, L, middle, R, rem);
    }
}
//---------------------------------------------------------------------------
 
void TForm1::Merge(float merged[99], int lend, float L[99], int lenl, float R[99], int lenr)
{
    i = 0; j = 0;
    while (i < lenl || j < lenr)
    {
        if (i < lenl && j < lenr) {
            if (L[i] <= R[j]) {
                merged[i+j] = L[i];
                i++;
            }
            else {
                merged[i+j] = R[j];
                j++;
            }
        }
        else if (i < lenl) {
                merged[i+j] = L[i];
                i++;
             }
             else if (j < lenr) {
                    merged[i+j] = R[j];
                    j++;
                  }
 
    }
    DeleteFile("SortDist.txt");
    ofstream file;
    file.open("SortDist.txt");
    for (i = 0; i < k; i++) {
            file << merged[i] << "\n";
    }
    file.close();
}
 
 
 
//Вот как я её использую ->
 
void __fastcall TForm1::N6CrezfierulSortDisttxt1Click(TObject *Sender)
{
    Form1->Refresh();
    Form1->Inregistreaza();
    Form1->MergeSort(d, k);
}
 
// d -> массив который нужно сортировать
// k -> длинна массива

-----
template <class Item>
void mergeAB(Item c[], Item a[], int N, 
                       Item b[], int M )
  {
    for (int i = 0, j = 0, k = 0; k < N+M; k++)
      {
        if (i == N) { c[k] = b[j++]; continue; }
        if (j == M) { c[k] = a[i++]; continue; }
        c[k] = (a[i] < b[j]) ? a[i++] : b[j++];
      }
  }
-----
template <class Item>
void merge(Item a[], int l, int m, int r)
  { int i, j;
    static Item aux[maxN];
    for (i = m+1; i > l; i--) aux[i-1] = a[i-1];
    for (j = m; j < r; j++) aux[r+m-j] = a[j+1];
    for (int k = l; k <= r; k++)
       if (aux[j] < aux[i]) 
          a[k] = aux[j--]; else a[k] = aux[i++];
  }
-----
template <class Item>
void mergesort(Item a[], int l, int r)
  { if (r <= l) return;
    int m = (r+l)/2;
    mergesort(a, l, m);  
    mergesort(a, m+1, r);
    merge(a, l, m, r);
  }
-----
template <class Item>
void mergesortABr(Item a[], Item b[], int l, int r)
  { if (r-l <= 10) { insertion(a, l, r); return; }
    int m = (l+r)/2;
    mergesortABr(b, a, l, m);  
    mergesortABr(b, a, m+1, r);
    mergeAB(a+l, b+l, m-l+1, b+m+1, r-m);
  }
template <class Item>
void mergesortAB(Item a[], int l, int r)
  { static Item aux[maxN];
    for (int i = l; i <= r; i++) aux[i] = a[i];
    mergesortABr(a, aux, l, r);
  }
-----
inline int min(int A, int B) 
  { return (A < B) ? A : B; }
template <class Item>
void mergesortBU(Item a[], int l, int r)
  {
    for (int m = 1; m <= r-l; m = m+m)
      for (int i = l; i <= r-m; i += m+m)
        merge(a, i, i+m-1, min(i+m+m-1, r));
  }
-----
link merge(link a, link b)
  { node dummy(0); link head = &dummy, c = head;
    while ((a != 0) && (b != 0))
      if (a->item < b->item)
        { c->next = a; c = a; a = a->next; }
      else
        { c->next = b; c = b; b = b->next; }
    c->next = (a == 0) ? b : a;
    return head->next;
  }
-----
link mergesort(link c)
  { 
    if (c == 0 || c->next == 0) return c;
    link a = c, b = c->next;
    while ((b != 0) && (b->next != 0))
      { c = c->next; b = b->next->next; }
    b = c->next; c->next = 0;
    return merge(mergesort(a), mergesort(b));
  }
-----
link mergesort(link t)
  { QUEUE<link> Q(max);
    if (t == 0 || t->next == 0) return t;
    for (link u = 0; t != 0; t = u) 
      { u = t->next; t->next = 0; Q.put(t); }
    t = Q.get();     
    while (!Q.empty())
      { Q.put(t); t = merge(Q.get(), Q.get()); }
    return t;
  }

template <class Item>
void merge(Item a[], int l, int m, int r)
  { int i, j;
    static Item aux[maxN];
    for (i = m+1; i > l; i--) aux[i-1] = a[i-1];
    for (j = m; j < r; j++) aux[r+m-j] = a[j+1];
    for (int k = l; k <= r; k++)
       if (aux[j] < aux[i]) 
          a[k] = aux[j--]; else a[k] = aux[i++];
  }
-----
template <class Item>
void mergesort(Item a[], int l, int r)
  { if (r <= l) return;
    int m = (r+l)/2;
    mergesort(a, l, m);  
    mergesort(a, m+1, r);
    merge(a, l, m, r);
  }

void merge(int a[], int l, int m, int r)
  { int i, j;
    static int aux[maxN];
    for (i = m+1; i > l; i--) aux[i-1] = a[i-1];
    for (j = m; j < r; j++) aux[r+m-j] = a[j+1];
    for (int k = l; k <= r; k++)
       if (aux[j] < aux[i]) 
          a[k] = aux[j--]; else a[k] = aux[i++];
  }
-----
 
void mergesort(int a[], int l, int r)// l - индекс начала сортировки, r - индекс конца. может не весь массив надо сортировать.
  { if (r <= l) return;
    int m = (r+l)/2;
    mergesort(a, l, m);  
    mergesort(a, m+1, r);
    merge(a, l, m, r);
}
 
int main(){
int a[1000] = {1, 2, 3, 4, ...};
mergesort(a, 0, 999)
}