Problema ordinamento di un array

[franksisca]

ohhh.....vedi che piano piano stiamo arrivando a capire l'errore

la prima volta ti dava in output sbagliato, adesso rimane in esecuzione per 20 minuti (loop infinito suppongo).
confermi?

per eliminare i valori, essendo gli array elementi statici, devi semplicemente:

a) settartli ad un valore blank (in questo caso puo` essere 0) e poi ordinarlo
b) contarti quanti sono i valori che rispettano quella relazione, crearti un nuovo vettore e rifare il giro mettendoci i valori per te validi.

[hhh6]

cioè un esempio pratico,amico??perchè a parole è un tantinello difficile capirlo...Comunque si mi da quel problema,con il primo codice ci sono dei problemi di non combaciamento dei valori,con l'altro questi errori....

[franksisca]

si mi dai un esempio pratico di dati (il tuo main in pratica) e quello che ti aspetteresti?

[hhh6]

il main è quello che ho scritto ieri,il secondo,quello che mi aspetto è questo:
Esempio 1:
INPUT
Numero di titoli da considerare: 5
Andamenti percentuali: +1.2 -3.4 -2.2 +2.5 +1.1
OUTPUT
Valori negativi ordinati: -2.2 -3.4

A me basterebbe soltanto che mi aiutassi con la parte in cui vengono eliminati i termini negativi,insomma mi servirebbe quella piccola parte di codice per capire come fare...

[francesco.muia]

Ciao,
Qui sotto trovi un implementazione della tua richiesta.
Sicuramente si può fare meglio ma ti può servire come esempio.

import java.util.Arrays;
import java.util.Scanner;


public class JavaApplication23
{


	public static double[] acquisisciValori(Scanner sc, int numeroTitoli)
	{
		double[] valori = new double[numeroTitoli];
		for (int i = 0; i < valori.length; i++)
		{
			System.out.println("Inserisci i valori dei titoli");
			valori[i] = sc.nextDouble();
		}
		return valori;
	}


	public static double[] dammiValoriNegativi(double[] valori)
	{
		// CONTO LE OCCORRENZE NEGATIVE
		int n = 0;
		for (int i = 0; i < valori.length; i++)
		{
			if (valori[i] < 0)
			{
				n++;
			}
			else
			{
				// SE TROVO UN NUMERO POSITIVO E' INUTILE CHE CONTINUI (ARRAY
				// ORDINATO)
				break;
			}
		}
		// Se ci sono valori negativi
		if (n > 0)
		{
			double[] valoriNegativi = new double[n];
			for (int j = 0; j < valoriNegativi.length; j++)
			{
				valoriNegativi[j] = valori[j];
			}
			// OPPURE SE PUOI USARE CLASSI DEL SDK
			// double[] valoriNegativi = Arrays.copyOfRange(valori, 0, n);
			return valoriNegativi;
		}
		// GESTIRE IL CASO NON SIANO PRESENTI NUMERI NEGATIVI
		return null;
	}


	public static void bubleSort(double[] valori)
	{
		for (int i = 0; i < valori.length; i++)
		{
			boolean flag = false;
			for (int j = 0; j < valori.length - 1; j++)
			{


				// Se l' elemento j e maggiore del successivo allora
				// scambiamo i valori
				if (valori[j] > valori[j + 1])
				{
					double k = valori[j];
					valori[j] = valori[j + 1];
					valori[j + 1] = k;
					flag = true; // Lo setto a true per indicare che é avvenuto
									// uno scambio
				}


			}


			if (!flag)
				break; // Se flag=false allora vuol dire che nell' ultima
						// iterazione
						// non ci sono stati scambi, quindi il metodo può
						// terminare
						// poiché l' array risulta ordinato
		}
	}


	/**
	 * @param args the command line arguments
	 */
	public static void main(String[] args)
	{
		// TODO code application logic here
		Scanner sc = new Scanner(System.in);


		System.out.println("Inserisci la lunghezza dell'array");
		int n = sc.nextInt();
		double[] valori = acquisisciValori(sc, n);
		bubleSort(valori);
		double[] valoriNegativi = dammiValoriNegativi(valori);
		System.out.println(Arrays.toString(valoriNegativi));
	}
}

[franksisca]

allora....giusto per....questo e` il mio input:

Inserisci la lunghezza dell'array
5
Inserisci [1]  valore del titolo: 
1,2
Inserisci [2]  valore del titolo: 
-3,4
Inserisci [3]  valore del titolo: 
-2,2
Inserisci [4]  valore del titolo: 
2,5
Inserisci [5]  valore del titolo: 
1,1
1.2 -3.4 -2.2 2.5 1.1
-3.4 -2.2
-2.2 -3.4

e questo e` il codice

package ssc.energy.enipower.controller;


import java.util.Scanner;


public class JavaApplication23 {
	static Scanner scanner = new Scanner(System.in);


	public static void main(String... args) {
		System.out.println("Inserisci la lunghezza dell'array");
		double vettore[] = creoArray(scanner.nextInt());
		stampaVettore(vettore);
		double[] vettoreElementiNegativi = creaVettoreElementiNegativi(vettore);


		stampaVettore(vettoreElementiNegativi);
		ordinaVettore(vettoreElementiNegativi);
		stampaVettore(vettoreElementiNegativi);
	}


	private static double[] creaVettoreElementiNegativi(double[] vettore) {
		double[] newVettore = new double[contaElementiNegativi(vettore)];
		int k = 0;
		for (int index = 0; index < vettore.length; index++) {
			if (vettore[index] < 0) {
				newVettore[k] = vettore[index];
				k++;
			}
		}
		return newVettore;
	}


	private static void ordinaVettore(double[] array) {
		for (int i = 0; i < array.length; i++) {
			boolean flag = false;
			for (int j = 0; j < array.length - 1; j++) {
				if (array[j] < array[j + 1]) {
					double k = array[j];
					array[j] = array[j + 1];
					array[j + 1] = k;
					flag = true;
				}
			}
			if (!flag)
				break;
		}
	}


	private static void stampaVettore(double[] vettore) {
		for (int index = 0; index < vettore.length; index++) {
			System.out.print(vettore[index]);
			if (index != vettore.length - 1)
				System.out.print(" ");
		}
		System.out.println();
	}


	private static int contaElementiNegativi(double[] vettore) {
		int counter = 0;
		for (int index = 0; index < vettore.length; index++) {
			if (vettore[index] < 0)
				counter++;
		}
		return counter;
	}


	private static double[] creoArray(int dimensione) {
		double vettore[] = new double[dimensione];
		for (int index = 0; index < vettore.length; index++) {
			System.out.println("Inserisci [" + (index + 1) + "]  valore del titolo: ");
			vettore[index] = scanner.nextDouble();
		}
		return vettore;
	}
}

ovviamente ci sono miliardi di modi per farlo meglio...usando le collection, scrivendo codice ottimizzato...ma non credo che in questo caso si cerchi questo risultato!!!

[hhh6]

è ottima francesco,posso prendere spunto per siglare un main mio,non posso ancora utilizzare più classi,però è un ottimo punto di inizio...grazie ancora

[hhh6]

Ecco fatto ho elaborato un codice buono ma non ottimo,il motivo lo spiegherò dopo: ho preso un pò di spunti dai due ragazzi,gentilissimi,che mi hanno fornito indicazioni:

 public static void main(String[] args) {        // TODO code application logic here
    Scanner sc= new Scanner (System.in);
        
        System.out.println("Inserisci la lunghezza dell'array");
        int n=sc.nextInt();
        double v[]=new double [n];
        int cont=0;
        int cont1=0;
       
        double s[]=new double [n];
      //Inserimento valori array
        for (int i=0; i<n;i++)
        {System.out.println("Inserisci i valori dei titoli");
        v[i]=sc.nextDouble();}
      
      for (int i=0; i<n;i++)
      {if (v[i]<0){s[i]=v[i];
      cont++;}}
    for (int i=0; i<n;i++)
         {int min = i;
for(int j=i+1; j<n; j++) 
  if(s[j] > s[min]) 
   min = j;
{double temp;
temp=s[min]; 
s[min]=s[i]; 
s[i]=temp;}
System.out.println(+s[i]);}
      
      
      }
}

Non è ottimo il codice,perchè mi mancherebbe come eliminare tutti gli zeri dell'array di supporto: cioè se io ho una sequenza in input di questo tipo:-3,5,2,-4,7
l'output sarà dato da 0,0,0,-3,-4
Se riuscissimo ad eliminare tutti questi "zeri" l'esercizio sarebbe risolto.....

[franksisca]

ma guarda che io l'ho fatto....devi per forza contarli, con queste tipologie di strutture non puoi fare altrimenti!!!

[hhh6]

si ma ripeto,non posso usare più classi,devo solo usare il main con i vari costrutti,ragion per cui ho dovuto tradurre,tutto il vostro,ammirabile,lavoro in un'unica classe:e ho pensato a un vettore di supporto tale che prendesse solo valori negativi,come mi hai suggerito tu,però naturalmente restano "degli spazi vuoti" rappresentati dagli zero,se io volessi in qualche modo eliminare questi valori zero,lo potrei fare in un modo "elementare"?
ora io su internet,ho trovato quest'algoritmo,per eliminare tutte le occorrenze di un valore,quindi anche lo 0

int cont = 0;for (int i = 0; i < n; i++)
if (v[i] == val)
cont++;
else
v[i-cont] = v[i];
//Aggiornamento della lunghezza dell’array
n -= cont;