Newsgroup: it.comp.lang.pascal
Titolo: Ordinare lista di parole

e il tutto lo dovrebbe fare abbastanza velocemente
Nel caso in cui i due file in input non siano ordinati, io utilizzerei due
liste.
Cioè:
1) leggi il file 1 e costruisci la lista ordinata senza ripetizioni delle
parole in esso contenute
2) leggi il file 2 e costruisci la lista ordinata senza ripetizioni delle
parole in esso contenute
3) scandisci le due liste e scrivi il file di output..
3.1) ultimo elemento inserito=""
3.2) leggi l'elemento della lista1 e quello della lista 2
3.3) scegli il minore tra i due elementi
3.4) se l'elemento scelto è diverso dall'ultimo elemento inserito (vedi 3.1)
allora
3.4.1) inseriscilo nell'output (scusa il frasario..)
3.4.2) ricordalo come ultimo elemento inserito
3.5) avanza col puntatore corrispondente alla lista da cui hai scelto
l'elemento minore
3.6) vai al passo 3.2 a meno che non sia terminata almeno una delle due
liste
3.7) se una delle due liste non è vuota copia le parole in essa contenute
nell'output (non ci sono ripetizioni perchè sono state eliminate ai passi 1
e 2)
Credo che sia più difficile da spiegare che da scrivere..
-----
  Alessandro Caproni
 
cap...@cifra.it
 
cap...@cli.di.unipi.it
    home page: 
http://www.cli.di.unipi.it/~caproni/intro.html

sono ben accetti listati completi :P
Io per ora non ho tempo, mi dispiace!
Spero di esserti stato utile, ciao!!!
    Gianfranco
e-mail: 
defe...@hendrix.NOSPAMextero.it
Rimuovere NOSPAM per rispondere
----------------------------------------------------------------------------
                  Non si odia finchč la stima č ancora poca,
                  ma solo quando si stima qualcuno
                  come uguale o superiore
                   Dalla scuola di guerra della vita:
                   quello che non mi ammazza
                   mi rende piů forte.
Nietsche
----------------------------------------------------------------------------

e il tutto lo dovrebbe fare abbastanza velocemente
Devi costruire un albero binario del genere :
type ptr_nodo = ^nodo;
        nodo = record
                        dato : string;
                        sinistra, destra : ptr_nodo;
                     end;
Costruisci due routine, una per l'inserimento ed una per la lettura delle
parole.
Il criterio di inserimento delle parole deve essere il seguente :
if (nodo_da_aggiungere^.dato = nodo_esaminato^.dato) then
begin
    { non faccio nulla }
    { ma se aggiungessi un campo "p : word" al record potrei contare il peso dei
doppioni }
end
else
if (nodo_da_aggiungere^.dato < nodo_esaminato^.dato) then
begin
   aggiungi se possibile il nuovo nodo alla sinistra di nodo_esaminato;
end
else
if (nodo_da_aggiungere^.dato > nodo_esaminato^.dato) then
begin
   aggiungi se possibile il nuovo nodo alla destra di nodo_esaminato;
end
Dopodichè leggi il primo file, ad una ad una aggiungi le parole all'albero
binario.
Leggi il secondo file e fai la stessa cosa.
I doppioni saranno esclusi automaticamente nella procedura di inserimento.
Per la scrittura delle parole in ordine alfabetico ti basterà leggere l'albero e
scrivere le parole ad una ad una con un procedimento del genere :
procedure leggi_albero(nodo : ptr_nodo);
begin
    if (nodo^.sinistra <> nil) then leggi_albero(nodo^.sinistra);
    scrivi nodo^.dato sul nuovo file;
    if (nodo^.destra <> nil) then leggi_albero(nodo^.destra);
end;
Sempre che non abbia sbagliato a considerare gli algoritmi, ma credo di no, il
tutto dovrebbe funzionare abbastanza velocemente.
Andrea Laforgia
----------------------------------------------------------------------
Sto facendo il militare.....vi rispondo tra una o due settimane !!! :)

e il tutto lo dovrebbe fare abbastanza velocemente
Ti illustro la tecnica da usare con un listato :
uses crt;
type  ptr_nodo_albero = ^nodo_albero;
      nodo_albero = record
                      ptr_parola : ^string;
                      peso : word;
                      sinistra, destra : ptr_nodo_albero;
                    end;
