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

Save this PDF as:
 WORD  PNG  TXT  JPG

Størrelse: px
Begynne med side:

Download "/* 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

Kartlegging av leseferdighet Trinn 2 og 3 på bosnisk

Kartlegging av leseferdighet Trinn 2 og 3 på bosnisk Lærerveiledning Bosnisk, 2. og 3. trinn Lærerveiledning Kartlegging av leseferdighet Trinn 2 og 3 på bosnisk Priručnik za učitelje Ispitivanje sposobnosti čitanja 2. i 3. razred na bosanskom jeziku 2013

Detaljer

Dagens tema. C-programmering. Nøkkelen til å forstå C-programmering ligger i å forstå hvordan minnet brukes.

Dagens tema. C-programmering. Nøkkelen til å forstå C-programmering ligger i å forstå hvordan minnet brukes. Dagens tema Dagens tema C-programmering Nøkkelen til å forstå C-programmering ligger i å forstå hvordan minnet brukes. Adresser og pekere Parametre Vektorer (array-er) Tekster (string-er) Hvordan ser minnet

Detaljer

1 - Prvi deo upitnika

1 - Prvi deo upitnika Copyright! All rights reserved www.anestesi.no 2010- Serbo-Kroatisk side 1 av 6 Serbia Kroatia osnia Språk: Serbo-Kroatisk Oversatt av: Ivan uljovcic to: Juni 2010 1 - Prvi deo upitnika Del 1 Spørreskjema:

Detaljer

Løsningsforslag til eksamen i INF1000 våren 2006

Løsningsforslag til eksamen i INF1000 våren 2006 Løsningsforslag til eksamen i INF1000 våren 2006 Oppgave 1 a) -1 false 7 b) 30 c) Verdien til j er: 4Verdien til k er: 3Verdien til n er: 7 d) Andre if-test er true Tredje if-test er true e) k = 4 k =

Detaljer

import java.io.*; import java.util.*; import javagently.text;

import java.io.*; import java.util.*; import javagently.text; //-------------------------------------------------------- // // Fil: Oppg1.java - // løser oppgave 1 i eksamensettet for in105 - v99 // //-------------------------------------------------------- import

Detaljer

Kontinuasjonseksamen

Kontinuasjonseksamen Høgskolen i Gjøvik Avdeling for teknologi Kontinuasjonseksamen FAGNAVN: FAGNUMMER: Objekt-orientert programmering IMT1082 / ELE2092 EKSAMENSDATO: 5. januar 2007 KLASSE(R): 05HBIND*, 05HBINFA, 05HBISA,

Detaljer

Dagens tema. Dynamisk allokering Signaturer Definisjon av typer og nye typenavn Typekonvertering Pekere, vektorer og lister Dokumentasjon

Dagens tema. Dynamisk allokering Signaturer Definisjon av typer og nye typenavn Typekonvertering Pekere, vektorer og lister Dokumentasjon Dagens tema Dagens tema Dynamisk allokering Signaturer Definisjon av typer og nye typenavn Typekonvertering Pekere, vektorer og lister Dokumentasjon Verdt å huske på! Husk! Nøkkelen til å forstå C er å

Detaljer

Høgskolen i Gjøvik Avdeling for informatikk og medieteknikk. Eksamen. Objekt-orientert programmering

Høgskolen i Gjøvik Avdeling for informatikk og medieteknikk. Eksamen. Objekt-orientert programmering Høgskolen i Gjøvik Avdeling for informatikk og medieteknikk Eksamen EMNENAVN: EMNENUMMER: Objekt-orientert programmering IMT1082 EKSAMENSDATO: 4. juni 2010 KLASSE(R): 09HBIND*, 09HBPUA, 09HBDRA, 09HBISA,

Detaljer

Kontinuasjonseksamen

Kontinuasjonseksamen Høgskolen i Gjøvik Avdeling for teknologi Kontinuasjonseksamen FAGNAVN: FAGKODE: Objekt-orientert programmering L 183 A EKSAMENSDATO: 8. januar 2003 KLASSE(R): 01HIND* / 01HINE* / 01HDMU* TID: 09.00-13.00

Detaljer

TOD063 Datastrukturer og algoritmer

TOD063 Datastrukturer og algoritmer TOD063 Datastrukturer og algoritmer Øving : 3 Utlevert : Uke 7 Innleveringsfrist : 26. februar 2010 Klasse : 1 Data og 1 Informasjonsteknologi Gruppearbeid: 2-3 personer pr. gruppe. Oppgave 1 Vi skal lage

Detaljer

E K S A M E N. Grunnleggende datakunnskap og programmering 02HIND*, 02HINE*, 02HDMU*, 02HING*, 02HGEOMAA, 02HSIV5

E K S A M E N. Grunnleggende datakunnskap og programmering 02HIND*, 02HINE*, 02HDMU*, 02HING*, 02HGEOMAA, 02HSIV5 Høgskolen i Gjøvik Avdeling for teknologi E K S A M E N FAGNAVN: FAGKODE: Grunnleggende datakunnskap og programmering L 182 A EKSAMENSDATO: 19. desember 2002 KLASSE(R): 02HIND*, 02HINE*, 02HDMU*, 02HING*,

Detaljer

Kontinuasjonseksamen

Kontinuasjonseksamen Høgskolen i Gjøvik Avdeling for teknologi Kontinuasjonseksamen FAGNAVN: FAGNUMMER: Objekt-orientert programmering L 183 A EKSAMENSDATO: 5. januar 2004 KLASSE(R): 02HIND* 02HDMU* 02HINE* 02HING* 01HINGA

Detaljer

E K S A M E N. Grunnleggende datakunnskap og programmering 98HINDA / 98HINDB / 98HINEA 98HDMUA / 98HDMUB / 98HINGA

