next up previous contents
Next: Comentarea programului Up: Problema rezolvata Previous: Problema rezolvata   Cuprins


Sursa programului

Fisierul tip.h

/* tipul unui nod al listei ce implementeaza evidenta */
typedef struct nod_lista 
{
  char *nume; /* nume */
  char *loc_munca; /* locul de munca */
  int varsta; /* varsta */
  struct nod_lista *alf; /* inlantuirea in ordine alfabetica */
  struct nod_lista *varcr; /* inlantuirea in ordinea 
                              crescatoarea a varstei */
  struct nod_lista *vardes; /* inlantuirea in ordinea 
                               descrescatoarea a varstei */
} nod;


/* operatiile asupra listei */
nod *cauta(char *);
void introdu(char *, char *, int);
void afis_alf(void);
void afis_des(void);
void afis_loc_munca(char *);
void afis_varsta(int);
void elimin(char *);
void elimin_loc_munca(char *);

Fisierul lista.c

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "tip.h"

static nod *inc1=NULL, *inc2=NULL, *inc3=NULL ;
/* nodurile listei sunt inlantuite dupa cele trei 
   criterii de ordonare */
/* cele trei liste sunt indicate de inc1, inc2 si inc3 */
/* inc1 indica lista ordonata in ordine alfabetica */
/* inc2 indica lista ordonata in ordinea crescatoare a varstei */
/* inc3 indica lista ordonata in ordinea descrecatoare a varstei*/

static nod *auxp; /* variabila auxiliara 
                     folosita la eliminarea unui nod */

/*---------------------------------------------------------*/
/*                                                         */
/*    cauta in lista ordonata alfabetic nodul care are     */
/*    numele egal cu parametrul n;                         */
/*    returneaza pointerul la nod sau NULL                 */
/*                                                         */
/*---------------------------------------------------------*/
nod *cauta(char *n)
{
  nod *l;


  for(l=inc1; l!=NULL && strcmp(l->nume, n) < 0; l=l->alf); 
     /* parcurge lista cautand nodul cu nume egal cu n */

  if (l!=NULL && strcmp(l->nume, n)==0) 
  /* daca nodul a fost gasit */
    return l;
  return NULL;
} /* cauta */

/*---------------------------------------------------------*/
/*                                                         */
/*     scot1 elimina din lista ordonata alfabetic nodul    */
/*     care  are numele egal cu parametrul l               */
/*                                                         */
/*---------------------------------------------------------*/
nod *scot1(nod *p, char *l)
/* p este inceputul listei din care se face eliminarea */
{
  nod *l1, *l2;

  for(l1=l2=p; l1!=NULL && strcmp(l1->nume, l) < 0; 
      l2=l1, l1=l1->alf); /* se parcurge lista ordonata alfabetic
                             cautand nodul cu numele egal cu l */

  if (l1!=NULL && strcmp(l1->nume, l) == 0) 
        /*daca s-a gasit nodul*/
    if(l1 == l2 ) /* daca este primul nod in lista */
      return p->alf; 
    else
    {
      l2->alf=l1->alf;
      return p;
    }
  else /* nodul nu a fost gasit in lista */
  {
    printf("Eroare: %s nu apare in evidenta\n", l);
    return p;
  }
} /* scot1 */

/*---------------------------------------------------------*/
/*                                                         */
/*     scot2 elimina din lista ordonata crescator dupa     */
/*  varsta, nodul care are numele egal cu parametrul l     */ 
/*                                                         */
/*---------------------------------------------------------*/
nod *scot2(nod *p, char *l)
/* p este inceputul listei din care se face eliminarea */
{
  nod *l1, *l2;

  for (l1=l2=p; l1!=NULL && strcmp(l1->nume, l)!=0; 
       l2=l1, l1=l1->varcr); /* se parcurge lista ordonata 
                             crescator functie de varsta cautand
                             nodul cu numele egal cu l */

  if (l1!=NULL && strcmp(l1->nume, l)==0) 
      /* daca s-a gasit nodul */
    if(l1 == l2 ) /* daca este primul nod in lista */
      return p->varcr;
    else
    {
      l2->varcr=l1->varcr;
      return p;
    }
  else
  {
    printf("Eroare: %s nu apare in evidenta\n",l);
    return p;
  }
} /* scot2 */

