/* Adresu promenjive x zapamticemo u novoj promeljivoj. Nova promenljiva je tipa pokazivaca na int (int*) */ int* px;

Transkript

1 1. 0B 2. PODSEĆANJE 1. /* Pokazivaci - osnovni pojam */ #include <stdio.h> main() { int x = 3; /* Adresu promenjive x zapamticemo u novoj promeljivoj. Nova promenljiva je tipa pokazivaca na int (int*) */ int* px; printf("adresa promenljive x je : %p\n", &x); printf("vrednost promenljive x je : %d\n", x); px = &x; printf("vrednost promenljive px je (tj. px) : %p\n", px); printf("vrednost promenljive na koju ukazuje px (tj. *px) je : %d\n", *px); /* Menjamo vrednost promenljive na koju ukazuje px */ *px = 6; printf("vrednost promenljive na koju ukazuje px (tj. *px) je : %d\n", *px); /* Posto px sadrzi adresu promenljive x, ona ukazuje na x tako da je posredno promenjena i vrednost promenljive x */ printf("vrednost promenljive x je : %d\n", x); 2. (DOMAĆI) Popuniti sledeću tabelu: A B C P1 P2 Init &A &C *P1 = (*P2) &A &C P1 = P &C &C P1 = &B &B &C *P1 = *P1 - *P &B &C

2 3. /* swap : Demonstracija prenosa argumenata preko pokazivaca */ #include <stdio.h> int tmp; /* Pogresna verzija funkcije swap. Zbog prenosa po vrednosti, funkcija razmenjuje kopije promenljivih iz main-a, a ne samih promenljivih */ void swap_wrong(int x, int y) { printf("swap_wrong: "); printf("funkcija menja vrednosti promenljivim na adresama : \n"); printf("x : %p\n", &x); printf("y : %p\n", &y); tmp = x; x = y; y = tmp; int tmp; /* Resenje je prenos argumenata preko pokazivaca */ void swap(int* px, int* py) { printf("swap : Funkcija menja vrednosti promenljivim na adresama : \n"); printf("px = %p\n", px); printf("py = %p\n", py); tmp = *px; *px = *py; *py = tmp; main() { int x = 3, y = 5; printf("adresa promenljive x je %p\n", &x); printf("vrednost promenljive x je %d\n", x); printf("adresa promenljive y je %p\n", &y); printf("vrednost promenljive y je %d\n", y);

3 /* Pokusavamo zamenu koristeci pogresnu verziju funkcije */ swap_wrong(x, y); printf("posle swap_wrong:\n"); printf("vrednost promenljive x je %d\n", x); printf("vrednost promenljive y je %d\n", y); swap(&x, &y); /* Vrsimo ispravnu zamenu. Funkciji swap saljemo adrese promenljvih x i y, a ne njihove vrednosti */ printf("posle swap:\n"); printf("vrednost promenljive x je %d\n", x); printf("vrednost promenljive y je %d\n", y); 2 Pokazivači - veza sa nizovima 1. /* Pokazivacka aritmetika */ #include <stdio.h> main() { char s[] = "abcde"; int t[] = {1, 2, 3, 4, 5; /* Inicijalizujmo pokazivace ps i pt na pocetke nizova s i t */ char* ps = &s[0]; int* pt = &t[0]; /* Pokazivace je moguce sabirati sa celim brojevima i od njih je moguce oduzimati cele brojeve*/ /* Ispisimo vrednosti pokazivaca */ printf("ps = %p\n", ps); printf("ps+1 = %p\n", ps+1); printf("ps+2 = %p\n", ps+2); printf("ps-1 = %p\n", ps-1); printf("ps-2 = %p\n", ps-2); printf("pt = %p\n", pt); printf("pt+1 = %p\n", pt+1); printf("pt+2 = %p\n", pt+2); /* Prilikom sabiranja pokazivaca i celih brojeva, dodaje se velicina odgovarajuceg tipa. */

4 printf("pt-1 = %p\n", pt-1); printf("pt-2 = %p\n", pt-2); /* Na pokazivace je moguce primenjivati i operatore ++ i -- */ for (ps = s; *ps; ps++) putchar(*ps); putchar( \n ); ps = &s[3]; printf("s = %p\n", s); printf("ps = %p\n", ps); printf("ps - s = %d\n", ps - s); pt = &t[3]; printf("t = %p\n", t); printf("pt = %p\n", pt); /* Slicno, dva pokazivaca istog tipa se mogu oduzimati. Prilikom sracunavanja rezultata, uzima se u obzir velicina tipa. */ printf("pt - t = %d\n", pt - t); 2. /* Veza izmedju pokazivaca i nizova */ #include <stdio.h> void print_array(int* pa, int n); main() { int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10; int num_of_elements = sizeof(a)/sizeof(int); int* pa; /* Niz je isto sto i adresa prvog elementa */ printf("niz a : %p\n", a); printf("adresa prvog elementa niza a (&a[0]) : %p\n", &a[0]); /* Moguce je dodeliti niz pokazivacu odgovarajuceg tipa */ pa = a; printf("pokazivac pa ukazuje na adresu : %p\n", pa); /* Nizu nije moguce dodeliti pokazivacku promenljivu (nizove mozemo smatrati KONSTANTNIM pokazivacima na prvi element) */

