c++ skripta

Objektno Orijentisano Programiranje & ASP C++

1

NIZOVI

1.2. zbir.cpp (izračunava zbir niza celih brojeva)

#include "iostream" using namespace std; int main (){ const int DUZ = 100; while (true){ cout<< "Duzina Niza Je? "<< endl; int n; cin>>n; if (n<0 || n>DUZ) break; int a[DUZ]; cout << "Unesite elemente niza:"<< endl; for(int i =0; i<n; cin>> a[i++]); int s=0; for (int i=0; i<n; s+=a[i++]); cout<< "Suma elemenata NIZA a[i] je"<<endl<<"s="<< s<<endl; } }

- Predstavljanje nizova u memoriji:

Koristi se isključivo (skoro) SEKVENCIJALNA REPREZENTACIJA

Sekvencijalna reprezentacija niza u memoriji predstavlja prirodan način implementacije linearne liste

U ovom slučaju ne razdvajamo LOGIČKI KONCEPT NIZA OD NJEGOVE IMPLEMENTACIJE( niz je

implementiran u memoriji kao kontinualan skup susednih memorijskih lokacija)

Nepogodna struktura za UMETANJE I BRISANJE na proizvoljnom mestu - zbor pomeranja elemenata

za jednu poziciju naviše( menja se INDEX svih elemenata IZNAD POZICIJE NA KOJOJ je

UMETANO/BRISANO )

- Smeštanje nizova:

Jednodimenzionalni nizovi ( vektori ):

* Neka jedan element niza zauzima s memorijskih reči.

* Tada je za smeštaj čitavog niza X [ l : u]od n = (u-l)+1 elemenata (l-index,donja granica niza; u –

gornja granica niza) potrebno s*n memorijskih reči

* Pristupanje i-tom elementu niza:

Potrebna je adresna funkcija za pristup elementu niza X[i]

* Ispred elementa sa indexom i nalazi se (i-l) elemenata; je adresa prvog elementa

niza(podetna adresa niza), pa je ADRESNA FUNKCIJA ZA i-ti ELEMENT NIZA: = + (i-l)s

* Ovo je linearna funkcija, pa je laka za izračunavanje – poželjan oblik adresne funkcije (posebno

za slučaj l=0 !!!) – u C-u je : l=0 , X=adr(X*0+) što znači X je const pokazivač na prvi element niza,

pok u okviru niza se ink i dek za kvant = s (veličina jednog elementa) – ovo su pogodnosti za

adresnu aritmetiku

* ISKORIŠDENJE PROSTORA kod sekvencijalne reprezentacije niza – OPTIMALNO

* PRISTUP PODACIMA NIZA kod sekvencijalne reprezentacije niza – EFIKASAN ako je s jednak

jednoj memorijskoj reči ili njenom celom CELOM MULTIPLU ( s – veličina elementa niza!!! )

* Ako je s = 1.6 memorijskih reči : znači kada je veličina jednog elementa –s, veda nego što je

jedna memorijska reč , tada de se jedan element niza prostirati na dva, tri ili možda više

memorijskih reči pa su potrebne dodatne operacije da bi se dohvatio element niza i pristupa

se više memorijskim lokacijama a ne samo jednom


2

* REŠENJE nedostatka s=1.6: Ako je s> 0.5 – DOPUNJAVANJE (padding) – za jedan element se

uzima memorijskih reči i smešta se tako da preostali prostor u poslednjij memorijskoj reči

koju elemnt zazuzima do početka naredne memorijske reči ostavlja neiskorišdenjim; time svaki

element niza počinje od početka naredne mem reči; STEPEN ISKORIŠDENJA za

DOPUNJAVANJE je =

=

* REŠENJE nedostatka s=1.6: Ako je s<0.5 – PAKOVANJE – u jednu memorijsku reč se smešta

više od jednog elementa niza( k elemenata se stavlja u jednu memorijsku reč );ako ostane

nešto slobodnog prostora posle smeštanja k elemenata u toj jednoj mem reči on ostaje prazan

do početka nove mem reči; STEPEN ISKORIŠDENJA za PAKOVANJE je

=

=

, gde je k=

* ADRESNa FUNKCIJa ZA PRISTUP ELEMENTU NIZA KADA JE s>0.5 ( DOPUNJAVANJE ) :

= + (i-l) * ADRESNa FUNKCIJa ZA PRISTUP ELEMENTU NIZA KADA JE s<0.5 ( PAKOVANJE ) :

= +

, gde je s=

Dvodimenzioni nizovi ( MATRICE ): * Potrebno je dvodimenzionalni logički poredak pretvoriti u jednodimenzioni fizički poredak –

linearizacija dvodimenzionalne strukture(matrice), jer je memorija jednodimenzioni niz reči sa

linearno rastudim adresama * Smeštanje po vrstama: prvo se alocira prostor za nxm elemenata kvadratne matrice, zatim se

počev od početne adrese matrice smešta prvo 1va vrsta, 2ga vrsta,..., nta vrsta; na neki način

vrsta se tretira kao zapis od onoliko elemenata koliko ima kolona.Za matricu X[ : , : ]]:

= + ( (i- )( - + 1) + j- )s

Za matricu sa X[1:N , 1:M] važi sledede:

= + ( (i- )M + j- )s * Izvođenje adresne funkcije za matr X[ ; ] : ispred vrste u kojoj se nalazi traženi

element nalazi se ( i- ) vrsta; svaka vrsta ima ( - +1 ) elemenata; u vrsti u kojoj se

nalazi traženi element ima još ( j- )elemenata; svaki element zauzima s mem reči.

* Smeštanje po kolonama: prvo se alocira prostor za nxm elemenata kvadratne matrice, zatim

se počev od početne adrese matrice smešta prvo 1va kolona, 2ga kolona,..., mta kolona; na

neki način kolona se tretira kao zapis od onoliko elemenata koliko ima vrsta.

= + ( (j- )( - + 1) + i- )s

Za matricu sa X*1:N, 1:M+ važi sledede:

= + ( (j- )N + i- )s Višedimenzioni nizovi :


3

Primer: Sumiranje pomodu programskih segmenta SUM1 i SUM 2 ( str 28 “smeštanje matrica –po vrsti” )

Na slici je prikazan izgled keš memorije kapaciteta 256 reči ( reč može biti proizvoljne veličine izražena u

bajtovima/bitovima npr: 1 B, 2 B, 4 B….. ) . Podeljena je u 16 blokova, a veličina svakog bloka je 16 reči (dužina

jednog bloka = 16 reči); zato ona izgleda kao matrica od 16x16 = 256 elemenata (mislim na grafički prikaz keš

memorije; naravno ona u fizičkom prikazu nije matrica od row x column elemenata ved je to jednodimenzioni niz

gde adrese rastu linearno)

Keš memorija je direktno mapirana a prvi element matrice se mapira u prviu reč prvog bloka. Na početku keš je

prazana

Sumira se matrica kapaciteta 512 elemenata ( row x colmn = 32 x16 =512 ) ;svaki element matrice staje u jednu

mem reč. Matrica se smešta PO VRSTI!!!!

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

0 M[1,1] M[1,2] M[1,3] M[1,4] M[1,16]

1 M[2,1] M[2,2] M[2,3] M[2,4] M[2,16]

2 M[3,1] M[3,2] M[3,3] M[3,4] M[3,16]

3

4

5

6

7

8

9

10

11

12

13

14

