8. Fisierul ARBOREB.H (interfata moduluilui ARBOREB.CPP) contine:

/****************************************************************
                      Fisierul ARBOREB.H
*****************************************************************/

struct Nod{
	   char data;
	   Nod* stg, *drt;
	   };

Nod* creareArbore();


Functia creareArbore() creeaza o un arbore binar si intoarce un 
pointer la aceasta. Arborele este creat pornind de la o descriere 
cu paranteze introdusa de la tastatura, de forma indicata 
de urmatoarele diagrame de sintaxa:

                                 ÉÍÍÍ» 
       ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĶ - ÇÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
       ³                         ÈÍÍͼ                         ³
 Arbore³ ÚÄÄÄÄÄÄ¿                                              ³
  ÄÄįÄÁÄ´ Nume ÃÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄįÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÂÁ¯Ä
         ÀÄÄÄÄÄÄÙ ³                                           ³
                  ³ ÉÍÍÍ» ÚÄÄÄÄÄÄÄÄ¿                    ÉÍÍÍ» ³
                  À¯¶ ( ÇÄ´ Arbore ÃÂÄÄÄÄÄÄÄįÄÄÄÄÄÄÄÄÂĶ ) ǯÙ
                    ÈÍÍͼ ÀÄÄÄÄÄÄÄÄÙ³ ÉÍÍÍ» ÚÄÄÄÄÄÄÄÄ¿³ ÈÍÍͼ
                                    À¯¶ , ÇÄ´ Arbore ÃÙ   
                                      ÈÍÍͼ ÀÄÄÄÄÄÄÄÄÙ

Arborele vid este reprezentat prin caracterul -. 
De exemplu:
Arborele:       A      va fi dat sub forma:
               / \
              B   C         A(B,C)

Arborele:        A          va fi dat sub forma:      
                / \               
              B    C        A(B(D),C(-,E))
             /       \      sau
            D         E     A(B(D,-),C(-,E))

Spatiile inserate in sirul de caractere introdus de la tastatura
sint ignorate. 

Se cere:
     a) Sa se afiseze in inordine continutul unui arbore obtinut
     printr-un apel la functia creareArbore.
     b) Sa se construiasca structurile de date si functiile care
     definesc o coada ordonata in care sa poata fi memorati 
     "pointeri la nod" (Tipul Atom va fi echivalent cu Nod*). 
     c) Utilizind coada definita la punctul (b) sa se afiseze pe
     nivele continutul arborelui obtinut prin apelul la functia
     creareArbore.


EXEMPLU DE RULARE:
     Introduceti arborele:  A(B(D),C(-,E))
     Arborele parcurs in inordine: D B A C E
     Arborele parcurs pe nivele: A B C D E


=====================================================


#include <alloc.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include "arboreb.h"
#include "coada1.cpp"

void eroare();
char readchar();
char citesteNume();
Nod* citesteArbore();
Nod* creareArbore();

char car;

void eroare()
{
     printf("Sirul de intrare este eronat!\n");
     printf("Apasati tasta o tasta...");
     getch();
     exit(1);
}

char readchar()
{
     char c;
     do  c=getchar();  while(c==' ');
     return c;
}

char citesteNume()
{
     char c;
     if(!isalpha(car)) eroare();
     c = car;
     car = readchar();
     return c;
}

Nod* citesteArbore()
{
     Nod* rad;
     if( car=='-' )  {
		     rad=0;
		     car = readchar();
		     }
     else {
	  rad = (Nod*) malloc(sizeof(Nod));
	  rad->data = citesteNume();
	  if( car!='(' )  {
			 rad->stg = 0;
			 rad->drt = 0;
			 }
	  else {
	       car = readchar();
	       rad->stg = citesteArbore();
	       if( car!=',' )    rad->drt = 0;
	       else {
		    car = readchar();
		    rad->drt = citesteArbore();
		    }
	       if( car!=')' )  eroare();
	       car = readchar();
	       }
	  }
     return rad;
}

Nod* creareArbore()
{
     printf("\nIntroduceti arborele:");
     car = readchar();
     return citesteArbore();
}

void afisinordine(Nod *&c)
{
  Nod *cap;
  cap=c;
  if(c!=0)
   {
     afisinordine(cap->stg);
     printf(" %c",cap->data);
     afisinordine(cap->drt);
    }
}

void nivel(Nod*& rad)
{
  Coada q;
  Nod* s;
  init(q);
  insert(q,rad);
  while(!isEmpty(q)){
		      s=get(q);
		      printf("%c",s->data);
		      if(s->stg)
		      insert(q,s->stg);
		      if(s->drt)
		       insert(q,s->drt);
		       }
	       }


*/ arbore.h
struct Nod{
	   char data;
	   Nod* stg, *drt;
	   };

Nod* creareArbore();
void afisinordine(Nod *&c);

*/


#include <stdio.h>
#include <conio.h>

struct Element {
		 Nod* adr;
		 Element* urm;
		 };
typedef Element* Coada;

void init(Coada& q)
{
  q=0;
  }
void insert(Coada& q,Nod*& e)
{
   Element* p=new Element;
   Element* r;
   p->urm=0;
   p->adr=e;
   if(q==0){
	    q=p;
	    return;
	    }
    r=q;
    while(r->link)
      r=r->link;
    r->link=p;
    }
Nod* get(Coada& q)
{
  Element* e;
  e=q;
  delete q;
  q=e->urm;
  return e->adr;
  }
int isEmpty(Queue& q)
{
  return q==0;
  }

*/

#include<stdio.h>
#include<conio.h>

struct Element{
		Nod *adr;
		Element *link;
		};

Element* creareCoada();
void insert(Element*& cap,Nod*& d);
void parcurgere(Nod *&n,Element *&e);
void afisare(Element *&cap);

Element* creareCoada()
{
  Element *c;
  c=new Element;
  c->link=0;
  return c;
}
void insert(Element*& cap,Nod*& d)
{
  Element *p,*q;
  Nod *n;
  q=new Element;
  q->link=0;
  q->adr=d;
  p=cap;
coada  while(p->link!=0)
       p=p->link;
  p->link=q;
}
 void parcurgere(Nod *&n,Element *&e)
 {
  Nod *p,*q;
  e->adr=n;
  p=n->stg;
  q=n->drt;
  if(p!=0)
     insert(e,p);
  if(q!=0)
     insert(e,q);
  while(e->link!=0)
     {
      e=e->link;
      p=e->adr->stg;
      q=e->adr->drt;
      if(p!=0)
	  insert(e,p);
      if(q!=0)
	  insert(e,q);
      }
 }

void afisare(Element *&cap)
{
 Element *c;
 c=cap;
 while(c!=0)
   {
     printf(" %c",c->adr->data);
     c=c->link;
    }
}





#include<stdio.h>
#include<conio.h>
#include"arboreb.cpp"


void main(void)
{
 Nod *r;
 Element *c,*q;
 clrscr();
 r=creareArbore();
 c=creareCoada();
 q=c;
 printf("\n arborele parcurs in inordine :");
 afisinordine(r);
 parcurgere(r,q);
 printf("\n afisare pe nivele :");
 afisare(c);
 getch();
 }