Newsgroup: it.comp.lang.visual-basic
Titolo: Ordinare stringhe

Qual'è il metodoto più veloce per ordinare delle stringhe contenute in un
array?
Tenete presente che devo ordinare circa 400 stringhe e che questa operazione
deve girare su un 386 cin windows 3.1 e un prg fatto in vb 1.0 per Windows!
Grazie!
Andrea
anfa...@tin.it


penso che nella tua "magra" situazione il quick sort e' l'unica alternativa.
Fai una ricerca in rete dovresti trovarlo facilmente l'algoritmo.
Ciao
Ven.

...

Ho trovato in rete quello che hai detto ma purtroppo credo che sia in
liguaggio C e non ci ho capito nulla! C'è qualcuno che mi puo dare una mano?
Grazie
Andrea


Posta e te la converto
Marco

/* * @(#)QSortAlgorithm.java 1.6f 95/01/31 James Gosling *
 * Copyright (c) 1994-1995 Sun Microsystems, Inc. All Rights Reserved. *
 * Permission to use, copy, modify, and distribute this software
 * and its documentation for NON-COMMERCIAL or COMMERCIAL purposes and
 * without fee is hereby granted.
 * Please refer to the file 
http://java.sun.com/copy_trademarks.html
 * for further important copyright and trademark information and to
 * 
http://java.sun.com/licensing.html
 for further important licensing
 * information for the Java (tm) Technology. *
 * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
 * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
 * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
 * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
 * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. *
 * THIS SOFTWARE IS NOT DESIGNED OR INTENDED FOR USE OR RESALE AS ON-LINE
 * CONTROL EQUIPMENT IN HAZARDOUS ENVIRONMENTS REQUIRING FAIL-SAFE
 * PERFORMANCE, SUCH AS IN THE OPERATION OF NUCLEAR FACILITIES, AIRCRAFT
 * NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL, DIRECT LIFE
 * SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH THE FAILURE OF THE
 * SOFTWARE COULD LEAD DIRECTLY TO DEATH, PERSONAL INJURY, OR SEVERE
 * PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH RISK ACTIVITIES").  SUN
 * SPECIFICALLY DISCLAIMS ANY EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR
 * HIGH RISK ACTIVITIES. *//** * A quick sort demonstration algorithm
 * SortAlgorithm.java, Thu Oct 27 10:32:35 1994 * * @author James Gosling
 * @version  1.6f, 31 Jan 1995 *//**
 * 19 Feb 1996: Fixed to avoid infinite loop discoved by Paul Haeberli.
 *              Misbehaviour expressed when the pivot element was not
unique.
 *              -Jason Harrison *
 * 21 Jun 1996: Modified code based on comments from Paul Haeberli, and
 *              Peter Schweizer (
Peter.S...@mni.fh-giessen.de
).
 *              Used Daeron Meyer's (
dae...@geom.umn.edu
) code for the
 *              new pivoting code. - Jason Harrison *
 * 09 Jan 1998: Another set of bug fixes by Thomas Everth
(
eve...@wave.co.nz
)
 *              and John Brzustowski (
jbrz...@gpu.srv.ualberta.ca
). */
class QSortAlgorithm extends SortAlgorithm {
    void sort(int a[], int lo0, int hi0) throws Exception { int lo = lo0;
 int hi = hi0; pause(lo, hi); if (lo >= hi) {     return; }
        else if( lo == hi - 1 ) {            /*
             *  sort a two element list by swapping if necessary
*/
            if (a[lo] > a[hi]) {                int T = a[lo];
                a[lo] = a[hi];                a[hi] = T;            }
            return; }        /*
         *  Pick a pivot and move it out of the way         */
 int pivot = a[(lo + hi) / 2];        a[(lo + hi) / 2] = a[hi];
        a[hi] = pivot;        while( lo < hi ) {            /*
             *  Search forward from a[lo] until an element is found that
             *  is greater than the pivot or lo >= hi              */
            while (a[lo] <= pivot && lo < hi) {  lo++;     }            /*
             *  Search backward from a[hi] until element is found that
             *  is less than the pivot, or hi <= lo              */
     while (pivot <= a[hi] && lo < hi ) {  hi--;     }            /*
             *  Swap elements a[lo] and a[hi]             */
            if( lo < hi ) {                int T = a[lo];
                a[lo] = a[hi];                a[hi] = T;
pause();
            }     if (stopRequested) {                return;            } }
        /*         *  Put the median in the "center" of the list         */
        a[hi0] = a[hi];        a[hi] = pivot;        /*
         *  Recursive calls, elements a[lo0] to a[lo-1] are less than or
         *  equal to pivot, elements a[hi+1] to a[hi0] are greater than
         *  pivot.         */ sort(a, lo0, lo-1); sort(a, hi+1, hi0);    }
    void sort(int a[]) throws Exception { sort(a, 0, a.length-1);    }
Ecco quello che ho trovato!
Grazie tante
Andrea
anfa...@tin.it

Il codice e' Java, non C.
Comunque il codice VB e' il seguente :
Private Sub QuickSort(Array() As String, SortFrom As Integer,_
                      SortTo As Integer)       
        Dim Temp As String
        Dim I As Integer
        Dim J As Integer 
        Dim AtRandom As Integer
        Dim Test As String
        Select Case SortFrom
 
               Case Is >= SortTo
                    Exit Sub
 
               Case Is = SortTo-1
                    If Array(SortFrom) > Array(SortTo) Then
                       Temp = Array(SortFrom)
                       Array(SortFrom) = Array(SortTo) 
                       Array(SortTo) = Temp
                    End If
                    Exit Sub
               Case Else
                    AtRandom = (SortFrom+SortTo)/2
                    Test = Array(AtRandom)
                    Temp = Array(AtRandom)
                    Array(AtRandom) = Array(SortTo)
                    Array(SortTo) = Temp
                    Do
                         For I = SortFrom To SortTo-1
                             If Array(I) > Test Then
                                Exit For
                             End If
                         Next I
                         For J = SortTo To I+1 Step -1
                             If Array(J) < Test Then
                                Exit For
                             End If
                         Next J
                         If I < J Then
                            Temp = Array(I)
                            Array(I) = Array(J)
                            Array(J) = Temp
                         End If
                    Loop Until I >= J
                    Temp = Array(I)
                    Array(I) = Array(SortTo)
                    Array(SortTo) = Temp 
 
                    QuickSort Array(), SortFrom, I-1
                    QuickSort Array(), I+1, SortTo
        End Select
End Sub
Andrea Laforgia        (
andrea_...@bigfoot.com
)
----------------------------------------------------
There is nothing better for understanding a kangaroo
than seeing it jump.
----------------------------------------------------

Dove abito io si dice!
Sei un GRANDE!!!
Grazie per la tua velocita!
--
Andrea
anfa...@tin.it






Si ma tre volte mi sembra un po' troppo
ciao