15 M[16,1] M[16,2] M[16,3] M[16,4] M[16,16]

row - vrsta keš mem :16x16=256reči

HIT RATIO – STEPEN (faktor ) USPEŠNOSTI za SUMIRANJE PO VRSTAMA – SUM1:

Iz memorije u keš se dovlači ceo jedan blok (svi elementi jedne vrste i sumira svih 16 elemenata njene vrste), ne

samo jedan element koji se trenutno obrađuje.

UKUPAN BR PROMAŠAJA = 32 ( jedan po vrsti – br vrsta=32 )svaki put kada programski segment zatraži prvi

element bilo koje vrste obratide se kešu koji je u početku prazan pa de to biti MISS za prvi element svake

vrste;dalje, kada zatraži drugi element bilo koje vrste on de biti u kešu ( HIT ) jer smo prethodno dovukli ceo blok

iz OM

BROJ OBRADANJA OPERATIVNOJ MEM = UKUPAN BR ELEMENATA MATRICE = 32x16 = 512

HIT RATIO =

= 0,938 = 93,8 % =

=

colu

mn

– k

olo

na


4

PRIMETITI: stepen uspešnosti bi bio isti za ovaj primer i kada bi povedali kapacitet OM pa čak i smanjili na 16 redi

!!!

HIT RATIO – STEPEN (faktor ) USPEŠNOSTI za SUMIRANJE PO KOLONAMA – SUM2:

Smeštanje elemenata matrice je PO VRSTAMA, a sumiranje elemenata matrice je PO KOLONAMA!!!

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

0 M[1,1] M[1,2] M[1,3] M[1,4] M[1,16]

1 M[2,1] M[2,2] M[2,3] M[2,4] M[2,16]

2 M[3,1] M[3,2] M[3,3] M[3,4] M[3,16]

3

4

5

6

7

8

9

10

11

12

13

14

15 M[16,1] M[16,2] M[16,3] M[16,4] M[16,16]

Sumiranje po kolonama : pri obradanju prvom element matrice M*1,1+ imamo MISS pa se iz OM dovlači u KEŠ

prva vrsta matrice tj u prvoj vrsti keša bide elementi matrice M*1,1+, M[1,2], M[1,3+ …, M*1,16]; zatim se traži

element M*2,1+ na adresi KEŠ*2+ a to je MISS pa se iz om u keš dovlači druga vrsta M*2,1+, M[2,2], M*2,3+…

M*2,16+;zatim se traži element M*3,1+, pa tako redom M*4,1+ ….M*32,1+

Primeduješ da svaki put kada se obratiš kešu imaš MISS to je ukupno 512 MISSova; zato je HIT RATIO = 0% ;

Smeštanje po kolonama:

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

0 M[1,1] M[2,1] M[3,1] M[4,1] M[5,1] M[6,1] M[7,1] M[8,1] … … … … … … … M[16,1]

1 M[17,1] M[18,1] M[19,1] M[20,1] M[21,1] M[22,1] M[1,1] M[1,1] … … … … … … … M[32,1]

2 M[1,2] M[2,2] M[3,2] M[4,2] M[16,2]

3 M[17,2] M[18,2] M[19,2] M[20,2] M[32,2]

4

5

6

7

8

9

10

11

12

13

14 M[1,8] M[2,8] M[3,8] M[4,8] M[5,8] M[6,8] M[7,8] M[8,8] M[16,8]

15 M[17,8] M[18,8] M[19,8] M[20,8] M[21,8] M[22,8] M[23,8] M[24,8] M[32,8]


5

Trougaone matrice

- Kvadratna matrica kod koje su svi elementi ispod/iznad glavne dijagonale =nula

- Gornja trougaona matrica: za nju važi X[i,j] =0 za i>j ( pišeš da je i>j jer su X[2,1]=X[3,1]=X[3,2] =0)

- Strogo gornja trougaona matrica: za nju važi Y[i,j] = 0 za i≥j

- Donja trougaona matrica: za nju važi Z[i,j] =0 za i<j

- Strogo dojna trougaona matrica: za nju važi W[i,j] =0 za i≤j

X=

; Y=

; Z=

; W=

- Kod ovih matrica se otvara mogudnost OPTIMIZACIJE ISKORIŠDENJA PROSTORA tako što se pamte SAMO

NENULTI elementi matrice X,Y,Z ili W.

- MAX BR NENULTIH ELEMENATA za gornju/donju trougaonu matricu je = =

- Ušteda prostora je praktično polovina prostora koja bi bila rezervisana za nxn elemenata matrice :

Za moj kokretan slučaj

Ušteda prostora za X/Z je :

= 0,3 = 30% =

Ušteda prostora za Y/W je :

= 0,6 = 60%

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

0 Z[1,1] Z[2,1] Z[2,2] Z[3,1] Z[3,2] Z[3,3] Z[4,1] Z[4,2] Z[4,3] Z[4,4] Z[5,1] Z[5,2] Z[5,3] Z[5,4] Z[5,5] Z[6,1]

1 Z[6,2] Z[6,3] Z[6,4] Z[6,5] Z[6,6] Z[7,1] Z[7,2] Z[7,3] Z[7,4] Z[7,5] Z[7,6] Z[7,7]

2

3

4

5

6

7

8

9

10

11

12

13

14

15

Na slici je prikazan poredak elemenata u npr keš memoriji za matricu 7x7

U ovom primeru, za donju trougaonu matricu je

= 0,42 = 42% ušteda prostora

- Definicija adresne funkcije (opšta formula):

= (adr prvog el matrice) + ( (pomeraj i-te vrste / j-te kolone u odnosu na adr prvog el matrice)

+ (br elemenata ispred traženog elemenata u vrsti / koloni u kojoj se nalazi traženi el ) )* s , gde je

s-veličina jednog elementa,

pomeraj i-te vrste / j-te kolone u odnosu na ard prvog el matrice – broj vrsta/kolona ispred

vrste / kolone u kojoj je traženi element.


6

- Adresna funkcija za donju/gornju trougaonu matricu koja se smešta po vrsti :

= + (

+ j- )s ako je i ≥ j i = ako je i<j

- Adresna funkcija za donju/gornju trougaonu matricu koja se smešta po koloni:

= + (

+ i- )s ako je j ≥ i i = ako je j<i

gde je

pomeraj i-te vrste u odnosu na , a

pomeraj j-te kolone u odnosu na

Symbol Naziv matr index adresne funkcije 0 1 2 3 4 5 smeštanje po vrsti

X gornja 11 12 13 22 23 33 = + (

+ j- )s

Z donja 11 21 22 31 32 33 = + (

+ j- )s

Y strogo gornja 12 13 23 = +(i+j-3)s

W strogo donja 21 31 32 = +(i+j-3)s

METODA ZA IZRAČUNAVANJE ADRESNIH FUNKCIJA:

* Nacrtati tabelu koja prikazuje redosled smeštanja elemenata matrice u memoriju i pomeraj u odnosu na add

prvog elementa – index

* Uočiti: add funkcija linearno zavisi od (1) broja vrste – i i (2) broja kolone – j tj formulom

pomeraj= A*vrsta + B*kolona +C

- Rešavaš system od tri jednačine sa tri nepoznate A,B,C koje treba nadi

- Uzimaš iz tabele tri poznata pomeraja i formiraš taj system jednačina ali tako da j-ne budu linearno

