[C] ordinamento di un array tridimensionale

[thesalien]

Salve a tutti, riesco a ordinare un array monodimensionale ma non capisco proprio perchè non riesca a ordinare un array tridimensionale. Si blocca in fase di runtime e non capisco proprio il motivo

Vi posto il codice..
PS ho creato una funzione che mi inizializza i dati di input

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#ifdef _WIN32
#include <windows.h>
#define MAX_CIFRE 4 // numeri compresi tra 0 e 999
#define RADICE_SIZE 10
#define IS_FULL(ptr) (!ptr)
#define IS_EMPY(ptr) (!ptr)
#define MAX 5000
#define MAX_CIFRE 4 // numeri compresi tra 0 e 999
#define RADICE_SIZE 10
#define IS_FULL(ptr) (!ptr)
#define IS_EMPY(ptr) (!ptr)
#define ITERAZIONI 7
#define DIMENSIONE_MAX_LISTA 5000

typedef struct list_node *list_pointer;
typedef struct list_node {
int chiave[MAX_CIFRE];
list_pointer link;
}lista;

int dimensioni[]= {50,100,200,500,1000,2000,5000};

void creazione_dati (int testa[][ITERAZIONI][DIMENSIONE_MAX_LISTA]);
void scambia(int *x,int *y);
void sort_inserzione(int lista[][ITERAZIONI][DIMENSIONE_MAX_LISTA],int m,int n);



main(){
randomize();
printf("\nEsercitazione numero 23\n");
int i,j,k;

int testa[4][7][DIMENSIONE_MAX_LISTA];



//****************************************************************************
//****************************************************************************
//****************************************************************************
//*************************ORDINAMENTO PER SELEZIONE**************************
//****************************************************************************
//****************************************************************************
//****************************************************************************

creazione_dati (testa);

//### ARRAY ORDINATO #################################################*SELEZIONE

for(i=0;i<50;i++)printf("testa[0][0][i]");
for(i=0;i<4;i++)
for(j=0;j<7;j++)


sort_inserzione(testa,i,j);



for(i=0;i<50;i++)printf("testa[0][0][i]");

}

