nelinearne strukture

8/20/2019 Nelinearne strukture

1/51

2007

Prirodno-matematičkifakultet u Nišu

Ivan Stanković

[STRUKTURE I BAZEPODATAKA - NELINEARNE

STRUKTURE]


2/51

DEFINICIJE I KONCEPTI 2


3/51

3 STABLA

1. NELINEARNE STRUKTURE PODATAKA

Najznačajnije nelinearne strukture podataka su stabla i grafovi.

1.1. STABLA

1.1.1. DEFINICIJE I KONCEPTI

Graf G=(V,E) se sastoji od nepraznog skupa čvorova G i skupa E koji je skup grana grafa.

Stablo je acikličan, orijentisan graf koji ima jedan čvor koji se zove koren (root) sa ulaznim

stepenom 0 dok svi drugi čvorovi imaju ulazni stepen 1. Ako izbrišemo koren i njegove grane dobijamo

skup disjunktnih stabala. Svaki čvor kojiima izlazni stepen 0 naziva se terminalni čvor ili list, dok se svi

drugi čvorovi nazivaju čvorovi grananja (brunch nodes).

• Nivo čvora je njegova dužina od korena, d.

• Dubina (visina) stabla je maksimalna vrednost nivoa nekog čvora u stablu.

• Za stablo se kaže da je n-arno (reda n) ako svaki čvor ima najviše n podčvorova.

• Za stablo se kaže da je puno ako se svi listovi nalaze na istom rastojanju od korena, tj. ako

od korena do svakog lista odgovara put dužine h-1.

• Za stablo se kaže da je kompletno ako svi njegovi čvorovi koji ne predstavljaju listove imaju

svih n odlaznih potega.

• Broj čvorova kompletnog punog stabla iznosi

C = n0 + n1 + n3 + ... + nh = ∑ ℎ =0 =(ℎ+1−1)

(−1)

• Kapacitet čvora k predstavlja broj elemenata koji se može smestiti u čvor.

• Za stablo se kaže da je balansirano ako za svaki čvor važi da se broj čvorova u svakom

njegovom podstablu ne razlikuje za više od 1.


4/51

OPERACIJE NA BINARNIM STABLIMA 4

• Za stablo reda n čiji su svi čvorovi na nivoima od 1 do h-1 kompletni, kaže se da je

optimalno balansirano.

1.1.2. OPERACIJE NA BINARNIM STABLIMANeke od operacija nad binarnim stablom su: prolaz, umetanje, brisanje, pretraživanje i kopiranje.

/ * r ad sa bi nar ni m st abl om - i mpl ement aci j a f unkci j a koj e vr se speci f i cnuobr adu nad cvorovi ma

bi nar nog st abl a */

#i ncl ude #i ncl ude

t ypedef struct cvor { i nt broj ; struct cvor *l evo, *desno; } Cvor ;t ypedef Cvor *St abl o;

St abl o st vor i ( voi d) ; / * Stavaranj e pr aznogstabl a. * /i nt vel ( St abl o kor en) ; / * Br oj cvor ova u st abl u.*/i nt zbi r ( St abl o kor en) ; / * Zbi r br oj eva u st abl u.*/voi d pi s i _kl d ( St abl o kor en) ; / * Pr ef i ksno i spi s i vanj e.*/voi d pi s i _ l kd ( St abl o kor en) ; / * I nf i ksno i spi s i vanj e.*/voi d pi s i _ l dk (St abl o kor en) ; / * Postf i ksno i spi s i vanj e.*/voi d cr t aj ( St abl o kor en, i nt ni vo) ; / * Graf i cki pr i kaz stabl a.

*/i nt poj av ( St abl o kor en, i nt b ) ; / * Br oj poj avl j i vanj a u stabl u.*/i nt mi n_u ( St abl o kor en) ; / * Naj manj i u ur edj enom st abl u.*/i nt max_u ( St abl o kor en) ; / * Naj veci u ur edj enom st abl u.*/i nt mi n_n ( St abl o kor en) ; / * Naj manj i u neur edj enom st abl u.*/i nt max_n (St abl o kor en) ; / * Naj veci u neur edj enom st abl u.*/i nt ur edj eno ( St abl o kor en) ; / * Da l i j e st abl o ur edj eno?*/Cvor *nadj i _u ( St abl o kor en, i nt b ) ; / * Trazenj e u ur edj enom st abl u.

*/Cvor *nadj i _n ( St abl o kor en, i nt b ) ; / * Tr azenj e u neur edj enom st abl u.*/St abl o dodaj _u (St abl o koren, i nt b ) ; / * Dodavanj e u ur edj eno stabl o.*/St abl o dodaj _n (St abl o koren, i nt b ) ; / * Dodavanj e u neur edj eno st abl o.*/St abl o ci t aj _u ( i nt n ) ; / * Ci t anj e ur edj enog st abl a.*/


5/51

5 STABLA

St abl o ci t aj _n ( i nt n ) ; / * Ci t anj e neur edj enog st abl a.*/St abl o br i si ( St abl o kor en) ; / * Br i sanj e cel og st abl a.*/St abl o i zost _u ( St abl o kor en, i nt b ) ; / * I zost. i z ur edj enog stabl a.

*/St abl o i zost _n ( St abl o kor en, i nt b ) ; / * I zost . i z neur edj enog st abl a.*/St abl o bal ans_u ( St abl o kor en) ; / * Bal ansi r anj e ur edj enog st abl a.*/St abl o bal ans_n ( St abl o kor en) ; / * Bal ansi r anj e neur edj enogsat bl a. * /i nt moze ( St abl o kor en) ; / * Da l i moze ur edj ena r adnj a? */St abl o radi ( St abl o (*f ) ( St abl o, i nt ) , St abl o kor en) ; / * Pr i mena operaci j e nast abl o za svaki pr oci t ani br oj */