/*---------------------------------------------------------*/
/*                                                         */
/*   scot3 elimina din lista ordonata descrescator dupa    */
/* varsta nodul care are numele egal cu parametrul l       */
/*                                                         */
/*---------------------------------------------------------*/
nod *scot3(nod *p, char *l)
/* p este inceputul listei din care se face eliminarea */
{
  nod *l1, *l2;

  for (l1=l2=p; l1!=NULL && strcmp(l1->nume, l)!=0; 
       l2=l1, l1=l1->vardes); /* se parcurge lista ordonata 
                             descrescator functie de varsta 
                             cautand nodul cu numele egal cu l*/

  if (l1!=NULL && strcmp (l1->nume, l)==0)
  /* daca s-a gasit nodul */
  {
    auxp=l1; /* auxp indica spre nodul care se elimina */
    if (l1==l2) /* daca este primul nod in lista */
      return p->vardes;
    else
    {
      l2->vardes=l1->vardes;
      return p;
    }
  }
  else
  {
    printf("Eroare: %s nu apare in evidenta\n", l);
    return p;
  }
} /* scot3 */

/*---------------------------------------------------------*/
/*                                                         */
/*      intr1 introduce nodul indicat de l in lista        */
/*      ordonata alfabetic, cu adresa de inceput in p      */
/*                                                         */
/*---------------------------------------------------------*/
nod *intr1(nod *p, nod *l)
/* p este inceputul listei in care se face introducerea */
/* l este nodul care este inserat */
{
  nod *l1, *l2;

  for(l1=l2=p; l1!=NULL && strcmp(l1->nume, l->nume)<0; 
      l2=l1, l1=l1->alf);

  l->alf=l1;
  if (l1==l2) /* daca nodul este inserat la inceputul listei */
    return l;
  else
  {
    l2->alf=l;
    return p;
  }
} /* intr1 */

/*----------------------------------------------------------*/
/*                                                          */
/*   intr2 introduce nodul indicat de l in lista ordonata   */    
/*   crescator functie de varsta, cu adresa de inceput in p */
/*                                                          */
/*----------------------------------------------------------*/
 
nod *intr2( nod *p, nod *l)
/* p este inceputul listei in care se face introducerea */
/* l este nodul care este inserat */ 
{
  nod *l1, *l2;

  for (l1=l2=p; l1!=NULL && l1->varsta<l->varsta; 
       l2=l1, l1=l1->varcr);

  l->varcr=l1;
  if (l1==l2) /* daca nodul este inserat la inceputul listei */
    return l;
  else
  {
    l2->varcr=l;
    return p;
  }
} /* intr2 */

/*---------------------------------------------------------*/
/*                                                         */
/*    intr3 introduce nodul indicat de l in lista ordonata */
/*              descrescator functie de varsta,            */
/*                cu adresa de inceput in p                */
/*                                                         */
/*---------------------------------------------------------*/
nod *intr3(nod *p, nod *l)
/* p este inceputul listei in care se face introducerea */
/* l este nodul care este inserat */
{
  nod *l1, *l2;

  for (l1=l2=p; l1!=NULL && l1->varsta>l->varsta;
       l2=l1, l1=l1->vardes);

  l->vardes=l1;
  if (l1==l2) /* daca nodul este inserat la inceputul listei */
    return l;
  else
  {
    l2->vardes=l;
    return p;
  }
} /* intr3 */

/*---------------------------------------------------------*/
/*                                                         */
/* introdu creeaza un nod nou pentru o persoana noua si il */
/* inlantuie in cele trei evidente                         */
/*                                                         */
/*---------------------------------------------------------*/

