Newsgroup: it.comp.lang.c
Titolo: Alberi binari

Salve a tutti.
Sto cercando di capire come funzionano gli alberi binari, in particolare
devo inserire in uno di questi i campi (3 per riga) che vengono letti da un
file di testo. I campi sono separati da un ";".
Utilizzando l'albero devo poi stampare l'output ordinato per il terzo campo
(che è il CAP) utilizzando il metodo INORDER.
Grazie per le eventuali "dritte".
--
_________________
    - Marco Coltri -
_________________

(che č il CAP) utilizzando il metodo INORDER.
Attento che non ho compilato :
#include <stdio.h>
#include <stdlib.h>
typedef struct _nodo {  
                        int dato ; 
                        struct _nodo *sx ;
                        struct _nodo *dx ;
                     } nodo ; 
typedef nodo * ptr_nodo ;
void inserisciNodo( ptr_nodo *P, int x )
{
     if ( *P == NULL ) 
     {
        *P = malloc( sizeof **P ) ;
        (*P)->dato = x ;
        (*P)->sx = (*P)->dx = NULL ;
     }
     else
     if ( x < (*P)->dato )
        inserisciNodo( &(*P)->sx, x ) ;
     else
        inserisciNodo( &(*P)->dx, x ) ;
}
void scriviInOrdine( ptr_nodo P ) 
{
     if ( P != NULL ) 
     {
        scriviInOrdine( P->sx ) ;
        printf( "%d ", P->dato ) ;
        scriviInOrdine( P->dx ) ;
     } else printf( "\n" ) ;
}
main()
{
    ptr_nodo Radice = NULL ;
    inserisciNodo( &Radice, 5 ) ;
    inserisciNodo( &Radice, 2 ) ;
    inserisciNodo( &Radice, -5 ) ;
    inserisciNodo( &Radice, 3 ) ;
    inserisciNodo( &Radice, -7 ) ; 
    scriviInOrdine( Radice ) ;
}         

di tasti tipo control C ,control X,... ?
purtroppo in maniera standard non si puo'.
Dovresti controllare le funzioni che ti mette a disposizione il tuo
compilatore.

 Forse per qualcuno sarа ovvio...
No, non и cosм ovvio
Tutti sanno che i caratteri di controllo sono caratteri ASCII, CTRL-A ha
ASCII code 1 e gli altri a seguire. Quindi sono char come gli altri.
Mentre rilevare direttamente le pressioni dei tasti non produce
certamente codice portabile, leggere dei chars ovviamente sм. Questa и
la buona notizia.
La cattiva notizia и che si chiamano caratteri di controllo perchи
spesso, ma non sempre, il sistema interpreta tali caratteri e reagisce.
A seconda delle situazioni, un CTRL puт segnare la fine di un file, di
una linea o di un campo, produrre un avvertimento acustico,
interrompere, con diverse varianti, l'esecuzione di un programma, e
altro ancora.
Questo и il tuo problema. Devi vedere in quale situazione specifica sei,
quali caratteri di controllo giungono fino al tuo programma e quali
vengono interpretati prima dall'ambiente di esecuzione e dal sistema in
generale. Quindi il risultato alla fine non potrа essere veramente
portabile.
Il comportamento alla pressione del CTRL-C и un buon esempio di tutto
ciт: se lanciamo un programma dalla shell di un buon vecchio DOS, и
possibile interromperne l'esecuzione col CTRL-C se la cosa и prevista
nel codice o nei flag di compilazione. Un programma lanciato da una
qualunque shell in ambiente Un*x sarа interrompibile da chi lo ha
lanciato, tramite un CTRL (magari diverso da C), purchи il programma
stesso non imposti determinati settaggi del terminale o non si svincoli
da esso.
In entrambi gli ambienti, se il programma и interrompibile con un
CTRL-??, esso non potrа leggere da tastiera il CTRL-??. Questo и il
nocciolo della questione. Da un file su disco sм, per esempio.
Il problema in realtа ha anche trattazioni teoriche (alfabeti di
macchina) che non и il caso  di tirare fuori qui. Mi sono reso conto di
aver scritto tantissimo e me ne scuso. Se devi semplicemente ripetere un
input da tastiera e permettere all'utente di uscire dal ciclo premendo
un tasto speciale, perchи non consideri di usare un valore prefissato
non accettabile come input? Voglio dire che se l'utente deve inserire
delle stringhe, per esempio, potresti far terminare il loop qualora
inserisca soltanto un . eppoi prema Invio, supponendo che la stringa "."
non sia accettabile come input dal programma. Analogamente se si tratta
di numeri.
ciao.

Preso dalla documentazione di Linux -KDE
/******************************************************************
 *
 * Purpose: Program to demonstrate the use of ^ (XOR).
 * Date:    03-Dec-96
 * Author:  M J Leslie.
 * Descrip: The contents of two variables are swapped without
 *          the use of a temorary variable  
 *
 ******************************************************************/
#include <stdio.h>
main()
{
  int    	One = 20;
  int		Two = 12;
  printf("One = %d Two = %d\n", One, Two);
  One ^= Two;
  Two ^= One;
  One ^= Two;
  printf("One = %d Two = %d\n", One, Two);
}

  One ^= Two;
Dato che l'operazione di XOR e' cosi' definita :
A B   A xor B
-------------
0 0   0
0 1   1
1 0   1
1 1   0
Se One vale 20 in binario ha valore 00010100
Se Two vale 12 in binario ha valore 00001100
La prima espressione significa One = One ^ Two 
e quindi 
00010100 xor
00001100 =
--------
00011000 (nuovo valore di One)
La seconda espressione significa Two = Two ^ One
e quindi
00001100 xor
00011000 =
--------
00010100 (nuovo valore di Two)
La terza espressione ripete la prima e quindi :
00011000 xor
00010100 =
--------
00001100 (nuovo valore di One)
Come vedi adesso One vale 00001100 e 
                 Two vale 00010100
ovvero i valori sono stati scambiati.
Questo metodo di scambiare i valori interi NON e' portabile ed e' poco
chiaro : utilizza una variabile intermedia.
--
Andrea Laforgia (
andrea_...@bigfoot.com
)
"There is nothing better for understanding a kangaroo than seeing it jump."
[D.Grune, C.J.H. Jacobs]

 chiaro : utilizza una variabile intermedia.
E se non mi sbaglio e' pure coperto da copyright...
Cmq, perche' non e' portabile?
--
 Ciao, Luca.
 Reply to 
luca....@tiscalinet.it

Cmq, perche' non e' portabile?
La spiegazione (non la ricordo) c'e' sulle FAQ di comp.lang.c.
--
Andrea Laforgia (
andrea_...@bigfoot.com
)
-----------------------------------------------------------------------