voi d mai n ( ) {St abl o kor en = st vor i ( ) ; / / s tabl oi nt kraj = 0, br oj , n; / / i ndi kat or kraj a r ada, el ement u cvor u st abl a,

duzi nachar i zbor [ 2] ; / / i zbor kor i sni ka sa meni j a opci j a

/ / obr ada meni j a opci j a koj e se pr i kazuj u kor i sni kuwhi l e ( !k raj ) {

pr i nt f ( " \ nDodavanj e br oj eva: a) ur edj eno b) neur edj eno\ n""I zost avl j anj e br oj eva: c) ur edj eno d) neur edj eno\ n""Ci t anj e st abl a: e) ur edj eno f ) neur edj eno\ n""Naj manj i el ement : g) ur edj eno h) neur edj eno\ n""Naj veci el ement : i ) ur edj eno j ) neur edj eno\ n""Pret r azi vanj e: k) ur edj eno l ) neur edj eno\ n""Bal ansi r anj e: m) ur edj eno n) neur edj eno\ n""Pi sanj e st abl a: p) kor en- l evo- desno\ n"

" q) l evo- kor en- desno ( ur edj eno) \ n"" r ) l evo- desno- kren\ n"" s) crt anj e\ n""1. Vel i ci na st abl a 2. Zbi r el emenat a\ n""3. Br oj poj avl j i vanj a 4. Pr aznj enj e st abl a\ n"" 0. Zavrset ak r ada\ n\ n""Vas i zbor ? "

) ;scanf ( "%s" , &i zbor) ;swi t ch ( i zbor[ 0] ) {case ' a' : case ' A' : / * Dodavanj e br oj eva u ur edj eno st abl o: */

i f ( moze ( kor en) ) kor en = r adi ( dodaj _u, kor en) ; break;case ' b' : case ' B' : / * Dodavanj e br oj eva u neur edj eno st abl o: */

kor en = r adi ( dodaj _n, kor en) ; break;case ' c' : case ' C' : / * I zost avl j anj e br oj eva i z ur edj enog st abl a: */

i f ( moze ( kor en) ) kor en = r adi ( i zost_ u, kor en) ; break;case ' d' : case ' D' : / * I zost avl j anj e br oj eva i z neur edj enog st abl a: */

kor en = r adi ( i zost _n, kor en) ; break;case ' e' : case ' E' : / * Ci t anj e ur edj enog st abl a: */

pr i nt f ( "Duzi na? ") ; scanf ( "%d" , &n) ;pr i nt f ( "Br oj evi ? " ) ; kor en = br i si ( kor en) ; kor en = ci t aj _u ( n) ;break;

case ' f ' : case ' F' : / * Ci t anj e neur edj enog st abl a: */


6/51


pr i nt f ( "Duzi na? ") ; scanf ( "%d" , &n) ;pr i nt f ( "Br oj evi ? ") ; kor en = br i si ( kor en) ; kor en = ci t aj _n ( n) ;break;

case ' g' : case ' G' : case ' h' : case ' H' :case ' i ' : case ' I ' : case ' j ' : case ' J ' :

i f ( kor en) swi t ch ( i zbor[ 0] ) {case ' g' : case ' G' : / * Naj manj i el ement ur edj enog stabl a: */

i f ( moze ( kor en) ) pr i nt f ( "mi n= %d\ n" , mi n_u ( kor en) ) ; break;case ' h' : case ' H' : / * Naj manj i el ement neur edj enog st abl a: */

pr i nt f ( "mi n= %d\ n" , mi n_n ( kor en) ) ; break;case ' i ' : case ' I ' : / * Naj veci el ement ur edj enog st abl a: */

i f ( moze ( kor en) ) pr i nt f ( "max= %d\ n" , max_u ( kor en) ) ; break;case ' j ' : case ' J ' : / * Naj veci el ement neur edj enog stabl a: */

pr i nt f ( "max= %d\ n" , max_n ( kor en) ) ; break;} el se pr i nt f ( "* ** St abl o j e par zno! ***\ a\ n" ) ;break;

case ' k' : case ' K' : / * Br oj poj avl j i vanj a u ur edj enom stabl u: */i f ( moze ( koren) ) {

pr i nt f ( "Br oj ? " ) ; scanf ( "%d" , &broj ) ;pr i nt f ( "Br oj se%s nal azi u st abl u. \ n" ,

( nadj i _u ( kor en, br oj ) ! = NULL ? "" : " NE") ) ;} break;

case ' l ' : case ' L' : / * Br oj poj avl j i vanj a u neur edj enom st abl u: */pr i nt f ( "Br oj ? " ) ; scanf ( "%d" , &broj ) ;pr i nt f ( "Br oj se%s nal azi u st abl u. \ n" ,

( nadj i _n ( kor en, br oj ) ! = NULL ? "" : " NE") ) ;break;

case ' m' : case ' M' : / * Bal ansi r anj e ur edj enog st abl a: */i f ( moze ( kor en) ) kor en = bal ans_u ( kor en) ; break;

case ' n' : case ' N' : / * Bal ansi r anj e neur edj enog st abl a: */kor en = bal ans_n ( kor en) ; break;

case ' p' : case ' P' : / * Pi sanj e st abl a kor en- l evo- desno: */

pr i nt f ( "St abl o= " ) ; pi s i _kl d ( kor en) ; put char ( ' \ n' ) ; break;case ' q' : case ' Q' : / * Pi sanj e st abl a l evo- kor en- desno: */

pr i nt f ( "St abl o= " ) ; pi s i _ l kd ( kor en) ; put char ( ' \ n' ) ; break;case ' r ' : case ' R' : / * Pi sanj e st abl a l evo- desno- kor en: */

pr i nt f ( "Stabl o= " ) ; pi s i _ l dk (kor en) ; put char ( ' \ n' ) ; break;case ' s' : case ' S' : / * Cr t anj e stabl a: */

crt aj ( kor en, 0) ; break;case ' 1' : / * Vel i ci na stabl a: * /

pr i nt f ( "Vel = %d\ n", vel ( koren) ) ; break;case ' 2' : / * Zbi r el emenat a st abl a: */

pr i nt f ( "Zbi r = %d\ n", zbi r (koren) ) ; break;case ' 3' : / * Br oj poj avl j i vanj a dat og br oj a: */

pr i nt f ( "Br oj ? " ) ; scanf ( "%d" , &br oj ) ;pr i nt f ( "Br oj se poj avl j uj e %d put a. \ n" , poj av (koren, broj ) ) ;break;

case ' 4' : / * Pr aznj enj e stabl a: */kor en = br i si ( kor en) ; break;

case ' 0' : / * Zavr set ak rada: */kraj = 1; break;

def aul t : / * Pogr esan i zbor : */pr i nt f ( "*** Nedozvol j eni i zbor ! ***\ a\ n" ) ; break;

}}


7/51

7 STABLA

}

St abl o st vor i ( voi d) { return NULL; } / * St var anj e pr aznog st abl a. */

i nt vel ( St abl o kor en) / * Br oj cvor ova u st abl u.

*/{ return kor en ? 1 + vel ( kor en- >l evo) + vel ( kor en- >desno) : 0; }

i nt zbi r ( St abl o kor en) / * Zbi r br oj eva u st abl u.*/

{ return kor en ? kor en- >br oj + zbi r ( kor en- >l evo) + zbi r ( kor en- >desno) :0; }

voi d pi si _kl d ( St abl o kor en) { / * Pref i ksno i spi s i vanj e.*/

i f ( kor en) {pr i nt f ( "%d " , kor en- >br oj ) ; pi si _kl d ( kor en- >l evo) ; pi si _kl d ( kor en-

>desno) ;}

}

voi d pi si _l kd ( St abl o kor en) { / * I nf i ksno i spi s i vanj e.*/

i f ( kor en) {pi s i _ l kd ( kor en- >l evo) ; pr i nt f ( "%d " , kor en- >br oj ) ; pi si _l kd ( kor en-

>desno) ;}

}

voi d pi si _l dk (St abl o kor en) { / * Postf i ksno i spi s i vanj e.*/

i f ( kor en) {

pi si _l dk (kor en- >l evo) ; pi si _l dk (kor en- >desno) ; pr i nt f ( "%d " , kor en->br oj ) ;

}}

voi d cr t aj ( St abl o kor en, i nt ni vo) { / * Gr af i cki pr i kaz stabl a.*/

i f ( kor en) {cr t aj ( kor en- >desno, ni vo+1) ;pr i nt f ( "%*s%d\ n" , 4*ni vo, "" , kor en- >br oj ) ;crt aj (kor en- >l evo, ni vo+1) ;

}}

i nt poj av ( St abl o kor en, i nt b) / * Br oj poj avl j i vanj a br oj a b ustabl u. * /

{ return koren ? ( koren- >br oj ==b) +poj av( kor en- >l evo, b) +poj av( koren->desno, b) : 0; }

i nt mi n_u ( St abl o koren) / * Naj manj i u ur edj enom st abl u.*/

{ return koren- >l evo ? mi n_u ( kor en- >l evo ) : kor en- >br oj ; }


8/51


i nt max_u ( St abl o kor en) / * Naj veci u ur edj enom st abl u.*/

{ return koren- >desno ? max_u (koren- >desno) : koren- >broj ; }

i nt mi n_n ( St abl o koren) { / * Naj manj i u neur edj enom st abl u.

*/i nt m = kor en- >br oj , k;i f ( koren- >l evo ) { k = mi n_n ( kor en- >l evo ) ; i f ( k < m) m = k; }i f ( koren- >desno) { k = mi n_n ( koren- >desno) ; i f ( k < m) m = k; }return m;

}

i nt max_n (Stabl o kor en) { / * Naj veci u neur edj enom st abl u.*/

i nt m = kor en- >br oj , k;i f ( koren- >l evo ) { k = max_n ( koren- >l evo ) ; i f ( k > m) m = k; }i f ( kor en- >desno) { k = max_n ( kor en- >desno) ; i f ( k > m) m = k; }return m;

}

i nt ur edj eno (St abl o kor en) { / * Da l i j e st abl o ur edj eno?*/

i f (! koren) return 1;i f ( kor en- >l evo && ( ! uredj eno ( kor en- >l evo ) | |

max_u ( koren- >l evo) > koren- >br oj ) ) return 0;i f ( koren- >desno && ( ! ur edj eno ( kor en- >desno) | |

mi n_u ( koren- >desno) < koren- >br oj ) ) return 0;return 1;

}

Cvor *nadj i _u ( St abl o kor en, i nt b) { / * Trazenj e u ur edj enom st abl u.*/

i f (! koren) return NULL;i f ( koren- >broj == b) return kor en;i f ( kor en- >br oj > b) return nadj i _u ( kor en- >l evo, b) ;

return nadj i _u (koren- >desno, b) ;}

Cvor *nadj i _n ( St abl o kor en, i nt b) { / * Tr azenj e u neur edj enom st abl u.*/

i f (! koren) return NULL;i f ( koren- >broj == b) return kor en;{ Cvor *cvr = nadj i _n ( kor en- >l evo, b) ; i f ( cvr ) return cvr ; }return nadj i _n ( kor en- >desno, b) ;

}

St abl o dodaj _u (St abl o koren, i nt b) { / * Dodavanj e u ur edj eno stabl o.*/

i f ( ! kor en) {koren = mal l oc ( si zeof ( Cvor) ) ;koren- >broj = b; kor en- >l evo = kor en- >desno = NULL;

} el se i f ( kor en- >br oj > b)kor en- >l evo = dodaj _u ( kor en- >l evo, b) ;

el se i f ( kor en- >br oj < b)koren- >desno = dodaj _u ( koren- >desno, b) ;


9/51

9 STABLA

el se i f ( r and( ) / ( RAND_MAX+1. ) < 0. 5)kor en- >l evo = dodaj _u ( kor en- >l evo, b) ;

el sekoren- >desno = dodaj _u ( koren- >desno, b) ;

return kor en;

}

