Stiva alocata static

typedef int Atom ;

#define dim 10
struct Stack
{
int sp;
Atom vect[dim];
};
void InitS(Stack &S)
{ S.sp=-1;
}
1

Functii - Stiva alocata static

int EmptyS(Stack S)
{ return(S.sp= =-1); }
Atom Pop(Stack &S)
{ if(!EmptyS(S))
return(S.vect[S.sp--]);
else
{cout<<"Pop -- stiva vida\n"; return 0;}
}
2

Functii - Stiva alocata static

void Push(Stack &S,Atom val)
{
if(S.sp<dim-1)
S.vect[++S.sp]=val;
else cout<<"Push - stiva plina";
}
Atom Top(Stack S)
{
if(EmptyS(S) = = 1)
{cout<<"Top -- stiva vida\n";
return 0;
}
else return(S.vect[S.sp]);
}
3

Aplicaie: conversia n binar

void binar(int n)
{
int b; Stack S;
//int s[20],vs,b;
InitS(S); //vs=-1;
while(n>0)
{
b=n%2;
n=n/2;
Push(S,b);
//s[++vs]=b;
}
while(EmptyS(S)!=1)
{
cout<<Pop(S);
//cout<<s[vs--];
}
cout<<endl;
}

//Trecerea unei expresii aritmetice din forma infixata in

postfixata----solutie Andrei Romila
char sir1[]="12 + (2 * 3 + 4 ) / ( 6 - 5 )", sir2[300];
S=0; InitS(S);
int i,k=0;
char ext;
for(i=0;i<strlen(sir1);++i)
{
if(sir1[i]>='0'&& sir1[i]<='9' || sir1[i]==' ')//operand
sir2[k++]=sir1[i];
if(sir1[i]=='*'|| sir1[i]=='/')
//prioritate mare
{
while(Top(S)=='*' || Top(S)=='/')
sir2[k++]=Pop(S);
Push(S,sir1[i]);
}

if(sir1[i]=='+' || sir1[i]=='-') //op. prioritate mica

{
while(Top(S)!='(' && !EmptyS(S))
sir2[k++]=Pop(S);
Push(S,sir1[i]);
}
if(sir1[i]=='(')
Push(S,'(');
if(sir1[i]==')')
//scot din stiva pana la (
{
while(Top(S)!='(')
sir2[k++]=Pop(S);
ext=Pop(S);
}
} //inchei for
6

while(!EmptyS(S))
//daca mai sunt operatori in stiva
sir2[k++]=Pop(S);
for(int i=0;i<k;++i)
putchar(sir2[i]); //afisez sirul rezultat

Teme
S se scrie un program care folosete o
stiv pentru a verifica nchiderea corect a
parantezelor ntr-o expresie. Expresia are
maxim 80 de caractere i conine
patrutipuri de paranteze: { }, ( ), < >, [ ].
S se inverseze ordinea elementelor ntrun vector utiliznd o stiv.
S se scrie un program care folosete o
stiv pentru a verifica dac un ir de
caractere este palindrom.
8

Coad circular alocat static

typedef int atom;
#define dimmax 5
struct queue
{
int head,tail;
atom vect[dimmax];
};
int nextpos(int index)
{
if (index<dimmax-1)
return (index+1);
else return 0;
}
9

Coad circular alocat static

int isempty(queue Q)
{
return(Q.head==Q.tail);
}
void initQ(queue &Q)
{
Q.head=Q.tail=0;
}
10

Coad circular alocat static

void put(queue &Q, atom a)
{
if(Q.head==nextpos(Q.tail))
cout<<"\n buffer plin!";
else
{
Q.vect[Q.tail]=a;
Q.tail=nextpos(Q.tail);
}
}
11

Coad circular alocat static

atom get(queue &Q)
{
atom aux;
if(isempty(Q)==1)
{cout<<"\n Coada vida"; return 0;}
else
{
aux=Q.vect[Q.head];
Q.head=nextpos(Q.head);
return aux;
}
}

12

Coad circular alocat static

atom front(queue Q)
{
if(isempty(Q) = =1)
{
Cout<<"\n Coada vida";
return 0;
}
else
return Q.vect[Q.head];
}

13

Structuri generice
Cerin fundamental a programelor dezvoltate n
mod profesionist caracterul de generalitate
O funcie generic definete o secven de aciuni ce
pot fi aplicate unor tipuri de date diferite;
Tipurile de date asupra crora acioneaz funcia
sunt transmise ca parametri;
n limbajul C, implementarea unei funcii generice se
se realizeaz astfel: n lista de argumente, funcia
primete un pointer la o valoare de orice tip (void *) i
o funcie ce prelucreaz valori de acel tip;
Remember PC
Pointeri la funcii
Pointeri la void
14

