13. 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 preordine nodurile arborelui obtinut
					printr-un apel la functia creareArbore.

		 b) Sa se afiseze frunzele arborelui.

		 c) Sa se determine daca arborele dat este heap.

		 d) Daca arborele dat este heap, sa se afiseze literele
					memorate in nodurile arborelui in ordine descrescatoare (prin
					extrageri repetate din heap).

EXEMPLU DE RULARE:
     Introduceti arborele:  H(B(A),E(-,D))
     Frunzele: A D
     Este heap: TRUE
     Literele ordonate (extrase din heap): H E D B A


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





#include <alloc.h>
#include <conio.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <ctype.h>
#include "arbore.h"

char v[100];
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 AfisPreordine(Nod* rad)
{
	if ( rad != NULL )
	{
		printf("%c ",rad->data);
		if ( rad->stg != NULL ) AfisPreordine(rad->stg);
		if ( rad->drt != NULL ) AfisPreordine(rad->drt);
	}
}

void AfisFrunze(Nod* rad)
{
	if ( rad != NULL )
	{
		if ( rad->stg == NULL && rad->drt ==NULL )
			printf("%c ",rad->data);
		if ( rad->stg != NULL ) AfisFrunze(rad->stg);
		if ( rad->drt != NULL ) AfisFrunze(rad->drt);
	}
}

int DetAHip(Nod* rad)
{
	int test = 1;
	if ( rad != NULL )
	{
		if ( (rad->stg)->data < rad->data && (rad->drt)->data < rad->data )
			test = 1;
		 else
			test = 0;
		if ( rad->stg != NULL && test == 1) test = DetAHip(rad->stg);
		if ( rad->drt != NULL && test == 1) test = DetAHip(rad->drt);
	}
	return test;
}

void Afis(Nod* rad)
{
	int i=0;
	if ( rad != NULL )
	{
		 = rad->data;
		if ( rad->stg != NULL ) v[i++] = Afis(rad->stg);
		if ( rad->drt != NULL ) v[i++] = Afis(rad->drt);
	}
}

void AfisDescrescator(Nod* rad)
{

	int i=0;
	Afis(rad);
	Sort(v,strlen(v));
	for ( i=0;i<strlen(v);i++)
		printf("%c ",v[i]);

}

void Sort(char* v,int n)
{
	int cond,i;
	char t;
	cond = 0;
	while ( cond == 0 )
	{
		cond = 1;
		for ( i=0;i<n;i++)
			if ( v[i] < v[i+1] )
			{
				t = v[i];
				v[i] = v[i+1];
				v[i+1] = t;
				cond = 0;
			}
	}
}




#ifndef _ARBORE_
#define _ARBORE_


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


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

Nod* CreareArbore();
void AfisPreordine(Nod* );
void AfisFrunze(Nod* );
int DetAHip(Nod* );
void AfisDescrescator(Nod* );
void Sort(char* ,int );
void Afis(Nod* );


#endif




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

#include "arbore.cpp"

void main()
{
	Nod* cap;
	clrscr();
	cap = CreareArbore();
	printf("\nARBORELE AFISAT IN PREORDINE ESTE : ");
	AfisPreordine(cap);
	printf("\n\nFRUNZELE ARBORELUI INTRODUS SINT : ");
	AfisFrunze(cap);
	if ( DetAHip(cap) == 1)
		printf("\nARBORELE ESTE HEAP ");
	else
		printf("\nARBORELE NU ESTE HEAP \a");

	if ( DetAHip(cap) == 1)
	{
		printf("\nAFISAREA NODURILOR IN ORDINE DESCRESCATOARE : ");
		AfisDescrescator(cap);
	}

	getch();
}