St abl o dodaj _n (St abl o kor en, i nt b) { / * Dodavanj e u neur edj eno st abl o.*/

i f ( ! kor en) {koren = mal l oc ( si zeof ( Cvor) ) ;koren- >broj = b; kor en- >l evo = kor en- >desno = NULL;

} el se i f ( r and( ) / ( RAND_MAX+1. ) < 0. 5)kor en- >l evo = dodaj _u ( kor en- >l evo, b) ;

el sekoren- >desno = dodaj _u ( koren- >desno, b) ;

return kor en;}

St abl o ci t aj _u ( i nt n) { / * Ci t anj e ur edj enog st abl a. */Stabl o koren = NULL; i nt i , b;f or ( i =0; i l evo) ; kor en- >desno = br i si ( kor en- >desno) ;f r ee ( kor en) ; kor en = NULL;

}return kor en;

}

St abl o i zost _u ( St abl o kor en, i nt b) { / * I zost. i z ur edj enog stabl a.*/

i f ( kor en) {i f ( kor en- >br oj > b) kor en- >l evo = i zost _u ( kor en- >l evo, b) ;el se i f ( kor en- >broj < b) koren- >desno = i zost _u ( koren- >desno, b) ;el se i f ( kor en- >l evo) {

i nt m = max_u ( koren- >l evo) ;koren- >br oj = m; koren- >l evo = i zost _u ( kor en- >l evo, m) ;

} el se i f ( koren- >desno) {i nt m = mi n_u ( koren- >desno) ;koren- >broj = m; koren- >desno = i zost _u ( koren- >desno, m) ;

} el se {f r ee ( kor en) ; kor en = NULL;

}}


10/51


return kor en;}

St abl o i zost _n ( St abl o kor en, i nt b) { / * I zost . i z neur edj enog st abl a.*/

i f ( kor en) {i f ( koren- >broj == b) {

i f ( kor en- >l evo ) {kor en- >br oj = kor en- >l evo- >br oj ;kor en- >l evo = i zost _n ( kor en- >l evo, kor en- >br oj ) ;

} el se i f ( koren- >desno) {kor en- >br oj = kor en- >desno- >br oj ;kor en- >desno = i zost _n ( koren- >desno, kor en- >br oj ) ;

} el se { f r ee ( koren) ; kor en = NULL; }} el se {

i nt v = vel ( kor en- >l evo) ; kor en- >l evo = i zost _n ( kor en- >l evo, b) ;i f ( v == vel ( kor en- >l evo) ) koren- >desno = i zost _n ( kor en- >desno, b) ;

}}return kor en;

}

St abl o bal ans_u (St abl o kor en) { / * Bal ansi r anj e ur edj enog st abl a.*/

i f ( kor en) {i nt k = vel ( kor en- >l evo) - vel ( kor en- >desno) ;f or ( ; k>1; k- =2) {

koren- >desno = dodaj _u ( kor en- >desno, koren- >br oj ) ;koren- >br oj = max_u ( kor en- >l evo ) ;kor en- >l evo = i zost _u ( kor en- >l evo , kor en- >br oj ) ;

}f or ( ; kl evo = dodaj _u ( kor en- >l evo , kor en- >br oj ) ;koren- >broj = mi n_u ( koren- >desno) ;koren- >desno = i zost _u ( kor en- >desno, koren- >br oj ) ;

}kor en- >l evo = bal ans_u ( kor en- >l evo ) ;koren- >desno = bal ans_u ( koren- >desno) ;

}return kor en;

}

St abl o bal ans_n (St abl o kor en) { / * Bal ansi r anj e neur edj enogsatbl a. * /

i f ( kor en) {i nt k = vel ( kor en- >l evo) - vel ( kor en- >desno) ;f or ( ; k>1; k- =2) {

koren- >desno = dodaj _n ( kor en- >desno, koren- >br oj ) ;kor en- >br oj = kor en- >l evo - >br oj ;kor en- >l evo = i zost _n ( kor en- >l evo , kor en- >br oj ) ;

}f or ( ; kl evo = dodaj _n ( kor en- >l evo , kor en- >br oj ) ;koren- >br oj = koren- >desno- >br oj ;koren- >desno = i zost _n ( kor en- >desno, koren- >br oj ) ;


11/51

11 STABLA

}kor en- >l evo = bal ans_n ( kor en- >l evo ) ;koren- >desno = bal ans_n ( koren- >desno) ;

}return kor en;

}

i nt moze (Stabl o kor en) { / * Da l i moze ur edj ena r adnj a? */i f ( ! ur edj eno (kor en) ) {

pr i nt f ( "*** St abl o ni j e ur edj eno! ***\ a\ n" ) ;return 0;

}el se return 1;

}

/ * Pr i mena oper aci j e na st abl o za svaki pr oci t ani br oj : */St abl o radi ( St abl o (*f ) ( St abl o, i nt ) , St abl o kor en) {

i nt b; char zn;pr i nt f ( "Br oj evi ? ") ;do { scanf ( "%d%c" , &b, &zn) ; kor en = ( *f ) ( kor en, b) ; } whi l e ( zn !=

' \ n' ) ;return kor en; / * do kraj a r eda */

}

1. U datoteci zad1in.txt se nalazi niz reči (koje su zapisane u posebnim redovima datoteke) od kojih ni

jedna nije dužine veće od 30 karaktera. Ispisati na standardni izlaz samo različite reči sortirane

leksikografski. Uz svaku reč ispisati i broj pojava. Kraj unosa je marker kraja (EOF). Smatrati da je reč

niska sastavljen isključivo od slova i cifara i broj pojava svake reči nije veći od 10000.

/ * Samor ef er ent ne st r uktur e , bi narno pr et r azi vacko st abl o */#i ncl ude #i ncl ude #i ncl ude #i ncl ude #def i ne MAXREC 31t ypedef struct dr vo_t ag{

char *rec; / * pokazuj e na r ec t ekst a */i nt broj ; / * br oj poj avl j i vanj a pod

pr et post avkom da j e i nt dovol j an */struct dr vo_t ag *l evo; / * l eva gr ana */struct dr vo_t ag *desno; / * desna gr ana */

} dr vo;/ * Protot i povi f unkc i j a * /dr vo *addt r ee( dr vo *, char * ) ;

voi d tr eepr i nt ( dr vo *) ;i nt uzmi _r ec(char *, i nt , FI LE* ) ;dr vo *t al l oc( voi d ) ;char *st r dpl ( char * ) ;voi d osl obodi t i ( dr vo *k) ;mai n( ) {

dr vo *koren; / *kor en st abl a pr et r azi vanj a */char r ec[ MAXREC] ; / *sadr zaj r eci sa ul aza */FI LE * f ;/ *uci t avanj e reci ci j i br oj poj avl j i vanj a se br oj i * /


12/51


kor en = NULL;f =f open( "zad1i n. t xt " , " r " ) ;whi l e( 1 ) {

i nt kraj = uzmi _r ec( r ec, MAXREC, f ) ;/ *dodavanj e novog cvor a u st abl o i l i i zmena nad pol j em br oj vec

post oj eceg cvor a */i f ( st r l en( r ec) ) kor en = addt r ee( kor en, r ec) ;i f ( kr aj == EOF) break; / *uci t avanj e se vr si do mar ker a kr aj a */

}/ *st ampanj e sadr zaj a st abl a - l eksi kogr af ski por edak reci */t r eepr i nt ( kor en) ;/ *osl obadj anj e zauzet og pr ostor a za st abl o pr et r age */osl obodi t i ( kor en) ;f cl ose( f ) ;return 0;

}/ * addt r ee - dodaj e cvor sa t ekst om na koj i pokazuj e w, na i l i i spod p udr vet u*/dr vo *addt r ee( drvo *p, char *w ){

i nt cond;i f ( p == NULL ) / * nai sl a nova r ec */{

p = t al l oc() ;p- >r ec = st r dpl ( w) ;p- >br oj = 1;p- >l evo = p- >desno = NULL;

}el se i f ( ( cond = st r cmp(w, p- >r ec) ) == 0 )

p- >broj ++; / * ponovl j ena r ec */el se i f ( cond < 0 ) / * manj e => l evi ogr anak */

p- >l evo = addt r ee( p- >l evo, w) ;

el se / *vece =>desni ogr anak*/p- >desno = addt r ee( p- >desno, w) ;

return p;}voi d t r eepr i nt ( dr vo *p) / * t r eepr i nt - r ekur zi vno stampanj e dr vet a*/{

i f ( p != NULL ){

t r eepr i nt ( p- >l evo ) ;pr i nt f ( "%4d %s\ n" , p- >br oj , p- >r ec );t r eepr i nt ( p- >desno );

}}i nt uzmi _r ec(char s [ ] , i nt l i m, FI LE * f ){

char c, i = 0;/ * pr eskoci t i sve znake do s l ova i l i c i f r e */whi l e( ! i sal num( c = s[ 0] = f get c( f ) ) && c! =EOF) ;i f ( c==EOF ) {s[ 0] = ' \ 0' ; return EOF; } / * pr azna r ec i vr at i t i EOF *// * uci t at i ost at ak r eci : ( u s[ 0] se vec nal azi pr vo sl ovo) */whi l e( ( c = f getc( f ) ) ! = EOF && i sal num( c) && i < l i m)

s[ ++i ] = c;s[ ++i ] = ' \ 0' ; / * zavrs i t i ni sku * /


13/51

13 STABLA

i f ( c==EOF )return EOF;

return i ;}/ * t al l oc pr avi j edan cvor dr vet a */

