Ordinare matrici

[fefuccia]

Salve eccomi nuovamente qui a implorare il vostro aiuto mi trovo a dover fare questo esercizio:
Scrivere il codice di una classe java che permetta di ordinare una matrice di float.La matrice dovrà essere ordinata per righe in ordine crescente in funzione del modulo(somma dei quadrati dei valori) di ciascuna riga.
Da premettere ho provato a studiare alcuni algoritmi di ordinamento ma a parte che li ho capiti solo in teoria e poco tutti gli esempi che ho trovato per rendermi meglio conto erano con i vettori... quindi per le matrici mi trovo un po' in difficoltà. Intanto però ho scomposto il problema facendo due metodi uno per calcolare il modulo e uno per scambiare le righe perchè poi avevo pensato al metodo vero e proprio in cui avrei passato la matrice per ogni riga far calcolare il modulo e se il modulo della riga i-sima risulta maggiore della riga i+1 invocare il metodo scambia..... però quest'ultima parte non riesco proprio a buttarla giù intanto vi allego il codice che ho scritto fin'ora e spero possiate aiutarmi!

public class OrdinaMatrice 
{
	public static float calcolamodulo(float v[])
	{
		float modulo=0;
		for(int i=0;i<v.length;i++)
			modulo += v[i]*v[i];
		
		return modulo;
	}//chiusura metodo modulo
	
	public static float[][]scambiarighe(float mat[][],int k,int h)
	
	{
		float temp[]= new float[mat[0].length];
		for(int j=0;j<mat[0].length;j++)
		
			{
				for(int i=0;i<mat[0].length;i++)
					{
					  temp[i]=mat[k][j];
					  mat[k][j]=mat[h][j];
					  mat[h][j]=temp[i];
					}
				}
		return mat;
	}//chiusura metodo scambia

[desa]

In realtà il tuo problema di ordinamento riguarda un vettore (quindi, puoi utilizzare uno degli innumerevoli algoritmi già esistenti). Data una matrice con N righe e M colonne:
- crei un array di float (per i "moduli") di lunghezza N;
- crei un array di int (per tenere traccia del riordinamento delle righe) di lunghezza N;
- riempi il primo array con i "moduli";
- inizializzi il secondo array con i valori da 0 a N-1;
- esegui l'ordinamento sul primo array e, parallelamente, tieni aggiornati di conseguenza gli indici del secondo array;
- analizzando gli indici-riga presenti nel secondo array riordini la matrice.

Cosa ne pensi?

[fefuccia]

potrei provar così speriamo di riuscire bene a tradurlo in codice e che finalmente funzioni!grazie del suggerimento

[fefuccia]

allora ci ho studiato un po' è ho fatto una prova solo che non funziona come dovrebbe.... dove sbaglio (non riposto tutto il codice ma solo il metodo mancante)

public static float [][] ordina(float [][]matx)
	
	{

		float [] moduli=new float [matx[0].length];
		float max=0;
		int index=0;
		for(int k=0;k<matx[0].length; k++)
			{
			  moduli[k]= OrdinaMatrice.calcolamodulo(matx[k]);
				if(max<=moduli[k])
				index=k;
				moduli[k]=max;
				matx = OrdinaMatrice.scambiarighe(matx, index,index+1);
						
		      }
			
		return matx;
	}

[desa]

In effetti c'è qualcosa che non torna...
Ok, vediamo se ho capito quello che vuoi fare: ad ogni iterazione del ciclo for (e quindi, ad ogni nuova riga della matrice) calcoli il "modulo" e sposti la riga in posizione corretta nell'ordinamento. Ti trovi quindi nello scenario in cui, se stai considerando l'indice k, sei sicura che tutte le righe fino all'indice k-1 sono ordinate correttamente TRA LORO. Quello che devi fare, quindi, ad ogni nuova riga è "spostarla" verso l'alto finchè il suo modulo non risulta nella posizione corretta (utilizzando un ciclo - e non un "if" - che ha come terminazione il raggiungimento della "prima posizione" OR dell'ordinamento corretto)

[fefuccia]

si hai capito quel che volevo fare io ma sono io che non capisco il tuo ultimo suggerimento....l'if non fa utilizzato anche all'interno di un eventuale ciclo for? ho provato a rifarlo ma non riesco ad ottenere il risultato che voglio! me lo potresti correggere per favore?

public static float [][] ordina(float [][]matx)
	
	{

		float [] moduli=new float [matx[0].length];
		float max=0;
		//int index=0;
		for(int k=0;k<matx[0].length; k++)
			{
			  moduli[k]= OrdinaMatrice.calcolamodulo(matx[k]);
			  for(int i=0;i<moduli.length;i++ )
			  { if(max<moduli[k])
					  i=k;
			          matx=OrdinaMatrice.scambiarighe(matx, i,i+1);
			  }


		      }
			
		return matx;
	}

potrei non uscirne più!

[desa]

Prova così:

public static float[][] ordina(float[][] matx)
{
  float[] moduli = new float[matx[0].length];

  for (int k = 0; k < matx[0].length; k++)
  {
    moduli[k] = OrdinaMatrice.calcolamodulo(matx[k]);

    int i = k - 1;

    while (i >= 0 && moduli[i] > moduli[i + 1])
    {
      OrdinaMatrice.scambiarighe(matx, i, i + 1);

      int temp = moduli[i];
      moduli[i] = moduli[i + 1];
      moduli[i + 1] = temp;
      
      i--;
    }
  }

  return matx;
}

Il metodo può tranquillamente essere void, visto che lavora sul parametro matx che - come dovresti sapere - è passato per riferimento

[fefuccia]

L'ho provato ma ancora non da quel che voglio io! ovvero quel che fa è scambiarmi solo le prime due righe indipendentemente dal valore dei moduli.....

[desa]

Il problema è nel metodo di scambio: l'ho riscritto piuttosto che cercare di capire dov'è l'errore, ci mettevo meno

public static float[][]scambiarighe(float mat[][],int k,int h)
{
  for (int j = 0; j < mat[0].length; j++)
  {
    float temp = mat[k][j];
    mat[k][j] = mat[h][j];
    mat[h][j] = temp;
  }
  return mat;
}//chiusura metodo scambia

Ti riposto anche il metodo di ordinamento, visto che avevo fatto un paio di errori:

public static float[][] ordina(float[][] matx)
{
  float[] moduli = new float[matx.length];

  for (int k = 0; k < matx.length; k++)
  {
    moduli[k] = Prova.calcolamodulo(matx[k]);

    int i = k - 1;

    while (i >= 0 && moduli[i] > moduli[i + 1])
    {
      Prova.scambiarighe(matx, i, i + 1);

      float temp = moduli[i];
      moduli[i] = moduli[i + 1];
      moduli[i + 1] = temp;

      i--;
    }
  }

  return matx;
}

[fefuccia]

ok grazie ora lo studio per benino, però strano che mi dici che il metodo di scambio era errato perchè nel cercare di capire dove fosse l'errore avevo testato ogni singolo metodo e quello funzionava! mah... io e programmazione siamo proprio come il diavolo e l'acquasanta...speriamo bene per l'esame!