9. 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 toti atomii din lista.
     b) Sa se afiseze lista citita in formatul folosit la intrare
     (cu paranteze).
     c) Sa se stearga toate sublistele vide si sa se afiseze lista
     rezultata apelind procedura de la punctul b.

EXEMPLU DE RULARE:
     Introduceti lista: (F,(T,(C)),(),(D,E,()))
     Atomii: F T C D E
     Lista citita: (F,(T,(C)),(),(D,E,()))
     Lista prelucrata: (F,(T,C),(D,E))


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




/****************************************************************
                      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());
}

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(")");
}


void DelListaVida(GLista v)
{
	GElement* p,*q;
	p = v;
	while ( p != NULL )
	{
		if ( p -> tag == ATOM && p -> data.A == NULL)
		{
			q -> link = p;
			q -> link = p-> link;
			p = q;
			delete q;
		}
	 else DelListaVida (p->data.L);

	 p = p -> link;
	}
}




/****************************************************************
                      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();
     // citeste si returneaza o lista generalizata data de la
     // intrarea standard, respectind sintaxa specificata.


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

void main()
{
	GElement* cap;
	clrscr();
	printf("\nINTRODUCETI LISTA \n");
	cap = CreareGLista();
	printf("\nLISTA INTRODUSA ESTE URMATOAREA : \n");
	AfisLista(cap);
	DelListaVida(cap);
	printf("\nLISTA REZULTATA ESTE : \n");
	AfisLista(cap);


	getch();
}