Newsgroup: it.comp.lang.visual-basic
Titolo: ORDINARE UNA SEQUENZA DI NUMERI

Qualcuno può darmi il codice per ordinare in senso decrescente una serie di
numeri?
Grazie e scusate la banalità della richiesta.
Andrea
--
file...@tin.it

...


...


Il più veloce è il classico QuickSort recursivo:
Public Sub QuickSortNumbers(iArray() As Long, l&, r&)
    Dim i&, j&
    Dim X
    Dim Y
    ' iArray() The iArray to sort
    ' l& First element of iArray to start sort
    ' r& Last element of iArray to start sort
 
    i& = l&
    j& = r&
    X = iArray((l& + r&) / 2)
    While (i& <= j&)
        While (iArray(i&) < X And i& < r&)
            i& = i& + 1
        Wend
        While (X < iArray(j&) And j& > l&)
            j& = j& - 1
        Wend
        If (i& <= j&) Then
            Y = iArray(i&)
            iArray(i&) = iArray(j&)
            iArray(j&) = Y
            i& = i& + 1
            j& = j& - 1
        End If
    Wend
    If (l& < j&) Then QuickSortNumbers iArray, l&, j&
    If (i& < r&) Then QuickSortNumbers iArray, i&, r&
End Sub
Ciao
Igor
-----------------------------------------------------------
"We are such stuff as dream are made on"
William Shakespeare, "The Tempest"
-----------------------------------------------------------
Email: 
igor.ba...@imola.nettuno.it

ok
Num=10
Dim Numero(num)
for a=1 to 10
    for b=1 to num-1
        if numero(b)>numero(b+1) then
                k1=numero(b)
                k2=numero(b+1)
            numero(b)=k2
            numero(b+1)=k1
                    endif
                        next b
                            next a
questo in VB il modo più veloce
se vuoi ordinarli in senso crescente cambi > in < cioè maggior in minore
piccola citazione
in QB c'era la cara vecchia SWAP
per cui al posto di quel ciclo If Then bastava ques'unica istruzione
        if numero(b)>numero(b+1) then Swap numero(b), numero(b+1)
ehehehe
gallina vecchia fa sempre buon brodo
ciao Davide

Mi sono accorto di essermi spiegato male. Per farmi perdonare ti mando il
mio sorgente. Dovrai adattarlo al tuo contesto, ma ti garantisco che
funziona.
La ShakeSort ha prestazioni leggermente superiori alla BubbleSort, ma
entrambe non possono competere col QuickSort (proposto da Igor).
Quest'ultimo ha pero` il suo tallone di achille sulla determinazione del
valore mediano di ogni partizione. Nel caso peggiore, ovvero il valore
uguale o vicino agli estremi, le sue prestazioni sono alquanto deludenti. Lo
si puo` raffinare con una routine apposita per evitare il problema. Ma e`
una questione di ... fortuna.
Public Sub BubbleSort()
    Dim i As Integer
    Dim j As Integer
    Dim lElem As typeElem
    Dim bChange As Boolean
    Dim iFirstChange As Integer
    Dim iLastChange As Integer
    iFirstChange = 0
    iLastChange = m_iElemCount - 2
    If m_iElemCount > 1 Then
        For i = iFirstChange To iLastChange
            bChange = False
            For j = iLastChange To iFirstChange Step -1
                If m_tElemArray(j).lValue > m_tElemArray(j + 1).lValue Then
                    lElem = m_tElemArray(j)
                    m_tElemArray(j) = m_tElemArray(j + 1)
                    m_tElemArray(j + 1) = lElem
                    iFirstChange = j
                    bChange = True
                End If
            Next
            If bChange = False Then Exit For
        Next
    End If