dr vo *t al l oc(voi d){ return ( dr vo *) mal l oc( si zeof ( dr vo) ) ; }char *st r dpl ( char *s) / * pr avi se kopi j a ni ske s */{

char *p;p = ( char *) mal l oc(st r l en( s) + 1 ) ;i f ( p ! = NULL ) st r cpy(p, s) ;return p;/ * u post oj i st andar dna f unkci j a "st r dup" koj a obavl j a navedene

oper aci j e*/}voi d osl obodi t i ( dr vo *k){ / *r ekur zi vno se osl obadj a l evo i desno podst abl o kor ena zadatog st abl a */

i f ( k- >l evo) osl obodi t i ( k->l evo) ;i f ( k- >desno) osl obodi t i ( k- >desno) ;f ree (k ) ; / *br i sanj e cvor a koj i pr edst avl j a kor en zadat og st abl a */

}

2. Napisati program koji sa standardnog ulaza čita aritmetički izraz zapisan u prefksnoj notaciji operator

izraz1 izraz2, smešta ga u niz karaktera dužine do 20 karaktera i formira stablo u čijem se korenu nalazi

zadati operator, u levom podstablu izraz1 a u desnom izraz2. Pri tome se izraz zadaje ili kao ceo broj ili

kao operator izraz1 izraz2. Napisati rekurzivnu funkciju koja od učitanog stringa formira binarno stablo.

Prilikom zadavanja izraza očekujemo da su svi operandi razdvojeni jedan od drugog razmakom i da je

izraz pravilno zadat. Napisati i funkcije koje ovako zadato stablo ispisuju u prefksnom i infiksnom

poretku i funkciju koja računa vrednost izraza koji se nalazi u stablu.

#i ncl ude #i ncl ude #i ncl ude #i ncl ude

/ * Def i ni semo novi t i p oper aci j a */t ypedef enum oper aci j a {pl = ' +' , mi n = ' - ' , pod = ' / ' , put = ' *' }oper aci j a;/ * St r uktura koj a pr edst avl j a j edan cvor */t ypedef struct _cvor {

i nt i nd; / * i ndi kat or da l i se u cvor u nal azi oper at or ( u t om sl ucaj ui nd i ma vr ednost 1)

i l i br oj ( u t om sl ucaj u i nd i ma vr ednost 0) */i nt br ; / * pol j e u kome cuvamo ceo br oj , popunj eno samo ako j e pol j e

i nd post avl j eno na 0 */oper aci j a op; / * pol j e u kome cuvamo operat or , popunj eno samo ako j e

pol j e i nd post avl j eno na 1 */struct _cvor * l , *d;} cvor ;/ * Funkci j a koj a pr avi j edan cvor pr i cemu ost avl j a nei ni ci j al i zovane

vr ednost i br i op */cvor * napr avi _cvor ( ) {

cvor * novi = ( cvor *) mal l oc( si zeof (cvor) ) ;i f ( novi == NULL) {


14/51


f pr i nt f ( s tder r , "greska pr i l i kom al okaci j e memor i j e\ n" ) ;exi t (1) ;

}novi - >l = NULL;novi - >d = NULL;

return novi ;}

/ * Rekur zi vna f unkci j a koj a ukl anj a dr vo, obi l azak mor a bi t i post or der */voi d obr i si _dr vo( cvor *dr vo) {

i f ( drvo!=NULL) {obr i s i _dr vo( dr vo- >l ) ;obr i si _dr vo( dr vo- >d) ;f r ee( dr vo) ;

}}

/ * Rekur zi vna f unkci j a koj a par si r a st r i ng. Pr edaj emo j oj adr esust r i nga da bi znal i dokl e smo st i gl i u t oku par si r anj a */

voi d pr et vor i _u_st abl o( char ** s, cvor ** pdr vo) {i nt c , b r ;cvor * novi ;/ * Uzi mamo sl edeci kar akter i z st r i nga. */c = *( *s) ;/ * Ako smo st i gl i do kraj a st r i nga i zl azi mo */i f ( c == ' \ 0' ) return;/ * U supr otnom popunj avamo kr ei r amo novi cvor */novi = napr avi _cvor ( ) ;/ * Ako ni j e u pi t anj u ci f r a znaci da smo uci t al i oper at or . . . */i f ( ! i sdi gi t ( c) ) {

/ * . . . post avl j amo i ndi kat or na 1 */novi - >i nd = 1;

/ * . . . i oper at or na uci t an kar akt er */novi - >op = c;/ * Unosi mo podat ak u drvo */*pdr vo = novi ;/ * Prel azi mo na sl edeci r el evant an podatak, pr eskacemo

bl anko*/*s = *s+2;/ * I r ekur zi vno par si r amo st r i ng da bi smo f ormi r al i l evo pa

zat i m i desno podst abl o */pr et vor i _u_stabl o( s, &( ( *pdr vo) - >l ) ) ;pr et vor i _u_st abl o( s, &( ( *pdr vo) - >d) ) ;

}/ * A ako j e u pi t anj u ci f ra. . . * /el se{

/ * . . . uci t avamo i ost at ak br oj a ako post oj i */br = 0;whi l e( i sdi gi t ( c) ) {

br = br *10+c- ' 0' ; / * ur acunavamo t ekuci kar akt er ubroj * /

( *s) ++; / * pomeramo se za j edno mest o u st r i ngu */c = *( *s) ; / * i ci t amo sl edeci kar akt er */

}/ * post avl j amo i ndi kat or na 0 */


15/51

15 STABLA

novi - >i nd = 0;/ * i br oj evnu vrednost na br */novi - >br = br ;/ * Unosi mo podat ak u drvo */*pdr vo = novi ;

/ * Prel azi mo na sl edeci r el evant an podatak. Uzi mamo u obzi rda pokazi vac vec pokazuj e na bl anko */

*s = *s+1;}

}

voi d i spi si _dr vo( cvor *dr vo) {i f ( drvo!=NULL) {

/ * Pr vo i spi suj emo koren. Prover avamo vr ednost i ndi kat ora*/

i f ( ! dr vo- >i nd)/ * ako j e i ndi kat or j ednak 0 st ampamo br oj */pr i nt f ( "%d" , dr vo- >br ) ;

el se/ * a i nace st ampamo kar akt er */pr i nt f ( "%c" , dr vo- >op) ;

/ * . . . a zat i m i l evo pa desno podstabl o. */i spi s i _drvo( drvo- >l ) ;i spi si _dr vo( dr vo- >d) ;

}}

voi d i spi si _dr vo_i nf i ksno( cvor *drvo) {i f ( dr vo == NULL)

return;i f ( ! dr vo- >i nd)

/ * Ako smo nai sl i na br oj evnu vrednost st ampamo j e. */

pr i nt f ( "%d" , dr vo- >br ) ;el se{

/ * U supr otnom i mamo pr avo st abl o pa i spi suj emo pr vo l evuzagr adu. . . */

pr i nt f ( " ( " ) ;/ * pa l evi i z raz. . . * /i spi s i _dr vo_i nf i ksno( dr vo- >l ) ;/ * pa operator . . . * /pr i nt f ( " %c " , dr vo- >op) ;/ * pa desni i zraz. . . * /i spi si _dr vo_i nf i ksno( dr vo- >d) ;/ * i na kr aj u i spi suj emo desnu zagr adu */pr i nt f ( " ) " ) ;

}}

i nt i zr acunaj _drvo( cvor *dr vo) {i f ( ! dr vo- >i nd)

return drvo- >br ;el seswi t ch ( dr vo- >op) {

case ' +' :return i zr acunaj _drvo( dr vo- >l ) +


16/51


i zr acunaj _dr vo( dr vo- >d) ;case ' - ' :

return i zr acunaj _dr vo( dr vo- >l ) –i zr acunaj _dr vo( dr vo- >d) ;

case ' *' :

return i zr acunaj _dr vo( dr vo- >l ) *i zr acunaj _dr vo( dr vo- >d) ;

case ' / ' :return i zr acunaj _dr vo( dr vo- >l ) /

i zr acunaj _dr vo( dr vo- >d) ;}

}