E K S A M E N. Grunnleggende datakunnskap og programmering 98HINDA / 98HINDB / 98HINEA 98HDMUA / 98HDMUB / 98HINGA Høgskolen i Gjøvik E K S A M E N FAGNAVN: FAGNUMMER: Grunnleggende datakunnskap og programmering L 182 A EKSAMENSDATO: 15. desember 1998 KLASSE: 98HINDA / 98HINDB / 98HINEA 98HDMUA / 98HDMUB / 98HINGA

Detaljer

13.09.2012 LITT OM OPPLEGGET. INF1000 EKSTRATILBUD Stoff fra uke 1-3 12. September 2012 Siri Moe Jensen EKSEMPLER

13.09.2012 LITT OM OPPLEGGET. INF1000 EKSTRATILBUD Stoff fra uke 1-3 12. September 2012 Siri Moe Jensen EKSEMPLER .9.22 LITT OM OPPLEGGET INF EKSTRATILBUD Stoff fra uke - 2. September 22 Siri Moe Jensen Målgruppe: De som mangler forståelse for konseptene gjennomgått så langt. Trening får du ved å jobbe med oppgaver,

Detaljer

Sensur-veiledning INF1000 h 2013 (fasit) am - 6. des. 2013

Sensur-veiledning INF1000 h 2013 (fasit) am - 6. des. 2013 Sensur-veiledning INF1000 h 2013 (fasit) am - 6. des. 2013 Oppgave 1) Her var det en manglende høyreparentes i 1 b) slik at de som svarer virker ikke eller lignende istedenfor det riktige svaret, skal

Detaljer

OPPGAVE 5b og 8b Java Kode

OPPGAVE 5b og 8b Java Kode OPPGAVE 5b og 8b Java Kode public class Kant boolean behandlereturavbil() BehandleReturAvBil behandler = new BehandleReturAvBil(this); String regnr; int kmstand, tanknivaa; boolean erskadet; // 1: Få verdiene

Detaljer

IN 147 Program og maskinvare

IN 147 Program og maskinvare Dagens tema Deklarasjon av nye typer Typekonvertering Regning med pekere Pekere til funksjoner Pekere til pekere til... Vanlige feil ved bruk av pekere Feilsøking Debuggere lint Kompilatormeldinger Egne

Detaljer

Kontinuasjonseksamen

Kontinuasjonseksamen Høgskolen i Gjøvik Avdeling for informatikk og medieteknikk Kontinuasjonseksamen EMNENAVN: EMNENUMMER: Objekt-orientert programmering IMT1082 / IMT1182 EKSAMENSDATO: 5. januar 2009 KLASSE(R): 07HB IND*

Detaljer

Høgskolen i Gjøvik Institutt for informatikk og medieteknikk E K S A M E N. Grunnleggende programmering

Høgskolen i Gjøvik Institutt for informatikk og medieteknikk E K S A M E N. Grunnleggende programmering Høgskolen i Gjøvik Institutt for informatikk og medieteknikk E K S A M E N FAGNAVN: Grunnleggende programmering FAGNUMMER: IMT 1031 EKSAMENSDATO: 19.desember 2005 KLASSE(R): 05HBIND*, 05HBINFA, 05HBISA,

Detaljer

Høgskolen i Gjøvik Avdeling for informatikk og medieteknikk. Eksamen. Objekt-orientert programmering

Høgskolen i Gjøvik Avdeling for informatikk og medieteknikk. Eksamen. Objekt-orientert programmering Høgskolen i Gjøvik Avdeling for informatikk og medieteknikk Eksamen EMNENAVN: EMNENUMMER: Objekt-orientert programmering IMT1082 EKSAMENSDATO: 3. juni 2009 KLASSE(R): 08HBIND* / 08HBPUA / 08HBDRA / 08HBISA

Detaljer

Løsningsforslag EKSAMEN

Løsningsforslag EKSAMEN 1 Løsningsforslag EKSAMEN Emnekode: ITF20006 000 Dato: 18. mai 2012 Emne: Algoritmer og datastrukturer Eksamenstid: 09:00 til 13:00 Hjelpemidler: 8 A4-sider (4 ark) med egne notater Faglærer: Gunnar Misund

Detaljer

Eksamen. Objekt-orientert programmering KLASSE(R): 02HIND* 02HDMU* 02HINE* 02HING* 01HINGA 02HSIV5 02HGEOMAA

Eksamen. Objekt-orientert programmering KLASSE(R): 02HIND* 02HDMU* 02HINE* 02HING* 01HINGA 02HSIV5 02HGEOMAA Høgskolen i Gjøvik Avdeling for teknologi Eksamen FAGNAVN: FAGNUMMER: Objekt-orientert programmering L 183 A EKSAMENSDATO: 27. mai 2003 KLASSE(R): 02HIND* 02HDMU* 02HINE* 02HING* 01HINGA 02HSIV5 02HGEOMAA

Detaljer

Repetisjon. INF1000 - gruppe 13

