Ciao a tutti,
mi ritrovo a dover mettere in ordine crescente un array in C composto da int....
Fin qui nulla di male, ho usato tale il mergeSort che vi propongo qui sotto in codice.
codice:
/*
* Dato un array d di s valori int, ordina l'array in maniera crescente.
*/
void
MergeSort (int d[], int s)
{
int c = s / 2; /* Il punto in cui dividere l'insieme di dati */
if (s > 1)
{
MergeSort (d, c); /* La prima meta` */
MergeSort (d + c, s - c); /* La seconda meta` */
Merge (d, c, s); /* Fondiamo le sequenze */
}
}
/* Dato un array v di lunghezza lung diviso in due parti (la prima di lunghezza
* mezzo la seconda di lunghezza lung - mezzo) ciascuna delle quali ordinata,
* questa funzione riordina la sequenza fondendo insieme le due parti. */
void
Merge (int v[], int mezzo, int lung)
{
int i, j, k;
int *b; /* Abbiamo bisogno di un vettore di supporto */
if ((b = malloc (lung * sizeof (int))) == NULL)
{
printf ("Errore: non posso allocare il vettore di supporto!\n");
exit (0);
}
k = i = 0;
j = mezzo;
/*
* Scorro le due parti di sequenza
*/
while ((i < mezzo) && (j < lung))
{
if (v[i] < v[j]) /* Se e` maggiore l'elemento che si trova nella */
b[k] = v[i++]; /* seconda meta` copio quello nella prima meta` */
else /* o viceversa. */
b[k] = v[j++];
k++;
}
/*
* Potremmo non aver finito di scorrere le due meta`. Se non ho finito con
* la seconda meta` i dati sono gia` al loro posto.
*/
if (i < mezzo)
for (j = 0; j < mezzo - i; j++) /* Copio i dati della prima meta` */
v[k + j] = v[i + j]; /* nel posto giusto */
/*
* Ricopio i dati dal vettore di supporto nel vettore originale
*/
for (j = 0; j < k; j++)
v[j] = b[j];
free (b);
}
Il mio problema nasce dal fatto che l'array che ottengo da un programma di terze parti è formato da coppie [x,y], in cui la X è il tempo e la Y è il valore in quel dato momento.
Quindi il mio array è formato cosi: {[x0,y0],[x1,y1],.....[xn,yn]}
e i vari istanti ,cioè le X non sono in ordine.
Ho quindi la necessità di riordinare l'intero array "a coppie" secondo il valore della X.
Come mi dite di procedere?
Di modificare l'algoritmo qui sopra secondo le mie esigenze?
Di ottenere un array delle X, diviso da quelle delle Y, e una volta ordinato cercare in qualche modo di riottenere la giusta corrispondenza biunivoca???
Grazie 1000