Documente Academic
Documente Profesional
Documente Cultură
IC.04.Tipurile Abstracte de Date Stiva Si Coada PDF
IC.04.Tipurile Abstracte de Date Stiva Si Coada PDF
Cuvinte-cheie
Stiv ordonat, stiv nlnuit, coad ordonat, coad liniar, coad circular,
Coad nluit, inserare, tergere, evaluare expresii aritmetice
IC.04.1.1 Introducere
O stiv este o structura de date de tip container (depoziteaz obiecte de un anumit tip)
organizat dup principiul LIFO (Last In First Out). Operaiile de acces la stiv (push -
adaug un element n stiv i pop - scoate un element din stiv) sunt create astfel nct pop
scoate din stiv elementul introdus cel mai recent.
Dup tablou, stiva este probabil cea mai important structur de date. Majoritatea
sistemelor de calcul pun la dispoziia programatorului instruciuni implementate direct n
hardware pentru manipularea stivelor.
O stiv este un caz particular de list, i anume este o list pentru care operaiile de
acces (inserare, tergere, accesare element) se efectueaz la un singur capt al listei.
Daca STACK este tipul stiv i ATOM tipul obiectelor coninute n stiv, atunci
operaiile care definesc tipul structur de stiva pentru tipul STACK sunt:
-1-
INFORMATIC*I* IC.04. Tipurile abstracte de date stiv i coad
A) Stiv ordonat
struct Stack{
int sp; // "stack pointer"
Atom vect[DIMSTACK];
};
Operaiile care definesc structura de stiv vor fi implementate prin urmtoarele funcii:
Observaie:
Un obiect Stack este un obiect de dimensiuni mari, fapt pentru care nu este eficient
pasarea obiectelor de acest tip prin valoare. Este indicat folosirea parametrilor referin
pentru pasarea stivei chiar daca procedura nu are intenia de a o modifica (cazul funciilor top
si isEmpty).
Funciile date mai sus pot avea implementarea urmtoare:
void initStack(Stack& S)
{
S.sp=-1;
}
Atom pop(Stack& S)
{
if(isEmpty(S)==1)
{printf("Eroare! Stiva vida!"); return 0;}
else
return(S.vect[S.sp--]);
}
-2-
INFORMATIC*I* IC.04. Tipurile abstracte de date stiv i coad
Atom top(Stack& S)
{
if(isEmpty(S)==1)
{printf("Eroare! Stiva vida!"); return 0;}
else return(S.vect[S.sp]);
}
int isEmpty(Stack& S)
{
return(S.sp==-1);
}
B) Stiv nlnuit
O stiv poate fi implementata ca o list nlnuit pentru care operaiile de acces se fac
numai asupra primului element din list. Deci operaia PUSH va nsemna inserare n prima
poziie din list (n fa) iar POP va nsemna tergerea primului element din list. Pentru a
manevra o stiv vom avea nevoie de un pointer la primul element din nlnuire, deci vom
echivala tipul Stack cu tipul "pointer la element de lista", iar funciile care implementeaz
operaiile de acces vor avea aceleai prototipuri cu cele date mai sus.
struct Element {
Atom data;
Element* next; //legatura
};
void initStack(Stack& S)
{
S=0;
}
Atom pop(Stack& S)
{
Atom aux;
Element *p;
p=S;
if(isEmpty(S)==1)
{printf("Eroare!Stiva vida!"); return 0;}
else
{
aux=p->data;
S=S->next;
delete p;
-3-
INFORMATIC*I* IC.04. Tipurile abstracte de date stiv i coad
return aux;
}
}
Atom top(Stack& S)
{
if(isEmpty(S)==1)
{printf("Eroare!Stiva vida!"); return 0;}
else
return S->data;
}
int isEmpty(Stack& S)
{
return(S==0);
}
C) Stiv generic
Acest tip de implementare se obine definind tipul Atom drept "pointer" n definiia
stivei nlnuite de mai sus.
O astfel de definiie are avantajul c o aceeai stiv pstreaz elemente de tipuri
diferite, tipul pointer nsemnnd tocmai "pointer la orice". Rmne n sarcina programatorului
s defineasc un mecanism prin care s recunoasc tipul elementului scos din stiv.
Funciile generice pentru stive implementate prin liste nlnuite pot fi:
STIVA InitS(void);
int IsEmptyS(STIVA);
void *Pop(STIVA &);
-4-
INFORMATIC*I* IC.04. Tipurile abstracte de date stiv i coad
STIVA InitS(void)
{
return NULL;
}
int IsEmptyS(STIVA s)
{
return s == NULL;
}
void* Top(STIVA s)
{
if(IsEmptyS(s)) printf("Top -- stiva vida\n");
return s->info;
}
Expresiile aritmetice n forma uzual, form n care operatorii sunt lsai ntre
operanzii, se numesc expresii n forma infixat. Pentru evaluare, aceste expresii se convertesc
n aa numita form postfixat (numit i forma polonez invers dup naionalitatea
matematicianului Lukasiewicz). O expresie postfixat nu conine paranteze i poate fi
evaluat foarte uor folosind o stiv. ntr-o expresie postfixat nu este necesar specificarea
precedenei operatorilor.
De exemplu, expresia infixat:
a+b/c+(d*e-f)*g
admite scrierea postfixat:
abc/+de*f-g*+
Se observ c forma postfixat a unei expresii aritmetice se caracterizeaz prin aceea
c operatorii apar n ordinea n care se execut operaiile la evaluarea expresiei. De aceea,
evaluarea unei expresii n forma polonez se face parcurgnd ntr-un singur sens expresia i
executnd operaiile innd seama de paritatea lor.
-5-
INFORMATIC*I* IC.04. Tipurile abstracte de date stiv i coad
i=0
while (nu s-a terminat sirul s) do
if (s[i] este operand) then
depune s[i] in stiva
else if (s[i] este operator) then
extrage din stiva doua simboluri t1 si t2;
executa operatia s[i] asupra lui t1 si t2;
depune rezultatul in stiva
else semnalizeaza eroare
endif
endif
i=i+1
endwhile
Tema 3: S se scrie un program C (C++) care evalueaz o expresie dat n forma polonez.
O alt form fr paranteze a unei expresii aritmetice este forma prefixat. n acest tip
operatorii preced operanzii.
-6-
INFORMATIC*I* IC.04. Tipurile abstracte de date stiv i coad
FUNCTII.H
#ifndef _FUNCTII_H_
#define _FUNCTII_H_
#include <stdio.h>
#include <string.h>
#include <ctype.h>
int IsNumber(char*);
int IsOperator(char);
int Priorit(char*);
-7-
INFORMATIC*I* IC.04. Tipurile abstracte de date stiv i coad
}
if(i == strlen(sir))
return 1;
else
return 0;
}
int Priorit(char* c)
{
if((*c == '*') || (*c == '/')) return 2;
else return 1;
}
int IsOperator(char c)
{
if((c == '*') || (c == '/') || (c == '+') || (c == '-'))
return 1;
else
return 0;
}
*operand = *((int*)Pop(sarg));
//in final stiva trebuie contina un singur element
-8-
INFORMATIC*I* IC.04. Tipurile abstracte de date stiv i coad
return *operand;
}
-9-
INFORMATIC*I* IC.04. Tipurile abstracte de date stiv i coad
{
ch=(char*)Pop(s);
strcat(co, ch);
strcat(co, " ");
}
bufo=co;
// printf("in conversie\n");
// puts(bufo);
}
#endif
MAIN.CPP
#include <stdio.h>
#include <string.h>
#include <conio.h>
void main()
{
//clrscr();
char bufi[128], buffer_intermediar[128];
printf("Introduceti forma infixata, numerele separate de spatii\n");
gets(bufi);
puts(bufi);
InfixToPostfix(bufi, buffer_intermediar);
printf("dupa conversie\n");
puts(buffer_intermediar);
printf("Valoarea Expresiei este: %d\n",
EvalPolon(buffer_intermediar));
getch();
}
Tema 4:
b) Scriei un program C (C++) de conversie a unei expresii din forma postfixat n forma
prefixat.
IC.04.3.1 Introducere
Coada este o list n care operaiile de acces sunt restricionate la inserarea la un capat i
extragerea de la cellalt capt. Coada este o structur de date de tip FIFO (First In First Out)
n care elementul care este extras este ntotdeauna cel care a stat cel mai mult n coad.
-10-
INFORMATIC*I* IC.04. Tipurile abstracte de date stiv i coad
-11-
INFORMATIC*I* IC.04. Tipurile abstracte de date stiv i coad
sau astfel:
Tema 5
S se construiasc fiierul QUEUE1.CPP care sa conin implementarea unei cozi circulare,
respectnd specificaiile din fiierul QUEUE1.H i s se testeze implementarea realizat.
QUEUE1.H
-12-
INFORMATIC*I* IC.04. Tipurile abstracte de date stiv i coad
#ifndef _QUEUE_H_
#define _QUEUE_H_
struct Queue {
int head,tail;
Atom vect[DIMMAX];
};
#endif
O coada poate fi implementat printr-o list liniar simplu nlnuit n care operaiile
de acces sunt restricionate corespunztor.
Initial: head=tail=nil
Final: Coad cu un element:
-13-
INFORMATIC*I* IC.04. Tipurile abstracte de date stiv i coad
COADA *InitQ(void)
{
COADA *q=(COADA*)malloc(sizeof(COADA));
if(q==NULL) {printf("eroare alocare"); exit(1);}
q->head = q->tail = NULL;
return q;
}
temp = q->head->info;
if(q->head==q->tail)
{
q->head = q->tail = 0;
return temp;
}
else
{
ELEMENT *p;
p=q->head;
q->head=p->succ;
free(p);
return temp;
}
}
-14-
INFORMATIC*I* IC.04. Tipurile abstracte de date stiv i coad
p->succ=NULL;
if(IsEmptyQ(q)) {q->head=q->tail=p;}
else
{
q->tail->succ=p;
q->tail=p;
}
}
Dac reprezentm coada printr-o structur nlnuit circular este nevoie de un singur
pointer prin intermediul cruia se pot face ambele operaii de adugare i tergere din coada:
Tema 6
Problem propus
Definim "domeniu" ca fiind o zona din ecranul grafic care conine pixeli nvecinai direct sau
indirect, pe vertical sau orizontal, i care au aceeai culoare. De exemplu:
Indicaii
-15-
INFORMATIC*I* IC.04. Tipurile abstracte de date stiv i coad
Descrierea metodei:
Se folosete o coad n care se plaseaz coordonate ale unor pixeli.
struct Pozitie {
int x,y;
};
Pseudocod:
coloreaza_domeniu(pozitie_initiala)
{
memoreaza culoarea domeniului (culoarea pozitiei initiale)
put(C, pozitie_initiala);
coloreaza pozitia_initiala;
WHILE not isEmpty(C) DO
p := get(C); // scoate in p urmatoarea pozitie din coada
FOR pi:=toate pozitiile invecinate lui p DO
IF pi nu iese in afara ecranului si
pi are culoarea domeniului THEN
put(C, pi);
coloreaza pi;
}
-16-
INFORMATIC*I* IC.04. Tipurile abstracte de date stiv i coad
#include <stack>
#include <queue>
#include <iostream>
#include <conio.h>
void main()
{
queue<char> q, q1;
stack<char> s;
char c;
queue<char>::size_type nr=0;
while(cin.peek() !='\n')
{
cin >> c;
if(isalpha(c))
{
q.push(toupper(c));
s.push(toupper(c));
}
}
while(!q.empty() && !s.empty())
{
if((c=q.front()) != s.top()) {nr++; break;}
q.pop();
s.pop();
q1.push(c);
}
if(nr)
{
cout << "Nu este palindrom\n";
while(!q1.empty())
{
cout << q1.front();
q1.pop();
}
}
else cout << "Este palindrom\n";
getch();
}
-17-
INFORMATIC*I* IC.04. Tipurile abstracte de date stiv i coad
Bibliografie
[C01] Craus M., Brsan C., Structuri de date i algoritmi, Editura Gh. Asachi, Iai, 2002
[U02] Ungureanu F., Structuri de date i algoritmi Note de curs, Universitatea Tehnic
Gheorghe Asachi din Iai, Facultatea de Automatic i Calculatoare
[Z03] Zaharia M. D., Structuri de date i algoritmi n limbajele C i C++, Editura Albastr,
Cluj-Napoca, 2002
[I04] Ignat I., Ignat C., Structuri de date i algoritmi, Editura Albastr, Cluj-Napoca, 2007
-18-