16. Se citeste de la intrare un sir de valori numerice intregi, pe
o linie, separate de spatii, sir care se incheie cu o valoare 0.
      a) Sa se introduca valorile citite intr-un arbore binar de
					cautare (exclusiv valoarea 0 care incheie sirul).
			b) Sa se afiseze in inordine continutul arborelui
			c) Se citeste o valoare pentru care sa se raspunda daca este
					sau nu continuta in arbore.
      d) Sa se determine daca arborele binar de cautare creat este
					echilibrat.

EXEMPLU:
      Pentru arborele binar de cautare:

                                5
                               / \
                             3     7
                                  /  
                                 6

      Exemplu de rulare:

            Introduceti valorile:5 3 7 6 0
            Arborele: 3 6 7 5 
            Valoarea cautata:7
            ESTE
            Este echilibrat!       


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





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

#include "arbore.h"

void InitArbore(Nod*& rad)
{
	rad = NULL;
}

void CreareArbore(Nod*& rad)
{
	int nr = 0;
	char c;
	printf("Introduceti sirul : ");
	while( (c=getchar()) != '\n' )
	{
		if ( c >= '0' && c <= '9')
	nr = nr*10+c-'0';
		else
			 if ( c != '0' )
			 {
				 Insert(rad,nr);
				 nr = 0;
			 }
	}
}

void Insert(Nod*& rad,int nr)
{
	if ( rad == NULL )
		 rad = make_nod(nr);
	else
	{
		if ( rad->data < nr )
			Insert(rad->drt,nr);
		else
			Insert(rad->stg,nr);
  }
}

Nod* make_nod(int val)

{
	Nod* p;
	p = new Nod;
	p->data = val;
	p->stg = NULL;
	p->drt = NULL;

	return p;
}


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

int Cauta(Nod* rad,int val)
{
	int n;
	if ( rad != NULL )
	{
		if ( rad -> data == val )
			n = 0;
		else
		{
			n = -1;
			if ( rad->stg != NULL && n != 0) n = Cauta(rad->stg,val);
			if ( rad->drt != NULL && n != 0) n = Cauta(rad->drt,val);
		}
	}
	return n;
}

void CautaVal(Nod* rad)
{
	int val;
	printf("\nValoarea cautata : ");
	scanf("%d",&val);
	if ( Cauta(rad,val) == 0 )
		printf("ESTE !\n");
	else
		printf("NU ESTE !\a\n");

}

int Adincime(Nod* rad)
{
	int s,d;


	if ( rad == NULL )
		return 0;
	else
		if ( (s=Adincime(rad->stg)) > (d=Adincime(rad->drt)) )
			return s+1;
		else
			return d+1;
}

int Echilibrat(Nod* rad)
{
	int s,d,cond=0;
	if ( rad != NULL && cond == 0)
	{
		s = Adincime(rad->stg);
		d = Adincime(rad->drt);
		if ( s == d || s == d+1 || s == d-1 || d == s+1 || d == s-1 )
			cond = 0;
		else
			cond = -1;
	}
		if (rad->stg != NULL && cond == 0 ) cond = Echilibrat(rad->stg);
		if (rad->drt != NULL && cond == 0 ) cond = Echilibrat(rad->drt);

	return cond;
}



#ifndef _ARBORE_
#define _ARBORE_

struct Nod
{
	int data;
	Nod* stg;
	Nod* drt;
};

void InitArbore(Nod*& );
void CreareArbore(Nod*& );
void AfisInordine(Nod* );
void Insert(Nod*& rad,int nr);
Nod* make_nod(int val);
void CautaVal(Nod* );
int Cauta(Nod* ,int );
int Echilibrat(Nod* );
int Adincime(Nod* rad);

#endif



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

void main()
{
	Nod* rad;

	clrscr();
	InitArbore(rad);
	CreareArbore(rad);
	printf("\nArborele introdus : ");
	AfisInordine(rad);
	CautaVal(rad);
	if ( Echilibrat(rad) == 0 )
		printf("Este echilibrat");
	else
		printf("NU este echilibrat\a");

	getch();
}