nezavisne ( praktično znači da u j-ni za add funkciju moraš da imaš obe dimenzije – tačnije sve dimenzije

vrsta+kolona;ona add funkcija u kojoj ne postoje sve dimenzije ona je dobijena od zavisnih jednačina pa nije

dobra funkcija )

- Primer: uzimam Y – strogo gornju matricu kao primer

, , su njeni elementi koji se smeštaju u mem na pozicijama 0,1,2, respektivno;jednačine su:

A*i+B*j+C=pomeraj

*1 + B*2 + C = 0

*1+B*3+C=1

*2+B*3+C=2

B=1;A=1;C=-3 pa je ADD FUNKCIJA ZA STROGO GORNJU/DONJU TROUGAONU MATRICU: = +(i+j-3)s

- ! VAŽNO: Transponovanjem trougaone matrice dobija se trougaona matrica i to:

Transponovanjem GORNJE trougaonae matrice dobija se DONJA trougaona matrica i obrnuto.


7

Simetrične matrice

- Pripada grupi trougaonih matrica jer simetrična matrica podrazumeva da elementi na simetričnim

pozicijama u odnosu na glavnu dijagonalu imaju jednake vrednosti pa je optimizacija u pogledu iskorišdenja

mem prostora identična torugaonim

- ! VAŽNO: Transponovanjem simetrične matrice dobija se simetrične matrica , koja je IDENTIČNA polaznoj

matrici

B=

A=

- Primer : Stepenovanje Simetrične Matrice Potrebne su tri matrice A,B,C ( polazna-njen stepen računamo, rezultat i pomodna-koristi se u toku

množenja matrica, respektivno ) istih dimenzija mxm (m-vrsta,m-kolona) Posle unosa dimenzije matrice, alocira se proctor za sve tri matrice dakle formiraju se a,b,c, matrice

sa vrstama promenljive dužine

Na početku matrica B se inicijalizuje da bude jedinična tj da na glavnoj dijagonali budu sve jedninice.

Stepenovanje matrice se izvodi na slededi načina

* Početna matrica A se množi n(stepeni koeficijent) puta sa jediničnom matricom B

* Matematika: C=AxB gde se elementi matrice = gde su i,k=0,1,…(m-1)

a

3

4 2

1 8 5


8

Slika : Stepenovanje simetrilne matrice


9

OPERACIJE S MATRICAMA

INVERZNA MATRICA:

- I način: Ako je polazna matrica A imamo da je inverzna matrica :

=

adj A , gde je adj A =

gde je može da bude , -det komatrica

na preseku i,j

- II način: Ako je polazna matrica A imamo da je inverzna matrica : od matrice napravimo proširenu

matricu :

A=

B=

Radi se normiranje vrste – za prvu,drugu,tredu,…,m-tu vrstu

Radi se stvaranje nula u koloni nadole/nagore– za prvu,drugu,…, n-tu kolonu , dok se ne dobije slededi oblik:

R =

- II način je lakši za implementaciju u C/C++:

Izmena deo programa “Stepenovanje matrice” izgleda ovako: deo koda koji je izmenjen vezan je za podešavanje

odgovarajudih vrednosti matrice B koja treba da ima sledede vrednosti

naravno ako je n=3. Ranija

verzija je imala dodatnu for (j=0;j<=i;j++), b*i+*j+=0;b*i+*j+=1; - petlju koja je usložnjavala algoritam;sada je ona

redukovana

Retki nizovi

- Kod njih je ušteda veda nego kod trougaonih

- Niz koji ima preko 80 % ili 90 % nultih elemenata – redak niz

- Optimizacija : postoje različiti načini, a svi su zasnovani na pamdenju samo nenultih elemenata

- 2 načina optimizacije: predstavljanje u obliku vektora ili ulančanim listama

- Ova filozofija može da se primeni i na elemente koji imaju iste vrednosti pa se pamte samo one koje su

različite

- VEKTORSKA REPREZENTACIJA RETKIH NIZOVA :

Format jednog elementa X[ , , ,…, ] koji je član jednog niza X koji ima n dimenzija je:

… Vrednost ≠0

* ovo je izgled jednog nenultog elementa u vektoru koji predstavlja niz X *


10

Za jedan element se troši više prostora ali se ušteda prostora postiže jer je br el koji se pamte mnogo

manji.

Neka u nizu X[1: , 1: , … , 1: ] postoji nenultih elemenata; neka vrednost i index

zauzimaju po jednu mem reč:

* Tada je

=

* Odavde sledi USLOV DA VEKTORSKA REPREZENTACIJA BUDE PROSTORNO EFIKASNA:

<

2 načina ekonomisanja sa mem prostorom:

* Vektorska reprezentacija retke matrice sa jednim vektorom zapisa od po n polja (n= polja za

dimenzije + jedno polje za vrednost≠0), održavati uređenost elemenata niza po RASTUDIM

VREDNOSTIMA INDEXA po PRVOJ DIMENZIJI (zbog pristupa pojedinim elementima), ako su

indexi po prvoj dimenziji isti onda je poredak određen rastudim vred indexa po drugoj dimen

itd…

* Vektorska reprezentacija retke matrice sa n posebnih vektora

* NEDOSTATAK vektorske implementacije:

Kod operacije PRISTUPA proizvoljnom element – nema direktni pristup element niza ved mora

SEARCH na zadate indexe- dosta je sporije(zato se uređuju rastude po indexima);akko se

pronađe vrada se vrednost elementa ako se ne pronađe u nizu onda je taj element sa zadatim

indexima nulti

Kod operacije UPISA/BRISANJA – isto se radi SEARCH i dosta je zahtevna po pitanju ažuriranja

indexa elemenata niza(moraš obezbediti dinamičku alokaciju/realokaciju prostora jer se ovm

operacijama menja i veličina niza)

* Primer:

ULANČANA LISTA

- Razlika između ULANČANE i SEQVENCIJALNE implementacije(reprezentacije) u memoriji:

Obe služe za predstavljanje linearne liste elemenata

Kod ulančane uzastopni elementi mogu biti bilo gde u memoriji – zato mora postojati explicitna

adresa na naredni element

Kod seqvencijalne uzastopni elementi su susedi u memoriji a početne adrese su na fiksnom

rastojanju određenom veličinom elementa

JEDNOSTRUKO ULANČANA LISTA

INSERT_AFTER(p,x)

q=GETNODE

info.q=x

next.q=next.p

next.p=q

INSERT_BEFORE(p,x)

q=GETNODE

next.q=next.p

info.q=info.p

info.p=x

next.p=q

DELETE_AFTER(p)

q=next.p

next.p=next.q

FREENODE(q)

DELETE(p)

q=next.p

next.p=next.q

info.p=info.q

FREENODE(q)


11

SEARCH(list, x) p=list while(p nil)and(info.p x)do p=next.p end_while return p

SEARCH_ORD(list, x) p=list while(p nil)and(info.p<x)do p=next.p end_while if(p nil)and(info.p>x)then p=nil end_if return p

INVERT(list) CONCATENATE(list1,list2)


12

DVOSTRUKO ULANČANA LISTA

next.(prev.p) =p= prev.(next.p)

p

1 q r

3 5 6 4 p

q 2

r q p q r

s q p ptr info r

KRUŽNE ULANČANE LISTE

INSERT_AFTER_D(p,x)

q=GETNODE ...1

info.q=x ... 2

r=next.p

prev.q=p ... 3

next.q=r ... 4

next.p=q ... 5

prev.r=q ... 6

