Newsgroup: it.comp.lang.visual-basic
Titolo: Ordinare un file txt....................................

Mi servirebbe un algoritmo per ordinare alfabeticamente un file di testo
contenete una lista di parole (una per riga) e possibilmente che elimini le
parole uguali.
Qualcuno mi puņ aiutare?
saluti e grazie
ps ho gią cercato sul sito comune


Basta un qualsiasi libro di principi di programmazione. Li' trovi tutti gli
algoritmi di ordinamento che vuoi.
Ciao
Aldo


Dipende da quante parole hai.
Se sono poche puoi caricarle in memoria, eseguire un semplice ordinamento in
ram,
ad esempio il bubble sort (il primo che mi viene in mente) e poi fare uno
scan
per eliminare le parole doppie,
oppure se le parole sono tante puoi creare un database temporaneo e creare
poi l'indice.
Ciao
Sirjo


Come ti ha suggerito Sirjo prova il Bubble Sort, che è un algoritmo di
ordinamento molto
elegante e veloce. Il principio è molto semplice.   Parti da una array di
stringhe t()
contenente le parole prelevate dal tuo file testo t() .
' 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
Per eliminare i doppioni potresti utilizzare un secondo array t1() e
procedere in questo modo :
    Elemento = ""
    Indice = 0
    ' Scan di tutti gli elementi dell'array originale
    For nI = 1 To UBound(t)
       If Elemento <> t(nI) then
            ' Se il precedente è diverso dal seguente
            ' aggiungo l'elemento all'array finale
             Indice = Indice + 1
             Elemento = t(nI)
             t1(Indice) = Elemento
       Endif
    Next nI
End Sub
Ciao, Vito
-- 
Posted from 
smtp1.libero.it
 [193.70.192.51] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG


Oppure puoi fare in modo piu' veloce usando un secondo array fatto di
boolean true: se un elemento del primo array e' uguale a quello precedente
poni a false il valore dell'indice relativo.
Alla fine salvi il file usando solo gli elementi del primo array per cui il
valore del secondo e' true.
Questo metodo e' meno consigliabile se con l'array devi farci dei lavori in
memoria e non solo salvarlo: in questo caso e' meglio il metodo suggerito da
vito (porta via piu' tempo all'inizio ma lo recuperi poi).
Ciaotutti,
Alesandro

 stack overflow.
Una implementazione in VB del QuickSort lo trovate sul Sito Comune sezione
FAQ/Prime piccole perle.
http://www.murialdo.i/it_lang_vb
Ciao
Ettore Maronese
il mes
http://www.maronese.com/mes

 elegante e veloce. Il principio è molto semplice.   Parti da una array di
BubbleSort veloce?
Non direi. Tempo fa avevo fatto un programma per testare la velocità di vari
algoritmi di ordinamento.
La tabella mostra il tempo in secondi e centesimi per ordinare un vetore di
5000 elementi random, ordinati inversamente e ordinati.
Se ho tempo converto il programma in VB e lo mando al SC.
InsertionSort            02,63     05,27     00,00
BinaryInsertionSort 01,43     02,80     00,06
SelectionSort          01,70     03,07     01,65
BubbleSort              06,32     09,34     03,29
BubbleSort ver. 2    06,15     09,18     00,00
ShakeSort               05,82     10,60     00,00
ShellSort                  00,44     00,72     00,05
HeapSort                 00,00     00,06     00,00
QuickSort ricorsivo 00,05     00,06     00,00
QuickSort iterativo  00,05     00,06     00,00
MergeSort               00,06     00,11     00,05
P.S. La tabella è indicativa per confrontare i "lenti" (i primi 6) con
quelli "veloci", non per confrontare i veloci fra di loro.