End Sub
Public Sub ShakeSort()
    Dim i As Integer
    Dim j As Integer
    Dim lElem As typeElem
    Dim bChange As Boolean
    Dim iFirstChange As Integer
    Dim iLastChange As Integer
    iFirstChange = 0
    iLastChange = m_iElemCount - 2
    If m_iElemCount > 1 Then
        For i = iFirstChange To iLastChange
            bChange = False
            For j = iLastChange To iFirstChange Step -1
                If m_tElemArray(j).lValue > m_tElemArray(j + 1).lValue Then
                    lElem = m_tElemArray(j)
                    m_tElemArray(j) = m_tElemArray(j + 1)
                    m_tElemArray(j + 1) = lElem
                    iFirstChange = j
                    bChange = True
                End If
            Next
            If bChange = False Then Exit For
            For j = iFirstChange To iLastChange
                If m_tElemArray(j).lValue > m_tElemArray(j + 1).lValue Then
                    lElem = m_tElemArray(j)
                    m_tElemArray(j) = m_tElemArray(j + 1)
                    m_tElemArray(j + 1) = lElem
                    iLastChange = j
                    bChange = True
                End If
            Next
            If bChange = False Then Exit For
        Next
    End If
End Sub


Ammesso che i numeri siano "n" e memorizzati in un vettore "a" di tipo Long
cont = 0
Do
    If (a(cont) < a(cont + 1)) Or (a(cont) = a(cont + 1)) Then
    'If Not a(cont) > a(cont + 1) Then	'E' uguale all'istruzione precedente
        cont = cont + 1
    Else
        temp = a(cont)
        a(cont) = a(cont + 1)
        a(cont + 1) = temp
        cont = 0
    End If
Loop Until cont = n - 1
Questo algoritmo ti ritorna "a" ordinato in modo crescente
Oppure puoi fare così, dove però viene generato un vettore "b" con i valori di "a" ordinati:
    Dim b(n - 1) As Long
    Minimo = a(0)
    Massimo = a(0)
    indice = 0
 
    For x = 0 To n - 1
        If a(x) > Massimo Then
            Massimo = a(x)
        End If
    Next x
 
For cont = 0 To n - 1
    For x = 0 To n - 1
        If a(x) < Minimo Then
            Minimo = a(x)
            indice = x
        End If
    Next x
    b(cont) = Minimo
    Minimo = Massimo
    a(indice) = Massimo
Next cont
Oppure, ancora, un trucchetto, meno veloce, più pesante, ma piuttosto bastardo:
carichi gli elementi non ordinati in una listbox con la proprietà "Sorted=true" e poi la ricarichi in un vettore......
;-)) Non l'ho provato, ma dovrebbe andare....
Ciao,
Moreno
#sirri#@
tin.it
(togliete "#" dall'indirizzo)
---------------------------------------------------------------------------
Le risposte alle tue domande le trovi sul Sito Comune di questo NewsGroup:
 
http://www.murialdo.it/it_lang_vb
---------------------------------------------------------------------------

Grazie e scusate la banalità della richiesta.
Premetto che l'algoritmo non è il mio comunque:
scorri tutti i numeri da ordinare .. e riempi un vettore dimensionato
come il numero massimo possibile con tutti zero.
Quando trovi un numero da ordinare incrementa il valore del vettore
puntato da quel numero di uno, alla fine .. scorri il vettore .. se
trovi zero non scrivi nulla, se trovi qualcosa tipo N>0 scrivi N volte
il numero indice del vettore.
Per l'ordinamento decrescente devi scorrere il vettore al contrario
Mi sa che è l'algoritmo più veloce in assoluto, perchè in realtà non
ordina un bel niente =))
Wolf che il copyright è di Master/Parsifal =)
"Lo stress è quell'apostrofo grigio tra le parole...M'INCAZZO"
[Remove numbers for correct e-mail address]
"Tariffe a tempo sviluppano pensieri a breve termine"
(Nicholas Negroponte contro la TUT)
Visitate e supportate: --> 
www.notut.org
 <---

Wolf anche tu qui !!
ciao
Davide
NB
mancano solo Veneziani e Pulvirenti :-))

mancano solo Veneziani e Pulvirenti :-))
Pulvirenti ok, ma Claudio non credo che si interessi al VB
Wolf che IHL rulez !! =)))