y z

x

y z

y

x z

x z

DELETE_D(p)

q=prev.p

r=next.p

next.q=r

prev.r=q

FREENODE(p)

r+q

p+s


13

OPERACIJE SA SKUPOVIMA

PRESEK(A,B) UNIJA(A,B) RAZLIKA(A,B)

INTERSECTION(A,B) r=c=GETNODE p=next.A q=next.B while( p nil)and ( q nil )do if(info.p == info.q )then next.c=GETNODE c=next.c info.c=info.p p=next.p q=next.q else if ( info.p<info.q )then p=next.p else q=next.q end_if end_if end_while return r

UNION(A,B) r=c=GETNODE p=next.A q=next.B while( p nil) or ( q nil)do if(p== nil )then next.c=GETNODE c=next.c info.c=info.q q=next.q else if ( q== nil )then next.c=GETNODE c=next.c info.c=info.p p=next.p else if ( info.p<info.q )then next.c=GETNODE c=next.c info.c=info.p p=next.p else next.c=GETNODE c=next.c info.c=info.p q=next.q end_if end_if end_if p=next.p q=next.q end_while return r

DIFERENCE(A,B)


14

- Dve najčešde implementacije:

Seqvencijalna:

* koristi se VECTOR BITOVA – i-ti bit ovog vektora predstavlja i-ti element osnovnog skupa od

n elemenata;ako je bit na i-toj poziciji =1 to znači da element niza koji predstavlja skup

pripada tom osnovnom skupu,a =0 u suprotnom;

* operacije prisustva,ubacivanja,brisanja su efikasne – jednostavnim adresiranjem

odgovarajudeg bita u vektoru i njegovom proverom ili postavljanjem na 1 ili 0 , respektivno

* Vremenska složenost operacija UNIJE,PRESEKA,RAZLIKE – O(n) , gde je n broj elemenata skupa

* POBOLJŠANJE seqvencijalne implementacije vektorima bitova – ako je S dovoljno mali tako da

njegov VECTOR BITOVA može da STANE u JEDNU MAŠINSKU REČ, onda su sve operacije

direktno podržane logičkim operacijama u mašinskom jeziku A or B (UNIJA =>A+B), A and B

(PRESEK =>A*B) , A and (not B) (RAZLIKA=>A-B)

* NEDOSTATAK: zauzima dodatni prostor-rezerviše se max br elemenata bez obzira koliko

stvarno trenutno ima elemenata u skupu – pogodna za male skupove

Ulančana :

* Bolje iskorišdenje prostora

* Smanjena efikasnost skupovskih operacija – veoma zavisna od UREĐENOSTI SKUPA

* Složenost operacija – O( )


15

- Opis operacija:

PRESEK – kredemo se po skupu A i B; porede se elementi oba skupa, pa kada su JEDNAKI ta vred

ulazi u rezultatni skup,ako su RAZLIČITI fiksira se vedi od njih a krede se po skupu onog manjeg broja

sve dok se ne naiđe na jednakost;

* Seqvencijalna implementacija (C++):

I) Ako je i-ti element S1 skupa manji od j-tog elementa S2 skupa – INC i u suprotnom INC j; rezultat se

ne menja

II) Ako sui –ti i j-ti jednaki – i-ti element skupa S1 ulazi u rezultat; INC i and INC j

* Ulančana implementacija(C++):

//PRESEK Skup presek1 (const Skup& s1,const Skup& s2 ){ Skup s; for(Skup::2Elem* tek=s1.prvi;tek;tek=tek->sled){ if(s2.jednak( tek->broj))s.umetni(tek->broj); } return s; }//PRESEK //bool jednak(const double&) bool Skup:: jednak3 (const double &br)const{ for(Elem* tek=prvi;tek;tek=tek->sled) if(tek->broj==br) return true; return false; }//bool jednak(const double&) //void umetni(int) void Skup::umetni(double b){ Elem* tek=prvi, *pret=0; while(tek && tek->broj < b) {pret=tek;tek=tek->sled;} Elem* novi=new Elem(b,tek); if(!pret)prvi=novi; else pret->sled=novi; }//void umetni(int)

1 Funkcija je deklarisana kao friend funkcija – što implicira da nije član klase Skup, nego je globalna

2 da nismo stavili Skup :: Elem* tek => prevodilac bi prijavio grešku „neidentifikovan član“ – pristupaš članu izvan klase

3 Metoda jednak() je obična metoda(nije friend) i ona je članica klase Skup pa ti za Elem* ne treba Skup::


16

UNIJA – kada se naiđe na NEJEDNAKOST, manji od njih ulazi u rezultatni skup, kao i kada se naiđe na

JEDNAKOST

* Seqvencijalna implementacija

I) Proveravamo da li je S1/S2 prazan skup –true => rezultat je S2/S1 respektivno; INC j / INC i;false => II

or III

II) Ako je i-ti od S1 manji od j-tog S2 skupa – i-ti ulazi u rezultat; INC i; u suprotnom j-ti ulazi u rezultat i

INC j

III) Ako su i –ti i j-ti jednaki – i-ti ulazi u rezultat; INC i, INC j

* Ulančana implementacija:

//UNIJA friend Skup unija ( Skup& s1 ,const Skup& s2){return s1.spoji(s2);}

//UNIJA

//spoji(const Skup&) Skup& Skup :: spoji (const Skup& s){ for(Skup::Elem* tek=s.prvi;tek;tek=tek->sled){ if(!( (*this) .jednak( tek->broj))) umetni(tek->broj); } return *this; }//spoji(const Skup&)


17

RAZLIKA –Krede se po skupu B; u rezultatni skup ulaze SAMO elementi skupa A i to kada je trenutni

element skupa A manji od trenutnog elementa skupa B kao i od preostalih elemenata iz skupa A kada

se dođe do kraja skupa B

* Seqvencijalna implementacija:

I) Proveravamo da li smo stigli do kraja drugog niza(skupa) –možda je S2 prazan skup - true=> i-ti od

S1 ulazi u rezultatni skup ; INC i ; false => stavke II or III or IV.

II) Ako je i-ti element S1 manji od j-tog S2 skupa – i-ti ulazi u rezultatni skup; INC i

III) Ako je i-ti element S1 vedi od j-tog S2 skupa – rezultatni skup se ne menja ved samo INC j

IV) Ako su i-ti element S1 i j-ti S2 skupa jednaki – INC i & INC j

* Ulančana implementacija:

//RAZLIKA Skup razlika (const Skup& s1,const Skup& s2 ){ Skup s; for(Skup::Elem* tek=s1.prvi;tek;tek=tek->sled){ if(!(s2.jednak( tek->broj)))s.umetni(tek->broj); } return s; }//RAZLIKA


18

CEO PROGRAM u C++: skup.h,skup.cpp,skupt.cpp

Realizovano sa preklopljenim operatorima

