Newsgroup: it.comp.lang.visual-basic
Titolo: [?] Array: domande.

Ho alcune domande da farvi sugli array:
1.il
 comando Preserve salva i valori di un array quando questo viene
ridimensionato; ma dove? I nuovi valori vengono "appesi" a quelli vecchi che
sono stati preservati?
2.Ho il seg. codice, per inserire nuovi elementi in un array:
Sub InsertArrayItem (arr As Variant, index As Long, newValue As Variant)
Dim i as long
For i = UBound( arr ) - 1 To Index Step -1
    arr( i + 1 ) = arr( i )
Next
arr( index ) = newValue
End Sub
non l'ho capito: perchè parte da UBound( arr ) -1? Index quanto vale? Perchè
Step - 1? Perchè arr (i + 1 ) = arr( i ) ?
Se ho 
ad.es
. un array di 10 elementi  - numeri da 1 a 10 - e voglio
aggiungerne altri 10 - da 11 a 20 non posso fare:
Sub InsertArrayItem (arr As Variant, index As Long, newValue As Variant)
Dim i as long,
For i = UBound( arr ) To Index Step 1
    arr ( i ) = arr ( i +1 )
    arr ( i ) = newValue
    newValue = newValue + 1
Next
End Sub
Index in questo caso è un valore che indica il nuovo indice superiore. Boh,
non ci ho capito granchè di questa parte della storia :-!
3.Ordinamento di un array
Ho il seg. codice:
Sub ShellSortAny(arr As Variant, numEls As Long, descending As Boolean)
    Dim index As Long, index2 As Long, firstItem As Long
    Dim distance As Long, value As Variant
    ' Exit if it is not an array.
    If VarType(arr) < vbArray Then Exit Sub
    firstItem = LBound(arr)
    ' Find the best value for distance.
    Do
        distance = distance * 3 + 1
    Loop Until distance > numEls
    ' Sort the array.
    Do
        distance = distance \ 3
        For index = distance + firstItem To numEls + firstItem - 1
            value = arr(index)
            index2 = index
            Do While (arr(index2 - distance) > value) Xor descending
                arr(index2) = arr(index2 - distance)
                index2 = index2 - distance
                If index2 - distance < firstItem Then Exit Do
            Loop
            arr(index2) = value
        Next
    Loop Until distance = 1
End Sub
credo che numEls stia per number_of_elements.  Le sitruzioni nel ciclo che
fanno? Purtroppo nel testo non c'è alcun riferimento....:-((

 non ci ho capito granchè di questa parte della storia :-!
Non ho capito niente !!!!!!
for i = 1 to 20
   arr(i)=i
next i
non fa quello che piu' o meno ho capito tu volessi ?!?!?
P.S: Guardati la guida, mi sembra tu non abbia capito cosa restituisce
UBound.

Rinuncio :-(
Ciao.
Giorgio

 preservare ??? ;-)
Si, si lo avevo capito ma sono curuioso di sapere dove lo mantiene. Ad.es se
faccio un preserve su un array che aggiorno ma dopo voglio annullare
l'aggiornamento potrei semplicemente richiamare un oggetto creato da
Preserve se esso esistesse. Esiste?

Come no? E' per questo che non ho capito, UBound restituisce il limite
superiore di una matrice (o di un array)...per questo mi chiedevo perchè
pertisse da UBound fino ad Index.....Cmq nel secondo caso hai ragione tu, il
loop For...Next è semplice.

Ehehehehe...magari qlc lo sapesse qui :-) atrimenti mi tocca scrivere a
lui...

 loop For...Next č semplice.
Se parti dalla fine (UBound) e torni ad index sposti tutti gli elementi "in
avanti" di 1.
Se tu facessi il contrario, da index a UBound, copieresti nel valore
successivo quello attuale e al ciclo successivo copieresti lo stesso valore
in quello dopo ancora e cosi' via fino alla fine. Risultato: Tutti i valori
da index+1 in poi uguali !!!!!!!
Ciao.

 fanno? Purtroppo nel testo non c'è alcun riferimento....:-((
Si tratta di uno shellsort. Non è il sistema più veloce per eseguire
l'ordinamento di un array, ma è un buon compromesso.
Trovi spiegazioni dell'algoritmo in C, in inglese, e pure la descrizione di
un tentativo di brevettarlo, qui:
http://www-2.cs.cmu.edu/~dst/DeCSS/Baccash/shell-sort/
Qui invece c'è un esempio animato di come funziona. Un po' troppo veloce per
capirlo, però fa scena ;-)
http://www.cs.princeton.edu/~rs/shell/animate.html
Il sistema più rapido per ordinare un array è però il QuickSort, che si basa
sulla logica della divisione in pile. E' un po' lo stesso sistema che si usa
manualmente quando bisogna riordinare per numero un gran numero di riviste,
le si divide per pile e poi le si rimettono assieme. Questo metodo viene
implementato molto bene usando la ricorsione. Il QuickSort ha un solo
problema nel caso particolare in cui l'array sia già ordinato in ordine
contrario di quello che si desidera; in questo caso particolare diventa
particolarmente lento, ed è solo per questo caso particolare che (a volte)
si usa ancora lo shellsort.
Qui trovi un minicorso in italiano che spiega alcuni algoritmi di sort, tra
cui il QuickSort
http://www.redangel.it/programmatori/redangel/algoritmi/ordinamenti.asp
Se vuoi farti una cultura su tutti gli algoritmi di ordinamento, fai un
salto qui (in Java, ma si capisce)
http://www.cs.ubc.ca/spider/harrison/Java/sorting-demo.html
Se invece preferisci restare al VB, qui trovi sorgenti per ShellSort e
Bubble sort:
http://www.freevbcode.com/ShowCode.Asp?ID=776
Ciao
*Roby*

 
http://www.freevbcode.com/ShowCode.Asp?ID=776
e cercando con google nell'archivio del ng hellboy+quicksort trovi bell'e
pronto il codice del diavoletto.
ciao, j.sort

 pronto il codice del diavoletto.
Diavolo d'un ragazzo!
Ciao
*Roby*

 
http://www.vb2java.com/vb2java.html
ci mancavano i tuoi links.
(mugugno concorde dall'altra stanza)
j.roby