void sort_inserzione(int lista[][ITERAZIONI][DIMENSIONE_MAX_LISTA],int m,int n)
{
int i,j;
int prossimo;
n = dimensioni[n];
for(i=1;i<n;i++)
{
prossimo=lista[m][n][i];
for(j=i-1;j>=0 && prossimo<lista[m][n][j];j--)
lista[m][n][j+1] = lista[m][n][j];

lista[m][n][j+1] = prossimo;
}

[thesalien]

Ho aggiustato la funzione per la creazione dei dati, ora quella funziona, ma si blocca lo stesso

void creazione_dati (int testa[][ITERAZIONI][DIMENSIONE_MAX_LISTA])
{
int i,j;

//liste ordinate
for(i=0;i<ITERAZIONI;i++)
for(j=0;j<dimensioni[i];j++) testa[0][i][j]=j;

//liste inversamente ordinate
for(i=0;i<ITERAZIONI;i++)
for(j=dimensioni[i];j>0;j--) testa[1][i][dimensioni[i]-j]=j;

//liste con numeri casuali
for(i=0;i<ITERAZIONI;i++)
for(j=0;j<dimensioni[i];j++) testa[3][i][j]=rand();

//liste quasi ordinate  (il 10% non e ordinato)
for(i=(dimensioni[i]/10);i<ITERAZIONI;i++)
for(j=0;j<dimensioni[i];j++) testa[2][i][j]=j;

for(i=0;i<ITERAZIONI;i++)
for(j=0;j<(dimensioni[i]/10);j++) testa[2][i][j]=j + dimensioni[ITERAZIONI - 1] ;


}

[thesalien]

ci sn riuscito da solo VVoVe:

LASCIATE MORIRE QUESTO POST

[thesalien]

Non lasciate che muoia......
Ero sicuro di esserci riuscito ma purtroppo non è cosi..

Quest'algoritmo non ORDINA
non capisco come mai, l'ho copiato dal libro, ho sostituito solamente lista[x] con lista[y][z][x]

void sort_selezione (int lista[][ITERAZIONI][DIMENSIONE_MAX_LISTA],int m,int n)
{
int i,j,k,min;
k = dimensioni[n];
for(i=0;i<k-1;i++)
{
min =i;
for(j=i+1;j<n;j++)
   if(lista[m][n][j]<lista[m][n][min])min=j;
   scambia(&lista[m][n][i],&lista[m][n][min]);
}
}

questa è la chiamata:

for(i=0;i<4;i++)
for(j=0;j<7;j++)
sort_selezione(testa,i,j);

e questa è la funzione dello scambio

void scambia(int *x,int *y)
{
int temp= *x;
*x = *y;
*y = temp;
}

[perzem]

quale principio logico usi per ordinare???

[thesalien]

cioè? Cosa intendi per principio logico?

sto ordinando per selezione. Praticamente m sono creato un array tridimensionale, in cui il primo indice rappresenta il tipo di lista (ordinata,inversame ordinata, casuale ), il secondo la dimensione della lista(0=50,1=100,2=200... elementi) e l'ultimo ha tantiindici quanti indicati nel secondo (50 se il secondo era 0...).
Cmq il problema penso che sia nella funzione scambia.
X lìordinamento x inserzione non ci sono problemi, ci sono riuscito ma questo invece lascia la lista cosi come era, non la modifica.. A mio parere la funzione scambia dovrebbe essere modificata... ma non so come!

[nik600]

non credo che abbia molto senso creare una matrice tridimensionale dove un campo lo usi solo per memorizzare il numero di elementi.... :master:

non ti conviene memorizzare tale numero in una variabile?

[thesalien]

io penso che invece abbia senso.. gli altri due indici servono per i tipi di lista e i tipi di ordinamento, se mettessi solo un campo dovrei crearmi n*m=28 liste con nomi diversi.VVoVe:
PS ci sono riuscito da solo cmq..
quello che si blocca ora è il mergesort

void merge(int lista[ ][ITERAZIONI][DIMENSIONE_MAX_LISTA], int ordinata[ ][ITERAZIONI][DIMENSIONE_MAX_LISTA], int i, int m, int n, int z, int r)
{
/* fonde due file ordinati: lista[i],...,lista[m]
e lista[m+1],...,lista[n], per ottenere una sola lista ordinata
ordinata[i],...,ordinata[n]
*/      printf(" 1 ");
int j, k, t;
j = m+1;
// indice per la seconda lista
k = i;
printf(" 2 ");
// indice per la lista ordinata
while(i<=m && j<=n)
{    printf(" 3 ");
if(lista[z][r][i]<=lista[z][r][j]) ordinata[z][r][k++] = lista[z][r][i++];
else
ordinata[z][r][k++] = lista[z][r][j++];
}
printf(" 4 ");
if(i>m) for(t=j; t<=n; t++) ordinata[z][r][k+t-j] = lista[z][r][t];
// ordinata[k],...,ordinata[n] = lista[j],...,lista[n]
else for(t=i; t<=m; t++) ordinata[z][r][k+t-i] = lista[z][r][t];
// ordinata[k],...,ordinata[n] = lista[i],...,lista[m]
printf(" 5 ");
}

void passo_merge(int lista[ ][ITERAZIONI][DIMENSIONE_MAX_LISTA], int ordinata[][ITERAZIONI][DIMENSIONE_MAX_LISTA], int n, int lungh,int z, int r)
{
/*
Svolge un passo dell'ordinamento per fusione.
Fonde una coppia di sottofile adiacenti da lista a ordinata;
n è il numero di elementi nella lista;
lungh è la lunghezza del sottofile */
int i, j;
printf(" A ");
for(i = 0; i <= n-2*lungh; i += 2*lungh)
merge(lista, ordinata, i, i+lungh-1, i+2*lungh-1, z, r);
printf(" B ");
if(i+lungh < n)
merge(lista, ordinata, i, i+lungh-1, n-1, z, r);
else for(j = i; j < n; j++)
ordinata[z][r][j] = lista[z][r][j];
printf(" C ");
}

void mergesort(int lista[ ][ITERAZIONI][DIMENSIONE_MAX_LISTA], int n, int z, int r)
{
printf(" a ");
/* ordina la lista lista[0],...,lista[n-1] per fusione */
int lungh = 1;
printf(" b ");
// lunghezza corrente delle liste da fondere
printf(" c ");
int extra[MAX][ITERAZIONI][DIMENSIONE_MAX_LISTA];
printf(" d ");
while(lungh < n)
{
printf(" e ");
passo_merge(lista, extra, n, lungh, z, r);
printf(" f ");
lungh *= 2;
printf(" g ");

passo_merge(extra, lista, n, lungh, z, r);
printf(" h ");
lungh *= 2;
printf(" a ");
}
}