//skup.h #include<iostream> using namespace std; class Skup{ struct Elem{ double broj; Elem* sled; Elem(double b, Elem* s=0){broj=b;sled=s;} }; void kopiraj(const Skup& ); Elem* prvi; public: Skup(){prvi=0;} Skup(double b){prvi=new Elem(b);} Skup(const Skup& cs){kopiraj(cs);} ~Skup(){brisi();} bool operator% (const double &br)const; Skup& operator= ( const Skup& cs ){ if(this!=&cs){brisi();kopiraj(cs);return *this;} } void brisi(); void pisi()const; void naPocetak(double b){cout<<"\nMETODA naPocetak(double)";Elem* novi=new Elem(b,prvi);prvi=novi;cout<<"\nMETODA na Pocetak(double)-ENDED\n";} void citaj(int n); void umetni(double b); friend Skup operator* (const Skup& ,const Skup& ); friend Skup operator- (const Skup& ,const Skup& ); friend Skup operator+ (const Skup& s1 ,const Skup& s2){return Skup(s1) += s2;} Skup& operator*= (const Skup& s){return *this=*this*s;} Skup& operator-= (const Skup& s){return *this=*this-s;} Skup& operator+= (const Skup& s); friend ostream& operator<< (ostream& o, const Skup& s); };//skup.h


19

//skup.cpp #include"skup.h" #include<iostream> using namespace std; void Skup :: kopiraj(const Skup& cs){ prvi=0; //pokazivac nove kopije for(Elem* tek=cs.prvi,*posl=0;tek;tek=tek->sled){ Elem* novi=new Elem(tek->broj); //novi čvor sa novom kopijom info polja cs objekta if(!prvi)prvi=novi; else posl->sled=novi; posl=novi; } } void Skup :: brisi(){ while(prvi){ Elem* stari=prvi; prvi=prvi->sled; delete stari; } } void Skup :: pisi()const{ cout<< '{'; for(Elem* tek=prvi;tek;tek=tek->sled){ cout<<tek->broj; if(tek->sled!=0) cout<<','; } cout<<'}'; } void Skup :: citaj(int n){ brisi(); for(int i=0;i<n;i++){ double b; cin>>b; umetni(b); } } void Skup::umetni(double b){ Elem* tek=prvi, *pret=0; while(tek && tek->broj < b) {pret=tek;tek=tek->sled;} Elem* novi=new Elem(b,tek); if(!pret)prvi=novi; else pret->sled=novi; } bool Skup:: operator% (const double &br)const{ for(Elem* tek=prvi;tek;tek=tek->sled) if(tek->broj==br) return true; return false; } Skup operator* (const Skup& s1,const Skup& s2 ){ Skup s; for(Skup::Elem* tek=s1.prvi;tek;tek=tek->sled){


20

if(s2 % tek->broj)s.umetni(tek->broj); } return s; } Skup operator- (const Skup& s1,const Skup& s2 ){ Skup s; for(Skup::Elem* tek=s1.prvi;tek;tek=tek->sled){ if(!(s2 % tek->broj))s.umetni(tek->broj); } return s; } Skup& Skup :: operator+= (const Skup& s){ for(Skup::Elem* tek=s.prvi;tek;tek=tek->sled){ if(!(*this % tek->broj)) umetni(tek->broj); } return *this; } ostream& operator<< (ostream& d, const Skup& s){ d<<'{'; for(Skup::Elem* tek=s.prvi;tek;tek=tek->sled){ d<<tek->broj<<(tek->sled?", ":" "); } return d<<'}'; }//skup.cpp //skupt.cpp #include"skup.h" #include<iostream> using namespace std; int main(){ char jos; do{ Skup s1; cout<<"Duzina skupa S1? .... "; int n1; cin>>n1; cout<<"\nElementi S1: "; s1.citaj(n1); Skup s2; cout<<"Duzina skupa S2? .... "; int n2; cin>>n2; cout<<"\nElementi S2: "; s2.citaj(n2); cout<<"\n S1= "; s1.pisi(); cout<<endl; cout<<"\n S2= "; s2.pisi(); cout<<endl; Skup s; cout<<"\nPRESEK ...\nS1*S2= "<< s1*s2;cout<<endl;//PRESEK cout<<"\nUNIJA ...\nS1+S2= "<< s1+s2;cout<<endl;//UNIJA cout<<"\nRAZLIKA ...\nS1-S2= "<< s1-s2;cout<<endl;//RAZLIKA cout<<"\nDa li zelite jos da radite? ..(D or N) or (d or n).. \n";cin>>jos; }while(jos == 'd' || jos =='D'); return 0; }//skupt.cpp


21

CEO PROGRAM Skup

Realizovano sa metodama

//skup.h #include<iostream> using namespace std; class Skup{ struct Elem{ double broj; Elem* sled; Elem(double b, Elem* s=0){broj=b;sled=s;} }; void kopiraj(const Skup& ); Elem* prvi; public: Skup(){prvi=0;} Skup(double b){prvi=new Elem(b);} Skup(const Skup& cs){kopiraj(cs);} ~Skup(){brisi();} bool jednak (const double &br)const; void brisi(); void pisi()const; void naPocetak(double b){cout<<"\nMETODA naPocetak(double)";Elem* novi=new Elem(b,prvi);prvi=novi;cout<<"\nMETODA na Pocetak(double)-ENDED\n";} void citaj(int n); void umetni(double b); friend Skup presek(const Skup& ,const Skup& ); friend Skup razlika (const Skup& ,const Skup& ); friend Skup unija ( Skup& s1 ,const Skup& s2){return s1.spoji(s2);} Skup& spoji (const Skup& s); friend ostream& operator<< (ostream& o, const Skup& s); };//skup.h //skup.cpp #include"skup.h" #include<iostream> using namespace std; void Skup :: kopiraj(const Skup& cs){ prvi=0; //pokazivac nove kopije for(Elem* tek=cs.prvi,*posl=0;tek;tek=tek->sled){ Elem* novi=new Elem(tek->broj); //novi čvor sa novom kopijom info polja cs objekta if(!prvi)prvi=novi; else posl->sled=novi; posl=novi;


22

} } void Skup :: brisi(){ while(prvi){ Elem* stari=prvi; prvi=prvi->sled; delete stari; } } void Skup :: pisi()const{ cout<< '{'; for(Elem* tek=prvi;tek;tek=tek->sled){ cout<<tek->broj; if(tek->sled!=0) cout<<','; } cout<<'}'; } void Skup :: citaj(int n){ brisi(); for(int i=0;i<n;i++){ double b; cin>>b; umetni(b); } } void Skup::umetni(double b){ Elem* tek=prvi, *pret=0; while(tek && tek->broj < b) {pret=tek;tek=tek->sled;} Elem* novi=new Elem(b,tek); if(!pret)prvi=novi; else pret->sled=novi; } bool Skup:: jednak (const double &br)const{ for(Elem* tek=prvi;tek;tek=tek->sled) if(tek->broj==br) return true; return false; } Skup presek (const Skup& s1,const Skup& s2 ){ Skup s; for(Skup::Elem* tek=s1.prvi;tek;tek=tek->sled){ if(s2.jednak( tek->broj))s.umetni(tek->broj); } return s; } Skup razlika (const Skup& s1,const Skup& s2 ){ Skup s; for(Skup::Elem* tek=s1.prvi;tek;tek=tek->sled){ if(!(s2.jednak( tek->broj)))s.umetni(tek->broj); } return s; } Skup& Skup :: spoji (const Skup& s){ for(Skup::Elem* tek=s.prvi;tek;tek=tek->sled){


23

if(!( (*this) .jednak( tek->broj))) umetni(tek->broj); } return *this; } ostream& operator<< (ostream& d, const Skup& s){ d<<'{'; for(Skup::Elem* tek=s.prvi;tek;tek=tek->sled){ d<<tek->broj<<(tek->sled?", ":" "); } return d<<'}'; } //skupt.cpp #include"skup.h" #include<iostream> using namespace std; int main(){ char jos; do{ Skup s1; cout<<"Duzina skupa S1? .... "; int n1; cin>>n1; cout<<"\nElementi S1: "; s1.citaj(n1); Skup s2; cout<<"Duzina skupa S2? .... "; int n2; cin>>n2; cout<<"\nElementi S2: "; s2.citaj(n2); cout<<"\n S1= "; s1.pisi(); cout<<endl; cout<<"\n S2= "; s2.pisi(); cout<<endl; cout<<"\nPRESEK ...\nS1*S2= " ; ( presek(s1,s2)).pisi();cout<<endl;//PRESEK cout<<"\nUNIJA ...\nS1+S2= " ; (unija(s1,s2)).pisi();cout<<endl;//UNIJA cout<<"\nRAZLIKA ...\nS1-S2= "; (razlika(s1,s2)).pisi();cout<<endl;//RAZLIKA cout<<"\nDa li zelite jos da radite? ..(D or N) or (d or n).. \n";cin>>jos; }while(jos == 'd' || jos =='D'); return 0; }//skupt.cpp


