Programarea calculatoarelor

Cursul III

Inserarea unei informaii nainte de o celul cu informaie cunoscut

varianta 1
int inserare_i_i (ptnod *prim, int info, int infoi) {ptnod nou, p; if(nou=(ptnod)malloc(sizeof(nod))) {p=*prim;nou->inf=info; if (*prim==NULL) else {nou->inf=info; nou->leg=NULL;*prim=nou;} else if((*prim)->inf==infoi){nou->leg=(*prim);(*prim)=nou;}

{while ((p->leg!=NULL) && (p->leg->inf!=infoi) p=p->leg;

if(p->leg==NULL){nou->leg =(*prim);(*prim)=nou;} else {nou->leg=p->leg;p->leg=nou;} } return 1;} else return 0; }

Inserarea unei informaii nainte de o celul cu informaie cunoscut

varianta 2

varianta 2

ptnod cauta(ptnod prim,int info) { ptnod p; if(prim==NULL) return NULL; else if(prim->inf==info) return prim; else { p=prim; while(p->leg!=NULL) if(p->leg->inf==info) return p; else p=p->leg; } return NULL;

int inserare_inainte_informatie(ptnod *prim,int info,int infod) { ptnod nou,p; if(nou=(ptnod)malloc(sizeof(nod))) {nou->inf=info;

if (*prim==NULL) {nou->leg=NULL;*prim=nou;}
else {p=cauta(*prim,infod); if(p==NULL){nou>leg=*prim;*prim=nou;} else {nou->leg=p->leg;p->leg=nou;}

}
return 1; } return 0; }

Eliminarea unei date dintr-o list

Modificarea coninutului unei liste prin eliminarea uneia sau mai multor componente poate fi descris secvenial, astfel nct este suficient s dispunem de o procedur care realizeaz eliminarea unei singure componente. Criteriile de eliminare pot fi formulate diferit, cele mai uzuale fiind: prima component, ultima component, prima component care ndeplinete o anumit condiie, respectiv componenta care precede/urmeaz primei componente care ndeplinete o condiie dat.

n aceste cazuri este necesar verificarea existenei n lista considerat a componentei ce trebuie eliminat. Verificarea asigur i testarea faptului c lista prelucrat este vid sau nu.

Eliminarea primei componente a unei liste

Funcia elimina_de_la_inceput returneaz 1 dac lista nu este vid, deci eliminarea primului nod este posibil, altfel returneaz 0. Dac lista conine mcar un nod, este eliminat prima celul. int elimina_de_la_inceput(ptnod *prim, int *info) { if(*prim!=NULL) { ptnod aux=*prim; *info=aux->inf; *prim=(*prim)->leg; free(aux); return 1; } return 0; }

Eliminarea ultimei componente a unei liste

Similar operaiei de inserare a unui nod dup ultima celul a unei liste, eliminarea ultimului nod presupune determinarea acelei celule p cu proprietatea c p->leg este NULL.

Funcia elimina_ultim returneaz 1 dac lista nu este vid, n caz contrar 0.

int elimina_ultim(ptnod *prim,int *info) { ptnod p; if (*prim) { if((*prim)->leg) { p=*prim; while(p->leg->leg!=NULL) p=p->leg; *info=p->leg->inf; free(p->leg); p->leg=NULL; } else { *info=(*prim)->inf;free(*prim);*prim=NULL;} return 1; } return 0; }

Eliminarea primei celule a unei liste care are informaia egal cu o informaie dat
int elimina_informatie(ptnod *prim, int info) { ptnod aux,p,q; if(*prim!=NULL) { p=*prim; if((*prim)->inf==info) {aux=*prim; *prim=(*prim)->leg;free(aux);return 1;} else {while ((p->leg!=NULL) && (p->leg->inf!=info)) p=p->leg; if(p->leg->inf==info){ q=p->leg;p->leg=q->leg;free(q);return 1;} } } return 0; }

Eliminarea nodului care succede primei componente al crei cmp de informaie este cunoscut
int elimina_informatie_dupa(ptnod *prim, int info) { ptnod aux,p,q; p=*prim; if(*prim!=NULL) { if((*prim)->inf==info) {aux=(*prim)->leg; p->leg=aux>leg;free(aux);return 1;} else {while ((p->leg!=NULL) && (p->inf!=info)) p=p->leg; if(p->inf==info){ q=p->leg;p->leg=q>leg;free(q);return 1;} } } return 0; }

Coada
O coada este o list simplu nlnuit gestionat conform principiului FIFO (First In, First Out). Conform acestui principiu, primul element introdus n list este i primul care este scos din list. Cele doua capete ale listei simplu nlnuite care implementeaz coada sunt i capetele cozii. Asupra cozilor se definesc trei operaii (ca i asupra listelor):

pune un element n coada : adaug; scoate un element din coada : extragere; tergerea (vidarea) unei cozi : terg coada;

Coada

Conform principiului FIFO, funcia adaug pune un element la un capt al cozii (la sfrit), iar funcia elimin - elimin un element din celalalt capt al cozii (de la nceput)

Stiva
O stiv este o list simplu nlnuit gestionat conform principiului LIFO (Last In, First Out). Conform acestui principiu, primul element introdus n list este ultimul care iese din list i ultimul element din list este primul care este scos din list. Operaiile de baz efectuate asupra unei stive (inserarea/extragerea unui element) pot fi realizate numai n prima poziie. Asupra stivelor se definesc trei operaii (ca i asupra listelor):

pune un element n stiv : adaug; scoate un element din stiv: extragere; tergerea (vidarea) unei stive : terg stiv;

Stiva

Conform principiului LIFO, funcia adaug pune un element la un capt al stivei (la nceput), iar functia elimin elimin un element din acelai capt al stivei (de la nceput).

Stiva

Structura: typedef struct nod {

int inf; struct nod * leg; } *ptnod;

Afiare: void afisare(ptnod prim) { while(prim) { printf("%d",prim->inf); prim=prim->leg;} printf("\n"); }

Stiva

Inserare:
int push(ptnod *prim ,int info) { ptnod nou; if(nou=(ptnod)malloc(sizeof(nod))) {nou->inf=info; nou->leg=*prim; *prim=nou; return 1; } return 0; }

Stiva

Extragere:
int pop(ptnod *prim, int *info) { if(*prim!=NULL) { ptnod aux=*prim; *info=aux->inf; *prim=(*prim)->leg; free(aux); return 1; } return 0; }

Stiva
void main() { int er,a; ptnod prim=NULL; do {printf("Dati elemntul (1= inserare, -1 = extragere, 0 = stop)"); scanf("%d",&a); if(a!=0) if ((a==(-1))&&( pop(&prim,&er)!=0)) afisare(prim); else if(push(&prim,a)!=0) afisare(prim); } while (a); }