void introdu(char *n, char *lm, int v)
/* n reprezinta numele persoanei */
/* lm reprezinta locul de munca */
/* v reprezinta varsta */
{
  nod *t;
  if ((t=cauta(n))!=NULL) 
     /* daca exista deja o persoana cu numele n */
  {
    /* actualizeaza locul de munca */
    free(t->loc_munca); 
    if ((t->loc_munca=(char*)malloc(strlen(lm)+1))==NULL)
    {
      printf("Eroare: memorie insuficienta\n");
      exit(1);
    }
    else
    {
      strcpy(t->loc_munca, lm); /* noul loc de munca */ 
      t->varsta=v; /* noua varsta */
      inc2=scot2(inc2, t->nume); 
      /* elimina nodul din lista ordonata crescator dupa varsta */
      inc2=intr2(inc2, t); 
      /* introdu nodul in lista ordonata crescator dupa varsta */
      inc3=scot3(inc3, t->nume); 
      /*elimina nodul din lista ordonata descrescator dupa varsta*/
      inc3=intr3(inc3, t); 
      /* introdu nodul in lista ordonata crescator dupa varsta */
    }
  }
  else /* daca nodul nu apare in evidenta */
    /* aloca memorie pentru nod */
    if ((t=(nod*)malloc(sizeof(nod)))==NULL ||
      (t->nume=(char*)malloc(strlen(n)+1))==NULL ||
      (t->loc_munca=(char*)malloc(strlen(lm)+1))==NULL)
    {
      printf("Eroare: memorie insuficienta\n");
      exit(1);
    }
    else
    {
      /* initializeaza campurile nodului nou */
      strcpy(t->nume, n);
      strcpy(t->loc_munca, lm);
      t->varsta=v;
      inc1=intr1(inc1, t); /* nodul este introdus in lista 1 */
      inc2=intr2(inc2, t); /* nodul este introdus in lista 2 */
      inc3=intr3(inc3, t); /* nodul este introdus in lista 3 */
    }
} /* introdu */

/*---------------------------------------------------------*/
/*                                                         */
/*  parcurge lista ordonata alfabetic si afiseaza evidenta */
/*                                                         */
/*---------------------------------------------------------*/
void afis_alf(void)
{
  nod *p;

  for (p=inc1; p!=NULL ; p=p->alf) 
      /* parcurge lista ordonata alfabetic */
  {
    printf("Nume: %s\n", p->nume);
    printf("Loc de munca: %s\n", p->loc_munca);
    printf("varsta: %d\n\n", p->varsta);
  }
} /* afis_alf */

/*---------------------------------------------------------*/
/*                                                         */
/*  afiseaza evidenta in ordinea descrescatoare a varstei  */
/*                                                         */
/*---------------------------------------------------------*/
void afis_des(void)
{
  nod *p;

  for (p=inc3; p!=NULL; p=p->vardes)
  /*parcurge lista ordonata descrescator in functie de varsta*/
    printf("Nume: %s\n", p->nume);
} /* afis_des */

/*---------------------------------------------------------*/
/*                                                         */
/*     afiseaza ordonat alfabetic persoanele cu locul      */
/*                     de munca lm                         */
/*                                                         */
/*---------------------------------------------------------*/
void afis_loc_munca(char *lm)
{
  nod *l;

  for (l=inc1; l!=NULL; l=l->alf) 
        /* parcurge lista ordonata alfabetic */
    if (strcmp(l->loc_munca, lm)==0) 
        /* daca are locul de munca egal cu lm */
      printf(" Nume: %s\n", l->nume);
} /* afis_loc_munca */

/*---------------------------------------------------------*/
/*                                                         */
/*  afis_varsta parcurge lista ordonata crescator functie  */
/*  de varsta si afiseaza toate persoanele care au         */
/*  varsta >= ca si v                                      */
/*                                                         */
/*---------------------------------------------------------*/
void afis_varsta(int v)
{
  nod *l;

  for (l=inc2; l!=NULL; l=l->varcr) 
       /* se parcurge lista ordonata functie de varsta */
    if (l->varsta>=v) /* daca varsta este >= ca si limita v */
      printf("Nume: %s\n", l->nume);
} /* afis_varsta */

/*---------------------------------------------------------*/
/* elimin scoate persoana cu numele egal cu s din evidenta */
/*                                                         */
/*---------------------------------------------------------*/
void elimin(char *s)
{
  if (cauta(s)) /* daca s apare in evidenta */
  {
    inc1=scot1(inc1, s); /* scoate nodul din lista 1 */
    inc2=scot2(inc2, s); /* scoate nodul din lista 2 */
    inc3=scot3(inc3, s); /* scoate nodul din lista 3 */

    /* elibereaza memoria ocupata de nodul eliminat */
    free (auxp->nume);
    free (auxp->loc_munca);
    free (auxp);
  }
  else
    printf("Persoana %s nu apare in evidenta\n");
} /* elimin */