mai n( ) {cvor * dr vo = NULL;char s[20] , *ps;i nt i =0;pr i nt f ( "unesi t e ar i t met i cki i zraz u pr ef i ksnoj not aci j i , novi r ed za

kraj \ n" ) ;/ * Funkci j a f get s ci t a sa st andar dnog ul aza ( st di n) l i ni j u ( kar akt er edo unetog novog r eda) i l i dok se ne popuni 20 kar aktera */i f ( f get s( s, 20, st di n) == NULL){

f pr i nt f ( s tder r , "gr eska" ) ;exi t ( 1) ;

}/ * Kako s sada sadr zi i oznaku za novi r ed na kr aj u br i semo j e */whi l e( s [ i ] ! =' \ n' )

i ++;/ * i na kraj u dodaj emo ' \ 0' da bi pr i pr emi l i st r i ng za pr enosenj e u

f unkci j u * /s[ i ] = s[ i +1] ;/ * Kako j e s ni z kar akter a ( a ni z j e konst ant ni pokazi vac) on ne

sme bi t i pr edat f unkci j i koj a kr ei r a st abl o ( post o f unkci j amenj a pokazi vac koj i dobi j a kao pr vi argument ) pa uzi mamopomocni pokazi vac da bi smo mogl i da menj amo nj egovu vr ednost */ps = s;/ * Kr ei r amo st abl o pozi vom f unkci j e pr evor i _u_st abl o */pr et vor i _u_st abl o( &ps, &dr vo) ;/ * I spi suj emo ga u pr ef i ksnom por edku */i spi s i _dr vo( drvo) ;pr i nt f ( " \ n" ) ;/ * A zat i m i u i nf i ksnom. */i spi s i _dr vo_i nf i ksno( dr vo) ;/ * I spi suj emo vr ednost pocet nog i zr aza */pr i nt f ( " = %d\ n" , i zracunaj _dr vo( dr vo) ) ;obr i s i _dr vo( dr vo) ;}


17/51

17 GRAFOVI

1.2. GRAFOVI

Definicija: Graf G je uređeni par G=(V,E) gde je E VxV. Skup V je skup čvorova, dok skup E

predstavlja skup grana (veza između čvorova).

• Grane usmerenog grafa su uređeni parovi čvorova i redosled dva čvora koje povezujegrana je bitan.

• Za neusmeren graf važi da ukoliko je čvor u u vezi sa čvorom v, onda je i čvor v u vezi sačvorom u.

• Težinski graf je graf čijim granama su pridruženi jedan ili više realnih brojeva ( kaovrednost rastojanja, težina, cene,...).

usmeren graf neusmeren graf težinski graf

• Stepen d(v) čvora v je broj grana susednih čvoru v (broj grana koje direktno povezuju čvor v sa

nekim drugim čvorom).

• U usmerenom grafu razlikuju se ulazni stepen (broj grana čiji kraj je čvor v ) i izlazni stepen (broj

grana za koje je čvor v početak).

• Bipartitivni graf je graf čiji se čvorovi mogu podeliti na dva disjunktna podskupa tako da u grafu

postoje samo grane između čvorova iz različitih podskupova.

• Put od v1 do vk je niz čvorova v1, v2, . . . ,vk povezanih granama (v1, v2), (v2, v3), . . . , (vk-1, vk ).

• Hamiltonov put je prosti ciklus ili put u kom se svaki čvor grafa pojavljuje tačno jednom.

NAPOMENA: Sve date definicije su opisne. Za precizne definicije matematičkih pojmova vezanih

za grafove konsultovati literaturu.


18/51

Predstavljanje grafova u memoriji računara 18

1.2.1. Predstavljanje grafova u memoriji računara

Predstavljanje uz pomoć matrice susedstva

Jedan način predstavljanja grafa sa n čvorova je uz pomoć matrice susedstva dimenzija n x n (svaka

vrsta i kolona odgovaraju po jednom čvoru grafa). Ukoliko postoji veza između čvorova v i i v j tada se u

vrsti koja odgovara čvoru vi i koloni koja odgovara čvoru v j je 1 (adj[vi, v j] = 1, ako (vi, v j) ivica u G).

Ukoliko je e ukupan broj ivica grafa, tada će u matrici postojati 2e elemenata matrice koji su jednaki 1,

ako je G neorijentisan graf. Ako je G usmeren graf, samo e elemenata matrice će biti 1. Primeri

predstavljanja grafova uz pomoć matrice susedstva su dati na sledećim slikama:

Graf Matrica susedstva Ulazni i izlazni stepeni čvora

Predstavljanje grafova uz pomoć povezanih listi

Drugi način predstavljanja grafa G je uz pomoć povezanih listi. Za svaki čvor konsturišemo povezanu

listu koja sadrži sve čvorove susedne datom čvoru.


19/51

19 GRAFOVI

1.2.2. Računanje ulaznog i izlaznog stepena čvora grafa predstavljenogpomoću matrice susedstva

#i ncl ude #def i ne MAX 10