24

POLINOM

- Polinom sa jednom nezavisno promenljivom:

to je suma članova gde je koeficijent, a i kod stepen promenljive x.

Ima nepredvidiv broj članova

Javljaja se potreba za ubacivanjem novih i brisanjem starih članova

- Implementacija: u vidu ulančane liste gde je čvor liste oblika:

c Exp next

Koeficijent Stepen prom x Pok na slededi čvor

- SABIRANJE dva polinoma npr:

- - 2

+5

- + 3

- MNOŽENJE dva polinoma npr:

( - - 1)( + 1)

- – 1

- + – 2x

- + – 2x

- KOLIČNIK dva polinoma npr:


25

POREĐENJE: SEQVENCIJALNA vs ULANČANA REPREZENTACIJA

- MOja ideja (nedorađena! )- Poboljšanje efikasnosti operacija ( umetanje & brisanje ) kod niza :

Koristiti dva niza: 1.niz – vrednosti elemenata niza; 2.niz – logičke vrednosti su elementi ovog niza,

koje se koriste u nameri da kada se umetne element na i-tu poziciju 1.niza na i-tu poz 2.niza postaviš

1, a kada se obriše vred 0

Time si izbegao pomeranje elemenata pri umetanju/brisanju

Proverava se prvo niz sa bool vred pa tek tada se pristupa nizu sa traženim vred

Efekat je slededi: brišeš element logički a ne i fizički

OVO I NIJE BAŠ MOJA IDEJA – plagijat ideje iz pasusa o ‘’Predstavljanje skupova’’ seqvencijalno, ali

jeste moja ideja kako da se primeni kod operacija umetanja i brisanja kod niza

- Operacije UMETANJA i BRISANJA elementa na PROIZVOLJNOM MESTU, SPAJANJE / RAZBIJANJE DVE

STRUKTURE u jednu / na dve, favorizuju – ulančanu listu

- Operacija PRISTUPA PROIZVOLJNOM ELEMENTU favorizuje – seqvencijalnu reprezentaciju

- Memorijski proctor:

Ulančana lista – troši manje prostora i pored toga što traži dodatni prostor za jedan ili dva

pokazivača; koristi dinamičku alokaciju bez rezervisanja unapred

Seqvencijalna implementacija – zahteva fiksnu alokaciju mem na MAX br elemenata; PROBLEM:

neiskorišdenost prostora

STEK

MULTISTEK - Više stekova se smešta u zajednički vector ( zajednički blok memorije ) dužine V*1:m+

- Ovo se radi u slučaju kada se istovremeno koristi više stekova pa da bi iskorišdenje prostora bilo efikasnije

smeštaju se u jedan vector i dinamički preraspodeljuje proctor u skladu sa potrebama pojedinih stekova

- LIGHT MOTIV za ovakvu implementaciju je – vrlo je malo verovatno da de se svi ovi stekovi istovremeno

napuniti; kada se prekorači kap jednog steak da ne bi ostali stekovi zujali prazni

- SLUČAJ 2 STEKA:

b[1] & b[2] su vezana za dve fixne pozicije

PUSH_M(i,x) : Overflow pri umetanju => kada imaš : top[2]=top[1]+1 – vrhovi stekova su u susednim

lokacijama;to znači da je: SIZE_STEK*1++SIZE_STEK*2+=m

Stek1 Stek2

b[1]

top[1] top[2] b[2]

- SLUČAJ k STEKOVA:

Povremeno se vrši pomeranje stekova

Ne može da se fixiraju dna stekova

Vrši se preraspodela da bi se izbeglo prekoračenje – overflow

Koriste se pomodni vektori : top*1:k+ – pokazivači vrhova stekova i b*1:k+- pokazivači pozicije dna

stekova za k stekova


26

KONVERZIJA infix U postfix IZRAZ

IN2POST(infix,postix)

Ako je tabela prioriteta (IPR & SPR) i ranga(R(x)) rešiti ove primere:

Operator IPR SPR R

+,- 2 2 -1

*,/ 3 3 -1

^ 5 4 -1

( 6 0 -

) 1 - -

1) A+B*C-D+E-F*G/H next Stek Postfix rang

A A 1

+ + A 1

B + AB 2

*4 +* AB 2

C +* ABC 3

-5 - ABC*+ 1

D - ABC*+D 2

+6 + ABC*+D- 1

E + ABC*+D-E 2

- - ABC*+D-E+ 1

F - ABC*+D-E+F 2

* -* ABC*+D-E+F 2

G -* ABC*+D-E+FG 3

/ -/ ABC*+D-E+FG* 2

H -/ ABC*+D-E+FG*H 3

ABC*+D-E+FG*H/- 1

2) A+B/C^D-E*F

next Stek Postfix rang

A A 1

+ + A 1

B + AB 2

/ +/ AB 2

C +/ ABC 3

^ +/^ ABC 3

D +/^ ABCD 4

- - ABCD^/+ 1

E - ABCD^/+E 2

* -* ABCD^/+E 2

F -* ABCD^/+EF 3

ABCD^/+EF*- 1

4 IPR operatora * = 3 a SPR operatora + = 2 => IPR( * ) SPR( + ), pa se radi PUSH(S,next)

5 IPR(-)< SPR(*) , pa se radi while(...){ x=POP(s); OUTPUT(x,postfix); rank=rank + R(x) }

6 IPR(+)== SPR(-) , pa se radi while(...){ x=POP(s); OUTPUT(x,postfix); rank=rank + R(x) }


27

3) A+B*C-(D+E-F^G^H)*(I+(J-K)*L)/M next Stek Postfix rang

A A 1

+ + A 1

B + AB 2

* +* AB 2

C +* ABC 3

- - ABC*+ 1

( -( ABC*+ 1

D -( ABC*+D 2

+ + ABC*+D- 1 ERROR: IPR(+) SPR( ( )

E + ABC*+D-E 2

- - ABC*+D-E+ 1

F - ABC*+D-E+ 2

^ -^ ABC*+D-E+ 2

G -^ ABC*+D-E+G 3

^ -^^ ABC*+D-E+G 3

H -^^ ABC*+D-E+GH 4

) ) ABC*+D-E+GH^^- 1

* )* ABC*+D-E+GH^^- 1

( )*( ABC*+D-E+GH^^- 1

I )*( ABC*+D-E+GH^^-I 2

+ )+ ABC*+D-E+GH^^-* 1

( )+( ABC*+D-E+GH^^-* 1

J )+( ABC*+D-E+GH^^-*J 2

- - ABC*+D-E+GH^^-*J+ 1

K - ABC*+D-E+GH^^-*J+K 2

) ) ABC*+D-E+GH^^-*J+K- 1