procedure inserisci_parola(var nodo : ptr_nodo_albero; parola : string);
var nodo_temp : ptr_nodo_albero;
begin
  new(nodo_temp);
  nodo_temp^.peso := 1;
  nodo_temp^.sinistra := nil;
  nodo_temp^.destra := nil;
  getmem(nodo_temp^.ptr_parola, length(parola)+1);
  nodo_temp^.ptr_parola^ := parola;
  if (nodo = nil) then
    nodo := nodo_temp
  else
  if (nodo^.ptr_parola^ = parola) then
  begin
    freemem(nodo_temp^.ptr_parola, length(parola)+1);
    dispose(nodo_temp);
    inc(nodo^.peso);
  end
  else
  if (nodo^.ptr_parola^ < parola) then
  begin
    if (nodo^.sinistra <> nil) then
       inserisci_parola(nodo^.sinistra, parola)
    else
       nodo^.sinistra := nodo_temp;
  end
  else
  if (nodo^.ptr_parola^ > parola) then
  begin
    if (nodo^.destra <> nil) then
       inserisci_parola(nodo^.destra, parola)
    else
       nodo^.destra := nodo_temp;
  end
end;
procedure scrivi_albero(nodo : ptr_nodo_albero);
begin
  if (nodo^.destra <> nil) then scrivi_albero(nodo^.destra);
  writeln(nodo^.ptr_parola^+' (',nodo^.peso,')');
  if (nodo^.sinistra <> nil) then scrivi_albero(nodo^.sinistra);
end;
var radice : ptr_nodo_albero;
begin
  clrscr;
  radice := nil;
  inserisci_parola(radice, 'armadio');
  inserisci_parola(radice, 'scarpa');
  inserisci_parola(radice, 'imbuto');
  inserisci_parola(radice, 'stuzzicadenti');
  inserisci_parola(radice, 'attaccapanni');
  inserisci_parola(radice, 'imbuto');
  inserisci_parola(radice, 'imbuto');
  inserisci_parola(radice, 'armadio');
  inserisci_parola(radice, 'canneto');
  inserisci_parola(radice, 'uccello');
  inserisci_parola(radice, 'indirizzo');
  inserisci_parola(radice, 'lettera');
  inserisci_parola(radice, 'attaccapanni');
  inserisci_parola(radice, 'asino');
  inserisci_parola(radice, 'cassetto');
  inserisci_parola(radice, 'brocca');
  scrivi_albero(radice);
end.



Poi per riscriverlo fai una bella percorrenza inorder.... mah, per me č
                            ** masochismo puro **
Ciao, Gianfranco
e-mail: 
defe...@hendrix.NOSPAMextero.it
Rimuovere NOSPAM per rispondere
Mi puoi trovare anche su IRCnet
   Nick ---> gagna


                            ** masochismo puro **
Per me no.


Ho dato un'occhiata moooolto veloce al tuo listato e mi è parso un po'
troppo complicato (più che altro lungo) per la reale difficoltà del
problema.
Mia soluzione:
apri il primo file e applichi l'inserimento in ordine in una lista
apri il secondo file e fai anche qui l'inserimento in ordine nella stessa
lista
riscrivi la lista sul file di output
(Esempio di ordinamento crescente) Nella procedura di inserimento se il
nuovo input rispetto all'elemento di confronto della lista è:
- minore passo al confronto con il successivo della lista
- uguale lo scarto e prendo un nuovo elemento dal file, altrimenti aggiungo
un carrello con i dati dell'elemento del file tra il carrello della lista
attualmente puntato ed il precedente e ricomincio.
Visto la manovra di inserimento tra l'attuale ed il precedente potrebbe
essere utile una lista bilinkata, altrimenti si può fare senza ma nei
confronti devi ragionare sempre con il successivo della lista.
Mi aspetto una risposta dal militare, possibilmente con una carica di nomi
oltre alla classica frase "Un bel giorno...".
Au revoir.
Sito: 
http://www.geocities.com/timessquare/chasm/5651
E-Mail: 
bor...@hotmail.com