Newsgroup: it.comp.java
Titolo: inserimento ordinato in array

Ciao a tutti :-)
Capisco di essere un po' babbeo, ma il seguente codice mi sembra perfetto,
eppure (visto che il programma non gira correttamente e le altre procedure
sono ok) è sbagliato, voi cosa ne dite? In pratica, ho un array a[n] con
a[0]=a[1]=...=a[n-1]=0. A mano a mano che inserisco un numero, questo deve
inserirsi "già in ordine".
*** BEGIN CODICE ***
    private static void     aux_insertinarray(int x)
    {
        int     shiftindex=0,
                tempindex=shiftindex;
        boolean foundpoint=false;
        // inserimento del numero nell'array
        while ((shiftindex<a.length)&&(!foundpoint))
            if ((a[shiftindex]<x)&&(a[shiftindex]>0)) shiftindex++;
            else foundpoint=true;
        tempindex=shiftindex;
        while (shiftindex<a.length-2)
        {
            a[shiftindex+1]=a[shiftindex];
            shiftindex++;
        };
        a[tempindex]=x;
    };
*** END CODICE ***
Grazie infinite e saluti :-)
Marco Zanon (
m.z...@usa.net
)
http://www.geocities.com/SiliconValley/Peaks/6455
(BUY CDS AT THE LOWEST PRICES through my site!!!
Zamorano fan page, free MIDI mailing list, Music db...)

        while ((shiftindex<a.length)&&(!foundpoint))
Perchè fate tutti &&?? Ne basta una!
--
Bye,
  Dario
ICQ: 
http://wwp.mirabilis.com/11871099
Remove anti-spam from e-mail address

  Dario
Ciao :-)

         a[tempindex]=x;
Qui sta l'errore: se vuoi shiftare a dx tutti gli
elementi di un array devi partire dal fondo, senno'
ogni volta vai a scrivere su tutto l'array da shiftindex in poi
sempre lo stesso elemnto, cioe' a[shiftindex].
Quindi il while va fatto la a.length all'indietro,
decrementando l'indice ad ogni giro.
Ma immagino che nel frattempo ci sarai arrivato anche 
da solo :-)
Ciao,
  Marina

 wrote in message
36BEA509...@dalia.cselt.it...

  Marina
Facendo come dici tu viene copiato sempre il valore dell'ultimo
elemento.
Prova cosi':
	String a[] = {"zero", "uno", "due", "tre", "quattro"};
	String temp[] = {"", ""};
	for (int i=0; i<a.length; i++) {
		if ( (i % 2)== 0 ) {
			temp[1]=a[i];
			a[i]=temp[0];
		} else {
			temp[0]=a[i];
			a[i]=temp[1];
		}
	}
	a[0]=temp[1];
Ciao
   Francesca

 (forse vale anche qui)...
Si', vale anche qui :)
Ciao
-- 
...almost any game *CAN* be imagined to be an RPG, but a "real RPG"
would facilitate role-playing, not require spending most of your effort
on sustaining your SOD.
M. Hughes

 elemento.
Cara Francesca,
non e' vero affatto.
Per inserire un elemento in un array ordinato, devi fargli spazio
spostando a dx di un posto tutti gli elementi piu'
grandi di quello nuovo, partendo dal fondo, ovviamente,
senno' perdi dei dati.
Fatto lo spazio inserisci l'elemento nello spazio vuoto.
Questo, ovviamente, se nell'array lo spazio c'e', in caso
contrario devi creare un nuovo array e copiare in esso tutti gli
elementi in modo ordinato, compreso quello nuovo.
Non so il codice che hai scritto tu a cosa serva, ma certo non
ad inserire un elemento in un array ordinato, visto che
l'emento da inserire non c'e'.
Ciao,
  Marina

Si', vale anche qui :)
Sono andato a leggermi le specifiche di Java e ho scoperto che in
realtà c'è una differenza, ma non quella che dite.
A & B valuta sia A che B
A && B valuta B solo se A è vera.
Secondo me era meglio fare il contrario...



   o o o   Java Tutorials: 
http://surf.to/tetractys
  o o o o  Java Jousters : 
www.uno.it/utenti/tetractys

  Dario
Ciao,


Perche'?
Perchè, secondo me, quello che si usa di più è il secondo e tocca
scrivere il doppio! ;-)
Adesso mi toccherà convertirli tutti.


Remove anti-spam from e-mail address
| --
| Bruno Bossola
| Groupware/Intranet B.U.           Phone:  +39-11-2252211
| ATOS SpA v.Vaninetti 27           Fax:    +39-11-2203182
| I-10148 Torino ITALY              Change NOSPAM in atos to email me!


  o o o o  Java Tutorials: 
http://surf.to/tetractys

diano come risultato un valore booleano
Dal basso della mia ignoranza: mi fai un esempio contrario? Credo di
non aver capito cosa intendi...


>Dal basso della mia ignoranza...
Spero che tu scherzi! Semmai sono io che tendo ad essere un po'
logorroico con l'eta', e mi sa che anche questa risposta viene
lunga...
Il succo e' che con & fai una operazione aritmetica, con && fai una
valutazione logica. La stessa sintassi di Java "aiuta" virtualmente a
non commettere errori, perche', a differenza del C, le uniche
espressioni valutabili in una funzione di controllo ciclo sono
booleane.
Ad esempio in C potevi fare:
 
	int x = 5;
	...
	if (x)
	{
	}
Mentre in Java sei costretto a convertire l'espressione "x" in una
espressione booleana:
	int x = 5;
	...
	if (x != 0)
	{
	}
In C scrivere quindi:
	int x = 5;
	int y = 7;
	if (x & y)
	{
	}
rappresentava di norma un _grave_ errore di programmazione, perche'
non equivaleva a dire "se x e' diverso da 0 _e_ y e' diverso da 0" ma
significava "esegui l'and binario fra x ed y, e verifica se il
risultato e' diverso da 0". Il codice che faceva invece l'operazione
tipicamente giusta era questo:
	if (x && y)
	{
	}
In Java il problema in espressioni semplici non si pone, in quanto e'
impossibile fare valutare una espressione del genere:
	int x = 5;
	int y = 7;
	if (x & y)
	{
	}
...ma e' possibile confondendo le due notazioni, in espressioni
complesse, fare questo:
	int x = 5;
	int y = 7;
	boolean found = true;
	if ((x & y) || found)
In tale caso dovrebbe comunque salvarti il compilatore, che ti
dovrebbe dare un errore del tipo "mi aspettavo un boolean ma mi hai
dato un intero": infatti x&y e' una _operazione_ che produce un
risultato intero, e non una valutazione.
Funzionerebbe invece in questo caso:
	boolean  x = true;
	boolean  y = true;
	boolean found = true;
	if ((x & y) || found)
in quanto l'operazione di & aritmetico e' effettuata fra due valori
boolean e quindi da' come risultato un boolean, accettabile per una
successiva valutazione dell'espressione. 
Comunque in espressioni complesse che non coinvolgano solo boolean (o
espressioni ridotte a boolean) ma anche valori interi, ricordati che &
e && non sono intercambiabili! Una fa l'AND aritmetico sui bit, una
valuta con AND logico una espressione. L'unica occasione in cui i due
comportamenti corrispondono e' quando entrambi gli operandi sono dei
boolean.
Ehm, mi sa che la risposta e' venuta lunga.... ma spero che ti abbia
chiarito la problematica.
Ciao,


| --


chiarito la problematica.
Si e no... :)