* )* ABC*+D-E+GH^^-*J+K- 1

L )* ABC*+D-E+GH^^-*J+K-L 2

) ) ABC*+D-E+GH^^-*J+K-L* 1

/ )/ ABC*+D-E+GH^^-*J+K-L* 1

M )/ ABC*+D-E+GH^^-*J+K-LM 2

ABC*+D-E+GH^^-*J+K-LM/ 1


28

ISPRAVKA: next Stek Postfix rang

A A 1

+ + A 1

B + AB 2

* +* AB 2

C +* ABC 3

- - ABC*+ 1

( -( ABC*+ 1

D -( ABC*+D 2

+ -(+ ABC*+D 2 FIXING

E -(+ ABC*+DE 3

- -(- ABC*+DE+ 2

F -(- ABC*+DE+F 3

^ -(-^ ABC*+DE+F 3

G -(-^ ABC*+DE+FG 4

^ -(-^^ ABC*+DE+FG 4

H -(-^^ ABC*+DE+FGH 5

) - ABC*+DE+FGH^^- 2 !!! KLIZAVO

* -* ABC*+DE+FGH^^- 2

( -*( ABC*+DE+FGH^^- 2

I -*( ABC*+DE+FGH^^-I 3

+ -*(+ ABC*+DE+FGH^^-I 3

( -*(+( ABC*+DE+FGH^^-I 3

J -*(+( ABC*+DE+FGH^^-IJ 4

- -*(+(- ABC*+DE+FGH^^-IJ 4

K -*(+(- ABC*+DE+FGH^^-IJK 5

) -*(+ ABC*+DE+FGH^^-IJK- 4 !!! KLIZAVO

* -*(+* ABC*+DE+FGH^^-IJK- 4

L -*(+* ABC*+DE+FGH^^-IJK-L 5

) -* ABC*+DE+FGH^^-IJK-L*+ 3 !!! KLIZAVO

/ -/ ABC*+DE+FGH^^-IJK-L*+* 2

M ABC*+DE+FGH^^-IJK-L*+*M 3

ABC*+DE+FGH^^-IJK-L*+*M/- 1


29

GENERISANJE KODA - ALGORITAM GENERISANJA KODA:

Skenira postfix izraz 7

Ako je next OPERAND onda – PUSH(S,next) , gde je next trenutni element postfix-a

Ako je next OPERATOR onda – radi se POP(S) x2 ; generiše se odgovarajudi segmenta koda tako što

se O2 = POP(S) –prvi koji se skine sa steak postaje O2 i O1=POP(S)-drugi koji se skine sa steak postaje

O1

Druga instrukcija ovog segmenta koda ( ADD,SUB,MUL,DIV,….. )–realizuje dati operator

Treda instrukcija ovog segmenta koda (STORE)-smešta rezultat operatora primenjenog na operand u

privremenu lokaciju (za svaki operator posebna privremena lokacija)

Međurezultat ide na stek – PUSH(S,rez)

Ovo se sve radi dok IMA OPERATORA

1A mašina; O1@O2: ako je @ = + npr

* LOAD O1 ; Read O1 sa mem add i Write u ACC

ADD O2 ; Read iz ACC i sabiranje sadržaja ACC sa sadržajem reg u kome je O2

STORE O2 ; smeštanje O2 u mem lokaciju

0A mašina; O1@O2: ako je @ = - npr

* PUSH O1 ; Smešta O1 na vrh steka

PUSH O2 ; Smešta O2 na vrh steka

SUB ; Skida sa vrha steaka O2, O1 respektivno i oduzima O1 i O2

ADD :

* Komutativna, asocijativna

SUB :

* NEKomutativna, NEasocijativna

MUL :

* Komutativna, asocijativna

DIV :

* NEKomutativna, NEasocijativna

- Process generisanja koda iz postfix-a je različit za različite računarske mašine( 0A,1ADRESNA, 2A)

STEK MAŠINE:

* Za 0A mašine ne treba optimizacija,

* Operandi se podrazumevano nalaze na vrhu steka

* algoritam generisanja koda je direktan,

* ne zahteva korišdenje korisničkog steak jer ved postoji hardwerski,

* za svaki element izraza generiše se po jedna instrukcija

AKUMULATORSKE MAŠINE: Za 1A mašine mogude su naknadne optimizacije i pri tom vodiš računa o

slededem:

* Komutativnost nekih operatora

* Broj privremeno korišdenih lokacija se može redukovati –ako se prethodno proveri da li se

upotrebljena privremena lokacija kasnije koristi

* Redundatni 8parovi instrukcija – znači tražiš koji su parovi instrukcija suvišni u tvom segment

koda

7 Smer grupisanja: sleva-udesno

8 Redundatni – suvišan,rezerva,zaliha,ponavljanje,višak


30

1) 1A mašina; ( A+B*C )/D => ABC*+D/

next stek instrukcije

A A

B AB

C ABC

* A T1 LOAD B, MUL C, STORE T1

+ T2 LOAD A, ADD T1, STORE T2

D T2 D

/ T3 LOAD T2, DIV D, STORE T3 Nekomtativna; O1/O2 ; O1=T2 , O2= D

Generisani kod u simboličkom mašinskom jeziku je slededi:

LOAD B ; Acc := B

MUL C ; Acc := Acc *C

STORE T1 ; Mem[T1] := Acc

LOAD A ; Acc := A

ADD T1 ; Acc := Acc +C


LOAD T2 ; Acc := T2

DIV D ; Acc := Acc /D


Optimizacija:

LOAD B

MUL C

ADD A

DIV D

STORE T1

2) 0A mašina; ABC*+D/

next stek instrukcije

A A PUSH A

B AB PUSH B

C ABC PUSH C

* A rezMul MUL

+ rezAdd ADD

D rezAdd D PUSH D

/ rezDiv DIV

PUSH A

PUSH B

PUSH C

MUL

ADD

PUSH D

DIV


31

RED

QUEUE

- Karakteristična stanja kružnog bafera:

Prazan red => front=rear=0

Red sa jednim elementom => front = rear 0

front < rear - normalno stanje; broj elemenata reda = rear-front+1

front > rear – rear je obrnuo ceo krug pa opet popunjava od Q[1]; broj

elemenata reda = n-front+rear+1

Pun red => front =(rear mod n) +1

Za Q[ 1:n ]

Kreiranje reda Umetanje broja Brisanje broja

INIT_QUEUE(Q,n) ALLOCATE(Q(1:n)) front[Q]=rear[Q]=0

INSERT(Q,x) rear[Q]=(rear[Q] mod n) +1 if(front[Q]==rear[Q])then ERROR(Overflow) else Q[rear[Q]]=x if(front[Q]==0)then front [Q]=1 end_if end_if

DELETE(Q) if(front[Q]==0)then return underflow else x=front[Q] if( front[Q]==rear[Q] )then front[Q]=rear[Q]=0 else front[Q]=front[Q] mod n+1 end_if return x end_if

Za Q[ 0:n-1 ]

Kreiranje reda Umetanje broja Brisanje broja

INIT_QUEUE_0(Q,n) ALLOCATE(Q(0:n-1)) front[Q]=rear[Q]=n-1

INSERT_0(Q,x) rear[Q]=(rear[Q] +1) mod n9 if(front[Q]==rear[Q]10])then ERROR(Overflow) else Q[rear[Q]]=x end_if

DELETE_0(Q) if(front[Q]==rear[Q ]11)then return underflow else front[Q]=(front[Q] +1) mod n return Q[front[Q]] end_if

9 Morali smo prvo u operaciji umetanja da inkrementiramo pokazivač rear po modulu n , pa ako je on dostigao front –

overflow - da bi nam front[Q]==rear[Q] ostao kriterijum za prazan red 10

Kriterijum punog reda u implementaciji Q[ 0:n-1 ] za operaciju umetanja 11

Kriterijum praznog reda za implementaciju Q[ 0:n-1 ] za operaciju brisanja


32

KOMPRESIJA / DEKOMPRESIJA PODATAKA

DHUFFMAN

LZW

UVOD: Pokazivači, dinamički objekat u C/C++

- Pokazivači:

Činjenica : pokazivač na neki tip podataka može da ukazuje na PROSTOR PROIZVOLJNE VELIČINE, a ne

samo na mem proctor veličine jednog tog podatka

* Zato imamo u C-u: int * p= malloc(n*sizeof(int)) što znači : pokazivač p, pokazuje na

memorijski proctor koji je dodeljen nizu veličine n elemenata gde jedan element tipa int

zauzima proctor od sizeof(int) pa je zato za ceo niz potreban proctor od n*sizeof(int)

* U C++: operator new ovo sve radi automatski

To su promenljive koje sadrže adresu neke lokacije u OM

Definisanje: ime_tipa * identifikator_pok

Moguda je dodela adrese nekog podatka pokazivaču POMODU ADRESNOG OPERATORA &:

int* pa,a; pa = &a;

Mogud je pristup lokaciji na koju pokazuje pokazivač POMODU OPERATORA ZA INIDREKTAN PRISTUP

*:

*pa =1; // dodela jedinice lokaciji na koju pok pa

Ako je definisan neki statički niz: int a*+ = ,1,2,3,4-; ime “a” predstavlja KONSTANTI POK NA

POČETAK NIZA

&a[0] a

&a[i] a+i

a[i] *(a+i)


33

Primer niz_vol1: pokazuje da je potrebna EXPLICITNA inicijalizacija svih članova niza ako želiš da oni imaju na

početku neke podrazumevane vrednosti


34

- Dinamički objekti (C++) :

Operatorom new kreira se jedan dinamički objekat nekog tipa T; alocira potreban prostor u OM za

objekat datog tipa, a zatim poziva konstruktor datog tipa;rezultat operacije je POKAZIVAČ na dati tip;

dinamički objekat TRAJE SVE DOK SE NE OZVRŠI operator delete

Operatorom delete uništava se jedan dinamički objekat nekog tipa T;poziva destructor za objekat koji

se briše tj objekat na koji ukazuje pokazivač koji je argument opearotra delete; operator vrada void

dakle bez rezultata je

- Funkicije/metode:

Inline funkcija :

friend funkcija :

const

volatile

- Konstruktori:

Podrazumevani:

Kopije:

Konverzije:

explicit – explicitno pozivanje konstruktora:


35

KONVERZIJA TIPA

PREKLAPANJE OPERATORA

- Podrazumeva definisanje tumačenja za standardne OPERATORE čiji su OPERANDI klasni tipovi

- Nemaju argument sa podrazumevanim vrednostima

- NE MOGU DA SE PREKLOPE operatori za :

Pristup članu klase . i .*

Razrešenje dosega ::

Uslovni izraz ?:

Veličinu objekata sizeof

Prijavljivanje izuzetka throw

- OGRANIČENJA kod preklapanja operatora- ne mogu da se:

Uvedu novi simboli

Promene prioriteti i smer grupisanja pojedinih operatora

Definišu nova tumačenja za standardne tipove (int,double,…)

- AUTOMATSKA TUMAČENJA SAMO ZA sledede operatore(naravno sve dok se ne redefinišu) :


36

Dodele vrednosti jednog obj drugom (=)

Obrazovanje adrese obj (&)

Obrazovanje niza izraza (,) za korisničke tipove

Pristup članu (.)

Indirektno adresiranje (*)

Posredan pristup članu (->) za pokazivačke tipove na korisničke tipove

Indeksiranje ([])

- POSEBNA OGRANIČENJA SU ZA operatore:

new One su deklarisane kao static (iako nije tako deklarisana), ne treba explicitno pozivati

konstruktor (implicitno se poziva posle opf-je operator new),rezultat – pok na alocirani

proctor(void*), argument- size_t velicina , gde je size_t celobrojni tip definisan u

<stddef.h> i izražava veličinu objekta u BAJTOVIMA, ne mogu biti virtual ali se nasleđuju

delete One su deklarisane kao static (iako nije tako deklarisana), ne treba explicitno pozivati

destruktor (implicitno se poziva pre opf-je operator delete),rezultat – void, argument –

void* pk gde je pk,pok na alocirani proctor koji se briše, ne mogu biti virtual ali se

nasleđuju

i++ PREFIX - metoda klase T bez argumenta T operator ++() ili kao friend f-ja klase T sa 1

argumentum T operator ++(T)

POSTFIX – sadrži jedan dodatni argument tipa int; metoda klase T sa 1 argumentom

T operator ++(int) ili friend f-ja sa 2 argumenta T operator ++(T,int)

!!!ako se koristi notacija i++ onda arg int =0, ako se koristi notacija i.operator++(k) ili

operator++(t,k) može biti k!=0

i— analogno sa i++;

= Mora biti ne static metoda, prvo uništava stari sadržaj a zatim kopira novi onaj sa desne

strane operatora =; NAPOMENA:ako neka klasa ima destructor, konstruktor

Kopije ili operator=(), sva je prilika da TREBA da sadrži SVA TRI

() binarni operator za pozivanje f-je: mora da bude ne static metoda( ne može biti friend),

Argument-proizvoljan broj proizvoljnog tipa(može i nula argumenta), rezultat- treba

da bude tipa koji je istog tipa kao i izraz koji vrada f-ja

[] NIJE INDEXIRANJE iako izgleda tako; Mora biti ne static metoda, kod standardnog

indexiranja index mora da bude celobrojnog tipa, kod preklopljenog može biti

proizvoljnog tipa, ako želimo slededi izraz obj[index]=izraz tip rezultata operator [] f-

je treba da je UPUDIVAČ na podatke koje sadrži posmatrana klasa-tada moraš

napraviti dve varijante ove f-je za PROMENLJIVE i NEPROMENLJIVE objekte;

operator[] dejstvuje na OBJEKAT SVOJE KLASE, a ne na niz objekata- tako da nije isto

obj[i] *(obj+i) po uzoru na niz[i] *(niz+i) za nizove podataka

-> Unarni operator za pristupanje članu klase(objekta):

mora da bude ne static metoda (ne može globalna-friend funkcija), bez argumenata,

rezultat – tipa pok na klasu koja sadrži član ili referenca(ili objekat) klase za koju je

definisan operator->()

(tip) Unarni operator koji treba da izvrši konverziju objekta klase :

mora da bude ne static metoda (ne može globalna-friend funkcija), bez argumenata

rezultat se ne navodi uopšte(podrazumeva se na osnovu imena f-je)

c++ skripta

Documents