Se ho tempo converto il programma in VB e lo mando al SC.
innanzitutto, buongiorno. Hai postato una interessante tabellina di
comparazione. Questi tempi
mi sono noti da più di dieci anni (Il programma che tu devi convertire e che
hai scritto era incluso
nei samples del Turbo Basic 1.0 della Borland, società gloriosa che
ultimamente è diventata Inprise,
se non sbaglio, insieme a quello della Torre di Hanoi ed altri. Lo stesso
programma lo ritrovai nei
samples a corredo di altri prodotti, tra cui il glorioso Microsoft Basic
Compiler 3.0 per DOS).
Vorrei precisare che :
1) I tempi riportati non si riferiscono a prove in ambiente 32 bit.
2) I suddetti tempi erano comprensivi della visualizzazione grafica
3) I valori da ordinare erano di tipo intero, non stringhe a lunghezza
variabile.
Ovviamente, queste considerazioni valgono per tutti i metodi. Comunque con i
moderni processori
i tempi si sono notevolmente appiattiti e le differenze non sono più
percepibili ma rientrano un una
unica fascia prestazionale.
Ho definito il metodo BubbleSort veloce. Non il più veloce. E' sicuramente
molto semplice, in termini di
implementazione e di algoritmo. E' pulito e richiede, vedi i post correlati,
limitate risorse di sistema.
Nella programmazione odierna tali metodi sono in disuso perchè, e questo
argomento è stato discusso
nei giorni scorsi sul NG, ormai ci sono innumerevoli sistemi "sporchi" per
ottenere lo stesso risultato.
Per esempio se carichi una listbox con i valori del file txt e poi applichi
la proprietà .Sort, ottieni lo
"stesso" risultato.
Ciao, Vito
-- 
Posted from 
smtp4.libero.it
 [193.70.192.54] 


 Ciao, Vito
Beh in realta' stai usando un oggetto ed un suo metodo per eseguire un
lavoro...
Il lato negativo della cosa e' che l'oggetto e' grafico, se non fosse per
quello non sarebbe diverso dall'usare ADO per accedere a un DB in testo tab
delimited anziche' parsarsi il file con un ciclo di Line Input...
Ciaotutti,
Alessandro


Ciao

Ciao, Samuele
la gente, sul NG, vuole idee, spunti, soluzioni, esempi, codice non
solo opinioni e pareri. 
Tra parentesi,  che ne dici di questo "relitto", affondato nel 1988 ?
E' un reperto archeologico nell'antico linguaggio Pascal,  
{ Copyright (c) 1985, 88 by Borland International, Inc. }
program qsort;
{$R-,S-}
uses Crt;
{ This program demonstrates the quicksort algorithm, which      }
{ provides an extremely efficient method of sorting arrays in   }
{ memory. The program generates a list of 1000 random numbers   }
{ between 0 and 29999, and then sorts them using the QUICKSORT  }
{ procedure. Finally, the sorted list is output on the screen.  }
{ Note that stack and range checks are turned off (through the  }
{ compiler directive above) to optimize execution speed.        }
const
  max = 1000;
type
  list = array[1..max] of integer;
var
  data: list;
  i: integer;
{ QUICKSORT sorts elements in the array A with indices between  }
{ LO and HI (both inclusive). Note that the QUICKSORT proce-    }
{ dure provides only an "interface" to the program. The actual  }
{ processing takes place in the SORT procedure, which executes  }
{ itself recursively.                                           }
procedure quicksort(var a: list; Lo,Hi: integer);
procedure sort(l,r: integer);
var
  i,j,x,y: integer;
begin
  i:=l; j:=r; x:=a[(l+r) DIV 2];
  repeat
    while a[i]<x do i:=i+1;
    while x<a[j] do j:=j-1;
    if i<=j then
    begin
      y:=a[i]; a[i]:=a[j]; a[j]:=y;
      i:=i+1; j:=j-1;
    end;
  until i>j;
  if l<j then sort(l,j);
  if i<r then sort(i,r);
end;
begin {quicksort};
  sort(Lo,Hi);
end;
begin {qsort}
  Write('Now generating 1000 random numbers...');
  Randomize;
  for i:=1 to max do data[i]:=Random(30000);
  Writeln;
  Write('Now sorting random numbers...');
  quicksort(data,1,max);
  Writeln;
  for i:=1 to 1000 do Write(data[i]:8);
end.


 E' un reperto archeologico nell'antico linguaggio Pascal,
Già lo conosco.
Ciao.