5 /* a = pa; */ /* Niz je moguce koristiti kao pokazivac tj. vaze pravila pokazivacke aritmetik printf("a + 3 = %p\n", a + 3); /* Vazi da je a + i = i] odnosno &a[ */ printf("&a[3] = %p\n", &a[3]); *(a + i) = a[i] /* Identiteti a + i = i] odnosno *(a + i) = a[i] &a[ vazi i za pokazivace i za nizove */ /* Pokazivace je na osnovu prethodnog moguce indeksirati kao nizove */ printf("pa[5] = %d\n", pa[5]); printf("*(pa + 5) = %d\n", *(pa+5)); /* Medjutim, sizeof(pa) je samo velicina pokazivaca, a ne niza */ printf("sizeof(a) = %d\n", sizeof(a)); printf("sizeof(pa) = %d\n", sizeof(pa)); /* Pozivamo funkciju za stampanje niza i saljemo joj niz */ print_array(a, num_of_elements); /* Pozivamo funkciju za stampanje niza i saljemo joj pokazivac na pocetak niza print_array(pa, num_of_elements); /* Proslednjivanje niza u funkciju void print_array(int pa[], int n); je ekvivalentno prosledjivanju pokazivaca u funkciju void print_array(int* pa, int n);

6 */ Izmedju ovih konstrukcija nema nikakve razlike. void print_array(int* pa, int n) { int i; for (i = 0; i<n; i++) printf("%d ", pa[i]); putchar( \n ); 3. /* strlen, strcpy, strcat, strcmp, strchr, strstr,... - verzije sa pokazivacima */ /* Vezbe radi, implementirane su funkcije biblioteke string.h */ #include <stdio.h> #include <stdlib.h> /* Zbog NULL */ char* t; /* Izracunava duzinu stringa */ int string_length(char *s) { for (t = s; *t; t++) return t - s; ; /* Kopira string src u string dest. Pretpostavlja da u dest ima dovoljno prostora. void string_copy(char *dest, char *src) { /* Kopira karakter po karakter, sve dok nije iskopiran karakter \0 */ while(*dest++ = *src++) ; /* Nadovezuje string t na kraj stringa s. Pretpostavlja da u s ima dovoljno prostor void string_concatenate(char *s, char *t)

7 { /* Pronalazimo kraj stringa s */ while (*s) s++; /* Vrsi se kopiranje, slicno funkciji string_copy */ while (*s++ = *t++) Vraca : ; /* Vrsi leksikografsko poredjenje dva stringa. */ 0 - ukoliko su stringovi jednaki <0 - ukoliko je s leksikografski ispred t >0 - ukoliko je s leksikografski iza t int string_compare(char *s, char *t) { /* Petlja tece sve dok ne naidjemo na prvi razliciti karakter */ for (; *s == *t; s++, t++) if (*s == \0 ) /* Naisli smo na kraj oba stringa, a nismo nasli razliku */ return 0; /* *s i *t su prvi karakteri u kojima se niske razlikuju Na osnovu njihovog odnosa, odredjuje se odnos stringova */ return *s - *t; /* Pronalazi prvu poziciju karaktera c u stringu s, i vraca pokazivac na nju, odnosno NULL ukoliko s ne sadrzi c */ char* string_char(char *s, char c) { for (; *s; s++) if (*s == c) return s; /* Nije nadjeno */ return NULL;

8 /* Pronalazi poslednju poziciju karaktera c u stringu s, i vraca pokazivac na nju, odnosno NULL ukoliko s ne sadrzi c */ char *t = s; char* string_last_char(char *s, char c) { /* Pronalazimo kraj stringa s */ while (*t++) ; /* Krecemo od kraja i trazimo c unazad */ for (t--; t >= s; t--) if (*t == c) return t; /* Nije nadjeno */ return NULL; /* Proverava da li string str sadrzi string sub. Vraca poziciju na kojoj sub pocinje, odnosno -1 ukoliko ga nema */ char* string_string(char *str, char *sub) { char *s, *t; /* Proveravamo da li sub pocinje na svakoj poziciji i */ for (; *str; str++) /* Poredimo sub sa str pocevsi od poziciji i sve dok ne naidjemo na razliku for (s = str, t = sub; *s == *t; s++, t++) /* Nismo naisli na razliku a ispitali smo sve karaktere niske sub */

9 /* Nije nadjeno */ return NULL; char s[100]; main() { if (*(t+1) == \0 ) return str; char t[] = "Zdravo"; char u[] = " svima"; char r[] = "racunari"; string_copy(s, t); printf("%s\n", s); string_concatenate(s, u); printf("%s\n", s); printf("%d\n",string_char(r, n ) - r); printf("%d\n",string_last_char(r, a ) - r); printf("%d\n",string_string(r, "racun") - r); printf("%d\n",string_string(r, "ari") - r); printf("%d\n",string_string(r, "cun") - r); printf("%p\n",string_string(r, "cna")); 9

10 3. LINEARNE STRUKTURE PODATAKA BPOLJE BDEFINICIJE I STRUKTURA Polje (array) predstavlja linearnu homogenu statičku strukturu podataka i sastoji se od fiksnog broja komponenata istog tipa. Svaki element polja se može označiti pomoću indeksa i svakom se elementu može direktno pristupati. Ukupan broj komponenti polja određen je pri njegovom opisu i ne može se menjati. Polje može biti jednodimenzionalno i višedimenzionalno. Adresa i-te komponente vektora A je data jednačinom: gde su: LR0R elementu. LR0R+c*(i-1), adresa prve reči prvog elementa vektora A, a c broj reči pridružen svakom Dvodimenzionalna polja se mogu memorisati po vrstama ili kolonama i mogu se prikazati ekvivalentnim jednodimenzionalnim vektorom. Adresa elementa A[i,j] dvodimenzionalnog polja smeštenog po kolonama data je izrazom: LR0R+c*[(j-1)*n + (i-1)], gde je n broj vrsta. izrazom: Analogno, adresa elementa A[i,j] dvodimenzionalnog polja smeštenog po vrstama data je LR0R+c*[(i-1)*n + (j-1)]. Analogno se smeštaju i višedimenzionalna polja u memoriju. 1. NCP koji sa standardnog ulaza učitava raspored 8 topova na šahovskoj tabli. Raspored se učitava u formi 8 linija sa po 8 brojeva po liniji. Ako na datom polju nema topa, učitava se 0, a inače 1. Program mora da ispita validnost unetog rasporeda ( da li su učitani brojevi ili 0 ili 1, da li ima 8 topova) i ispita da li se u datom rasporedu dva topa tuku. #include <stdio.h> #include <stdlib.h> main(){ int tabla[8][8]; /*matrica nula i jedinica cuva raspored 8 topova na tabli */ int suma; /* pamti se suma reda/kolone kao test osobina iz zahteva zadatka */ int i,j; /*brojaci u petljama */ /*ucitavanje podataka o rasporedu topova uz sumiranje broja topova i u slucaju greske stampa se odgovarajuca poruka i okoncava programa */ suma=0; for (i=0; i<8; i++ ) for (j=0; j<8; j++){ scanf("%d", &tabla[i][j]); 10

11 /*test korektnosti ulaza */ if (tabla[i][j]!=0 && tabla[i][j]!=1 ){ printf ("\nnekorektni ulazni podaci o rasporedu topova\n"); exit(exit_failure); suma=suma + tabla[i][j]; /*greska je ako je broj topova na tabli razlicit od 8 */ if(suma!=8){ printf ("\nnekorektni ulazni podaci o broju topova\n"); exit(exit_failure); /*proveravanje da li se dva topa nalaze u istom redu, tj. da li je suma clanova nekog reda veca od 1 */ for(i=0;i<8;i++){ suma=0; for (j=0;j<8;j++) suma+=tabla[i][j]; if (suma >1 ) { printf ("\ntopovi se tuku\n"); exit(exit_success); /*proveravanje da li se dva topa nalaze u istoj koloni, tj. da li je suma clanova neke kolone veca od 1 */ for(j=0;j<8;j++) { suma=0; for (i=0;i<8;i++) suma+=tabla[i][j]; if (suma >1 ) { printf ("\ntopovi se tuku\n"); exit(exit_success); /*inace se topovi ne tuku */ printf ("\ntopovi se ne tuku\n"); exit(exit_success); Ubacivanje elementa u rastuce sortiran niz public void InsertSortArray(int value, int[] niz) throws RuntimeException { if (breleme == niz.length) throw new RuntimeException(); int j = 0; // pozicija na koju se ubacuje nova vrednsto breleme++; while (j < breleme && value > niz[j]) j++; for (int k = breleme; k > j; k--) niz[k] = niz[k - 1]; 11

12 Definicija niz[j] = value; Metoda int prosekparnih(int [] niz) koja računa i vraća prosek parnih elemenata niza (onih koji imaju parne vrednosti, a ne na parnim mestima u nizu). public double prosekparnih(int[] niz) { double zbir = 0; double broj = 0; for (int i = 0; i <= niz.length - 1; i++) { if (niz[i] % 2 == 0) { zbir += niz[i]; broj++; if (broj == 0) return 0; else return zbir / broj; BLANČANE LISTE B Lančana lista, za razliku od prethodnih struktura koristi lančani (spregnuti) način zauzeća memorije. Prednosti korišćenja lančane liste: - Količina rezervisane memorije ne mora biti unapred zadata i fiksirana. Tačan iznos zauzete memorije će zavisiti isključivo od količine podataka koji se obrađuju. - Moguće je brzo i često brisanje i umetanje podataka. Elementi lančane liste nisu memorisani u uzastopnim memorijskim lokacijama, već svaki element eksplicitno ukazuje na naredni element u memoriji. Postoji nekoliko tipova listi: 1) jednostruko spregnuta lista 2) dvostruko spregnuta lista 3) kružna lista BJEDNOSTRUKO SPREGNUTA LINEARNA LISTA Svaki element ove strukture sadrži dva polja: podatak i pokazivač na naredni element u listi. Glava liste je pokazivač koji sadrži adresu prvog elementa liste. 12

13 /* Rad sa jednostruko spregnutom listom - iterativne verzije funkcija za rad sa povezanom listom */ #include <stdio.h> #include <stdlib.h> typedef struct elem { int broj; struct elem *sled; Elem; /*Element liste*/ int duz (Elem *lst); /* Broj elemenata liste. */ void pisi (Elem *lst); /* Ispisivanje liste. */ Elem *na_pocetak (Elem *lst, int b); /* Dodavanje na pocetak. */ Elem *na_kraj (Elem *lst, int b); /* Dodavanje na kraj. */ Elem *citaj1 (int n); /* Citanje liste stavljajuci brojeve na pocetak. */ Elem *citaj2 (int n); /* Citanje liste stavljajuci brojeve na kraj. */ Elem *umetni (Elem *lst, int b); /* Umetanje u uredjenu listu. */ void brisi (Elem *lst); /* Brisanje svih elemenata liste. */ Elem *izostavi (Elem *lst, int b); /* Izostavljanje svakog pojavljivanja. */ void main () { Elem *lst = NULL; int kraj = 0, izbor, broj, n; while (!kraj) { printf ("\n1. Dodavanje broja na pocetak liste\n" "2. Dodavanje broja na kraj liste\n" "3. Umetanje broja u uredjenu listu\n" "4. Izostavljanje broja iz liste\n" "5. Brisanje svih elemenata liste\n" "6. Citanje uz obrtanje redosleda brojeva\n" "7. Citanje uz cuvanje redosleda brojeva\n" "8. Odredjivanje duzine liste\n" "9. Ispisivanje liste\n" "0. Zavrsetak rada\n\n" "Vas izbor? " ); scanf ("%d", &izbor); switch (izbor) { case 1: case 2: case 3: case 4: printf ("Broj? "); scanf ("%d", &broj); switch (izbor) { case 1: /* Dodavanje broja na pocetak liste: */ lst = na_pocetak (lst, broj); break; case 2: /* Dodavanje broja na kraj liste: */ lst = na_kraj (lst, broj); break; case 3: /* Umetanje broja u uredjenu listu: */ lst = umetni (lst, broj); break; case 4: /* Izostavljanje broja iz liste: */ lst = izostavi (lst, broj); break; break; case 5: /* Brisanje svih elemenata liste: */ brisi (lst); lst = NULL; break; case 6: case 7: /* Citanje liste: */ printf ("Duzina? "); scanf ("%d", &n); printf ("Elementi? "); brisi (lst); switch (izbor) { case 6: /* uz obrtanje redosleda brojeva: */ lst = citaj1 (n); break; case 7: /* uz cuvanje redosleda brojeva: */ lst = citaj2 (n); break; 13

14 break; case 8: /* Odredjivanje duzine liste: */ printf ("Duzina= %d\n", duz (lst)); break; case 9: /* Ispisivanje liste: */ printf ("Lista= "); pisi (lst); putchar ('\n'); break; case 0: /* Zavrsetak rada: */ kraj = 1; break; default: /* Pogresan izbor: */ printf ("*** Neozvoljeni izbor! ***\a\n"); break; /* Definicije funkcija za obradu lista (iterativno). */ int duz (Elem *lst) { /* Broj elemenata liste. */ int n = 0; while (lst){ n++; lst = lst->sled; return n; void pisi (Elem *lst){ /* Ispisivanje liste. */ while(lst){ printf("%d ",lst->broj); lst = lst -> sled; Elem *na_pocetak(elem *lst, int b){ /* Dodavanje na pocetak. */ Elem *novi = malloc(sizeof(elem)); novi->broj = b; novi->sled = lst; return novi; Elem *na_kraj (Elem *lst, int b) { /* Dodavanje na kraj. */ Elem *novi = malloc (sizeof(elem)); novi->broj = b; novi->sled = NULL; if (!lst) return novi; else { Elem *tek = lst; while (tek->sled) tek = tek->sled; tek->sled = novi; return lst; Elem *citaj1 (int n) { /* Citanje liste stavljajuci brojeve na pocetak. */ Elem *prvi = NULL; int i; for (i=0; i<n; i++) { Elem *novi = malloc (sizeof(elem)); scanf("%d", &novi->broj); novi->sled = prvi; prvi = novi; return prvi; Elem *citaj2 (int n) { /* Citanje liste stavljajuci brojeve na kraj. */ Elem *prvi = NULL, *posl = NULL; int i; for (i=0; i<n; i++) { Elem *novi = malloc (sizeof(elem)); 14

15 scanf ("%d", &novi->broj); novi->sled = NULL; if (!prvi) prvi = novi; else posl->sled = novi; posl = novi; return prvi; Elem *umetni (Elem *lst, int b) { /* Umetanje u uredjenu listu. */ Elem *tek = lst, *pret = NULL, *novi; while(tek && tek->broj < b){ pret = tek; tek = tek->sled; novi = malloc (sizeof(elem)); novi->broj = b; novi->sled = tek; if(!pret) lst = novi; else pret->sled = novi; return lst; void brisi (Elem *lst) { /* Brisanje svih elemenata liste. */ while(lst){ Elem *stari = lst; lst = lst->sled; free (stari); Elem *izostavi(elem *lst, int b){ /* Izostavljanje svakog pojavljivanja. */ Elem *tek = lst, *pret = NULL; while(tek) if (tek->broj!= b){ pret = tek; tek = tek->sled; else { Elem *stari = tek; tek = tek->sled; if (!pret) lst = tek; else pret->sled = tek; free (stari); return lst; 15

16 /* Rad sa povezanom listom - REKURZIVNE verzije funkcija za rad sa povezanom listom; */ #include <stdio.h> #include <stdlib.h> typedef struct elem { int broj; struct elem *sled; Elem; /*Element liste*/ int duz (Elem *lst); /* Broj elemenata liste. */ void pisi (Elem *lst); /* Ispisivanje liste. */ Elem *na_pocetak (Elem *lst, int b); /* Dodavanje na pocetak. */ Elem *na_kraj (Elem *lst, int b); /* Dodavanje na kraj. */ Elem *citaj1 (int n); /* Citanje liste stavljajuci brojeve na pocetak. */ Elem *citaj2 (int n); /* Citanje liste stavljajuci brojeve na kraj. */ Elem *umetni (Elem *lst, int b); /* Umetanje u uredjenu listu. */ void brisi (Elem *lst); /* Brisanje svih elemenata liste. */ Elem *izostavi (Elem *lst, int b); /* Izostavljanje svakog pojavljivanja. */ void main () { Elem *lst = NULL; int kraj = 0, izbor, broj, n; while (!kraj) { printf ("\n1. Dodavanje broja na pocetak liste\n" "2. Dodavanje broja na kraj liste\n" "3. Umetanje broja u uredjenu listu\n" "4. Izostavljanje broja iz liste\n" "5. Brisanje svih elemenata liste\n" "6. Citanje uz obrtanje redosleda brojeva\n" "7. Citanje uz cuvanje redosleda brojeva\n" "8. Odredjivanje duzine liste\n" "9. Ispisivanje liste\n" "0. Zavrsetak rada\n\n" "Vas izbor? " ); scanf ("%d", &izbor); switch (izbor) { case 1: case 2: case 3: case 4: printf ("Broj? "); scanf ("%d", &broj); switch (izbor) { case 1: /* Dodavanje broja na pocetak liste: */ 16

17 lst = na_pocetak (lst, broj); break; case 2: /* Dodavanje broja na kraj liste: */ lst = na_kraj (lst, broj); break; case 3: /* Umetanje broja u uredjenu listu: */ lst = umetni (lst, broj); break; case 4: /* Izostavljanje broja iz liste: */ lst = izostavi (lst, broj); break; break; case 5: /* Brisanje svih elemenata liste: */ brisi (lst); lst = NULL; break; case 6: case 7: /* Citanje liste: */ printf ("Duzina? "); scanf ("%d", &n); printf ("Elementi? "); brisi (lst); switch (izbor) { case 6: /* uz obrtanje redosleda brojeva: */ lst = citaj1 (n); break; case 7: /* uz cuvanje redosleda brojeva: */ lst = citaj2 (n); break; break; case 8: /* Odredjivanje duzine liste: */ printf ("Duzina= %d\n", duz (lst)); break; case 9: /* Ispisivanje liste: */ printf ("Lista= "); pisi (lst); putchar ('\n'); break; case 0: /* Zavrsetak rada: */ kraj = 1; break; default: /* Pogresan izbor: */ printf ("*** Neozvoljeni izbor! ***\a\n"); break; /* Definicije funkcija za obradu lista (REKURZIVNO). */ int duz (Elem *lst) { /* Broj elemenata liste. */ return lst? duz (lst->sled) + 1 : 0; void pisi (Elem *lst) { /* Ispisivanje liste. */ if (lst) { printf ("%d ", lst->broj); pisi (lst->sled); Elem *na_pocetak (Elem *lst, int b) { /* Dodavanje na pocetak. */ Elem *novi = malloc (sizeof(elem)); novi->broj = b; novi->sled = lst; return novi; Elem *na_kraj (Elem *lst, int b) { /* Dodavanje na kraj. */ if (!lst) { lst = malloc (sizeof(elem)); lst->broj = b; lst->sled = NULL; else lst->sled = na_kraj (lst->sled, b); return lst; Elem *citaj1 (int n) { /* Citanje liste uz obrtanje redosleda. */ if (n == 0) return NULL; else { Elem *novi = malloc (sizeof(elem)); 17

18 novi->sled = citaj1 (n - 1); scanf ("%d", &novi->broj); return novi; Elem *citaj2 (int n) { /* Citanje liste uz cuvanje redosleda. */ if (n == 0) return NULL; else { Elem *novi = malloc (sizeof(elem)); scanf ("%d", &novi->broj); novi->sled = citaj2 (n - 1); return novi; Elem *umetni (Elem *lst, int b) { /* Umetanje u uredjenu listu. */ if (!lst lst->broj >= b) { Elem *novi = malloc (sizeof(elem)); novi->broj = b; novi->sled = lst; return novi; else { lst->sled = umetni (lst->sled, b); return lst; void brisi (Elem *lst) { /* Brisanje svih elemenata liste. */ if (lst) { brisi (lst->sled); free (lst); Elem *izostavi (Elem *lst, int b){ /* Izostavljanje svakog pojavljivanja. */ if (lst) { if (lst->broj!= b) { lst->sled = izostavi (lst->sled, b); else { Elem *stari = lst; lst = izostavi (lst->sled, b); free (stari); return lst; Metoda int Prebroj(CvorListe Vrh) koja će vratiti koliko elemenata liste ima vrednost veću od elementa na početku liste. public int prebroj(cvorjsliste pocetak) { if (pocetak == null) { return 0; int broj = 0; CvorJSListe pom = pocetak; while (pom!= null) { if (pom.podatak > pocetak.podatak) { broj++; pom = pom.sledeci; return broj; 18

19 Metoda koja vraća broj ponavljanja zadate vrednosti u listi. public int brponavljanja(cvorjsliste prvi, int pod) { if (prvi == null) return 0; int broj = 0; CvorJSListe pom = prvi; while (pom!= null) { if (pom.podatak == pod) broj++; pom = pom.sledeci; return broj; Metoda koja izbacuje element koji se nalazi nakon elementa sa najmanjom vrednošću. public int poslenajmanjeg(cvorjsliste prvi) { if (prvi == null) return Integer.MIN_VALUE; CvorJSListe min = minelement(prvi); if (min.sledeci == null) return Integer.MIN_VALUE; broj = min.sledeci.podatak; min.sledeci = min.sledeci.sledeci; return broj; Broj pozitivnih elemenata rekurzivno public int izbrojpozitivne(cvorjsliste pom) { if (pom == null) return 0; else { if (pom.podatak > 0) return 1 + izbrojpozitivne(pom.sledeci); else return izbrojpozitivne(pom.sledeci); Metoda koja vraća invertovanu JSListu public CvorJSListe invertuj(cvorjsliste p1){ CvorJSListe p2 = null; 19

20 while(p1!= null){ p2 = new CvorJSListe(p1.podatak, p2); p1 = p1.sledeci; return p2; Metoda koja koja pravi indentičnu kopiju date JSListe public CvorJSListe klonirana(cvorjsliste pom) { if (pom!= null) { CvorJSListe novi = new CvorJSListe(pom.podatak, klonirana(pom.sledeci)); return novi; else { return null; Metoda koja od JSListe pravi niz public int[] transform(jslista l) { int br = 0; CvorJSListe pomocni = l.prvi; while (pomocni!= null) { br++; pomocni = pomocni.sledeci; pomocni = l.prvi; int[] stack = new int[br]; for (int i = 0; i < stack.length; i++) { stack[i] = pomocni.podatak; pomocni = pomocni.sledeci; return stack; Metoda koja od dve JSListe vraća treću listu koja predstavlja uniju datih listi public CvorJSListe unija(cvorjsliste c1, CvorJSListe c2) { if (c1 == null && c2 == null) return null; CvorJSListe novalista = null; while (c1!= null) { if (!postoji(novalista, c1.podatak)) { 20

21 novalista = new CvorJSListe(c1.podatak, novalista); c1 = c1.sledeci; while (c2!= null) { if (!postoji(novalista, c2.podatak)) { novalista = new CvorJSListe(c2.podatak, novalista); c2 = c2.sledeci; return novalista; Metoda koja proverava da li postoji vrednost u JSListi private boolean postoji(cvorjsliste c2, int p) { while (c2!= null) { if (c2.podatak == p) { return true; c2 = c2.sledeci; return false; KRUŽNO SPREGNUTA LINEARNA LISTA Kod ovog tipa liste pokazivač poslednjeg elementa nema NULL vrednost već ukazuje na prvi element liste. Prednosti ovog tipa liste su: - Svakom elementu se može pristupiti polazeći od bilo kog elementa liste. - Jednostavnije pronalaženje elemenata liste. - Efikasnije operacije dodavanja i brisanja elemenata iz liste. Kod ovog tipa liste neophodno je znati prvi ili poslednji element. To možemo rešiti na dva načina: 1) Pokazivač na glavu liste 2) Označavanje početnog elementa liste. Npr. ostaviti prazno polje za podatak, ili u njega upisati specijalni simbol... itd. 21

22 DVOSTRUKO POVEZANA LINEARNA LISTA Kod ovog tipa listi, svaki element ima dva pokazivača koji ukazuju na prethodni i naredni element (levi i desni ukazivač). Levi ukazivač krajnjeg levog i desni pokazivač krajnjeg desnog elementa su NULL. 22

23 2. NCP koji iz neprazne datoteke broj.txt ucitava paran broj celih brojeva x[1], x[2],...,x[n], gde n nije unapred poznato. Ispisati poruku na standardni izlaz da li vazi da x[1]==x[n], x[2]==x[n-1],..., x[k]=x[k+1], k=1..n/2 #include <stdio.h> #include <stdlib.h> typedef struct listacv dvlista; /*dvostruko povezana linearna lista*/ struct listacv{ int broj; /*informaciono polje je clan niza x*/ dvlista *sledeci, *prethodni; ; dvlista *ubaci(dvlista *kraj, int broj){ dvlista *novi; /*novi cvor za umetanje u listu*/ novi=(dvlista *)malloc(sizeof(dvlista)); /*alokacija memorije za novi cvor liste*/ novi->broj=broj; /*inicijalizacija polja broj u cvoru novi */ novi->sledeci=null; novi->prethodni=kraj; /*novi element se dodaje na kraj postojece liste*/ kraj->sledeci=novi; /* do tada poslednji cvor kraj je ispred clana novi*/ kraj=novi; /*poslednji dodat element je novi kraj liste*/ return kraj; main() { dvlista *prvi, *kraj; /*prvi i poslednji cvor dvostruke liste*/ int n; /*broj ucitanih celih brojeva*/ int broj; /*tekuci broj sa ulaza*/ int jednak; /*indikator jednakosti dva clana - cuva vrednost 0 ili 1 */ FILE *ulaz; int i; /*brojacka promenljiva*/ /*otvaranje datoteke za citanje i upis brojeva iz datoteke u dvostruku povezanu listu */ ulaz=fopen("broj.txt", "r"); fscanf(ulaz, "%d", &broj); /*kreiranje prvog cvora liste za prvi ucitan broj */ prvi=(dvlista*)malloc(sizeof(dvlista)); prvi->broj=broj; prvi->sledeci=null; prvi->prethodni=null; kraj=prvi; n=1; //za sada ucita je samo jedan clan /*formiranje liste od brojeva koji se ucitavaju sve do kraja datoteke - feof(ulaz) */ while (!feof(ulaz)) { fscanf(ulaz, "%d", &broj); kraj=ubaci (kraj, broj); n++; 23

24 fclose(ulaz); /*testiranje jednakih parova uz pomeranje tekuceg prvog clana i tekuceg poslednjeg clana ka sredini liste*/ jednak=1; for(i=1; i<=n/2 && jednak; i++) { jednak=jednak&&(prvi->broj==kraj->broj); prvi=prvi->sledeci; /*pomeranje ka sredini liste */ kraj=kraj->prethodni; /*pomeranje ka sredini liste */ printf("za unete broje jednakost "); if(!jednak) printf("ne "); printf("vazi\n"); return 0; PRIMENE SPREGNUTIH LINEARNIH LISTI Prikaz polinoma Pretpostavimo da imamo polinom od tri promenljive: 3X 2 + 4XY + Y 2 + XYZ Svaki element liste koji prikazuje jedan član polinoma dat je na sledećoj slici: Spregnuta lista za prikaz ovog polinoma izgledala bi: Odgovarajuća struktura elementa bi bila: typedef struct elem element; struct elem{ int expx; int expy; int expz; int koef; element *naredni; 3. NCP-e za sabiranje, oduzimanje i množenje polinoma jedne promenljive. #include <stdio.h> #include <stdlib.h> #include <math.h> struct pnode{ double coef; long power; struct pnode *link; ; typedef struct pnode poly; #define COEF(a) ((a)->coef) #define POWER(a) ((a)->power) 24

25 #define LINK(a) ((a)->link) poly *addelem(poly *p, double coef, long pow){ poly *c,*newel,*pret=null; c = p; while(c && POWER(c) > pow){ pret=c; c = LINK(c); if(!c POWER(c) < pow){ newel = (poly*)malloc(sizeof(poly)); COEF(newel) = coef; POWER(newel) = pow; LINK(newel) = c; if(!pret) p = newel; else LINK(pret) = newel; return p; if(power(c) == pow){ COEF(c) += coef; return p; poly *create(){ int pow; double c; poly *p=null; printf("\nunesite polinom pocev od najveceg stepena:\n"); while(1){ printf("\nkoeficijent: "); scanf("%lf",&c); printf("\nstepen: "); scanf("%d",&pow); if(c == 0) break; p = addelem(p,c,pow); if(pow == 0) break; return p; void display(poly *p){ poly *cur=p; if(cur){ printf(" %c %.2f * X^%d",COEF(cur)<0?'-':' ',fabs(coef(cur)),power(cur)); cur=link(cur); while(cur!= NULL){ printf(" %c %.2f * X^%d",COEF(cur)<0?'- ':'+',fabs(coef(cur)),power(cur)); cur=link(cur); poly *polyadd(poly* p1, poly* p2){ poly *p, *res=null; p=p1; while(p){ 25

26 res=addelem(res,coef(p),power(p)); p=link(p); p=p2; while(p){ res=addelem(res,coef(p),power(p)); p=link(p); return res; poly *polysub(poly* p1, poly* p2){ poly *p, *res=null; p=p1; while(p){ res=addelem(res,coef(p),power(p)); p=link(p); p=p2; while(p){ res=addelem(res,-coef(p),power(p)); p=link(p); return res; poly *polymul(poly* p1, poly* p2){ poly *pom1,*pom2,*res=null; pom1=p1; while(pom1){ pom2=p2; while(pom2){ res=addelem(res,coef(pom1)*coef(pom2),power(pom1)+power(pom2)); pom2=link(pom2); pom1=link(pom1); return res; poly *polydif(poly* p1){ poly *pom1,*res=null; pom1=p1; while(pom1){ if(power(pom1)!=0) res=addelem(res,coef(pom1)*power(pom1),power(pom1)-1); pom1=link(pom1); return res; void brisi(poly *p){ poly *stari; while(p){ stari=p; p=link(p); free(stari); void main(){ int ch; poly *poly1,*poly2,*poly3; poly1=poly2=poly3=null; 26

27 printf("\nunesite prvi polinom:\n"); poly1=create(); display(poly1); poly2=create(); display(poly2); while(1){ printf("************************" "\nodaberi operaciju:\n" "1.Sabiranje\n" "2.Oduzimanje\n" "3.Mnozenje\n" "4.Izvod\n" "5.Izlaz\n"); scanf("%d",&ch); switch(ch){ case 1: poly3=polyadd(poly1,poly2); break; case 2: poly3=polysyb(poly1,poly2); break; case 3: poly3=polymul(poly1,poly2); break; case 4: poly3=polydif(poly1); break; default: exit(1); brisi(poly1); brisi(poly2); brisi(poly3); Metoda koja prebacuje čvor sa najvećom vrednošću na početak te liste. public void prebacimaxelement(cvordsliste poslednji) { CvorDSListe max = poslednji; CvorDSListe pom = poslednji; while (pom.prethodni!= null) { pom = pom.prethodni; if (pom.podatak > max.podatak) { max = pom; if(max.prethodni == null) return; max.prethodni.sledeci = max.sledeci; if(max.sledeci!= null) max.sledeci.prethodni = max.prethodni; max.prethodni = null; 27

28 max.sledeci = pom; pom.prethodni = max; Napisati metodu koja prikazuje (štampa na ekranu) onu polovinu liste (levo od p ili desno od p) koja ima veći zbir public void vecizbir(cvordsliste p) { CvorDSListe pom = p; int zbir1 = 0; int zbir2 = 0; while (pom!= null) { zbir1 = zbir1 + pom.podatak; pom = pom.sledeci; pom = p; while (pom!= null) { zbir2 = zbir2 + pom.podatak; pom = pom.prethodni; if (zbir1 > zbir2) { pom = p.sledeci; while (pom!= null) { System.out.println(pom.podatak); pom = pom.sledeci; else { pom = p.prethodni; while (pom!= null) { System.out.println(pom.podatak); pom = pom.prethodni; Dat je pokazivač na prvi element DSListe čiji čvorovi predstavljaju elemente reči (slovo ili prazno mesto). Napisati metodu koja proverava da li je data rečenica (reč) palindrom. Palindrom je reč (rečenica) koja se čita isto sa obe strane (i sleva na desno i s desna na levo). public static boolean dalijepalindromds(cvordsliste p) { if (p == null) { return false; CvorDSListe pom = p; while (pom.sledeci!= null) { 28

29 pom = pom.sledeci; while (p!= pom && p.prethodni!= pom) { if (p.podatak == ' ') { p = p.sledeci; if (pom.podatak == ' ') { pom = pom.prethodni; if (p.podatak == pom.podatak) { p = p.sledeci; pom = pom.prethodni; else { return false; return true; Data je dvostruko spregnuta (DS) lista čiji su elementi čvorova pokazivači na početak jednostruko spregnute (JS) liste. Napisati klasu koja opisuje čvor ovakve DS liste, a zatim napisati algoritam za ubacivanje novog elementa u ovako definisanu strukturu, koji funkcioniše po sledećem principu: kreće se od početka DS liste. Ako je element koji se ubacuje manji od prvog elementa JS liste trenutnog čvora DS liste, onda se taj element ubacuje na kraj te JS liste. U suprotnom, prelazi se na sledeći čvor DS liste i algoritam se ponavlja. Ako se stigne do kraja DS liste, onda se kreira novi čvor i u njegovu JS listu se ubacuje novi element. Početna metoda prihvata pokazivač na početak DS liste i ceo broj koji se ubacuje. public class CvorListe { private CvorListe sledeci; private CvorListe prethodni; private CvorJSListe prvi; public void ubaci(cvorliste p, int pod) { if (p == null) { p = new CvorListe(); p.prvi = new CvorJSListe(pod, null); else { while (p.sledeci!= null && p.prvi.podatak <= pod) { p = p.sledeci; 29

30 if (p.prvi.podatak <= pod) { p.sledeci = new CvorListe(); p.sledeci.prethodni = p; p.sledeci.prvi = new CvorJSListe(pod, null); else { CvorJSListe pom = prvi; while (pom.sledeci!= null) { pom = pom.sledeci; pom.sledeci = new CvorJSListe(pod, null); Dat je pokazivac na neki element DS liste celih brojeva. Napisati funkciju koja ce izbaciti iz liste onaj element koji sadrži najmanju vrednost u listi. public int izbacimin(cvordsliste cvor) { if (cvor == null) return Integer.MAX_VALUE; while (cvor.prethodni!= null) { cvor = cvor.prethodni; CvorDSListe min = minelement(cvor); if (min.prethodni!= null) min.prethodni.sledeci = min.sledeci; if (min.sledeci!= null) min.sledeci.prethodni = min.prethodni; return min.podatak; Dat je pokazivač na prvi element DS liste. Napisati metodu koja vraća pokazivač na element sa najmanjom vrednošću u listi. private CvorDSListe minelement(cvordsliste cvor) { CvorDSListe min = cvor; while (cvor!= null) { if (cvor.podatak < min.podatak) min = cvor; cvor = cvor.sledeci; return min; 30

31 Dat je pokazivac na pocetni cvor DS liste sortirane u rastucem redosledu koja sadrži pozitivne cele brojeve. Napisati funkciju koja ce izmedju svih onih elementa liste koji se po vrednosti razlikuju za više od 1 ubaciti u datu listu nove elemente tako da lista posle poziva operacije ima u sebi sukcesivne cele brojeve. Na primer ako lista sadrži 3, 5, 8 nakon poziva ove opercije sadržace 3, 4, 5, 6, 7, 8 public void popuni(cvordsliste prvi) { if (prvi == null prvi.sledeci == null) return; if ((prvi.sledeci.podatak - prvi.podatak) > 1) { CvorDSListe novi = new CvorDSListe(prvi.podatak + 1, prvi, prvi.sledeci); prvi.sledeci.prethodni = novi; prvi.sledeci = novi; popuni(prvi.sledeci); Dat je pokazivac na neki cvor DS liste celih brojeva koja sigurno sadrži najmanje 4 elementa. Napisati funkciju ubacinti(int A, int N) koja ce ubaciti novi element sa sadržajem A i to tako da on bude na N-toj poziciji od pocetka. public void ubacin(cvordsliste cvor, int a, int n) { if (cvor == null) return; while (cvor.prethodni!= null) cvor = cvor.prethodni; CvorDSListe pom = new CvorDSListe(a, null, null); if (n < 0) { return; if (n == 0) { pom.prethodni = null; pom.sledeci = cvor; if (pom.sledeci!= null) pom.sledeci.prethodni = pom; int i = 0; while (i++ < n - 1) { if (cvor.sledeci == null) return; cvor = cvor.sledeci; 31

32 pom.prethodni = cvor; pom.sledeci = cvor.sledeci; if (cvor.sledeci!= null) cvor.sledeci.prethodni = pom; cvor.sledeci = pom; Metoda koja invertuje dvostruko-spregnutu listu. public CvorDSListe invertujlistu(cvordsliste cvor) { CvorDSListe c = null; while (cvor!= null) { c = new CvorDSListe(cvor.podatak, null, c); if (c.sledeci!= null) c.sledeci.prethodni = c; cvor = cvor.sledeci; return c; Metoda koja vraća DSListu koja predstavlja razliku (skupova) dve DSListe public CvorDSListe razlika(cvordsliste c1, CvorDSListe c2) { if (c1 == null c2 == null) return c1; CvorDSListe novi = null; CvorDSListe pom = c1; while (pom!= null) { if (!pronadji(pom.podatak, c2)) { novi = new CvorDSListe(pom.podatak, null, novi); if (novi.sledeci!= null) { novi.sledeci.prethodni = novi; pom = pom.sledeci; return novi; Metoda koja poslednji element DSListe prebacuje na početak te DSListe. Dati su pokazivačni na prvi i poslednji element public void prebaciposlednjinapocetak() { if (prvi == null) { return; 32

33 return; if (prvi.sledeci == null) { CvorDSListe pom = poslednji; poslednji = pom.prethodni; pom.sledeci = prvi; prvi.prethodni = pom; pom.prethodni.sledeci = null; pom.prethodni = null; prvi = pom; Metoda koja računa zbir elemenata koji se ponavljaju. Primer: Ulaz Rezultat je 2+5=7 public int ZbirDuplih(CvorDSListe p1) { if (p1 == null) return 0; CvorDSListe tek = p1; CvorDSListe tek1 = p1.sledeci; CvorDSListe tek2 = tek.prethodni; int ima = 0; int suma = 0; for (; tek!= null; tek = tek.sledeci) { for (; tek2!= null; tek2 = tek2.prethodni) { if (tek.podatak == tek2.podatak) { ima = 1; break; tek2 = tek; if (ima == 0) { for (; tek1.sledeci!= null; tek1 = tek1.sledeci) { if (tek.podatak == tek1.podatak) { suma = suma + tek.podatak; break; if (tek1.sledeci!= null) { tek1 = tek1.sledeci; return suma; 33

34 Metoda koja vraća pokazivač na prvi element ciklične DSListe sortirane u rastućem redosledu. Dat je pokazivač na neki element u listi. public CvorDSListe vratipoknaprviel(cvordsliste p) { if (p == null (p.sledeci == p && p.prethodni == p)) return p; CvorDSListe pom = p; while (pom.sledeci.podatak > pom.podatak && pom.prethodni.podatak < pom.podatak) pom = pom.sledeci; return pom.sledeci; 34

35 RETKO POSEDNUTE MATRICE Realizuje se preko spregnutih listi i ima za cilj smanjenje broja izračunavanja, kao i smanjenje potrebne memorije za čuvanje sturkture. Jedna moguća reprezentacija dvodimenzionalne retko posednute matrice bi bila preko jedne spregnute liste za svaki red i svaku kolonu matrice. Svaka od ovih listi ima zaglavlje, tj. glavu. Svakom nenultom mestu u matrici odgovara jedan čvor oblika: struct cvor { int red; int kolona; int vrednost; struct cvor *nar_u_kol; struct cvor *nar_u_vrsti; /* Implementacija dinamickih kvadratnih matrica preko pokazivaca na niz pokazivaca na kolone */ #include <stdio.h> #include <stdlib.h> /* Tip elemenata matrice ce biti float */ typedef float tip; /* Funkcija alocira matricu dimenzije n*n */ tip** allocate(int n){ tip **m; int i; /* Alocira se niz pokazivaca na kolone */ m=(tip**)malloc(n*sizeof(tip*)); for (i=0; i<n; i++) /* Alociraju se nizovi brojeva koji predstavljaju kolone */ 35

36 m[i]=(tip*)malloc(n*sizeof(tip)); return m; /* Funkcija vrsi dealociranje date matrice dimenzije n */ void deallocate(tip** m, int n){ int i; /* Uklanjaju se kolone */ for (i=0; i<n; i++) free(m[i]); /* Uklanja se niz pokazivaca na kolone */ free(m); /* Funkcija ispisuje datu matricu dimenzije n */ void IspisiMatricu(tip** matrica, int n){ int i,j; for (i=0; i<n; i++){ for(j=0; j<n; j++) printf("%f\t",matrica[i][j]); printf("\n"); /* Funkcija ucitava datu matricu i njenu dimenziju */ void UnesiMatricu(tip*** matrica,int *pn){ int i,j; printf("unesite dimenziju kvadratne matrice :"); scanf("%d",pn); *matrica=allocate(*pn); for (i=0; i<*pn; i++) for(j=0; j<*pn; j++){ printf("a[%d][%d]=",i+1,j+1); scanf("%f",&((*matrica)[i][j])); /* Rekurzivna funkcija koja vrsi Laplasov razvoj - neefikasna, ali dobra vezba */ tip determinanta(tip** matrica, int n){ int i; tip** podmatrica; int det=0,znak; /* Izlaz iz rekurzije je matrica 1x1 */ if (n==1) return matrica[0][0]; /* Podmatrica ce da sadrzi minore polazne matrice */ podmatrica=allocate(n-1); znak=1; for (i=0; i<n; i++){ int vrsta,kolona; for (kolona=0; kolona<i; kolona++) for(vrsta=1; vrsta<n; vrsta++) podmatrica[vrsta-1][kolona]=matrica[vrsta][kolona]; for (kolona=i+1; kolona<n; kolona++) for(vrsta=1; vrsta<n; vrsta++) podmatrica[vrsta-1][kolona-1]=matrica[vrsta][kolona]; det+=znak*matrica[0][i]*determinanta(podmatrica,n-1); znak*=-1; deallocate(podmatrica,n-1); return det; main(){ /* Matrica i njena dimenizija */ 36

37 tip **matrica; int n; /* Unosi se matrica */ UnesiMatricu(&matrica,&n); /* Ispisuje se determinanta */ printf("determinanta je : %f\n",determinanta(matrica,n)); return 0; 3.3. BSTEK BDEFINICIJE I STUKTURA Stek (stack) ili magacin je jedna od najznačajnijih linearnih i dinamičkih struktura podataka. Stavljanje (upis) ili brisanje (čitanje) elemenata se vrši samo na jednom kraju. Operacija stavljanja se naziva PUSH, a brisanja POP. Stek se prazni i puni po tzv. LIFO strategiji. #define MAXSTACKLEN 100 /* maksimalna dubina steka */ int stack[maxstacklen];/*vrednost steka */ int stackpointer;/*naredna slobodna pozicija na steku */ /* push: gurni na stek */ void push( int arg ){ if( stackpointer < MAXSTACKLEN ) stack[stackpointer++] = arg; else printf("greska: stek je pun, nemoguce je smestiti %g\n", arg); /* pop: skini sa steka*/ int pop( void ){ if( stackpointer > 0 ) return stack[--stackpointer]; else{ printf("greska: stek je prazan\n" ); return 0; int top(void){ if(stackpointer > 0) return stack[stackpointer-1]; else{ printf("greska: stek je prazan\n"); return 0; 01BOpis zadatka: Za aritmetičke izraze kao što su T2+3T, T2+3*4T, T(2+3)*4T, itd. sa kojima se tipično susrećemo kako u matematici tako i u programiranju, kažemo da su zapisani u Tinfiksnoj formit, s obzirom da se operator nalazi TizmeđuT operanada. Najveća mana ovakvog zapisa leži u činjenici da je neophodno uspostaviti konvencije o TprioritetuT pojedinih operatora (npr. konvenciju da množenje ima veći prioritet u odnosu na sabiranje), i eventualno koristiti zagrade za promenu prioriteta. 37

38 i U računarstvu je od velikog značaja jedan posve drugačiji zapis aritmetičkih izraza, poznat pod imenom TpostfiksnaT ili Tobrnuta poljska notacijat, u kojem se operatori navode TnakonT operanada (naziv obrnuta poljska notacija dat je u čast poljskog matematičara Jana Lukasiewitza, koji je predložio upravo obrnuti princip - da se operatori zapisuju TispredT operanada). Na primer, prethodna tri izraza zapisana u infiksnoj notaciji, u obrnutoj poljskoj notaciji zapisuju se ovako: * * Izračunavanje izraza u obrnutoj poljskoj notaciji izvodi se tako da se svaki operand na koji se naiđe dodaje na kraj liste (koja je na početku prazna), dok se prilikom nailaska na binarni operator poslednja dva elementa iz liste brišu i zamenjuju rezultatom operacije (sličan princip može se primeniti i na n-arne operatore). Broj koji na kraju izračunavanja ostane u listi predstavlja rezultat izračunavanja (taj broj mora biti jedinstven ako je izraz bio ispravan). Uzmimo na primer, sledeći izraz zapisan u obrnutoj poljskoj notaciji: * 6 + * 2 / Izračunavanje ovog izraza teklo bi ovako: T6 i 4 su zamijenjeni sa 6-4= T5 i 2 su zamijenjeni sa 5*2= T10 i 6 su zamijenjeni sa 10+6=16 48 T3 i 16 su zamijenjeni sa 3*16= T48 i 2 su zamijenjeni sa 48/2=24 Dakle, rezultat izračunavanja je 24. Jedna od glavnih prednosti obrnute poljske notacije leži u činjenici da nije potrebno voditi računa o prioritetu operacija, kao i da je TsvakiT izraz moguće zapisati Tbez upotrebe zagradat. Na primer, izraz koji bi se u infiksnom obliku zapisao kao ((3 + 5) / (7-2) + 4 / (8-5)) / (3 + 5 * (4 / (7-2))) u obrnutoj poljskoj notaciji zapisuje se kao / / / * + / Stoga, kompajleri većine programskih jezika interno prevode sve aritmetičke izraze u obrnutu poljsku notaciju pre bilo kakve dalje obrade. Vaš zadatak je da napravite program koji aritmetičke izraze u infiksnom obliku koji se sastoje od jednoslovnih promjenljivih (a-z), četiri računske operacije (T+T, T-T, T*T eventualno zagrada, pretvori u obrnutu poljsku notaciju. T/T), i 1BUlazna datoteka: U prvom i jedinom redu ulazne tekstualne datoteke TRPN.INT nalazi se niz znakova koji predstavlja aritmetički izraz u infiksnoj notaciji koji treba pretvoriti u postfiksnu odnosno obrnutu poljsku notaciju. 38

39 treba T Ispravan aritmetički izraz sme sadržavati samo jednoslovne promenljive pisane malim slovima (od "a" do "z"), binarne operatore " T+T", "T-T", "T*T" i "T/T" kao i male zagrade "(" i ")" za promenu prioriteta operacija. Ispravan aritmetički izraz neće sadržati nikakve razmake. 21BIzlazna datoteka: Ukoliko ulazna datoteka sadrži ispravan aritmetički izraz u infiksnoj notaciji, tada u prvi i jedini red izlazne tekstualne datoteke TRPN.OU T upisati niz znakova koji predstavlja aritmetički izraz u obrnutoj poljskoj notaciji. Ovaj izraz sastoji se od niza znakova koji smeju sadržavati samo mala slova (od "a" do "z") i binarne operatore "T+T", "T-T", "T*T" i "T/T". Nikakvi razmaci u izrazu nisu dozvoljeni. Ukoliko ulazna datoteka ne sadrži ispravan aritmetički izraz, u izlaznu datoteku treba samo ispisati tekst. NEISPRAVAN IZRAZ 31BPrimeri: TRPN.IN x+y+z TRPN.OUT xy+z+ TRPN.IN x+(y+z) TRPN.OUT xyz++ TRPN.IN x+y*z TRPN.OUT xyz*+ TRPN.IN (x+y)*z TRPN.OUT xy+z* TRPN.IN x*(y+z TRPN.OUT NEISPRAVAN IZRAZ RPN.IN a+b/c+d TRPN.OUT abc/+d+ TRPN.IN (a+b)/(c+d) TRPN.OUT ab+cd+/ TRPN.IN x*(y+z*(a+b*(c-d))/e) TRPN.OUT xyzabcd-*+*e/+* /****************************************** * IZRACUNAVANJE IZRAZA KOJI JE ZADAT U * * INVERZNOJ POLJSKOJ NOTACIJI * *******************************************/ int computepolish(char izraz[]){ char symbol; int sum,n,i; n=(int)strlen(izraz); i=0; while (i<n){ symbol=izraz[i]; if((symbol - '0')>=0 && (symbol - '0')<=9){ push(symbol-'0'); if ( symbol == '+' symbol == '-' symbol == '*' symbol == '/'){ int first, second; first = pop(); second = pop(); switch(symbol){ case '+': sum = first + second; break; 39

40 i++; return(top()); case '-': sum = second - first; break; case '*': sum = second * first; break; case '/': sum = second / first; break; push(sum); 40

41 /* PREVODJENJE IZRAZA IZ INFIKS U POSTFIKS FORMU */ #include <stdio.h> #include <stdlib.h> #include <io.h> #include <string.h> int Priority(char Operator) { if(operator=='*' Operator=='/') return 2; else if(operator=='+' Operator=='-') return 1; else return 0; char *Compile(char *Expr) { static char *Error="NEISPRAVAN IZRAZ"; static char Comp[256]=""; char Last=0,Ch,Ch1,Stack[256]=""; int FindFlag,VarFlag=0,SSPtr=0,CompLen=0,SynError; int I,Parenths=0,Balance=0; for(i=0;i < (int)strlen(expr);i++) { Ch=Expr[I]; SynError=1; if(ch>='a' && Ch<='z' &&!VarFlag) { VarFlag=1; SynError=0; Balance++; Comp[CompLen++]=Ch; else VarFlag=0; if(priority(ch)) { if(priority(last) Last=='(') return Error; while(1) { SynError=0; Ch1=Stack[SSPtr-1]; if(!ssptr Ch1=='(' Priority(Ch)>Priority(Ch1)) { Stack[SSPtr++]=Ch; break; Comp[CompLen++]=Ch1; SSPtr--; Balance-=(Ch1=='+' Ch1=='-' Ch1=='*' Ch1=='/'); if(ch=='(') { Stack[SSPtr++]='('; SynError=0; Parenths++; if(ch==')'&&!(synerror=--parenths<0)) while((ch1=stack[--ssptr])!='(') { Comp[CompLen++]=Ch1; Balance-=(Ch1=='+' Ch1=='-' Ch1=='*' Ch1=='/'); if(synerror) return Error; Last=Ch; if(parenths SynError) return Error; for(i=ssptr-1;i>=0;i--) { Ch=Comp[CompLen++]=Stack[I]; Balance-=(Ch=='+' Ch=='-' Ch=='*' Ch=='/'); if(balance!=1) return Error; Comp[CompLen]=0; return Comp; int main(void) { char Str[256]; //ifstream InFile("RPN.IN"); ofstream OutFile("RPN.OUT"); //InFile>>Str; OutFile<<Compile(Str); FILE *f,*g; f=fopen("rpn.in","r"); g=fopen("rpn.out","w"); fscanf(f,"%s",str); fprintf(g,"%s",compile(str)); fclose(f);fclose(g); return 0; 41

42 BPrimena steka rekurzija Prilikom rekurzije moraju se poštovati dva osnovna principa: 1) Svaki sledeći poziv mora voditi ka konačnom rešenju problema 2) Mora postojati uslov za završetak procesa #define DIM 1000 int faktorijelrekurzivno(int n){ int retv,pom; if(n==1) retv=1; else{ pom=faktorijelrekurzivno(n-1); retv=n*pom; return retv; int faktorijelnerekurzivno(int n){ int top=-1, stn[dim],stretv[dim],stadr[dim],stpom[dim]; int retv,adr,pom; step1: if(n==1){ retv=1; stretv[top]=retv; else{ step2: //prevodjenje poziva faktorijelrekurzivno(n-1) top++; stn[top] = n; stretv[top] = retv; stpom[top] = pom; stadr[top] = 3; //postavi paramertre na nove vrednosti n--; goto step1; step3: pom = retv; retv = n*pom; stretv[top]=retv; //prevodjenje return if(top == -1) return retv; else{ n = stn[top]; retv = stretv[top]; pom = stpom[top]; adr = stadr[top]; top--; if(adr == 3) goto step3; //posto je samo jedan rekurzivan poziv //jedno je i mesto odakle se posle pozivna nastavlja funkcija 42

43 //goto step3 void move(int d, char f, char t) { /* move disk d from peg f to peg t */; printf("moving disk %d : %c --> %c\n", d, f, t); void hanoi(int h, char f, char t, char r) { if (h > 0) { hanoi(h-1, f, r, t); move (h, f, t); hanoi(h-1, r, t, f); void hanoinerekurzivno(int n, char poc, char pom, char kraj){ int stn[dim], stpoc[dim], stpom[dim], stkraj[dim], stadr[dim]; int top=-1, adr, tmp; step1: if(n==1){ printf("\n %c -> %c ", poc, kraj); goto step5; //prevodjenje poziva hanoi(n-1,poc,kraj,pom); top++; stn[top] = n; stpoc[top] = poc; stpom[top] = pom; stkraj[top] = kraj; stadr[top] = 3; //setuj parametre na nove vrednosti n--; poc = poc; tmp = pom; pom = kraj; kraj = tmp; goto step1; step3: printf("\n %c -> %c ", poc, kraj); //prevodjenje poziva hanoi(n-1,pom,poc,kraj) top++; stn[top] = n; stpoc[top] = poc; stpom[top] = pom; stkraj[top] = kraj; stadr[top] = 5; //setuj parametre na nove vrednosti n--; tmp = poc; poc = pom; pom = tmp; kraj = kraj; goto step1; step5: if(top == -1) return; 43

44 else{ n = stn[top]; poc = stpoc[top]; pom = stpom[top]; kraj = stkraj[top]; adr = stadr[top]; top--; if(adr == 3) goto step3; if(adr == 5) goto step5; BRED Kod steka se sva umetanja i brisanja izvršavaju na kraju koji se naziva vrh (TOP), dok se kod reda sva umetanja izvršavaju na kraju KRAJ, a sva brisanja na drugom kraju reda, tj. početku Čelo. Redovi su poznati kao FIFO memorije. Red S možemo implementirati kao konačan niz S[0..n-1] i pri tome se koriste dva podatka, CELO i KRAJ da bi se oznčile granice reda. Ako je CELO < KRAJ tada se red sastoji od S[CELO]... S[KRAJ-1]. U suprotnom, ako je CELO > KRAJ, tada se red sastoji od S[CELO],...,S[n-1],S[0],...,S[KRAJ-1], i ako je CELO = KRAJ, tada je red prazan. 44

45 45

46 4. NELINEARNE STRUKTURE PODATAKA Najznačajnije nelinearne strukture podataka su stabla i grafovi STABLA 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 dužina puta 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 = n 0 + n 1 + n n h = h j=0 n j = (nh+1 1) (n 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. Za stablo reda n čiji su svi čvorovi na nivoima od 1 do h-1 kompletni, kaže se da je optimalno balansirano OPERACIJE NA BINARNIM STABLIMA Neke od operacija nad binarnim stablom su: prolaz, umetanje, brisanje, pretraživanje i kopiranje. 46

47 /* rad sa binarnim stablom - implementacija funkcija koje vrse specificnu obradu nad cvorovima binarnog stabla */ #include <stdio.h> #include <stdlib.h> typedef struct cvor { int broj; struct cvor *levo, *desno; Cvor; typedef Cvor *Stablo; Stablo stvori (void); /* Stavaranje praznog stabla. */ int vel (Stablo koren); /* Broj cvorova u stablu. */ int zbir (Stablo koren); /* Zbir brojeva u stablu. */ void pisi_kld (Stablo koren); /* Prefiksno ispisivanje. */ void pisi_lkd (Stablo koren); /* Infiksno ispisivanje. */ void pisi_ldk (Stablo koren); /* Postfiksno ispisivanje. */ void crtaj (Stablo koren, int nivo); /* Graficki prikaz stabla. */ int pojav (Stablo koren, int b); /* Broj pojavljivanja u stablu. */ int min_u (Stablo koren); /* Najmanji u uredjenom stablu. */ int max_u (Stablo koren); /* Najveci u uredjenom stablu. */ int min_n (Stablo koren); /* Najmanji u neuredjenom stablu. */ int max_n (Stablo koren); /* Najveci u neuredjenom stablu. */ int uredjeno (Stablo koren); /* Da li je stablo uredjeno? */ Cvor *nadji_u (Stablo koren, int b); /* Trazenje u uredjenom stablu. */ Cvor *nadji_n (Stablo koren, int b); /* Trazenje u neuredjenom stablu. */ Stablo dodaj_u (Stablo koren, int b); /* Dodavanje u uredjeno stablo. */ Stablo dodaj_n (Stablo koren, int b); /* Dodavanje u neuredjeno stablo. */ Stablo citaj_u (int n); /* Citanje uredjenog stabla. */ Stablo citaj_n (int n); /* Citanje neuredjenog stabla. */ Stablo brisi (Stablo koren); /* Brisanje celog stabla. */ Stablo izost_u (Stablo koren, int b); /* Izost. iz uredjenog stabla. */ Stablo izost_n (Stablo koren, int b); /* Izost. iz neuredjenog stabla. */ Stablo balans_u (Stablo koren); /* Balansiranje uredjenog stabla. */ Stablo balans_n (Stablo koren); /* Balansiranje neuredjenog satbla.*/ int moze (Stablo koren); /* Da li moze uredjena radnja? */ Stablo radi (Stablo (*f)(stablo,int), Stablo koren); /* Primena operacije na stablo za svaki procitani broj */ void main () { Stablo koren = stvori (); //stablo int kraj = 0, broj, n; //indikator kraja rada, element u cvoru stabla, duzina char izbor[2]; //izbor korisnika sa menija opcija //obrada menija opcija koje se prikazuju korisniku while (!kraj) { printf ("\ndodavanje brojeva: a) uredjeno b) neuredjeno\n" "Izostavljanje brojeva: c) uredjeno d) neuredjeno\n" "Citanje stabla: e) uredjeno f) neuredjeno\n" "Najmanji element: g) uredjeno h) neuredjeno\n" "Najveci element: i) uredjeno j) neuredjeno\n" "Pretrazivanje: k) uredjeno l) neuredjeno\n" "Balansiranje: m) uredjeno n) neuredjeno\n" "Pisanje stabla: p) koren-levo-desno\n" " q) levo-koren-desno (uredjeno)\n" " r) levo-desno-kren\n" " s) crtanje\n" "1. Velicina stabla 2. Zbir elemenata\n" "3. Broj pojavljivanja 4. Praznjenje stabla\n" " 0. Zavrsetak rada\n\n" "Vas izbor? " ); scanf ("%s", &izbor); 47

48 switch (izbor[0]) { case 'a': case 'A': /* Dodavanje brojeva u uredjeno stablo: */ if (moze (koren)) koren = radi (dodaj_u, koren); break; case 'b': case 'B': /* Dodavanje brojeva u neuredjeno stablo: */ koren = radi (dodaj_n, koren); break; case 'c': case 'C': /* Izostavljanje brojeva iz uredjenog stabla: */ if (moze (koren)) koren = radi (izost_u, koren); break; case 'd': case 'D': /* Izostavljanje brojeva iz neuredjenog stabla: */ koren = radi (izost_n, koren); break; case 'e': case 'E': /* Citanje uredjenog stabla: */ printf ("Duzina? "); scanf ("%d", &n); printf ("Brojevi? "); koren = brisi (koren); koren = citaj_u (n); break; case 'f': case 'F': /* Citanje neuredjenog stabla: */ printf ("Duzina? "); scanf ("%d", &n); printf ("Brojevi? "); koren = brisi (koren); koren = citaj_n (n); break; case 'g': case 'G': case 'h': case 'H': case 'i': case 'I': case 'j': case 'J': if (koren) switch (izbor[0]) { case 'g': case 'G': /* Najmanji element uredjenog stabla: */ if (moze (koren)) printf ("min= %d\n", min_u (koren)); break; case 'h': case 'H': /* Najmanji element neuredjenog stabla: */ printf ("min= %d\n", min_n (koren)); break; case 'i': case 'I': /* Najveci element uredjenog stabla: */ if (moze (koren)) printf ("max= %d\n", max_u (koren)); break; case 'j': case 'J': /* Najveci element neuredjenog stabla: */ printf ("max= %d\n", max_n (koren)); break; else printf ("*** Stablo je parzno! ***\a\n"); break; case 'k': case 'K': /* Broj pojavljivanja u uredjenom stablu: */ if (moze (koren)) { printf ("Broj? "); scanf ("%d", &broj); printf ("Broj se%s nalazi u stablu.\n", (nadji_u (koren, broj)!= NULL? "" : " NE")); break; case 'l': case 'L': /* Broj pojavljivanja u neuredjenom stablu: */ printf ("Broj? "); scanf ("%d", &broj); printf ("Broj se%s nalazi u stablu.\n", (nadji_n (koren, broj)!= NULL? "" : " NE")); break; case 'm': case 'M': /* Balansiranje uredjenog stabla: */ if (moze (koren)) koren = balans_u (koren); break; case 'n': case 'N': /* Balansiranje neuredjenog stabla: */ koren = balans_n (koren); break; case 'p': case 'P': /* Pisanje stabla koren-levo-desno: */ printf ("Stablo= "); pisi_kld (koren); putchar ('\n'); break; case 'q': case 'Q': /* Pisanje stabla levo-koren-desno: */ printf ("Stablo= "); pisi_lkd (koren); putchar ('\n'); break; case 'r': case 'R': /* Pisanje stabla levo-desno-koren: */ printf ("Stablo= "); pisi_ldk (koren); putchar ('\n'); break; case 's': case 'S': /* Crtanje stabla: */ crtaj (koren, 0); break; case '1': /* Velicina stabla: */ printf ("Vel= %d\n", vel (koren)); break; case '2': /* Zbir elemenata stabla: */ printf ("Zbir= %d\n", zbir (koren)); break; case '3': /* Broj pojavljivanja datog broja: */ printf ("Broj? "); scanf ("%d", &broj); printf ("Broj se pojavljuje %d puta.\n", pojav (koren, broj)); break; case '4': /* Praznjenje stabla: */ 48

49 koren = brisi (koren); break; case '0': /* Zavrsetak rada: */ kraj = 1; break; default: /* Pogresan izbor: */ printf ("*** Nedozvoljeni izbor! ***\a\n"); break; Stablo stvori (void) { return NULL; /* Stvaranje praznog stabla. */ int vel (Stablo koren) /* Broj cvorova u stablu. */ { return koren? 1 + vel (koren->levo) + vel (koren->desno) : 0; int zbir (Stablo koren) /* Zbir brojeva u stablu. */ { return koren? koren->broj + zbir (koren->levo) + zbir (koren->desno) : 0; void pisi_kld (Stablo koren) { /* Prefiksno ispisivanje. */ if (koren) { printf ("%d ", koren->broj); pisi_kld (koren->levo); pisi_kld (koren->desno); void pisi_lkd (Stablo koren) { /* Infiksno ispisivanje. */ if (koren) { pisi_lkd (koren->levo); printf ("%d ", koren->broj); pisi_lkd (koren->desno); void pisi_ldk (Stablo koren) { /* Postfiksno ispisivanje. */ if (koren) { pisi_ldk (koren->levo); pisi_ldk (koren->desno); printf ("%d ", koren->broj); void crtaj (Stablo koren, int nivo) { /* Graficki prikaz stabla. */ if (koren) { crtaj (koren->desno, nivo+1); printf ("%*s%d\n", 4*nivo, "", koren->broj); crtaj (koren->levo, nivo+1); int pojav (Stablo koren, int b) /* Broj pojavljivanja broja b u stablu. */ { return koren? (koren->broj==b)+pojav(koren->levo,b)+pojav(koren->desno,b) : 0; int min_u (Stablo koren) /* Najmanji u uredjenom stablu. */ { return koren->levo? min_u (koren->levo ) : koren->broj; int max_u (Stablo koren) /* Najveci u uredjenom stablu. */ { return koren->desno? max_u (koren->desno) : koren->broj; int min_n (Stablo koren) { /* Najmanji u neuredjenom stablu. */ int m = koren->broj, k; if (koren->levo ) { k = min_n (koren->levo ); if (k < m) m = k; if (koren->desno) { k = min_n (koren->desno); if (k < m) m = k; return m; int max_n (Stablo koren) { /* Najveci u neuredjenom stablu. */ int m = koren->broj, k; if (koren->levo ) { k = max_n (koren->levo ); if (k > m) m = k; 49

50 if (koren->desno) { k = max_n (koren->desno); if (k > m) m = k; return m; int uredjeno (Stablo koren) { /* Da li je stablo uredjeno? */ if (! koren) return 1; if (koren->levo && (! uredjeno (koren->levo ) max_u (koren->levo) > koren->broj)) return 0; if (koren->desno && (! uredjeno (koren->desno) min_u (koren->desno) < koren->broj)) return 0; return 1; Cvor *nadji_u (Stablo koren, int b) { /* Trazenje u uredjenom stablu. */ if (! koren) return NULL; if (koren->broj == b) return koren; if (koren->broj > b) return nadji_u (koren->levo, b); return nadji_u (koren->desno, b); Cvor *nadji_n (Stablo koren, int b) { /* Trazenje u neuredjenom stablu. */ if (! koren) return NULL; if (koren->broj == b) return koren; { Cvor *cvr = nadji_n (koren->levo, b); if (cvr) return cvr; return nadji_n (koren->desno, b); Stablo dodaj_u (Stablo koren, int b) { /* Dodavanje u uredjeno stablo. */ if (! koren) { koren = malloc (sizeof(cvor)); koren->broj = b; koren->levo = koren->desno = NULL; else if (koren->broj > b) koren->levo = dodaj_u (koren->levo, b); else if (koren->broj < b) koren->desno = dodaj_u (koren->desno, b); else if (rand() / (RAND_MAX+1.) < 0.5) koren->levo = dodaj_u (koren->levo, b); else koren->desno = dodaj_u (koren->desno, b); return koren; Stablo dodaj_n (Stablo koren, int b) { /* Dodavanje u neuredjeno stablo. */ if (! koren) { koren = malloc (sizeof(cvor)); koren->broj = b; koren->levo = koren->desno = NULL; else if (rand() / (RAND_MAX+1.) < 0.5) koren->levo = dodaj_u (koren->levo, b); else koren->desno = dodaj_u (koren->desno, b); return koren; Stablo citaj_u (int n) { /* Citanje uredjenog stabla. */ Stablo koren = NULL; int i, b; for (i=0; i<n; i++) { scanf ("%d", &b); koren = dodaj_u (koren, b); return koren; Stablo citaj_n (int n) { /* Citanje neuredjenog stabla. */ Stablo koren = NULL; int i, b; for (i=0; i<n; i++) { scanf ("%d", &b); koren = dodaj_n (koren, b); 50

51 return koren; Stablo brisi (Stablo koren) { /* Brisanje celog stabla. */ if (koren) { koren->levo = brisi (koren->levo); koren->desno = brisi (koren->desno); free (koren); koren = NULL; return koren; Stablo izost_u (Stablo koren, int b) { /* Izost. iz uredjenog stabla. */ if (koren) { if (koren->broj > b) koren->levo = izost_u (koren->levo, b); else if (koren->broj < b) koren->desno = izost_u (koren->desno, b); else if (koren->levo) { int m = max_u (koren->levo); koren->broj = m; koren->levo = izost_u (koren->levo, m); else if (koren->desno) { int m = min_u (koren->desno); koren->broj = m; koren->desno = izost_u (koren->desno, m); else { free (koren); koren = NULL; return koren; Stablo izost_n (Stablo koren, int b) { /* Izost. iz neuredjenog stabla. */ if (koren) { if (koren->broj == b) { if (koren->levo ) { koren->broj = koren->levo->broj; koren->levo = izost_n (koren->levo, koren->broj); else if (koren->desno) { koren->broj = koren->desno->broj; koren->desno = izost_n (koren->desno, koren->broj); else { free (koren); koren = NULL; else { int v = vel (koren->levo); koren->levo = izost_n (koren->levo, b); if (v == vel (koren->levo)) koren->desno = izost_n (koren->desno, b); return koren; Stablo balans_u (Stablo koren) { /* Balansiranje uredjenog stabla. */ if (koren) { int k = vel (koren->levo) - vel (koren->desno); for (; k>1; k-=2) { koren->desno = dodaj_u (koren->desno, koren->broj); koren->broj = max_u (koren->levo ); koren->levo = izost_u (koren->levo, koren->broj); for (; k<-1; k+=2) { koren->levo = dodaj_u (koren->levo, koren->broj); koren->broj = min_u (koren->desno); koren->desno = izost_u (koren->desno, koren->broj); koren->levo = balans_u (koren->levo ); koren->desno = balans_u (koren->desno); 51

52 return koren; Stablo balans_n (Stablo koren) { /* Balansiranje neuredjenog satbla.*/ if (koren) { int k = vel (koren->levo) - vel (koren->desno); for (; k>1; k-=2) { koren->desno = dodaj_n (koren->desno, koren->broj); koren->broj = koren->levo ->broj; koren->levo = izost_n (koren->levo, koren->broj); for (; k<-1; k+=2) { koren->levo = dodaj_n (koren->levo, koren->broj); koren->broj = koren->desno->broj; koren->desno = izost_n (koren->desno, koren->broj); koren->levo = balans_n (koren->levo ); koren->desno = balans_n (koren->desno); return koren; int moze (Stablo koren) { /* Da li moze uredjena radnja? */ if (! uredjeno (koren)) { printf ("*** Stablo nije uredjeno! ***\a\n"); return 0; else return 1; /* Primena operacije na stablo za svaki procitani broj: */ Stablo radi (Stablo (*f)(stablo,int), Stablo koren) { int b; char zn; printf ("Brojevi? "); do { scanf ("%d%c", &b, &zn); koren = (*f) (koren, b); while (zn!= '\n'); return koren; /* do kraja reda */ 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 /* Samoreferentne strukture, binarno pretrazivacko stablo */ #include <stdio.h> #include <ctype.h> #include <string.h> #include <stdlib.h> #define MAXREC 31 typedef struct drvo_tag{ char *rec; /* pokazuje na rec teksta */ int broj; /* broj pojavljivanja pod pretpostavkom da je int dovoljan */ struct drvo_tag *levo; /* leva grana */ struct drvo_tag *desno; /* desna grana */ drvo; /* Prototipovi funkcija */ drvo *addtree(drvo *, char *); void treeprint(drvo *); 52

53 int uzmi_rec(char *, int, FILE*); drvo *talloc( void ); char *strdpl(char *); void osloboditi( drvo *k); main(){ drvo *koren; /*koren stabla pretrazivanja */ char rec[maxrec]; /*sadrzaj reci sa ulaza */ FILE *f; /*ucitavanje reci ciji broj pojavljivanja se broji */ koren = NULL; f=fopen("zad1in.txt","r"); while( 1 ){ int kraj = uzmi_rec(rec, MAXREC, f); /*dodavanje novog cvora u stablo ili izmena nad poljem broj vec postojeceg cvora */ if( strlen(rec)) koren = addtree( koren, rec); if(kraj == EOF) break; /*ucitavanje se vrsi do markera kraja */ /*stampanje sadrzaja stabla -leksikografski poredak reci */ treeprint(koren); /*oslobadjanje zauzetog prostora za stablo pretrage */ osloboditi(koren); fclose(f); return 0; /* addtree - dodaje cvor sa tekstom na koji pokazuje w, na ili ispod p u drvetu*/ drvo *addtree( drvo *p, char *w ) { int cond; if( p == NULL ) /* naisla nova rec */ { p = talloc(); p->rec = strdpl(w); p->broj = 1; p->levo = p->desno = NULL; else if ((cond = strcmp(w,p->rec)) == 0 ) p->broj++; /* ponovljena rec */ else if ( cond < 0 ) /* manje => levi ogranak */ p->levo = addtree(p->levo, w); else p->desno = addtree(p->desno, w); return p; /*vece =>desni ogranak*/ void treeprint(drvo *p) /* treeprint - rekurzivno stampanje drveta*/ { if( p!= NULL ) { treeprint( p->levo ); printf("%4d %s\n", p->broj, p->rec ); treeprint( p->desno ); int uzmi_rec(char s[], int lim, FILE *f) { char c, i = 0; /* preskociti sve znake do slova ili cifre */ while(!isalnum(c = s[0] = fgetc(f)) && c!=eof); if( c==eof ) {s[0] = '\0'; return EOF; /* prazna rec i vratiti EOF */ /* ucitati ostatak reci: (u s[0] se vec nalazi prvo slovo) */ while((c = fgetc(f))!= EOF && isalnum(c) && i < lim) s[++i] = c; 53

54 s[++i] = '\0'; /* zavrsiti nisku */ if( c==eof ) return EOF; return i; /* talloc pravi jedan cvor drveta */ drvo *talloc(void) { return (drvo *) malloc(sizeof(drvo)); char *strdpl(char *s) /* pravi se kopija niske s */ { char *p; p = (char *) malloc(strlen(s) + 1 ); if( p!= NULL ) strcpy(p,s); return p; /* u <string.h> postoji standardna funkcija "strdup" koja obavlja navedene operacije*/ void osloboditi( drvo *k) { /*rekurzivno se oslobadja levo i desno podstablo korena zadatog stabla */ if (k->levo) osloboditi (k->levo); if (k->desno) osloboditi (k->desno); free (k); /*brisanje cvora koji predstavlja koren zadatog stabla */ 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. #include <stdlib.h> #include <stdio.h> #include <string.h> #include <ctype.h> /* Definisemo novi tip operacija */ typedef enum operacija {pl = '+',min = '-', pod = '/', put = '*' operacija; /* Struktura koja predstavlja jedan cvor */ typedef struct _cvor{ int ind; /* indikator da li se u cvoru nalazi operator (u tom slucaju ind ima vrednost 1) ili broj (u tom slucaju ind ima vrednost 0) */ int br; /* polje u kome cuvamo ceo broj, popunjeno samo ako je polje ind postavljeno na 0 */ operacija op; /* polje u kome cuvamo operator, popunjeno samo ako je polje ind postavljeno na 1 */ struct _cvor *l, *d; cvor; /* Funkcija koja pravi jedan cvor pri cemu ostavlja neinicijalizovane vrednosti br i op */ cvor * napravi_cvor(){ cvor * novi = (cvor *)malloc(sizeof(cvor)); if (novi == NULL){ fprintf(stderr, "greska prilikom alokacije memorije\n"); exit(1); 54

55 novi->l = NULL; novi->d = NULL; return novi; /* Rekurzivna funkcija koja uklanja drvo, obilazak mora biti postorder */ void obrisi_drvo(cvor *drvo){ if (drvo!=null){ obrisi_drvo(drvo->l); obrisi_drvo(drvo->d); free(drvo); /* Rekurzivna funkcija koja parsira string. Predajemo joj adresu stringa da bi znali dokle smo stigli u toku parsiranja */ void pretvori_u_stablo(char ** s, cvor ** pdrvo){ int c, br; cvor *novi; /* Uzimamo sledeci karakter iz stringa. */ c = *(*s); /* Ako smo stigli do kraja stringa izlazimo */ if (c == '\0') return; /* U suprotnom popunjavamo kreiramo novi cvor */ novi = napravi_cvor(); /* Ako nije u pitanju cifra znaci da smo ucitali operator... */ if (!isdigit(c)){ /*...postavljamo indikator na 1 */ novi->ind = 1; /*...i operator na ucitan karakter */ novi->op = c; /* Unosimo podatak u drvo */ *pdrvo = novi; /* Prelazimo na sledeci relevantan podatak, preskacemo blanko*/ *s = *s+2; /* I rekurzivno parsiramo string da bismo formirali levo pa zatim i desno podstablo */ pretvori_u_stablo(s, &((*pdrvo)->l)); pretvori_u_stablo(s, &((*pdrvo)->d)); /* A ako je u pitanju cifra... */ else{ /*...ucitavamo i ostatak broja ako postoji*/ br = 0; while(isdigit(c)){ br = br*10+c-'0'; /* uracunavamo tekuci karakter u broj */ (*s)++; /* pomeramo se za jedno mesto u stringu */ c = *(*s); /* i citamo sledeci karakter */ /* postavljamo indikator na 0 */ novi->ind = 0; /* i brojevnu vrednost na br */ novi->br = br; /* Unosimo podatak u drvo */ *pdrvo = novi; /* Prelazimo na sledeci relevantan podatak. Uzimamo u obzir da pokazivac vec pokazuje na blanko */ *s = *s+1; 55

56 void ispisi_drvo(cvor *drvo){ if (drvo!=null){ /* Prvo ispisujemo koren. Proveravamo vrednost indikatora */ if (!drvo->ind) /* ako je indikator jednak 0 stampamo broj */ printf("%d", drvo->br); else /* a inace stampamo karakter */ printf("%c", drvo->op); /*...a zatim i levo pa desno podstablo. */ ispisi_drvo(drvo->l); ispisi_drvo(drvo->d); */ void ispisi_drvo_infiksno(cvor *drvo){ if (drvo == NULL) return; if (!drvo->ind) /* Ako smo naisli na brojevnu vrednost stampamo je. */ printf("%d", drvo->br); else{ /* U suprotnom imamo pravo stablo pa ispisujemo prvo levu zagradu... printf("("); /* pa levi izraz... */ ispisi_drvo_infiksno(drvo->l); /* pa operator... */ printf(" %c ", drvo->op); /* pa desni izraz... */ ispisi_drvo_infiksno(drvo->d); /* i na kraju ispisujemo desnu zagradu */ printf(")"); int izracunaj_drvo(cvor *drvo){ if (!drvo->ind) return drvo->br; else switch (drvo->op){ case '+': return izracunaj_drvo(drvo->l) + izracunaj_drvo(drvo->d); case '-': return izracunaj_drvo(drvo->l) izracunaj_drvo(drvo->d); case '*': return izracunaj_drvo(drvo->l) * izracunaj_drvo(drvo->d); case '/': return izracunaj_drvo(drvo->l) / izracunaj_drvo(drvo->d); main(){ cvor * drvo = NULL; char s[20], *ps; int i=0; printf("unesite aritmeticki izraz u prefiksnoj notaciji, novi red za kraj\n"); /* Funkcija fgets cita sa standardnog ulaza (stdin) liniju (karaktere 56

57 do unetog novog reda) ili dok se ne popuni 20 karaktera */ if (fgets(s, 20, stdin) == NULL){ fprintf(stderr, "greska"); exit(1); /* Kako s sada sadrzi i oznaku za novi red na kraju brisemo je */ while(s[i]!='\n') i++; /* i na kraju dodajemo '\0' da bi pripremili string za prenosenje u funkciju */ s[i] = s[i+1]; /* Kako je s niz karaktera (a niz je konstantni pokazivac) on ne sme biti predat funkciji koja kreira stablo (posto funkcija menja pokazivac koji dobija kao prvi argument) pa uzimamo pomocni pokazivac da bismo mogli da menjamo njegovu vrednost */ ps = s; /* Kreiramo stablo pozivom funkcije prevori_u_stablo */ pretvori_u_stablo(&ps, &drvo); /* Ispisujemo ga u prefiksnom poredku */ ispisi_drvo(drvo); printf("\n"); /* A zatim i u infiksnom. */ ispisi_drvo_infiksno(drvo); /* Ispisujemo vrednost pocetnog izraza */ printf(" = %d\n", izracunaj_drvo(drvo)); obrisi_drvo(drvo); 57

58 4.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 povezuje grana 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 ( kao vrednost 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). Bipartitni 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 v 1 do v k je niz čvorova v 1, v 2,...,v k povezanih granama (v 1, v 2), (v 2, v 3),..., (v k-1, v k ). 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 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 v i i koloni koja odgovara čvoru v j je 1 (adj[v i, v j] = 1, ako (v i, 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 58

59 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. 59

60 Računanje ulaznog i izlaznog stepena čvora grafa predstavljenog pomoću matrice susedstva #include <stdio.h> #define MAX 10 /* funkcija uz pomoc koje pravimo matricu susedstva */ void buildadjm(int adj[][max], int n){ int i,j; for(i=0;i<n;i++) for(j=0;j<n;j++){ printf("enter 1 if there is an edge from %d to %d, otherwise enter 0 \n",i,j); scanf("%d",&adj[i][j]); /* funkcija za racunanje izlaznog stepena cvora */ int outdegree(int adj[][max],int x,int n){ int i, count =0; for(i=0;i<n;i++) if( adj[x][i] ==1) count++; return(count); /* funkcija za racunanje ulaznog stepena grafa */ int indegree(int adj[][max],int x,int n){ int i, count =0; for(i=0;i<n;i++) if( adj[i][x] ==1) count++; return(count); void main(){ int adj[max][max],node,n,i; printf("enter the number of nodes in graph maximum = %d\n",max); scanf("%d",&n); buildadjm(adj,n); for(i=0;i<n;i++){ printf("the indegree of the node %d is %d\n",i,indegree(adj,i,n)); printf("the outdegree of the node %d is %d\n",i,outdegree(adj,i,n)); Obilazak grafa u širinu (BFS) BREADTH-FIRST SEARCH je jeadan od najjednostavnijih algoritama za obilazak grafa. Za dati graf G=(V,E) i startni čvor s, BFS obilazi graf G otkrivajući svaki čvor koji je dostižan iz s. Istovremeno, možemo računati i rastojanje čvora s do svakog čvora do kojeg postoji put iz s. Izvršenjem algoritma možemo konstruisati tzv. BFS stablo koje će sadržati sve čvorove grafa G dostižne iz s. Algoritam se može primeniti i na orijentisane i neorijentisane grafove. Na sledećoj slici ilustrovano je izvršenje BFS algoritma za dati graf G i startni čvor s. 60

61 BFS(G, s) for each vertex u V [G] - {s do color[u] WHITE color[s] GRAY d[s] 0 π[s] NIL Q Ø ENQUEUE(Q, s) while Q Ø d[u] π[u] NIL do u DEQUEUE(Q) for each v Adj[u] do if color[v] = WHITE then color[v] GRAY d[v] d[u] + 1 color[u] BLACK π[v] u ENQUEUE(Q, v) 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šimo sa 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. 61

62 DFS(G) for each vertex u _ V [G] time 0 do color[u] WHITE π[u] NIL for each vertex u V [G] do if color[u] = WHITE then DFS-VISIT(u) DFS-VISIT(u) color[u] GRAY time time +1 d[u] <- time for each v in Adj[u] Explore edge(u, v). do if color[v] = WHITE then π[v] u DFS-VISIT(v) color[u] <- BLACK f [u] time time +1 White vertex u has just been discovered. Blacken u; it is finished. #include <stdio.h> #include <stdlib.h> #define MAX 10 struct node{ int data; struct node *link; ; /* funkcija uz pomoc koje pravimo matricu susedstva */ void buildadjm(int adj[][max], int n){ int i,j; for(i=0;i<n;i++) 62