10. Fisierul GLISTA.H (interfata moduluilui GLISTA.CPP) contine:

/****************************************************************
                      Fisierul GLISTA.H
*****************************************************************/
     typedef char Atom;
     enum { ATOM, LISTA};
     struct GElement;            // declaratie simpla
     typedef GElement* GLista;   // o lista generalizata este un
                                 // pointer la primul element 

     struct GElement{
            char tag;            // eticheta
            union {              // data poate fi
                Atom A;          //      Atom
                GLista L;        //  sau GLista
                } data;
	   GElement* link;        // legatura
           };                               

GLista creareGLista();

Functia creareGLista() creeaza o lista generalizata si intoarce un 
pointer la aceasta. Lista generaliozata este creata pornind de la o 
descriere cu paranteze introdusa de la tastatura, de forma indicata 
de urmatoarele diagrame de sintaxa:
                     ÚÄÄÄÄÄÄÄÄÄÄÄÄįÄÄÄÄÄÄÄÄÄÄÄ¿  
                     ³                         ³  
   Lista     ÉÍÍÍ»   ³       ÚÄÄÄÄÄÄÄÄÄ¿       ³   ÉÍÍÍ»  
   ÄÄÄÄÄÄÄįĶ ( ÇÄÄÄÁÄÄÄÂįĴ Element ÃÄÄÄÂįÄÁÄÄĶ ) ÇÄįÄÄÄ
             ÈÍÍͼ       ³   ÀÄÄÄÄÄÄÄÄÄÙ   ³       ÈÍÍͼ  
                         ³      ÉÍÍÍ»      ³              
                         ÀÄÄÄ®ÄĶ , ÇÄÄÄ®ÄÄÙ         
                    ÚÄÄÄÄÄÄÄÄÄÄ¿ÈÍÍͼ 
              ÚÄįÄÄ´   Atom   ÃÄÄÄÄ¿    
   Element    ³     ÀÄÄÄÄÄÄÄÄÄÄÙ    ³   
   ÄÄÄÄÄÄÄįÄÄ´                     ÃÄÄÄįÄÄÄÄ
              ³     ÚÄÄÄÄÄÄÄÄÄÄ¿    ³   
              ÀÄįÄÄ´   Lista  ÃÄÄÄÄÙ            
                    ÀÄÄÄÄÄÄÄÄÄÄÙ                 
Exemple: (A,(B,C),(D))   - O lista formata dintr-un atom A, o
                         lista cu doua elemente (B,C) si o lista
                         cu un element (D) ;
         ((A,B,C),(),B)  - O lista formata dintr-o lista cu trei
                         elemente (A,B,C), o lista vida () si un
                         atom B .
Spatiile inserate in sirul de caractere introdus de la tastatura
sint ignorate. Se cere:   
     a) Sa se afiseze numarul de atomi din lista citita.
     b) Sa se afiseze lista citita in formatul folosit la intrare
     (cu paranteze).
     c) Definim adincimea listei ca fiind numarul maxim de nivele
     de imbricare (lista in lista).
          De exemplu:
               (A, B)         - are adincimea 1;
               (A, (B,C))     - are adincimea 2;
               ((B, (C,D)),E) - are adincimea 3;
     Sa se afiseze adincimea listei citite.
EXEMPLU DE RULARE:
     Introduceti lista: (F,(T,(C)),(),(D,E))
     Nr. de atomi: 5
     Lista citita: (F,(T,(C)),(),(D,E))
     Adincimea: 3

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


/****************************************************************
                      Fisierul GLISTA.CPP
*****************************************************************/
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <ctype.h>

#include "GLISTA.H"

char crtChar;

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

void readchar()
{
     do crtChar=getchar();
     while(crtChar==' ');
}

char citesteAtom()
{
     char c;
     if(!isalpha(crtChar)) eroare();
     c = crtChar;
     readchar();
     return c;
}

GLista citesteGLista();

GElement* citesteGElement()
{
     GElement* p = new GElement;
     if(crtChar=='(') {
		      p->data.L = citesteGLista();
		      p->tag = LISTA;
		      }
     else {
	  p->data.A = citesteAtom();
		p->tag = ATOM;
		}
		p->link = NULL;
		return p;
}

GLista citesteGLista()
{
		 GElement* cap, *coada, *p;
		 if( crtChar!='(' ) eroare();
		 readchar();
		 if( crtChar==')' )  cap = NULL;
		 else {
		cap = citesteGElement();
		coada = cap;
		while( crtChar==',' ) {
		readchar();
								p = citesteGElement();
								coada->link = p;
								coada = p;
								}
					if( crtChar!=')' ) eroare();
					}
		 readchar();
		 return cap;
}

GLista CreareGLista()
{
		 do readchar();
		 while (crtChar=='\n');
		 return (citesteGLista());
}

int NrAtomi(GLista v)
{
	GElement* p;
	int nr = 0;

	p = v;

	while ( p != NULL )
	{
		if ( p -> tag == ATOM )
			nr ++;
		else
			nr += NrAtomi ( p -> data.L );

		p = p -> link;
	}

	return nr;
}

void AfisLista(GLista v)
{
	GElement* p;
	p = v;

	printf("(");

	while ( p != NULL )
	{
		if ( p->tag == ATOM )
		{
			printf("%c",p->data.A);
			if ( p -> link != NULL )
				printf(",");
		}
		else
		{
			AfisLista ( p->data.L );
			if ( p -> link != NULL )
				printf(",");
		}

		p = p -> link;
	}

	printf(")");
}

int AdincimeLista(GLista v)
{
	GElement* p;
	int adincime = 1;

	p = v;

	while ( p != NULL )
	{
		 if ( p -> tag == ATOM )
			adincime;
		 else
			adincime += AdincimeLista ( p -> data.L );

		p = p -> link;
	}

	return adincime;
}






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

void main()
{
	GElement* cap;
	char opt;

	do{

		clrscr();

		printf("\nINTRODUCETI LISTA\n");
		cap = CreareGLista();
		printf("\nLISTA INTRODUSA ARE %d ATOMI\n",NrAtomi(cap));
		printf("\nLISTA INTRODUSA IN FORMATUL DE INTRARE : \n");
		AfisLista(cap);
		printf("\n\nADINCIMEA LISTEI ESTE %d \n",AdincimeLista(cap));

		printf("\n\n\t\t\tRELUAM ? (Y/N)");
		opt = getche();

	} while( opt == 'y' || opt == 'Y' );
	getch();
}