/ * f unkci j a uz pomoc koj e pr avi mo matr i cu susedst va */voi d bui l dadj m( i nt adj [ ] [ MAX] , i nt n) {

i nt i , j ;f or ( i =0; i


20/51

Obilazak grafa u širinu (BFS) 20

scanf ( "%d" , &n) ;bui l dadj m( adj , n) ;f or ( i =0; i


21/51

21 GRAFOVI

Q← ØENQUEUE(Q, s)while Q ≠ Ø

do u← DEQUEUE(Q)

for each v∈ Adj[u]do if color [v] = WHITE

then color [v]← GRAY

d[v]← d[u] + 1

π[v]← uENQUEUE(Q, v)

color [u]← BLACK

1.2.4. Obilazak grafa u dubinu (DFS)

Strategija koju koristi DFS algoritam je tražiti čvorove sve „dublje“ u grafu kad god je to moguće.

Kod DFS algoritma pretražujemo granu koja napušta čvor v i a zatim i sve naredne grane. Kada završimosa pretragom svih grana koje napuštaju čvor v vraćamo se unazad da bi smo nastavili sa pretragom grana

koje napuštaju čvor iz kojeg smo stigli u čvor v .

DFS(G)for each vertex u _ V [G]

do color [u]← WHITE

π[u]← NIL

time← 0

for each vertex u∈ V [G]do if color [u] = WHITE

then DFS-VISIT(u)DFS-VISIT(u)


22/51

Obilazak grafa u dubinu (DFS) 22

color [u]← GRAY White vertex u has just been discovered.

time← time +1d[u] timefor each v _ Adj[u] Explore edge(u, v).

do if color [v] = WHITEthen π[v]← u

DFS-VISIT(v)color [u] BLACK Blacken u; it is finished.

f [u] ▹ time← time +1

#i ncl ude #i ncl ude #def i ne MAX 10

struct node{

i nt dat a;struct node *l i nk;};

/ * f unkci j a uz pomoc koj e pr avi mo matr i cu susedst va */voi d bui l dadj m( i nt adj [ ] [ MAX] , i nt n) {

i nt i , j ;f or ( i =0; i


23/51

23 GRAFOVI

i f ( p == NULL) {pr i nt f ( "Rezer vi sanj e memor i j e ni j e uspel o\ n" ) ;

exi t ( 0) ;}p- >data = val ;

p- >l i nk=NULL;} el se {

t emp= p;whi l e( t emp- >l i nk != NULL) {

t emp = t emp- >l i nk;}t emp- >l i nk = ( struct node*) mal l oc( si zeof ( struct node) ) ;t emp = t emp- >l i nk;i f ( t emp == NULL) {

pr i nt f ( "Rezer vi sanj e memor i j e ni j e uspel o\ n" ) ;exi t ( 0) ;

}t emp- >data = val ;t emp- >l i nk = NULL;

}return( p ) ;

}

struct node *del eteq( struct node *p, i nt *val ) {struct node *t emp;i f ( p == NULL) {

pr i nt f ( " r ed j e pr azan\ n" ) ;return( NULL) ;

}*val = p- >dat a;t emp = p;p = p- >l i nk;

f r ee( t emp) ;return( p ) ;

}

voi d bf s( i nt adj [ ] [ MAX] , i nt x, i nt vi si ted[ ] , i nt n, struct node ** p){i nt y, j , k;*p = addqueue( *p, x) ;do{

*p = del eteq( *p, &y) ;i f ( vi si t ed[ y] == 0) {

pr i nt f ( " \ nObi l azi m cvor = %d\ t " , y ) ;vi si t ed[ y] = 1;f or ( j =0; j


24/51

Topološko sortiranje 24

f or ( j =0; j


25/51

25 GRAFOVI

Na slici je dat primer grafa koji predstavlja redosled oblačenja delova odeće i topološko sortiranje

datog grafa (slika (b)).

Algoritam topološkog sortiranje koristi DFS algoritam i može se prikazati kao:

TOPOLOGICAL-SORT(G)call DFS(G) to compute finishing times f [v] for each vertex vas each vertex is finished, insert it onto the front of a linked listreturn the linked list of vertices

3. Napisati program koji će topološki sortirati graf koji je predstavljen uz pomoć povezanih listi.

#i ncl ude

#i ncl ude

#i f ndef MAX_NAME_CHAR#def i ne MAX_NAME_CHAR 50#endi f

t ypedef enum {FALSE, TRUE} bool ;t ypedef struct node node;

struct node {i nt count ; / / za cvor ove gr af a : ul azni st epen

/ / za cvor ove u l i st i : cvor sa koj i m j e cvor gr af apovezan

node *next ;};node *gr aph;node *zer ol i st ;

voi d addToZer ol i st ( i nt v){/ ** dodaj emo cvor v u zerol i st ukol i ko v i ma ul azni st epen 0*/

node *pt r = ( node *) mal l oc( si zeof ( node) ) ;


26/51


pt r - >count = v;pt r - >next = zer ol i st ;zerol i s t = pt r;

}

node *bui l dGr aph(char *f i l eName, i nt *n) {/ * uci t avamo gr af i z dat ot eke

pret post avi mo da u prvom r edu dat ot eke i mamo dat e br oj eve m nm - br oj cvor ovan - br oj gr anaa u ostal i h n r edova sve gr ane gr af a u obl i ku u v, gde su u i v

cvor ovi */i nt i , edges, u, v;FI LE * f ;f =f open( f i l eName, " r " ) ;fscanf( f , "%d %d" , n, &edges) ;

/ / i ni ci j al i zuj emo grafgr aph = ( node *) mal l oc( ( *n) *si zeof ( node) ) ;

f or ( i =0; i next = gr aph[ u] . next ;gr aph[ u] . next = pt r ;/ / i ncrease i ndegr ee of dst .

graph[ v] . count ++;}

/ / krei r amo l i st u cvor ova sa ul azni m st epenom 0zer ol i st = NULL;f or ( i =0; i count ) ;

pr i nt f ( " \ n" ) ;}pr i nt f ( " zerol i st : " ) ;f or ( pt r =zer ol i st ; pt r ; pt r =pt r - >next )


27/51

27 GRAFOVI

pr i nt f ( "%d " , pt r - >count ) ;pr i nt f ( " \ n" ) ;

}

i nt get Zer oVert ex( ) {

/ ** vraca cvor sa ul azni m st epenom 0.* ukol i ko t akav cvor ne post oj i vr aca - 1.*/

i nt v;node *pt r ;

i f ( zerol i st == NULL )return -1 ;

pt r = zer ol i s t ;v = pt r - >count ;zer ol i st = zer ol i st - >next ;f ree (p t r ) ;

return v;}

voi d removeVer t ex( i nt v ) {/ ** bri se cvor v i sve nj egove odl azne gr ane i z gr af a*/

node *pt r ;gr aph[ v]. count = - 1;/ / osl obadj amo l i st u gr aph[ v] . next .f or ( pt r =gr aph[ v] . next ; pt r ; pt r =pt r - >next ) {

i f ( gr aph[ pt r - >count ] . count > 0 ) / /gr aph[ pt r - >count ] . count - - ;

i f ( gr aph[ pt r - >count ] . count == 0 )addToZer ol i st ( pt r - >count ) ;

}}

voi d topsort( i nt nver t ) {/ ** r ekur zi vna f unkci j a koj a t opol oski sor t i r a gr af*/

i nt v;

i f ( nver t > 0 ) {v = get Zer oVer t ex( ) ;i f ( v == - 1 ) {

f pr i nt f ( stder r , "graph cont ai ns a cycl e. \ n" ) ;return;

}pr i nt f ( " - > %d" , v ) ;r emoveVert ex( v) ;t opsor t ( nver t - 1 ) ;

}}


28/51


i nt mai n( ) {i nt n;

bui l dGr aph( "mat . t xt " , &n) ;pr i nt Gr aph( gr aph, n) ;t opsor t ( n) ;

}

Objašnjenje

Digraf G je predstavljen uz pomoć povezanih listi. U ovakvoj reprezentaciji G je niz

graph[ 0…n–1] , gde je svaki element gr aph[ i ] povezana lista čvorova grafa sa kojima je

čvor i povezan, a n je broj čvorova u grafu G.

Promenljiva zerol i s t služi da bismo čuvali listu čvorova koji nemaju prethodnike.

Algoritam topsort() se služi rekurzijom. Iz promenljive zerol i s t , uklanjamo vektor v

koji ima 0 prethodnika i štampa ga. Ovaj čvor v ili nema prethodnika u grafu G, ili su svi

njegovi prethodnici već obiđeni. Svi čvorovi u zerol i s t su potencijalni kandidati za sledeći

čvor koji će biti odštampan, tj. ubačen u sortirani niz. Nakon što smo odštampali v svičvorovi sa kojima je on u vezi mogu postati kandidati za sledeći odštampani čvor.

Primer : Analiza algoritma na sledećem grafu

Korak Zerolist Izlaz

0 {0} nil

1 {1, 2, 3} 0

2 {2, 3} 1

3 {3} 2

4 {4,5} 3

5 {5} 4


29/51

29 GRAFOVI

Korak Zerolist Izlaz

6 {} 5

1.2.6. Jako povezane komponente grafa

Povezana komponenta grafa je maksimalni podgraf dataog grafa koji je povezan. Razmotrimo

sledeći graf.

Povezana komponenta ovog grafa je:

Jako povezane komponenteZa digraf G, jako povezana komponenta je podgraf grafa G u kojem za svaki par čvorova (u,v) važi

da postoji put i od u do v i od čvora v do čvora u. Posmatrajmo graf na sledećoj slici.


30/51

Jako povezane komponente grafa 30

Jako povezane komponente datog grafa su:


31/51

31 GRAFOVI


#def i ne MAXVERTI CES 20#def i ne MAXEDGES 20

t ypedef enum {FALSE, TRUE, TRI STATE} bool ;t ypedef struct node node;

struct node {i nt dst ;node *next ;

};

voi d pri nt Gr aph( node *gr aph[ ] , i nt nver t ) {/ ** pr i nt s t he gr aph.*/

i nt i ;f or ( i =0; i next )

pr i nt f ( " [ %d] " , pt r- >dst ) ;pr i nt f ( " \ n" ) ;

}}

voi d i nser t Edge( node **pt r , i nt dst ) {/ ** i nser t a new node at t he st ar t .*/

node *newnode = ( node *) mal l oc( si zeof ( node) ) ;

newnode- >dst = dst ;newnode- >next = *pt r ;*pt r = newnode;

}

voi d bui l dGr aph( node *graph[ ] , i nt edges[ 2] [ MAXEDGES] , i nt nedges ) {/ ** f i l l s gr aph as adj acency l i st f r om ar r ay edges.*/

i nt i ;f or ( i =0; i


32/51

Jako povezane komponente grafa 32

vi si t ed[ v] = TRI STATE;/ / pr i nt f ( "%d \ n" , v ) ;f or ( pt r =gr aph[ v] ; pt r ; pt r =pt r - >next )

i f ( vi si t ed[ pt r - >dst ] == FALSE )df s( pt r - >dst, vi s i t ed, gr aph ) ;

}voi d pr i nt Set Tr i state( i nt *vi s i ted, i nt nver t ) {

/ ** pr i nt s al l ver t i ces of vi si t ed whi ch ar e TRI STATE.* and set t hem t o TRUE.*/

i nt i ;

f or ( i =0; i


33/51

33 GRAFOVI

pr i nt Gr aph( gr aph, nver t ) ;compI NC( gr aph, nver t ) ;

f cl ose( f ) ;return 0;

}

Graf je predstavljen uz pomoć povezanih listi. Graf je predstavljen kao niz od n pokazivača gde n

predstavlja broj čvorova grafa. Svaki član niza i sadrži pokazivač na povezanu listu čvorova sa kojima je

čvor i u vezi. Na primer, sledeći graf:

se predstavlja sledećom strukturom:

1.2.7. Minimum Spanning Tree (minimalno razapinjuće stablo)

Definicija: Neka je dat povezan, neorijentisani graf G = (V, E ) sa težinskom funkcijom w : E → R.

Minimalno razapinjuće stablo grafa G je podgraf (V,T), gde je T ⊆ E , koji povezuje sve čvorove grafa G i

čija je ukupna težina ∑ (,)( ,) minimalna.

Pretpostavimo da imamo povezan, neorijentisani graf G = (V, E ) sa težinskom funkcijom w : E →

R, i želimo da nadjemo minimalno razapinjuće stablo za graf G . Dva algoritma koja ćemo predstaviti u


34/51

Minimum Spanning Tree (minimalno razapinjuće stablo) 34

osnovi imaju istu strategiju nalaženja minimalnog razapinjućeg stabla. Naime, oba polaze od skupa grana

A koji je na početku prazan, a u svakom koraku dodaju tom skupu po jednu granu, koju nazivamo sigurna

grana za podgraf A (safe edge), sve dok ne dobijemo minimalno razapinjuće stablo (znači imamo n-1

koraka). U svakom koraku A je podskup minimalnog razapinjućeg stabla.

GENERIC-MST(G, w )

A← Ø

while A does not form a spanning treedo find an edge (u, v ) that is safe for A

A← A ∪ {(u, v )}

return A

Kruskal-ov algoritam

MST-KRUSKAL(G, w ) A← Ø

for each vertex v ∈ V [G]do MAKE-SET(v )

sort the edges of E into nondecreasing order by weightw

for each edge (u, v )∈ E , taken in nondecreasing order by weightdo if FIND-SET(u) ≠ FIND-SET(v )

then A← A _ {(u, v )}

UNION(u, v )return A

U toku generisanja minimalnog drveta razapinjanja, sve vreme se manipuliše sa supergrafom koji je

indukovan polaznim grafom. Ako je polazni graf G=(V,E), onda je supergraf uređeni par SG=(SV,SE), takav

da je:

• SV skup čvorova;

• SE skup superivica;

• svaki superčvor sv je podskup skupa čvorova V;

• svaka dva superčvora su disjunktna;

• unija svih superčvorova je skup V ;

• između superčvorova su i sv postoji ivica ako i samo ako postoji čvor u∈ su i čvor v ∈ sv ,

tako da je (u,v)∈ E .

• dužina superivice (su,sv) je dužina najkraće ivice grafa (G,E) čiji je jedan kraj u superčvorusu, a drugi u superčvoru su.


35/51

35 GRAFOVI

Na početku izvršenja Kruskalovog algoritma superčvorovi su jednočlani, tj. svakom čvoru u

polaznog grafa odgovara superčvor su={u}, a E π je prazan. Algoritam je iterativan. U svakoj iteraciji SE

izvršava sledeći niz radnji:

• dva superčvora se spajaju u jedan, čime se broj superčvorova smanjuje;

• jedna ivica se dodaje minimalnom drvetu (skupu E π).

Pri tome:

• spajaju se najbliži superčvorovi (superčvorovi između kojih je najmanje rastojanje);

• određuje se najkraća ivica između čvorova koji su sadržani u paru prethodno određenihsuperčvorova i ta ivica se dodaje drvetu.

Petlja se ponavlja dok ne dobijemo supergraf sa samo jednim superčvorom. Kako je na početkuukupno |V | superčvorova, izvršiće se ukupno |V|-1 iteracija.


#def i ne MAXV 20#def i ne MAXEDGES 190

voi d bui l dGr aph( i nt adj [ ] [ MAXV] , i nt nver , i nt edges[ 3] [ MAXEDGES] , i nt nedges) {

/ ** popunj avamo mat r i cu susedst va

*/i nt i , j ;

f or ( i =0; i


36/51


i nt sv[ MAXV] ;f or ( i =0; i


37/51

37 GRAFOVI


38/51


Prim-ov algoritam

MST-PRIM(G, w , r )for each u _ V [G]

do key [u]← ∞

π[u]← NIL

key [r ]← 0

Q← V [G]

while Q ≠ Ø

do u← EXTRACT-MIN(Q)

for each v ∈ Adj [u]

do if v∈ Q and w (u, v ) < key [v ]

then π[v ]← u

key [v ]← w (u, v )

Kod Primovog algoritma drvo se generiše tako što se kreće od proizvoljnog čvora koji će biti koren

drveta, i dodaje jedan po jedan čvor. Tako da u toku izvršenja algoritma imamo:

• skup U koji se sastoji od čvorova već dodatih drvetu i

• skup V\U koji se sastoji od čvorova koji nisu u drvetu

Na početku se skup U sastoji samo od jednog čvora – izabrani koren drveta. U svakoj iteraciji se bira

nakraća ivica čiji je jedan kraj (čvor u) u skupu U, a drugi (čvor v ) u skupu V\U. Čvor v se dodaje skupu U,

a ivica (u,v ) se dodaje drvetu (E π).


39/51

39 GRAFOVI

Izbor najkrće ivice sa zadanim svojstvima je ekvivalentan izboru čvora iz skupa V\U koji je najbliži

skupu čvorova U. Rastojanje između čvora i skupa čvorova se definiše kao dužina najkraće ivice čiji je

jedan kraj upravo taj čvor, a drugi kraj je u skupu.

Da bismo smanjili računanje, nakon dodavanja novog čvora (u) u skup U, za sve čvorove iz skupa

V\U korigujemo najkraće rastojanje do skupa U. Korekciju izvodimo po formuli:

d(v,U∪{u}) = min {d(v,U),e(u,v)},

gde je e(u,v) dužina ivice (u,v).

Postupak se ponavlja sve dok skup U ne postane jednak skupu V . Kako se u svakom prolazu u skup

U dodaje jedan čvor, izvršava se ukupno |V |-1 iteracija. Funkcija se može zapisati na sledeći način:

(glavni program je identičan kao kod kruskalovig algoritma, sem poziva funkcije mdr_Prim umestomdr_kruskal)

i nt mdr _Pr i m( i nt vn, i nt e[ ] [ MAXV] , i nt v1[ ] , i nt v2[ ] ) {i nt i , j , k;i nt vi [ MAXV] ;i nt vp[ MAXV] ;i nt dm[ MAXV] ;/ *** vi [ i ] i ma vrednost 1, ako j e i vec ukl j ucen u dr vo, 0 u supr ot nom

*** /vi [ 0] = 1;f or ( i =1; i


40/51


i f ( ( dm[ j ] == 0) | | ( dm[ j ] > e[ k] [ j ] ) ) {vp[ j ] =k;dm[ j ] =e[ k] [ j ] ;

}}

return 0;}


41/51

41 GRAFOVI

1.2.8. Nalaženje najkraćeg puta od jednog do svih ostalih čvorova

INITIALIZE-SINGLE-SOURCE(G, s)

1 for each vertex v _ V [G] 2 do d [v ] ← ∞3 π[v ] ← NIL4 d [s] 0

RELAX(u, v , w )1 if d [v ] > d [u] + w (u, v )

2 then d [v ]← d [u] + w (u, v )

3 π[v ]← u

Bellman – Ford algoritam Bellman-Ford algoritam nalazi najkraće rastojanje od datog čvora do svih ostlih čvorova grafa čak i

za slučaj kada postoje ivice sa negativnom dužinom. Algoritam otkriva postojanje negativnih petlji i u

tom slučaju daje odgovarajući izveštaj, odnosno ne određuje rastojanja.

Polazna ideja je da svaki put, pa i najkraći između bilo koja dva čvora, može imati najviše |V | -1

ivicu. Tako se izvršava |V | -1 prolaz kroz petlju u kojoj se proverava za svaku ivicu da li smanjuje najkraće

rastojanje između polaznog čvora i nekog od preostalih čvorova.

Nakon toga još jednom ponovimo navedeni postupak za svaku ivicu. Ako se tim prolazom skratineko od izračunatih rastojanja, u grafu postoji petlja negativne dužine do koje se može stići od polaznog

čvora (s) i određivanje najkraćih rastojanja nema smisla.

BELLMAN-FORD(G, w , s)INITIALIZE-SINGLE-SOURCE(G, s)

for i← 1 to |V [G]| - 1

do for each edge (u, v ) _ E [G]do RELAX(u, v , w )

for each edge (u, v ) _ E [G]do if d [v ] > d [u] + w (u, v )

then return FALSEreturn TRUE

Na slici je prikazan graf i rezultat izvršenja ovog algoritma.


42/51

Nalaženje najkraćeg puta od jednog do svih ostalih čvorova 42


#def i ne MAXV 20#def i ne MAXEDGES 190#def i ne NEPOZNATO 1000000


/ ** popunj avamo mat r i cu susedst va

*/i nt i , j ;f or ( i =0; i


43/51

43 GRAFOVI

i nt For d_Bel man( i nt vn, i nt vs , i nt e[ ] [ MAXV] , i nt d[]){/ *****ul az:

vn - br oj cvor ova u gr af uvs - pol azni cvor

e - duzi ne i vi cai zl az:

d - duzi ne naj kraci h put eva od vs do ost al i h cvor ovarezul tat :

0 - ni j e odr edj eno rast oj anj e zat o sto se od vs moze st i ci doci kl usa negat i vne duzi ne

1 - odr edj ena su naj krca r ast oj anj a i upi sana su u ni z d******/i nt i , j , k;f or ( i =0; i


44/51

Nalaženje najkraćeg puta od jednog do svih ostalih čvorova 44

pr i nt f ( " \ nRast oj anj e od cvor a %d do cvora %d i znosi :%d", vs, i , d[ i ] ) ;

pr i nt f ( "\ n*************** kraj ****************\ n" ) ;return 0;

}

Dijkstrin algoritam za nalaženje najkraćih puteva

U svakoj iteraciji ovog algoritma se određuje najkraće rastojanje od početnog čvora (s) do jednog

od preostalih čvorova. U toku izvršavanja algoritma manipuliše se skupom čvorova U za koje je

izračunato najkraće rastojanje od čvora s.

Na početku taj skup se sastoji samo od jednog čvora (U={s}). U svakoj iteraciji skupu U se dodaje

jedan čvor. Pored toga, za svaki od čvorova v ∈ V\U određuje se najkraći put (dužina najkraćeg puta) od

čvora s do čvora v , pri čemu svi čvorovi na tom putu osim čvora v moraju biti u skupu U, naravno, ako

takav put postoji. Skupu U se dodaje čvor iz skupa V\U kome je taj put najkraći.

Dužine puteva se određuju na početku (kada je U={s}), posle čega se koriguje pri dodavanju novog

elementa u skup U. Na početku je dužina puta jednaka:

dužini ivice između čvora s i odgovarajućeg čvora ako ivica postoji;

+∞, tj. put ne postoji, ako ivica od čvora s do tog čvora ne postoji.

Po dodavanju novog čvora (u) u skup U, računati put se može promeniti. Jasno, taj put se menja

samo ako se na njemu nalazi i čvor u. Novi put vodi od čvora s do čvora u, a nakon toga duž ivice odčvora u do čvora v (ako postoji ivica (u,v )). Tako novi put ima dužinu jednaku zbiru dužine puta od čvora s

do u i dužinu ivice od čvora u do čvora v (ako ta ivica postoji). Najkraći put je jednak minimumu

dosadašnje dužine puta i gore pomenutog zbira.




/ ** popunj avamo mat r i cu susedst va*/

i nt i , j ;f or ( i =0; i


45/51

45 GRAFOVI

f or ( i =0; i


46/51

Najkraće rastojanje između svih parova čvorova (Floyd-Warshall) 46

1.2.9. Najkraće rastojanje između svih parova čvorova (Floyd-Warshall)

Alogoritam Floyd-Warshall – a podrazumeva iterativni postupak za određivanje najkraćih rastojanja

između svih parova čvorova.

Na početku čvorove numerišemo brojevima od 0 do n-1. Neka je d (k)i,j najkraći put između čvorova i

i j takav da su svi čvorovi na tom putu, osim krajnjih, manji ili jednaki čvoru k . Jasno, tada je d (-1)i,j jednako

dužini ivice između čvorova i i j , ako postoji. Takođe je d (n-1)i,j jednako upravo najkraćem putu između

čvorova i i j .

Računanje vrednosti d (k+1)i,j je prilično jednostavno. Može se pokazati da je:


47/51

47 GRAFOVI

d (k+1)i,j = min(d (k)

i,j , d (k)

i,k+1 + d (k)

k+1,j )

Program za računanje najkraćih rastojanja izgleda ovako:




/ ** popunj avamo mat r i cu susedst va*/

i nt i , j ;f or ( i =0; i


48/51


pr i nt f ( " \ n** **** ** ALGORI TAM FLOYD - WARSHALL ** ** **** ****** ***\ n" ) ;f l oyd_war shal l ( nver t , adj , shor t est) ;f or ( i =0; i


49/51

49 GRAFOVI

2. Zadaci za vežbu

1. Napisati program koji čvorove binarnog stabla štampa u redosledu koji odgovara

nivoima (prvo element koji se nalazi u prvom nivou, pa elemente drugog nivoa i tako

redom). Za ispis elemenata stabla po nivoima koristiti red.

/ * St r ukt ur a reda u koj oj cemo cuvat i pokazi vace na el ement e st abl a */t ypedef st r uct r ed{

cvor *el ;s tr uct red * s l ;

} r ed;/ * St r uktura bi nar nog st abl a*/

t ypedef struct cvor { i nt broj ; struct cvor *l evo, *desno; } Cvor ;t ypedef Cvor *St abl o;

2. Napisati metodu koja ce vratiti broj cvorova binarnog stabla kod kojih je zbir elemenata levog

podstabla veći od zbira elemenata desnog podstabla.

/ * St r uktura bi nar nog st abl a*/

t ypedef struct cvor { i nt broj ; struct cvor *l evo, *desno; } Cvor ;t ypedef Cvor * St abl o;

3. Napisati metodu koja će vratiti broj čvorova stabla koji su roditelji barem jednog lista (tj. koji

imaju barem jedan list kao direktnog potomka).


t ypedef struct cvor { i nt broj ; struct cvor *l evo, *desno; } Cvor ;

t ypedef Cvor * St abl o;

4. Napisati metodu koja vraća labelu onog lista binarnog stabla koji ima najmanji nivo. Ukoliko

postoji više listova na najmanjem nivou, treba vratiti onaj sa najmanjom labelom. Koren stabla

se nalazi na nivou 0.


t ypedef struct cvor { char c; struct cvor *l evo, *desno; } Cvor ;t ypedef Cvor * St abl o;

5. Dva binarna stabla su „slična kao u ogledalu“ ako su oba prazna ili ako nisu prazna, ako je levo stablo svakog stabla „slično kao u ogledalu“ desnom stablu onog drugog. Na

sledećoj slici su prikazana dva „slična kao u ogledalu“ stabla:

Napišite funkciju koja će proveriti da li su dva binarna stabla „slična kao u ogledalu“.


50/51




6. Rekonstruišite binarno stablo čiji čvorovi imaju imena A, B, . . ., J ako je poznato da

INORDER obilazak ispisuje čvorove u redosledu GDJEAICHBF, a POSTORDER obilazak uredosledu DJGIABHFCE. Detaljno obrazložite svaki korak. Nakon rekonstrukcije ispišite iPREORDER obilazak dobijenog stabla. Nacrtajte još neko stablo koje ima iste PREORDER iPOSTORDER obilaske kao ovo.



7. Kažemo da je čvor p binarnog stabla zajednički predak čvorovau i v ako je p istovremeno predak čvora u i predak čvora v.

Čvor np je najbliži predak od u i v ako od svih njihovihzajedničkih predaka upravo np ima najveću visinu. Napišitefunkciju node np(BTREE T, node u, node v) koja vraća imenajbližeg pretka čvorova u i v. U primeru desno, čvorovi a i c suzajednički pretci čvorova f i e - ali kako c ima veću visinu, on jena jbliži predak.

8. Udaljenost čvorova u i v računamo kao broj grana koji treba preći na putu koji spaja u i v.Napišite funkciju i nt udal j ( BTREE T, node u, node v) koja vraćaudaljenost čvorova u i v u stablu T. Možete koristiti pozive funkcije iz (a). U primerudesno, dužina puta koji spaja f i e je jednaka 3.

9. Kažemo da je čvor v binarnog stabla T k-potomak čvorau ako se v nalazi u podstablu od T kojem je u koren i pritome je nivo čvora v za k veći od nivoa čvora u. Tako sunpr. deca nekog čvora njegovi 1-potomci, deca od dece 2-potomci, itd. Napišite funkciju sa prototipoml abel t ype potomak( BTREE T, i nt k) kojavraća label onog ćvora bin. stabla T koji ima najviše k-potomaka. Ako ima više takvih čvorova, vratite labelu bilokojeg. Funkcija treba biti neovisna o implementaciji atp-a

BTREE; ne smete koristiti pomoćne atp-ove. Možetedefinisati pomoćne funkcije i globalne varijable. U primeru desno, uzmimo da je k = 2.Čvor a ima dvoje 2-potomaka, a čvor c jednog; kako ostali čvorovi nemaju 2-potomaka,funkcija treba vratiti a.


51/51

51 GRAFOVI

10. Napišite funkciju sa prototipom l abel t ype naj vi si _l i st ( BTREE T) koja vraćalabelu onog lista binarnog stabla T koji ima najmanji nivo. Ako ima više listova nanajmanjem nivou, treba vratiti onaj sa najmanjim label. U primeru desno, listovi su b, e if, najmanji nivo od njih ima b i taj nivo je 1; dakle funkcija za ovaj primer treba vratiti b.

11. Rekonstruišite binarno stablo ćiji čvorovi imaju imena A, B, . . ., J ako je poznato daINORDER obilazak ispisuje čvorove u redosledu GEAFDBHICJ, a POSTORDER obilazak uredosledu EFAGIHJCBD. Detaljno obrazložite svaki korak. Nakon rekonstrukcije ispišite iPREORDER obilazak dobivenog stabla.

12. Date su dve datoteke koje u svakoj liniji sadrže po jednu nisku sa ne više od 80karaktera. Napisati program koji na standardni izlaz ispisuje sve niske prve datotekekoje nisu sadržane u drugoj datoteci. Zadatak realizovati korišćenjem binarnog stablapretrage.

nelinearne strukture

Documents