/*---------------------------------------------------------*/
/*                                                         */
/*  elimin_loc_munca elimina persoanele avind locul        */
/*            de munca egal cu s                           */
/*                                                         */
/*---------------------------------------------------------*/

void elimin_loc_munca(char *s)
{
  nod *l, *aux;

  for (l=inc1; l!=NULL; )
    if (strcmp(l->loc_munca, s)==0) 
       /* s-a gasit o persoana cu locul de munca cautat */
    {
      aux=l->alf;
      elimin(l->nume); /* elimina persoana gasita */
      l=aux;
    }
    else
      l=l->alf; 
} /* elimin_loc_munca */

Fisierul main.c

#include <stdio.h>
#include <conio.h>
#include "tip.h"
/*---------------------------------------------------------*/
/*                                                         */
/*   Functia meniu afiseaza meniul programului, citeste    */
/*   comanda si apeleaza rutina care implementeaza         */
/*   functionalitatea comenzii respective                  */
/*                                                         */
/*---------------------------------------------------------*/
void meniu(void)
{
  char c, s[30], lm[30];
  int v;
  nod *t;

  while (1)
  {
    clrscr();
    printf("a- Introducerea unei persoane noi in evidenta\n");
    printf("t- Cautarea unui nume in evidenta\n");
    printf("l- Tipareste persoanele cu un anumit loc de munca\n");
    printf("p- Afiseaza persoanele de varsta mai mare sau 
               egala cu o valoare citita\n");
    printf("s- Elimina o persoana din evidenta\n");
    printf("d- Elimina persoanele cu un anumit loc de munca\n");
    printf("n- Afiseaza alfabetic persoanele din evidenta\n");
    printf("v- Afiseaza persoanele in ordinea descrescatoare 
               a varstei\n");
    printf("f- Termina programul\n\n\n");
    printf(" Introduceti optiunea: ");
    c=getchar(); getchar(); /* citeste optiunea */

    switch( c )
    {
    case 'a':
      printf("Numele persoanei: "); gets(s); /* citeste numele */
      printf(" Locul de munca: "); gets(lm); 
        /* citeste locul de munca */
      printf(" Varsta: "); scanf("%d", &v); getchar(); 
       /* citeste varsta */

      introdu(s, lm, v); 
      /* persoana si datele aferente sunt introduse in evidenta */
      break;
    case 'v':
      afis_des(); 
      /* tipareste evidenta in ordinea descrescatoare a varstei */ 
      break;
    case 't':
      printf("Numele persoanei: "); gets(s); /* citeste numele */
      if ((t=cauta(s))!=NULL) /*daca persoana apare in evidenta*/
      { 
        printf("Nume: %s\n", t->nume);
        printf("Loc de munca: %s\n", t->loc_munca);
        printf("varsta: %d\n", t->varsta);
      }
      else 
        printf("%s nu apare in evidenta\n",s);
      break;
    case 'l':
      printf(" Locul de munca: "); gets(lm); /* citeste numele */
      afis_loc_munca(lm); 
      /* afiseaza persoanele cu locul de munca citit */ 
      break;
    case 'p':
      printf(" varsta limita: "); 
      scanf("%d", &v); 
      /* citeste varsta */
      getchar();
      afis_varsta(v); 
      /* afiseaza persoanele cu varsta >= ca limita */
      break;
    case 's':
      printf(" Numele persoanei: "); gets(s); /* citeste numele */
      elimin(s); /* elimina persoana cu numele s din evidenta */
      break;
    case 'd':
      printf(" Locul de munca: "); gets(lm); /* citeste numele */
      elimin_loc_munca(lm); 
      /* elimina persoanele cu un anumit loc de munca */
      break;
    case 'n': 
      afis_alf(); 
      /* afiseaza evidenta in ordine alfabetica */
      break;
    case 'f':
      return; /* incheie meniu */
    }
    getchar();
  }
} /* meniu */


/*---------------------------------------------------------*/
/*                                                         */
/*          Functia main  apeleaza functia meniu           */
/*                                                         */
/*---------------------------------------------------------*/

void main()
{
  meniu();
} /* main */



Cristian Gavrila 2001-10-02