Newsgroup: it.comp.lang.pascal
Titolo: stampa iterativa

Salve il mio problema è semplice a dirsi ma, a quanto pare meno a farsi:
dovrei stampare un albero con una procedura iterativa, assolutamente senza
fare uso di ricorsione,
sapreste darmi qualche suggerimento??
La struttura dati dell albero è questa:
type albero= ^nodo;
     nodo=record
     val :integer;
     sx,dx:albero;
     end;
Grazie mille

 Grazie mille
Piů che mille da centomila, questa č un bella domanda....
In che ordine la vuoi stampare
        order
        post order
        pre order
Allora se non vuoi ricorrere l'unica cosa che ora come ora mi viene in mente
č l'utilizzo di uno stack
idea č questa :
Order
push(albero->radice)
while stack č pieno
       if albero-sinstro<>Nill then
           albero=albero->sinistro
          push(albero)
      endif
      pop(albero)
      stampa albero;
      if albero->destro <> null
          push(albero->destro);
          albero=albero->destro;
      endif
      pop(albero)
 end
Non ho provato... su carta sembra funzionare....
Ciao RDC
nuovo indirizzo di pascallike : 
www.pascallike.too.it
http://utenti.lycos.it/pascallike

 while stack è pieno


mi si direi che si fa cosi... se metti lo stack ottieni la visita deep-first
(in profondita'), se metti una lista ottieni la breath-first (in ampiezza)
--
Dreadnaut
(Life would be easier if I had the source code)

 destro no.
Mi fai vedere un esempio di uso del codice

 > (in C, scusami se non č l'Ng apposito, ma spero mi perdoniate)



Non è che si capisce tanto come è l'input
Cmq leggendo il tuo codice C hai scritto una cosa diversa dalla mia
io non metto nello stack la chiave ma il nodo dell'albero, se metti solo la
chiave
push(&p,a->chiave) quando fai il pop ti ritorna pop(&p,a) ti ritorna nelle
miglior ipotesi
un nodo  con (info :chiave; dx : NILL, sx:NILL) e quindi una volta andato a
sinistra non può, risalire
prova e fammi sapere
Ciao Re Di Cuori
www.pascallike.too.it
http://utenti.lycos.it/pascallike

 sinistra non puň, risalire


 m,p,v.  /*tralasciando la a*/
Allora c'era un bel errore, ora dovrebbe funzionare, sempre se nello stack
metti l'intero nodo (chave,sx,dx)
Scrivo in pseudocodice
push(albero);   inserisco la radice nello stack
while stack č pieno
    while albero->sinistra <>null
           albero=albero->sinistra;
            push(albero);
    endwhile
    pop(albero);
    stampa(albero->chiave);
    if albero->destro<>null
         push(albero);
    endif
endwhile
Vediamo se ora funge
Ciao Re Di Cuori
P.S.: fammi sapere se funziona cosě inserisco il codice nel sito

Il prog va molto meglio, infatti restituisce l'out sempre ordinato
alfabeticamente,
ma il problema che ti ho illustrato nel post precedente ancora persiste,
spero di non fare erroracci io, la stampa si trova nella pop,
dagli un occhiata, è il codice intero:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct nodialbero{
char chiave[50];
struct nodialbero* sx;
struct nodialbero* dx;
};
typedef struct nodialbero *ALBERO;
struct nodi{
char chiave[50];
struct nodi* next;
struct nodi* sx;
struct nodi* dx;
};
typedef struct nodi *PILA;
void ins_alb(char *word,ALBERO* t)
{ALBERO temp;
if (*t==NULL){
temp=malloc(sizeof(struct nodialbero));
strcpy(temp->chiave,word);
temp->sx=NULL;
temp->dx=NULL;
*t=temp;}
 else if (strcmp((*t)->chiave,word)>0)
  ins_alb(word,&((*t)->sx));
  else ins_alb(word,&((*t)->dx));
}
void push(PILA* p,ALBERO w)
{ PILA temp;
  temp =malloc(sizeof(struct nodi));
  strcpy(temp->chiave,w->chiave);
  temp->sx=w->sx;
  temp->dx=w->dx;
  temp->next = *p;
  *p = temp;
}
void pop(PILA* p)
{ALBERO ris;
  PILA temp=malloc(sizeof(struct nodi));
  if (*p != NULL)
  { temp = *p;
    printf("%s\n",temp->chiave);
    *p = temp->next;
    free(temp);
  }
}
void stampa(PILA p)
{while (p!=NULL)
 {printf("%s\n",p->chiave);
 p=p->next;
 }
}
void mergesort(ALBERO d,PILA p)
{
if (d!=NULL){
 push(&p,d);
 while (p!=NULL){
  while (d->sx!=NULL){
  d=d->sx;
  push(&p,d);
  }
  pop(&p);
  if (d->dx!=NULL){
  d=d->dx;
  push(&p,d);}
      } }
}
main()
{
char *x;
ALBERO a=NULL;
PILA p=NULL;
printf("INSERIRE INTERI\n");
scanf("%s", x);
while(*x!='.'){
ins_alb(x,&a);
scanf("%s", x);}
printf("ALBERO ORDINATO\n");
mergesort(a,p);
}

Scusami ma a sto punto nn sto capendo + niente a te serviva un modo per
scorrere un albero senza ricorsione il codice che ti ho mandato è giusto ?
Che errore ti da ora ?
push(albero);   inserisco la radice nello stack
while stack è pieno
    while albero->sinistra <>null
           albero=albero->sinistra;
            push(albero);
    endwhile
    push(albero);  <---- quando esci da ciclo l'ultimo nodo è una foglia
quindi ha sx,dx a null
                                    e non viene inserito, con questo
inserisce anche il nodo foglia
    pop(albero);
    stampa(albero->chiave);
    if albero->destro<>null
         push(albero);
    endif
endwhile
Ciao ReDiCuori    ... fammi sapere
P.s: lo so che so fiscale ma dato che siamo su it.comp.lang.pascal potresti
postare codice pascal

     push(albero);  <---- quando esci da ciclo l'ultimo nodo č una foglia