Repetisjon. INF1000 - gruppe 13 Repetisjon INF1000 - gruppe 13 Lese fra fil Scanner import java.util.*; void lesfrafil() { try { Scanner innfil = new Scanner(new File( fugleobservasjoner.txt )); while (innfil.hasnext()) { String linje

Detaljer

Oblig 4Hybelhus litt mer tips enn i oppgaven

Oblig 4Hybelhus litt mer tips enn i oppgaven Oblig 4Hybelhus litt mer tips enn i oppgaven lørdag 19. okt 2013 Arne Maus Obligatorisk oppgave 4 Gulbrand Grås husleiesystem I denne oppgaven skal vi se på hans studenthus Utsyn. Utsyn består av 3 etasjer,

Detaljer

INF1000 - Løsning på seminaropppgaver til uke 8

INF1000 - Løsning på seminaropppgaver til uke 8 INF1000 - Løsning på seminaropppgaver til uke 8 Oppgave 1 a) for(string nokkel : studenter.keyset){ System.out.println(nokkel); Studenten sitt navn blir skrevet ut. b) for(student dennestudenten : studenter.values()){

Detaljer

Oversikt. Introduksjon Kildekode Kompilering Hello world Hello world med argumenter. 1 C programmering. 2 Funksjoner. 3 Datatyper. 4 Pekere og arrays

Oversikt. Introduksjon Kildekode Kompilering Hello world Hello world med argumenter. 1 C programmering. 2 Funksjoner. 3 Datatyper. 4 Pekere og arrays Oversikt C programmering 1 C programmering Introduksjon Kildekode Kompilering Hello world Hello world med argumenter 2 Funksjoner 3 Datatyper 4 Pekere og arrays 5 Kontrollstrukturer Lars Vidar Magnusson

Detaljer

Programmering i C++ Løsningsforslag Eksamen høsten 2005

Programmering i C++ Løsningsforslag Eksamen høsten 2005 Programmering i C++ Eksamen høsten 2005 Simen Hagen Høgskolen i Oslo, Avdeling for Ingeniørutdanning 7. desember 2005 Generelt Denne eksamensoppgaven består av tre oppgaver, pluss en ekstraoppgave. Det

Detaljer

KONTINUASJONSEKSAMEN

KONTINUASJONSEKSAMEN Høgskolen i Gjøvik Avdeling for teknologi KONTINUASJONSEKSAMEN FAGNAVN: FAGKODE: Grunnleggende datakunnskap og programmering L 182 A EKSAMENSDATO: 9. august 2002 KLASSE(R): 01HIND*, 01HINE*, 01HDMU*, 01HING*

Detaljer

Algoritmer og datastrukturer Kapittel 11 - Delkapittel 11.2

Algoritmer og datastrukturer Kapittel 11 - Delkapittel 11.2 Algoritmer og datastrukturer Kapittel 11 - Delkapittel 11.2 11.2 Korteste vei i en graf 11.2.1 Dijkstras metode En graf er et system med noder og kanter mellom noder. Grafen kalles rettet Notasjon Verdien

Detaljer

Eksamen FSP5822/PSP5514 Bosnisk nivå II Elevar og privatistar / Elever og privatister. Nynorsk/Bokmål

Eksamen FSP5822/PSP5514 Bosnisk nivå II Elevar og privatistar / Elever og privatister.  Nynorsk/Bokmål Eksamen 20.11.13 FSP5822/PSP5514 Bosnisk nivå II Elevar og privatistar / Elever og privatister Nynorsk/Bokmål Oppgåve 1 Skriv ein kort tekst på 4 5 setningar der du svarer på spørsmåla nedanfor. Skriv

Detaljer

Tre måter å lese fra terminal. Java 4. Eksempel. Formatert utskrift til skjerm

Tre måter å lese fra terminal. Java 4. Eksempel. Formatert utskrift til skjerm Mer om easyio Mer om forgreninger Løkker 7. september 2004 Ole Christian Lingjærde Gruppen for bioinformatikk Institutt for informatikk Universitetet i Oslo Java 4 1 Tre måter å lese fra terminal Først:

Detaljer

1. Finn klassene (hvilke objekter er det i problemet) 1. Dataene som beskriver problemet (hvilke objekter har vi og hvor mange klasser er det?

1. Finn klassene (hvilke objekter er det i problemet) 1. Dataene som beskriver problemet (hvilke objekter har vi og hvor mange klasser er det? Obligatorisk oppgave 3 Gulbrand Grås husleiesystem Oblig 3hus litt mer tips enn i oppgaven I denne oppgaven skal vi se på hans studenthus Utsyn. Utsyn består av 3 etasjer, nummerert fra -3. I hver etasje

Detaljer

Dagens tema: Mer av det dere trenger til del 1

Dagens tema: Mer av det dere trenger til del 1 Dagens tema Dagens tema: Mer av det dere trenger til del 1 Hvilke klasser trenger vi? Uttrykk Typer Testutskrifter 12 gode råd Dagens tema Prosjektet Utifra dette AlboC-programmet: int pot2 (int x) { int

Detaljer

Eksempel: Body Mass Index (BMI) Forelesning inf1000 - Java 3. Ferdig program (første del) Ferdig program (siste del)

Eksempel: Body Mass Index (BMI) Forelesning inf1000 - Java 3. Ferdig program (første del) Ferdig program (siste del) Forelesning inf1000 - Java 3 Eksempel: Body Mass Index (BMI) Tema: Mer om forgreninger Løkker Arrayer Litt om easyio Ole Christian Lingjærde, 5. september 2012 Ole Chr. Lingjærde Institutt for informatikk,

Detaljer

HØGSKOLEN I SØR-TRØNDELAG Avdeling for informatikk og e-læring - AITeL

HØGSKOLEN I SØR-TRØNDELAG Avdeling for informatikk og e-læring - AITeL HØGSKOLEN I SØR-TRØNDELAG Avdeling for informatikk og e-læring - AITeL Kandidatnr: Eksamensdato:. desember 00 Varighet: timer (9:00 1:00) Fagnummer: LO117D Fagnavn: Algoritmiske metoder Klasse(r): DA DB

Detaljer

Forelesningsquiz. Forelesning inf1000 - Java 5. Sett dere to (eller tre) sammen og besvar de fire spørsmålene på utdelt ark. Tid: 15 min.

Forelesningsquiz. Forelesning inf1000 - Java 5. Sett dere to (eller tre) sammen og besvar de fire spørsmålene på utdelt ark. Tid: 15 min. Forelesning inf1000 - Java 5 Forelesningsquiz Tema: En liten quiz (se utdelt ark) Filbehandling Tekster Ole Christian Lingjærde, 19. september 2012 Sett dere to (eller tre) sammen og besvar de fire spørsmålene

Detaljer

Programmeringsspråket C

Programmeringsspråket C Programmeringsspråket C Programmeringsspråket C Laget til implementasjon av Unix ved AT&Ts Bell labs i Palo Alto 1969 73. Navnet kommer fra BCPL B C. Opphavsmannnen heter Dennis Ritchie. ANSI-standard

Detaljer

TDT4120 Øvingsforelesning 1 Introduksjon til Python

TDT4120 Øvingsforelesning 1 Introduksjon til Python TDT4120 Øvingsforelesning 1 Introduksjon til Python Basert på foiler av Åsmund Eldhuset Presentert av Martin Gammelsæter Python! A C program is like a fast dance on a newly waxed dance floor by people

Detaljer

Innlesning fra tastatur med easyio. INF1000 høst 2010. Vi må først skrive i toppen av programmet: import easyio.*;

Innlesning fra tastatur med easyio. INF1000 høst 2010. Vi må først skrive i toppen av programmet: import easyio.*; Innlesning fra tastatur med easyio INF1000 høst 2010 Forelesning 2: Innlesning fra terminal Boolean-variable if-setninger Løkker Litt mer om heltall: divisjon og modulo Vi må først skrive i toppen av programmet:

Detaljer

Dagens tema: Maskinkode. Litt datamaskinhistorie Hva er maskin- og assemblerkode? x86-prosessoren Programkode og variabler

Dagens tema: Maskinkode. Litt datamaskinhistorie Hva er maskin- og assemblerkode? x86-prosessoren Programkode og variabler Dagens tema Dagens tema: Maskinkode Litt datamaskinhistorie Hva er maskin- og assemblerkode? x86-prosessoren Programkode og variabler Charles Babbage Datamaskinenes historie Menneskene har alltid prøvd

Detaljer

Ta inn og ut av 2D-array. Java 6. Liste over ulike verdier i 2D-array. Det ferdige programmet. Vi skal lage et program som illustrerer hvordan man

Ta inn og ut av 2D-array. Java 6. Liste over ulike verdier i 2D-array. Det ferdige programmet. Vi skal lage et program som illustrerer hvordan man Eksempel med to-dimensjonal array Filbehandling Tekster Ole Christian Lingjærde Gruppen for bioinformatikk Institutt for informatikk Universitetet i Oslo Java 6 Vi skal lage et program som illustrerer

Detaljer

Løsningsforslag ukeoppg. 6: 28. sep - 4. okt (INF1000 - Høst 2011)

Løsningsforslag ukeoppg. 6: 28. sep - 4. okt (INF1000 - Høst 2011) Løsningsforslag ukeoppg. 6: 28. sep - 4. okt (INF1000 - Høst 2011) Løsningsforslag til oppgave 7, 8, og 9 mangler Klasser og objekter (kap. 8.1-8.14 i "Rett på Java" 3. utg.) NB! Legg merke til at disse

Detaljer

UNIVERSITETET I OSLO

UNIVERSITETET I OSLO Side 1 UNIVERSITETET I OSLO Kandidatnr Det matematisk-naturvitenskapelige fakultet LØSNINGSFORSLAG Eksamen i: PRØVEEKSAMEN INF1000 Eksamensdag: Prøveeksamen 22.11.2011 Tid for eksamen: 12:15-16:15 Oppgavesettet

Detaljer

Java-kurs. Andreas Knudsen Nils Grimsmo 9th October 2003

Java-kurs. Andreas Knudsen <andreakn@idi.ntnu.no> Nils Grimsmo <nilsgri@idi.ntnu.no> 9th October 2003 Java-kurs Andreas Knudsen Nils Grimsmo 9th October 2003 1 (Dette blir lagt ut på nett, du trenger ikke ta notater.) 1 Motivasjon For de som ikke går å data:

Detaljer

Dagens forelesning. Java 13. Rollefordeling (variant 1) Rollefordeling (variant 2) Design av større programmer : fordeling av roller.

Dagens forelesning. Java 13. Rollefordeling (variant 1) Rollefordeling (variant 2) Design av større programmer : fordeling av roller. Dagens forelesning Java 13 Design av større programmer : fordeling av roller INF 101-13. mars 2003 Flere eksempler på bruk av objekter MVC-prinsippet MVC-prinsippet Flere eksempler på programmer med objekter

Detaljer

HØGSKOLEN I SØR-TRØNDELAG Avdeling for informatikk og e-læring - AITeL

HØGSKOLEN I SØR-TRØNDELAG Avdeling for informatikk og e-læring - AITeL HØGSKOLEN I SØR-TRØNDELAG Avdeling for informatikk og e-læring - AITeL Kandidatnr: Eksamensdato: Varighet: Fagnummer: Fagnavn: Klasse(r): Studiepoeng: Faglærer(e): Hjelpemidler: Oppgavesettet består av:

Detaljer

Kontinuasjonseksamen

Kontinuasjonseksamen Høgskolen i Gjøvik Avdeling for Teknologi Kontinuasjonseksamen FAGNAVN: FAGNUMMER: Objekt-orientert programmering L 183 A EKSAMENSDATO: 3. januar 2001 KLASSE: 99HINDA / 99HINDB / 99HINEA 99HDMUA / 99HDMUB

Detaljer

Eksamen. Objektorientert Programmering IGR 1372

Eksamen. Objektorientert Programmering IGR 1372 + JVNROHQL1DUYLN $YGHOLQJIRU7HNQRORJL Eksamen i Objektorientert Programmering IGR 1372 7LG'HVHPEHU± 7LOODWWHKMHOSHPLGOHU 6NULYHVDNHU2UGE NHU -DYD6RIWZDUH6ROXWLRQV)RXQGDWLRQVRI3URJUDP 'HVLJQVNUHYHWDY/HZLV

Detaljer

Høgskolen i Gjøvik Avdeling for informatikk og medieteknikk E K S A M E N. Grunnleggende programmering

Høgskolen i Gjøvik Avdeling for informatikk og medieteknikk E K S A M E N. Grunnleggende programmering Høgskolen i Gjøvik Avdeling for informatikk og medieteknikk E K S A M E N EMNENAVN: EMNENAMN: EMNENUMMER: Grunnleggende programmering IMT 1031 (F) EKSAMENSDATO: 1.desember 2015 KLASSE(R): 15HBIDAT*, 15HBDRA,

Detaljer

Avdeling for ingeniørutdanning Institutt for teknologi

Avdeling for ingeniørutdanning Institutt for teknologi Avdeling for ingeniørutdanning Institutt for teknologi Oppgavetittel: Lab Fag(nr./navn): DOPS2021 - Operativsystemer Gruppemedlemmer: T. Alexander Lystad Faglærer: Karoline Moholth Dato: 15. oktober 2009

Detaljer

Løsningsforslag ukeoppg. 9: 19. - 25. okt (INF1000 - Høst 2011)

Løsningsforslag ukeoppg. 9: 19. - 25. okt (INF1000 - Høst 2011) Løsningsforslag ukeoppg. 9: 19. - 25. okt (INF1000 - Høst 2011) HashMap, innstikksortering, javadoc (kap. 9.1-9.11, m.m. i "Rett på Java" 3. utg.) NB! Legg merke til at disse er løsningsforslag. Løsningene

Detaljer

EKSAMEN. Algoritmer og datastrukturer. Eksamensoppgaven: Oppgavesettet består av 11 sider inklusiv vedlegg og denne forsiden.

EKSAMEN. Algoritmer og datastrukturer. Eksamensoppgaven: Oppgavesettet består av 11 sider inklusiv vedlegg og denne forsiden. EKSAMEN Emnekode: ITF20006 Emne: Algoritmer og datastrukturer Dato: Eksamenstid: 20. mai 2008 kl 09.00 til kl 13.00 Hjelpemidler: 4 A4-sider (2 ark) med valgfritt innhold Kalkulator Faglærer: Mari-Ann

Detaljer

Eksamen. Objekt-orientert programmering. EKSAMENSDATO: 25. mai 2000 99HINDA / 99HINDB / 99HINEA 99HDMUA / 99HDMUB TID: 09.00-13.00. Høgskolen i Gjøvik

Eksamen. Objekt-orientert programmering. EKSAMENSDATO: 25. mai 2000 99HINDA / 99HINDB / 99HINEA 99HDMUA / 99HDMUB TID: 09.00-13.00. Høgskolen i Gjøvik Høgskolen i Gjøvik Avdeling for Teknologi Eksamen FAGNAVN: FAGNUMMER: Objekt-orientert programmering L 183 A EKSAMENSDATO: 25. mai 2000 KLASSE: 99HINDA / 99HINDB / 99HINEA 99HDMUA / 99HDMUB TID: 09.00-13.00

Detaljer

Lese fra fil. INF1000 : Forelesning 5. Eksempel. De vanligste lesemetodene. Metoder:

Lese fra fil. INF1000 : Forelesning 5. Eksempel. De vanligste lesemetodene. Metoder: Lese fra fil Filbehandling Tekster Ole Christian Lingjærde Gruppen for bioinformatikk Institutt for informatikk Universitetet i Oslo INF1000 : Forelesning 5 Vi må først importere pakken easyio Vi åpner

Detaljer

INF1000 Metoder. Marit Nybakken marnybak@ifi.uio.no 16. februar 2004

INF1000 Metoder. Marit Nybakken marnybak@ifi.uio.no 16. februar 2004 INF1000 Metoder Marit Nybakken marnybak@ifi.uio.no 16. februar 2004 Motivasjon Når man begynner å skrive store programmer, vil man fort oppleve at programmene blir uoversiktlige. Det blir vanskeligere

Detaljer

Antall sider (inkl. forsiden): 7. Alle trykte og håndskrevne

Antall sider (inkl. forsiden): 7. Alle trykte og håndskrevne Side 1 av 7 Bokmålstekst Emne: PROGRAMMERING (nytt pensum, 10 studiep.) Grupper: laa, lab, lac, lia, lib, lic Eksamensoppgaven best~r av: Tillatte hjelpemidler: Antall sider (inkl. forsiden): 7 Alle trykte

Detaljer

Løse reelle problemer

Løse reelle problemer Løse reelle problemer Litt mer om løkker, metoder med returverdier og innlesing fra fil INF1000, uke4 Geir Kjetil Sandve Repetisjon fra forrige uke: while Syntaks: while (condition) do1; do2;... Eksempel:

Detaljer

22.02.2009. Spørsmål fra forrige forelesning. INF1000 Forelesning 7. Oppførselen til inword()/inint()/etc. Operator-presedens i Java

22.02.2009. Spørsmål fra forrige forelesning. INF1000 Forelesning 7. Oppførselen til inword()/inint()/etc. Operator-presedens i Java Spørsmål fra forrige forelesning INF1000 Forelesning 7 Operator-presedens i Java? Hvordan virker metodene inword()/inint()/etc. i In-klassen i easyio når vi skriver inn flere verdier på tastaturet? Litt

Detaljer

Programmeringsspråk for nybegynnere. Krav til språket. Krav til språket. Krav til språket

Programmeringsspråk for nybegynnere. Krav til språket. Krav til språket. Krav til språket Programmeringsspråk for nybegynnere Krav til språket Hva om vi laget vårt eget språk til INF1000? Programmeringsspråket må være så enkelt som mulig. (Programmering er vanskelig nok som det er.) Hvilke

Detaljer

Kontinuasjonseksamen

Kontinuasjonseksamen Høgskolen i Gjøvik Avdeling for teknologi Kontinuasjonseksamen FAGNAVN: FAGNUMMER: Objekt-orientert programmering IMT1081 / L183A EKSAMENSDATO: 5. januar 2005 KLASSE(R): 03HBIND*, 03HBINFA, 03HBMETEA TID:

Detaljer

HØGSKOLEN I SØR-TRØNDELAG

HØGSKOLEN I SØR-TRØNDELAG HØGSKOLEN I SØR-TRØNDELAG Avdeling for informatikk og e-læring - AITeL Kandidatnr: Eksamensdato: 4.mai 2011 Varighet: 0900-1300 Emnekode: Emnenavn: Klasse(r): LO191D / LC191D Campus: LC191D Videregående

Detaljer

3 emner i dag! INF1000 Uke 5. Objekter og pekere. null. Litt om objekter, pekere og null Filer og easyio Litt mer om tekster

3 emner i dag! INF1000 Uke 5. Objekter og pekere. null. Litt om objekter, pekere og null Filer og easyio Litt mer om tekster 3 emner i dag! INF1000 Uke 5 Litt om objekter, pekere og null Filer og easyio Litt mer om tekster Litt om objekter, filer med easyio, tekst 1 2 Objekter og pekere Vi lager pekere og objekter når vi bruker

Detaljer

Činjenice o hepatitisu A, B i C i o tome kako izbjeći zarazu

Činjenice o hepatitisu A, B i C i o tome kako izbjeći zarazu Činjenice o hepatitisu A, B i C i o tome kako izbjeći zarazu Fakta om hepatitt A, B og C og om hvordan du unngår smitte Bosnisk/kroatisk/serbisk/norsk Hva er hepatitt? Hepatitt betyr betennelse i leveren.

Detaljer

I dag skal vi se på. INF 1000 (uke 2) Variabler, tilordninger og uttrykk. Gruppene starter denne uken! Klart for første oblig

I dag skal vi se på. INF 1000 (uke 2) Variabler, tilordninger og uttrykk. Gruppene starter denne uken! Klart for første oblig INF 1000 (uke 2) Variabler, tilordninger og uttrykk Grunnkurs i programmering Institutt for Informatikk Universitet i Oslo I dag skal vi se på Flere praktiske opplysninger Litt repetisjon Hva er en variabel

Detaljer

Det matematisk-naturvitenskapelige fakultet

Det matematisk-naturvitenskapelige fakultet Kandidatnummer: BOKMÅL UNIVERSITETET I OSLO Det matematisk-naturvitenskapelige fakultet Eksamen i : INF1000 Grunnkurs i objektorientert programmering Eksamensdag : Mandag 1. desember 2008 Tid for eksamen

Detaljer

LO191D/LC191D Videregående programmering

LO191D/LC191D Videregående programmering LO191D/LC191D Videregående programmering Eksamen mai 2012 Løsningsforslag Oppgave 1 Klassen Destinasjon: // Oppgaven er uklar på hva som skal inn i klassen Destinasjon. // Her følger en minimumsutgave

Detaljer

G høgskolen i oslo. Emne: Algoritmer og datastrukturer. Emnekode: 80131A. Faglig veileder: UlfUttersrud. Gruppe(r) : Dato: 09.12.

G høgskolen i oslo. Emne: Algoritmer og datastrukturer. Emnekode: 80131A. Faglig veileder: UlfUttersrud. Gruppe(r) : Dato: 09.12. G høgskolen i oslo Emne: Algoritmer og datastrukturer Emnekode: 80131A Faglig veileder: UlfUttersrud Gruppe(r) : Dato: 09.12.2004 Eksamenstid: 9-14 Eksamensoppgaven består av: Tillatte hjelpemidler Antall

Detaljer

TDT4100 Objektorientert programmering

TDT4100 Objektorientert programmering Eksamensoppgave i TDT4100 Objektorientert programmering Torsdag 12. august 2010, kl. 09:00-13:00 Oppgaven er utarbeidet av faglærer Hallvard Trætteberg og kvalitetssikret av Svein Erik Bratsberg. Kontaktperson

Detaljer

INF1010. Grensesnittet Comparable

INF1010. Grensesnittet Comparable<T> INF1010 21. februar 2013 Grensesnittet Comparable Stein Michael Storleer Institutt for Informatikk Universitetet i Oslo Interface med parametre interface Utkledd { // T er klassen jeg er utkledd

Detaljer

Mašina za sušenje Priručnik za korisnika Tørretumbler Brugermanualen Tørketrommel Brukerhåndboken DCY 7202 YW3 2960310952_SB/300715.

Mašina za sušenje Priručnik za korisnika Tørretumbler Brugermanualen Tørketrommel Brukerhåndboken DCY 7202 YW3 2960310952_SB/300715. Mašina za sušenje Priručnik za korisnika Tørretumbler Brugermanualen Tørketrommel Brukerhåndboken DY 7202 YW3 2960310952_SB/300715.1119 Molimo da prvo pročitate ovo uputstva za upotrebu! Poštovani kupče,

Detaljer

Dagens tema: Kompilatorens struktur. De ulike modulene Prosjektet. Oppbyggingen Pakker i Java Avbrudd («exceptions») Enum-klasser i Java

Dagens tema: Kompilatorens struktur. De ulike modulene Prosjektet. Oppbyggingen Pakker i Java Avbrudd («exceptions») Enum-klasser i Java Dagens tema: Kompilatorens struktur Oppbyggingen Pakker i Java Avbrudd («exceptions») Enum-klasser i Java De ulike modulene Prosjektet Hva skal del-0 gjøre? Feilmeldinger Testutskrifter Siste råd og påbud

Detaljer

Object interaction. Innhold. Abstraksjon 03.09.2007. Grunnleggende programmering i Java Monica Strand 3. september 2007.

Object interaction. Innhold. Abstraksjon 03.09.2007. Grunnleggende programmering i Java Monica Strand 3. september 2007. Object interaction Grunnleggende programmering i Java Monica Strand 3. september 2007 1 Innhold Til nå: Hva objekter er og hvordan de implementeres I klassedefinisjonene: klassevariable (fields), konstruktører

Detaljer

Oversikt. INF1000 Uke 3. Repetisjon Program. Repetisjon Program. Litt repetisjon Program Variabler og Uttrykk Presedens Matematiske funksjoner

Oversikt. INF1000 Uke 3. Repetisjon Program. Repetisjon Program. Litt repetisjon Program Variabler og Uttrykk Presedens Matematiske funksjoner Oversikt INF1000 Uke 3 Innlesing fra terminal, formatert utskrift og forgreininger Litt repetisjon Program Variabler og Uttrykk Presedens Matematiske funksjoner Innlesing Formatert utskrift Repetisjon

Detaljer

INF1010 våren 2016. Arv og subklasser - del 2

INF1010 våren 2016. Arv og subklasser - del 2 INF1010 våren 2016 Onsdag 10. februar Arv og subklasser - del 2 pluss litt om feil og unntak hvis tid Stein Gjessing Institutt for informatikk Dagens tema Virtuelle metoder som er det samme som Polymorfi

Detaljer

INF1000 - Uke 10. Ukesoppgaver 10 24. oktober 2012

INF1000 - Uke 10. Ukesoppgaver 10 24. oktober 2012 INF1000 - Uke 10 Ukesoppgaver 10 24. oktober 2012 Vanlige ukesoppgaver De første 4 oppgavene (Oppgave 1-4) handler om HashMap og bør absolutt gjøres før du starter på Oblig 4. Deretter er det en del repetisjonsoppgaver

Detaljer

INF1000. Marit Nybakken 10. februar 2004

INF1000. Marit Nybakken 10. februar 2004 INF1000 Løkker Marit Nybakken marnybak@ifi.uio.no 10. februar 2004 Motivasjon En ting datamaskinen er veldig flink til er å gjøre den samme tingen mange mange ganger på rad. Oppgaver som skal utføres innebærer

Detaljer

Lær Kidsa Koding Olve Maudal, Cisco Systems

Lær Kidsa Koding Olve Maudal, Cisco Systems Lær Kidsa Koding Olve Maudal, Cisco Systems 6-timers introduksjonskurs i programmering for 24 barn/ungdom i alderen 9-16 år Cisco Systems, Lysaker Fredag 21. januar 2014 I dag vil du lære litt om: GNU/Linux

Detaljer

Kapittel 8: Programutvikling

Kapittel 8: Programutvikling Kapittel 8: Programutvikling Redigert av: Khalid Azim Mughal (khalid@ii.uib.no) Kilde: Java som første programmeringsspråk (3. utgave) Khalid Azim Mughal, Torill Hamre, Rolf W. Rasmussen Cappelen Akademisk

Detaljer

BOKMÅL Side 1 av 12. Fakultet for informasjonsteknologi,

BOKMÅL Side 1 av 12. Fakultet for informasjonsteknologi, BOKMÅL Side 1 av 12 NTNU Norges teknisk-naturvitenskapelige universitet Fakultet for informasjonsteknologi, matematikk og elektroteknikk Institutt for datateknikk og informasjonsvitenskap TENTATIVT LØSNINGSFORSLAG

Detaljer

EKSAMEN med løsningsforslag

EKSAMEN med løsningsforslag EKSAMEN med løsningsforslag Emnekode: ITF20006 Emne: Algoritmer og datastrukturer Dato: Eksamenstid: 20. mai 2009 kl 09.00 til kl 13.00 Hjelpemidler: 8 A4-sider (4 ark) med egne notater Kalkulator Faglærer:

Detaljer

Løsningsforslag Øving 7

Løsningsforslag Øving 7 Løsningsforslag Øving 7 Oppgave 1: Function BeregnKvadrat(ByVal tall As Double) As Double tall = tall * tall Function BeregnKvadratrot(ByVal tall As Double) As Double tall = Math.Sqrt(tall) Private Sub

Detaljer

HØGSKOLEN I SØR-TRØNDELAG Avdeling for informatikk og e-læring AITeL

HØGSKOLEN I SØR-TRØNDELAG Avdeling for informatikk og e-læring AITeL HØGSKOLEN I SØR-TRØNDELAG Avdeling for informatikk og e-læring AITeL Delprøve Kandidatnr: Prøvedato: 2. mars 2005 Varighet: 3 timer (9:00 12:00) Fagnummer: LO196D Fagnavn: Videregående programmering med

Detaljer

INF1000 Uke 4. Innlesning fra terminal. Uttrykk og presedens. Oversikt

INF1000 Uke 4. Innlesning fra terminal. Uttrykk og presedens. Oversikt Oversikt INF1000 Uke 4 Forgreininger, løkker og arrayer Litt repetisjon Blokker og forgreininger if-setninger if-else-setninger switch-setninger Løkker while-løkker do-while-løkker for-løkker Arrayer Opprette,

Detaljer

C++ versus Java 1. C++ versus Java

C++ versus Java 1. C++ versus Java Avdeling for informatikk og e-læring, Høgskolen i Sør-Trøndelag C++ versus Java Tore Berg Hansen 29.8.2006 Lærestoffet er utviklet for faget LV194D C++ for Javaprogrammerere 1. C++ versus Java Resymé:

Detaljer

Eksamen 00HINDA / 00HINDB / 00HINEA 00HDMUA / 00HDMUB

Eksamen 00HINDA / 00HINDB / 00HINEA 00HDMUA / 00HDMUB Høgskolen i Gjøvik Avdeling for Teknologi Eksamen FAGNAVN: FAGNUMMER: Objekt-orientert programmering L 183 A EKSAMENSDATO: 23. mai 2001 KLASSE: 00HINDA / 00HINDB / 00HINEA 00HDMUA / 00HDMUB TID: 09.00-13.00

Detaljer

Oppgave 1 (Programtolkning) INF1000 Eksamen V06. Oppgave 1 (Programtolkning) Oppgave 1 (Programtolkning)

Oppgave 1 (Programtolkning) INF1000 Eksamen V06. Oppgave 1 (Programtolkning) Oppgave 1 (Programtolkning) INF1000 Eksamen V06 1a: Hva blir skrevet ut når programmet nedenfor kjøres? class stringhåndtering{ public static void main (String[] args){ String s = "Lykke til på eksamen"; String t = "Eksamen"; System.out.println(s.indexOf(t));

Detaljer

TEMA: Kommunikasjon med Bruker INF1000 Plenumsgruppe 1, 08.09.02. -formatert utskrift

TEMA: Kommunikasjon med Bruker INF1000 Plenumsgruppe 1, 08.09.02. -formatert utskrift TEMA: Kommunikasjon med Bruker INF1000 Plenumsgruppe 1, 08.09.02 - terminal-i/o (bruker-i/o) - innlesing av ulike typer data - pakken easyio - klassene In og Out In in = new In(); Out ut = new Out(); int

Detaljer

TDT4102 Prosedyre og Objektorientert programmering Vår 2015

TDT4102 Prosedyre og Objektorientert programmering Vår 2015 Norges teknisk naturvitenskapelige universitet Institutt for datateknikk og informasjonsvitenskap TDT4102 Prosedyre og Objektorientert programmering Vår 2015 Øving 1 LF LØSNINGSFORSLAG Mål for denne øvinga:

Detaljer

static int ant_steiner; //antall steiner static int teller2 = 0; //teller for printing til Thread^ murer; //murertråden

static int ant_steiner; //antall steiner static int teller2 = 0; //teller for printing til Thread^ murer; //murertråden Øving 4 Thorstein Brekke Operativsystemer Oppgave 1 Kode for Murer: // Uke4oppgave1murer.cpp : main project file. #include "stdafx.h" using namespace System; using namespace Threading; using namespace

Detaljer

Hva er en kø? En lineær datastruktur der vi til enhver tid kun har tilgang til elementet som ble lagt inn først

Hva er en kø? En lineær datastruktur der vi til enhver tid kun har tilgang til elementet som ble lagt inn først Køer Hva er en kø? En lineær datastruktur der vi til enhver tid kun har tilgang til elementet som ble lagt inn først Et nytt element legges alltid til sist i køen Skal vi ta ut et element, tar vi alltid

Detaljer

EKSAMEN. Operativsystemer. 1. Læreboken "A Practical Guide to Red Hat Linux" av Mark Sobell 2. Maks. tre A-4 ark med selvskrevne notater.

EKSAMEN. Operativsystemer. 1. Læreboken A Practical Guide to Red Hat Linux av Mark Sobell 2. Maks. tre A-4 ark med selvskrevne notater. EKSAMEN Emnekode: ITF22506 Emne: Operativsystemer Dato: 12. desember 2007 Eksamenstid: kl. 9.00 til kl. 13.00 Hjelpemidler: 1. Læreboken "A Practical Guide to Red Hat Linux" av Mark Sobell 2. Maks. tre

Detaljer

UNIVERSITETET I OSLO

UNIVERSITETET I OSLO UNIVERSITETET I OSLO Det matematisk-naturvitenskapelige fakultet Kandidatnr Eksamen i INF1000 Grunnkurs i objektorientert programmering Eksamensdag: Onsdag 1. desember 2010 Tid for eksamen: 14.00 18.00

Detaljer

"Nelsons kaffebutikk"

Nelsons kaffebutikk "Nelsons kaffebutikk" et eksempel på systemutvikling med objekter Originale lysark av Jens Kaasbøll - mindre endringer av G. Skagestein og Knut Hegna IN105-javaNelson-1 Nelsons kaffebutikk Området som

Detaljer

Litt om pakker og mest om data inn og ut

Litt om pakker og mest om data inn og ut Litt om pakker og mest om data inn og ut IN105-javainnogut-1 import java.io.*;. Data inn fra tastaturet lesemetode tastatur BufferedReader void lesemetode (String [ ] args) throws IOException {... /* sett

Detaljer

NITH PG4200 Algoritmer og datastrukturer Løsningsforslag Eksamen 4.juni 2013

NITH PG4200 Algoritmer og datastrukturer Løsningsforslag Eksamen 4.juni 2013 NITH PG4200 Algoritmer og datastrukturer Løsningsforslag Eksamen 4.juni 20 ette løsningsforslaget er til tider mer detaljert enn det man vil forvente av en eksamensbesvarelse. et er altså ikke et eksempel

Detaljer

Fakultet for informasjonsteknologi, Institutt for datateknikk og informasjonsvitenskap

Fakultet for informasjonsteknologi, Institutt for datateknikk og informasjonsvitenskap Side 1 av 6 NTNU Norges teknisk-naturvitenskapelige universitet Fakultet for informasjonsteknologi, matematikk og elektroteknikk Institutt for datateknikk og informasjonsvitenskap BOKMÅL KONTINUASJONSEKSAMEN

Detaljer

1 ØVING I WINDOWS FRA CHRISTIAN ANDOLO

1 ØVING I WINDOWS FRA CHRISTIAN ANDOLO 1 ØVING I WINDOWS FRA CHRISTIAN ANDOLO Program fra sekunder Lag et program som leser inn en tid i sekunder (et stort tall). Deretter skal programmet skrive ut hvor mange timer, minutter og sekunder dette

Detaljer

Algoritmer og datastrukturer Kapittel 3 - Delkapittel 3.1

Algoritmer og datastrukturer Kapittel 3 - Delkapittel 3.1 Delkapittel 3.1 Grensesnittet Liste Side 1 av 11 Algoritmer og datastrukturer Kapittel 3 - Delkapittel 3.1 3.1 En beholder 3.1.1 En beholder En pappeske er en beholder En beholder er noe vi kan legge ting

Detaljer

Universitetet i Bergen Det matematisk-naturvitenskapelige fakultet Institutt for informatikk

Universitetet i Bergen Det matematisk-naturvitenskapelige fakultet Institutt for informatikk Side 1 av 20 Universitetet i Bergen Det matematisk-naturvitenskapelige fakultet Institutt for informatikk Bokmål Eksamen i emnet INF100 Grunnkurs i programmering Torsdag 27. november 2014 Tid: 09:00 14:00

Detaljer

Lær Kidsa Koding Olve Maudal, Cisco Systems

Lær Kidsa Koding Olve Maudal, Cisco Systems Lær Kidsa Koding Olve Maudal, Cisco Systems 5-timers introduksjonskurs i programmering for 12 barn/ungdom i alderen 10-17 år Cisco Systems, Lysaker Torsdag 1. oktober 2015 I dag vil du lære litt om: GNU/Linux

Detaljer