[C] MergeSort di array di puntatori a char anziché di array di int

[degosa]

Ciao,
volevo chiedervi un'aiuto per trasformare il seguente codice sorgente che fà il MergeSort su array di int in MergeSort su array di puntatori a char.

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

#define MAX 300


/*
* Legge in input il numero n ed n numeri interi
* che memorizza nell'array. Restituisce il numero
* di elementi letti (n).
*/

int leggi_array(int V[]) {
int n, i;

printf("Numero di elementi: ");
scanf("%d", &n);
for (i=0; i<n; i++)
scanf("%d", &V[i]);
return(n);
}


/*
* Stampa in output l'array.
*/

void stampa_array(int V[], int n) {
int i;

for (i=0; i<n; i++) {
printf("%d ", V[i]);
}
printf("\n");
return;
}

/*
* Funzione Merge per la fusione di due
* componenti ordinate dell'array.
*/

void Merge(int A[], int p, int q, int r) {
int i, j, k, B[MAX];

i = p;
j = q+1;
k = 0;
while (i<=q && j<=r) {
if (A[i]<A[j]) {
B[k] = A[i];
i++;
} else {
B[k] = A[j];
j++;
}
k++;
}
if (i<=q) {
while (i<=q) {
B[k] = A[i];
i++;
k++;
}
} else {
while (j<=r) {
B[k] = A[j];
j++;
k++;
}
}
for (k=p; k<=r; k++)
A[k] = B[k-p];
return;
}


/*
* Funzione ricorsiva MergeSort.
*/

void MergeSort(int A[], int p, int r) {
int q;

if (p<r) {
q = (p+r)/2;
MergeSort(A, p, q);
MergeSort(A, q+1, r);
Merge(A, p, q, r);
}
return;
}


/*
* Funzione principale
*/

int main(void) {
int n, V[MAX];

n = leggi_array(V);
MergeSort(V, 0, n-1);
stampa_array(V, n);
system("pause");
}

[^_^M@ttia^_^]

Ciao,

se vuoi con questo puoi fare il Mergesort su qualsiasi tipo tu voglia (una template function), purché ovviamente siano confrontabili fra loro (cioè esista una regola per il < e <=).
Eccolo:

Codice C++

// Merge-Sort Implementation for using with all Type

template<class Typ>
void Merge(vector<Typ>& A, unsigned int i1, unsigned int f1, unsigned int f2)
{
  unsigned int i1_ = i1;

  // X is an Auxiliary Array of Lenght f2- i1 + 1
  vector<Typ> X(f2 - i1 + 1);

  unsigned int i  = 0;
  unsigned int i2 = f1 + 1;

  while (i1 <= f1 && i2 <= f2)
  {
    if (A[i1] <= A[i2])
    {
      X[i] = A[i1];
      ++i; ++i1;
    }
    else
    {
      X[i] = A[i2];
      ++i; ++i2;
    }
  }

  if (i1 <= f1)
  {
    // Copy A[i1; f1] to the End of X
    for (unsigned int j = i1; j <= f1; ++j, ++i) X[i] = A[j];
  }
  else
  {
    // Copy A[i1; f2] to the End of X
    for (unsigned int j = i2; j <= f2; ++j, ++i) X[i] = A[j];
  }

  // Copy X in A[i1; f2]
  for (unsigned int j = 0; j < X.size(); ++j, ++i1_) A[i1_] = X[j];
}

template<class Typ>
void MergeSort(vector<Typ>& A, unsigned int i, unsigned int f)
{
  if (i >= f) return;
  unsigned int m = (i + f)/2;
  MergeSort(A, i, m);
  MergeSort(A, m+1, f);
  Merge(A, i, m, f);
} 

Poi lo usi (nel mio caso dovevo Ordinare "m" Lati secondo la loro lunghezza, ed erano di tipo "edge", una mia classe) normalmente così:

MergeSort(Edges, 0, m-1); 

Ciao!