Stive generice
Informaia din structura unui nod(element)
poate fi de orice tip: int, float, char, string
Cum se modific structura i funciile?
Cum se apeleaz funciile?
Stack
Pointer

void *

tip data

void *

tip data

void *

typedef struct nod

{
void *info;
struct nod *urm;
} *STIVA;

tip data

15

Stive generice
STIVA InitS(void);
int EmptyS(STIVA);
void *Pop(STIVA);
void Push(void*, STIVA);
void *Top(STIVA);

void* Pop(STIVA &s)

{
STIVA t; void* aux;
if(EmptyS(s))
{
printf("Pop -- stiva vida\n"); return 0;
}

t=s;
aux=t->info;
s=s->urm;
delete t;
return(aux);
}
16

Stive generice
void Push(void *x, STIVA &s)
{
STIVA t;
if((t=new nod)==NULL)
{ printf("Push - eroare alocare"); return 0;}
t->info=x;
t->urm=s;
s=t;
}
17

Stive generice. Exemple pentru apel

int n=5;
float *m, *m1; *m1=6.666; *m=3.333;
float v;
STIVA virf;
virf=InitS();
for(int i=1; i<=n; i++)
{printf("\nPun %d",i);
Push((void*)i, virf);
printf("Virf= %d",(int*)Top(virf));
}
printf("\nPOP %d\n",(int*)Pop(virf));
printf("\n Am in virf %d\n",(int*)Top(virf));
printf("\n POP %d\n",(int*)Pop(virf));
Push((void*)m, virf);
Push((void*)m1, virf);
printf("\n scot= %f ",*((float*)Pop(virf)));
printf("\n Am in virf= %f ",*((float*)Top(virf)));

18

Liste generalizate
O list generalizat conine elemente ce pot fi de tip atom sau lista.
Pentru a preciza tipul unui element, se memoreaz n fiecare nod tipul
acestuia (Atom sau Lista).
Cmpul data poate conine un Atom sau o Lista.
TAG

DATA

LINK

Alocarea eficient a memoriei: cmpul data de tip union

L=(a,(b,(c,d)),e,(f,g))
A a

A e

A b

A c

A f

A d

0
19

Structura unei liste generalizate

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
};
Cmpurile structurii:
GElement *p
p->data.A
p->data.L
p->link
20

Liste generalizate
Creare lista generalizat:
GLista L;
L=creareGLista();
//funcie dat
void Afis(GLista p)
{ printf("(");
while(p)
{
if(p->tag==ATOM)
if(p->link)
printf("%c,",p->data.A);
else printf("%c",p->data.A);
else {Afis(p->data.L);
if(p->link) printf(",");
}
p=p->link;
}
printf(")");
}

//pun prima (
//cit timp p<>0
//am atom
//si nu e ultunul din lista
//pun atomul si ,
//daca e ultimul NU pun ,
//daca e sublista apelez Afis
//si pun , daca nu nu e ultima sublist
//trec la urmatorul element
// pun ) finala

21

Funcii liste generalizate

int Nratomi(GLista GL)
{ int n=0;
GElement *p=GL;
//p pointer pt. parcurgerea listei
while(p)
{if (p->tag==ATOM) n++;
else n=n+Nratomi(p->data.L);
p=p->link;
}
return n;
}
int GasireAtom(GLista q, Atom c)
//caut atomul c in lista q
{int a=0, b=0;
//intorc 1 daca exista
GLista p=q;
//si 0 daca nu exista
while(p!=NULL) {
if(p->tag==ATOM)
{if(p->data.A==c) a=1;}
else b=GasireAtom(p->data.l,c)

p=p->link;
}
return (a.b?a:b);
}
22

Funcii liste generalizate

int AdincimeLista(GLista LG)
{
int amax=1, a=1;
//amax adincimea pe toata lista, a pe sublista
if(p==NULL) return 0;
//nua am elemente
GLista p=LG;
// L pointer pt. parcurgerea listei
while(p!=NULL)
{
if(p->tag==LISTA)
{
a=1+AdincimeLista(p->data.L);
if(a>amax) amax=a;
}
p=p->link;
}
return amax;
}

23

Funcii liste generalizate

Atom maxatom(GLista GL)
//caut cel mai mare atom
{Atom max=A'; //nu initializez cu primul element poate fi sublista
//se considera ca lista este corect scrisa sintactic
GElement *p; p=GL;
while(p)
{if(p->tag==ATOM)
{if(p->data.A>max) max=p->data.A}
else
if(maxatom(p->data.L)>max) max=maxatom(p->data.L);
p=p->link;
} return max;
}

24