Newsgroup: it.comp.lang.visual-basic
Titolo: Sort di un'array, qualè il metodo piu' veloce e efficente??.

Salve, fino ad ora ho risolto tutti i miei problemi grazie a questo
newsgroup quindi ci riprovo con una nuova domanda..........
Allora io ho un'array dinamico ( tipo Y(100) o Y(200) quale
e' secondo voi il metodo piu' efficente per ordinare i valori
all'interno in ordine crescente ( 1-2-3-4-20-60 ecc ) tenendo
conto che la variabile e tipo integer e quindi i valori possono
essere anche negativi ( -20 -50 ecc ) , magari esiste qualche
funzione avanzata API??, rigrazio tutti come sempre.
falco...@libero.it

...


Il tuo problema non č banale infatti ci sono esami universitari che trattano
quasi solo gli ordinamenti.
Secondo me se il tuo array non č molto grosso e strano puoi optare tra:
-Inseretion sort.
-Quick sort.
Li puoi trovare penso facilmente con una ricerca su internet o in un libro
di testo di programmazione1.
Andrea Degli Esposti


 Canzonetti Giuliano ha scritto


Ciao, Giuliano
perchè non lo fai fare a VB l'ordinamento ?
Segui passo passo questo esempio :
Metti in un form due listbox
Dim a As Integer
' Dichiaro la tabella , ho fatto la prova con  320 valori ma la tua tabella
' può essere lunga a piacere.
Dim tb(321) As Integer
' Valori Positivi
For a = 1 To 160
    tb(a) = a
Next a
' Valori Negativi
For a = 161 To 320
    tb(a) = a * (-1)
Next a
Per cui, se hai già una tabella riempita da ordinare
il tutto diventa :
List1.Clear
List2.Clear
' La lista List1 deve essere Sorted = True
For a = 1 To Ubound(tb)
    If tb(a) > 0 Then
        List1.AddItem Str$(200000 + tb(a))
        ' Ovvio che conservo anche il valore effettivo del numero
        List1.ItemData(List1.NewIndex) = tb(a)
    Else
        List1.AddItem Str$(190000 + tb(a))
        List1.ItemData(List1.NewIndex) = tb(a)
    Endif
Next a
Con questo sistema i numeri positivi cominceranno da 200000 e quelli
negativi arriveranno massimo a 189999
permettendo alla proprietà sort di ordinarli come stringe rispettando il
reale valore degli interi che comunque ti
sei salvato nella proprietà ItemData di ciascun elemento della Lst1
Il ciclo seguente è solo per la visualizzazione.
' La lista List2 deve essere Sorted = False
For a = 0 To List1.ListCount - 1
    If List1.ItemData(a) < 0 Then
        List2.AddItem "-" & Abs(List1.ItemData(a))
    Else
        List2.AddItem "+" & Abs(List1.ItemData(a))
    End If
    List2.ItemData(List2.NewIndex) = List1.ItemData(a)
Next a
Ho provato l'esempio e funziona.
Ciao Vito
-- 
Posted from 
smtp2.libero.it
 [193.70.192.52] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

Ciao,
un altro metodo di ordinamento č quello definito EXCHANGING.
Si basa sul seguente algoritmo.
1) Si parte con un contatore degli scambi azzerato (=0).
2) Tutti gli elementi dell'array vengono confrontati a coppie.
3) Se sono consecutivi (leggi: il primo č piů piccolo del secondo)
     si confronta il secondo con il terzo e cosě fino all'ultima coppia.
4) Se, invece, non sono in ordine, si procede ad uno scambio.
    A scambio avvenuto si incrementa il contatore degli scambi.
5) Si completa il ciclo di confronti, operando tutti gli scambi
    necessari.
6) Se alla fine del ciclo si č operato almeno uno scambio si
    ricomincia dal punto 1. Altrimenti, si esce. (Ovviamente a
    punto l'array č ordinato.
La codifica, in VB potrebbe somigliare a questo :
Dim t(9) As Integer
Dim nI As Integer
Dim nBuffer As Integer
Dim nScambi As Integer
List1.Clear
List2.Clear
' Questo solo per ricavare una tabella di numeri casuali da  ordinare
Randomize ' Per ottenere una sequenza sempre diversa
List1.AddItem Int(100 * Rnd(100)) + 1
List1.AddItem Int(100 * Rnd(100)) + 1
List1.AddItem Int(100 * Rnd(100)) + 1
List1.AddItem Int(100 * Rnd(100)) + 1
List1.AddItem Int(100 * Rnd(100)) + 1
List1.AddItem Int(100 * Rnd(100)) + 1
List1.AddItem Int(100 * Rnd(100)) + 1
List1.AddItem Int(100 * Rnd(100)) + 1
List1.AddItem Int(100 * Rnd(100)) + 1
' Caricamento della tabella
For nI = 0 To List1.ListCount - 1
    t(nI + 1) = Val(List1.List(nI))
Next nI
' Inizio Ciclo
Do
    ' Azzero gli scambi
    nScambi = 0
    ' Passo a confrontare tutti gli
    ' elementi della tabella a coppie
    For nI = 1 To UBound(t) - 1
        ' Confronto l'ennesino con il successivo
        If t(nI) > t(nI + 1) Then
            ' Se non sono consecutivi
            ' opero uno scambio di posto
            ' e incremento il contatore
            ' degli scambi
            nScambi = nScambi + 1
            nBuffer = t(nI)
            t(nI) = t(nI + 1)
            t(nI + 1) = nBuffer
        End If
    Next nI
    ' Alla fine della serie di confronti
    ' se non ho operato alcuno scambio
    ' la tabella č ordinata
    If nScambi = 0 Then Exit Do
' altrimenti ricomincio
Loop
' Output del risultato
For nI = 1 To UBound(t)
    List2.AddItem t(nI)
Next nI
End Sub
Ciao, Vito
-- 
Posted from 
smtp3.libero.it
 [193.70.192.53] 


 via Mailgate.ORG Server - 
http://www.Mailgate.ORG
Quello che si chiama BubbleSort, per intenderci... :-)
Bye.

Ciao, Giorgio
la precisazione giunge gradita .
Grazie.
Bye
-- 
Posted from 
smtp2.libero.it
 [193.70.192.52] 
